diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 0000000000..70b44d2f41
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,5 @@
+repos:
+- repo: https://github.com/pre-commit/mirrors-clang-format
+  rev: v14.0.6
+  hooks:
+    - id: clang-format
diff --git a/contrib/runtime/aer_runtime.cpp b/contrib/runtime/aer_runtime.cpp
index 865fc46513..b3826cfc15 100644
--- a/contrib/runtime/aer_runtime.cpp
+++ b/contrib/runtime/aer_runtime.cpp
@@ -11,218 +11,224 @@
  * copyright notice, and modified files need to carry a notice indicating
  * that they have been altered from the originals.
  */
-#include <cmath>
 #include "controllers/state_controller.hpp"
+#include <cmath>
 
 // initialize and return state
 extern "C" {
 
-void* aer_state() {
-  AER::AerState* handler = new AER::AerState();
+void *aer_state() {
+  AER::AerState *handler = new AER::AerState();
   return handler;
 };
 
-void* aer_state_initialize(void* handler) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void *aer_state_initialize(void *handler) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->initialize();
   return handler;
 };
 
 // finalize state
-void aer_state_finalize(void* handler) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
-  delete(state);
+void aer_state_finalize(void *handler) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
+  delete (state);
 };
 
 // configure state
-void aer_state_configure(void* handler, char* key, char* value) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_state_configure(void *handler, char *key, char *value) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->configure(key, value);
 };
 
 // allocate qubits and return the first qubit index.
 // following qubits are indexed with incremented indices.
-uint_t aer_allocate_qubits(void* handler, uint_t num_qubits) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+uint_t aer_allocate_qubits(void *handler, uint_t num_qubits) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   auto qubit_ids = state->allocate_qubits(num_qubits);
   return qubit_ids[0];
 };
 
 // measure qubits
-uint_t aer_apply_measure(void* handler, uint_t* qubits_, size_t num_qubits) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+uint_t aer_apply_measure(void *handler, uint_t *qubits_, size_t num_qubits) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   std::vector<uint_t> qubits;
   qubits.insert(qubits.end(), &(qubits_[0]), &(qubits[num_qubits - 1]));
   return state->apply_measure(qubits);
 };
 
 // return probability of a specific bitstring
-double aer_probability(void* handler, uint_t outcome) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+double aer_probability(void *handler, uint_t outcome) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   return state->probability(outcome);
 };
 
 // return probability amplitude of a specific bitstring
-complex_t aer_amplitude(void* handler, uint_t outcome) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+complex_t aer_amplitude(void *handler, uint_t outcome) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   return state->amplitude(outcome);
 };
 
 // return probability amplitudes
 // returned pointer must be freed in the caller
-complex_t* aer_release_statevector(void* handler) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+complex_t *aer_release_statevector(void *handler) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   AER::Vector<complex_t> sv = state->move_to_vector();
   return sv.move_to_buffer();
 };
 
 // phase gate
-void aer_apply_p(void* handler, uint_t qubit, double lambda) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_apply_p(void *handler, uint_t qubit, double lambda) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->apply_mcphase({qubit}, lambda);
 };
 
 // Pauli gate: bit-flip or NOT gate
-void aer_apply_x(void* handler, uint_t qubit) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_apply_x(void *handler, uint_t qubit) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->apply_mcx({qubit});
 };
 
 // Pauli gate: bit and phase flip
-void aer_apply_y(void* handler, uint_t qubit) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_apply_y(void *handler, uint_t qubit) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->apply_mcy({qubit});
 };
 
 // Pauli gate: phase flip
-void aer_apply_z(void* handler, uint_t qubit) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_apply_z(void *handler, uint_t qubit) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->apply_mcz({qubit});
 };
 
 // Clifford gate: Hadamard
-void aer_apply_h(void* handler, uint_t qubit) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_apply_h(void *handler, uint_t qubit) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->apply_mcu({qubit}, M_PI / 2.0, 0, M_PI);
 };
 
 // Clifford gate: sqrt(Z) or S gate
-void aer_apply_s(void* handler, uint_t qubit) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_apply_s(void *handler, uint_t qubit) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->apply_mcu({qubit}, 0, 0, M_PI / 2.0);
 };
 
 // Clifford gate: inverse of sqrt(Z)
-void aer_apply_sdg(void* handler, uint_t qubit) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
-  state->apply_mcu({qubit}, 0, 0, - M_PI / 2.0);
+void aer_apply_sdg(void *handler, uint_t qubit) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
+  state->apply_mcu({qubit}, 0, 0, -M_PI / 2.0);
 };
 
 // // sqrt(S) or T gate
-void aer_apply_t(void* handler, uint_t qubit) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_apply_t(void *handler, uint_t qubit) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->apply_mcu({qubit}, 0, 0, M_PI / 4.0);
 };
 
 // inverse of sqrt(S)
-void aer_apply_tdg(void* handler, uint_t qubit) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
-  state->apply_mcu({qubit}, 0, 0, - M_PI / 4.0);
+void aer_apply_tdg(void *handler, uint_t qubit) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
+  state->apply_mcu({qubit}, 0, 0, -M_PI / 4.0);
 };
 
 // sqrt(NOT) gate
-void aer_apply_sx(void* handler, uint_t qubit) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
-  state->apply_mcrx({qubit}, - M_PI / 4.0);
+void aer_apply_sx(void *handler, uint_t qubit) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
+  state->apply_mcrx({qubit}, -M_PI / 4.0);
 };
 
 // Rotation around X-axis
-void aer_apply_rx(void* handler, uint_t qubit, double theta) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_apply_rx(void *handler, uint_t qubit, double theta) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->apply_mcrx({qubit}, theta);
 };
 
 // rotation around Y-axis
-void aer_apply_ry(void* handler, uint_t qubit, double theta) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_apply_ry(void *handler, uint_t qubit, double theta) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->apply_mcry({qubit}, theta);
 };
 
 // rotation around Z axis
-void aer_apply_rz(void* handler, uint_t qubit, double theta) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_apply_rz(void *handler, uint_t qubit, double theta) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->apply_mcrz({qubit}, theta);
 };
 
 // controlled-NOT
-void aer_apply_cx(void* handler, uint_t ctrl_qubit, uint_t tgt_qubit) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_apply_cx(void *handler, uint_t ctrl_qubit, uint_t tgt_qubit) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->apply_mcx({ctrl_qubit, tgt_qubit});
 };
 
 // controlled-Y
-void aer_apply_cy(void* handler, uint_t ctrl_qubit, uint_t tgt_qubit) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_apply_cy(void *handler, uint_t ctrl_qubit, uint_t tgt_qubit) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->apply_mcy({ctrl_qubit, tgt_qubit});
 };
 
 // controlled-Z
-void aer_apply_cz(void* handler, uint_t ctrl_qubit, uint_t tgt_qubit) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_apply_cz(void *handler, uint_t ctrl_qubit, uint_t tgt_qubit) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->apply_mcz({ctrl_qubit, tgt_qubit});
 };
 
 // controlled-phase
-void aer_apply_cp(void* handler, uint_t ctrl_qubit, uint_t tgt_qubit, double lambda) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_apply_cp(void *handler, uint_t ctrl_qubit, uint_t tgt_qubit,
+                  double lambda) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->apply_mcphase({ctrl_qubit, tgt_qubit}, lambda);
 };
 
 // controlled-rx
-void aer_apply_crx(void* handler, uint_t ctrl_qubit, uint_t tgt_qubit, double theta) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_apply_crx(void *handler, uint_t ctrl_qubit, uint_t tgt_qubit,
+                   double theta) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->apply_mcrx({ctrl_qubit, tgt_qubit}, theta);
 };
 
 // controlled-ry
-void aer_apply_cry(void* handler, uint_t ctrl_qubit, uint_t tgt_qubit, double theta) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_apply_cry(void *handler, uint_t ctrl_qubit, uint_t tgt_qubit,
+                   double theta) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->apply_mcry({ctrl_qubit, tgt_qubit}, theta);
 };
 
 // controlled-rz
-void aer_apply_crz(void* handler, uint_t ctrl_qubit, uint_t tgt_qubit, double theta) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_apply_crz(void *handler, uint_t ctrl_qubit, uint_t tgt_qubit,
+                   double theta) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->apply_mcrz({ctrl_qubit, tgt_qubit}, theta);
 };
 
 // controlled-H
-void aer_apply_ch(void* handler, uint_t ctrl_qubit, uint_t tgt_qubit) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_apply_ch(void *handler, uint_t ctrl_qubit, uint_t tgt_qubit) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->apply_mcu({ctrl_qubit, tgt_qubit}, M_PI / 2.0, 0, M_PI);
 };
 
 // swap
-void aer_apply_swap(void* handler, uint_t qubit0, uint_t qubit1) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_apply_swap(void *handler, uint_t qubit0, uint_t qubit1) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->apply_mcswap({qubit0, qubit1});
 };
 
 // Toffoli
-void aer_apply_ccx(void* handler, uint_t qubit0, uint_t qubit1, uint_t qubit2) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_apply_ccx(void *handler, uint_t qubit0, uint_t qubit1, uint_t qubit2) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->apply_mcx({qubit0, qubit1, qubit2});
 };
 
 // // controlled-swap
-void aer_apply_cswap(void* handler, uint_t ctrl_qubit, uint_t qubit0, uint_t qubit1) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_apply_cswap(void *handler, uint_t ctrl_qubit, uint_t qubit0,
+                     uint_t qubit1) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->apply_mcswap({ctrl_qubit, qubit0, qubit1});
 };
 
 // four parameter controlled-U gate with relative phase γ
-void aer_apply_cu(void* handler, uint_t ctrl_qubit, uint_t tgt_qubit, double theta, double phi, double lambda, double gamma) {
-  AER::AerState* state = reinterpret_cast<AER::AerState*>(handler);
+void aer_apply_cu(void *handler, uint_t ctrl_qubit, uint_t tgt_qubit,
+                  double theta, double phi, double lambda, double gamma) {
+  AER::AerState *state = reinterpret_cast<AER::AerState *>(handler);
   state->apply_mcphase({ctrl_qubit}, gamma);
   state->apply_mcu({ctrl_qubit, tgt_qubit}, theta, phi, lambda);
 };
diff --git a/contrib/runtime/aer_runtime_api.h b/contrib/runtime/aer_runtime_api.h
index 2e27a6fcc0..d08a51c8fd 100644
--- a/contrib/runtime/aer_runtime_api.h
+++ b/contrib/runtime/aer_runtime_api.h
@@ -14,93 +14,99 @@
 #include <complex.h>
 #include <stdint.h>
 
-typedef uint_fast64_t uint_t; 
+typedef uint_fast64_t uint_t;
 
 // construct an aer state
-void* aer_state();
+void *aer_state();
 
 // initialize aer state
-void* aer_state_initialize();
+void *aer_state_initialize();
 
 // finalize state
-void aer_state_finalize(void* state);
+void aer_state_finalize(void *state);
 
 // configure state
-void aer_state_configure(void* state, char* key, char* value);
+void aer_state_configure(void *state, char *key, char *value);
 
 // allocate qubits and return the first qubit index.
 // following qubits are indexed with incremented indices.
-uint_t aer_allocate_qubits(void* state, uint_t num_qubits);
+uint_t aer_allocate_qubits(void *state, uint_t num_qubits);
 
 // measure qubits
-uint_t aer_apply_measure(void* state, uint_t* qubits, size_t num_qubits);
+uint_t aer_apply_measure(void *state, uint_t *qubits, size_t num_qubits);
 
 // return probability of a specific bitstring
-double aer_probability(void* state, uint_t outcome);
+double aer_probability(void *state, uint_t outcome);
 
 // return probability amplitude of a specific bitstring
-double complex aer_amplitude(void* state, uint_t outcome);
+double complex aer_amplitude(void *state, uint_t outcome);
 
 // return probability amplitudes
 // returned pointer must be freed in the caller
-double complex* aer_release_statevector(void* state);
+double complex *aer_release_statevector(void *state);
 
 // phase gate
-void aer_apply_p(void* state, uint_t qubit, double lambda);
+void aer_apply_p(void *state, uint_t qubit, double lambda);
 
 // Pauli gate: bit-flip or NOT gate
-void aer_apply_x(void* state, uint_t qubit);
+void aer_apply_x(void *state, uint_t qubit);
 // Pauli gate: bit and phase flip
-void aer_apply_y(void* state, uint_t qubit);
+void aer_apply_y(void *state, uint_t qubit);
 // Pauli gate: phase flip
-void aer_apply_z(void* state, uint_t qubit);
+void aer_apply_z(void *state, uint_t qubit);
 
 // Clifford gate: Hadamard
-void aer_apply_h(void* state, uint_t qubit);
+void aer_apply_h(void *state, uint_t qubit);
 // Clifford gate: sqrt(Z) or S gate
-void aer_apply_s(void* state, uint_t qubit);
+void aer_apply_s(void *state, uint_t qubit);
 // Clifford gate: inverse of sqrt(Z)
-void aer_apply_sdg(void* state, uint_t qubit);
+void aer_apply_sdg(void *state, uint_t qubit);
 
 // sqrt(S) or T gate
-void aer_apply_t(void* state, uint_t qubit);
+void aer_apply_t(void *state, uint_t qubit);
 // inverse of sqrt(S)
-void aer_apply_tdg(void* state, uint_t qubit);
+void aer_apply_tdg(void *state, uint_t qubit);
 
 // sqrt(NOT) gate
-void aer_apply_sx(void* state, uint_t qubit);
+void aer_apply_sx(void *state, uint_t qubit);
 
 // Rotation around X-axis
-void aer_apply_rx(void* state, uint_t qubit, double theta);
+void aer_apply_rx(void *state, uint_t qubit, double theta);
 // rotation around Y-axis
-void aer_apply_ry(void* state, uint_t qubit, double theta);
+void aer_apply_ry(void *state, uint_t qubit, double theta);
 // rotation around Z axis
-void aer_apply_rz(void* state, uint_t qubit, double theta);
+void aer_apply_rz(void *state, uint_t qubit, double theta);
 
 // controlled-NOT
-void aer_apply_cx(void* state, uint_t ctrl_qubit, uint_t tgt_qubit);
+void aer_apply_cx(void *state, uint_t ctrl_qubit, uint_t tgt_qubit);
 // controlled-Y
-void aer_apply_cy(void* state, uint_t ctrl_qubit, uint_t tgt_qubit);
+void aer_apply_cy(void *state, uint_t ctrl_qubit, uint_t tgt_qubit);
 // controlled-Z
-void aer_apply_cz(void* state, uint_t ctrl_qubit, uint_t tgt_qubit);
+void aer_apply_cz(void *state, uint_t ctrl_qubit, uint_t tgt_qubit);
 // controlled-phase
-void aer_apply_cp(void* state, uint_t ctrl_qubit, uint_t tgt_qubit, double lambda);
+void aer_apply_cp(void *state, uint_t ctrl_qubit, uint_t tgt_qubit,
+                  double lambda);
 // controlled-rx
-void aer_apply_crx(void* state, uint_t ctrl_qubit, uint_t tgt_qubit, double theta);
+void aer_apply_crx(void *state, uint_t ctrl_qubit, uint_t tgt_qubit,
+                   double theta);
 // controlled-ry
-void aer_apply_cry(void* state, uint_t ctrl_qubit, uint_t tgt_qubit, double theta);
+void aer_apply_cry(void *state, uint_t ctrl_qubit, uint_t tgt_qubit,
+                   double theta);
 // controlled-rz
-void aer_apply_crz(void* state, uint_t ctrl_qubit, uint_t tgt_qubit, double theta);
+void aer_apply_crz(void *state, uint_t ctrl_qubit, uint_t tgt_qubit,
+                   double theta);
 // controlled-H
-void aer_apply_ch(void* state, uint_t ctrl_qubit, uint_t tgt_qubit);
+void aer_apply_ch(void *state, uint_t ctrl_qubit, uint_t tgt_qubit);
 
 // swap
-void aer_apply_swap(void* state, uint_t qubit0, uint_t qubit1);
+void aer_apply_swap(void *state, uint_t qubit0, uint_t qubit1);
 
 // Toffoli
-void aer_apply_ccx(void* state, uint_t qubit0, uint_t qubit1, uint_t qubit2);
+void aer_apply_ccx(void *state, uint_t qubit0, uint_t qubit1, uint_t qubit2);
 // controlled-swap
-void aer_apply_cswap(void* state, uint_t ctrl_qubit, uint_t qubit0, uint_t qubit1);
+void aer_apply_cswap(void *state, uint_t ctrl_qubit, uint_t qubit0,
+                     uint_t qubit1);
 
 // four parameter controlled-U gate with relative phase γ
-void aer_apply_cu(void* state, uint_t ctrl_qubit, uint_t tgt_qubit, double theta, double phi, double lambda, double gamma);
\ No newline at end of file
+void aer_apply_cu(void *state, uint_t ctrl_qubit, uint_t tgt_qubit,
+                  double theta, double phi, double lambda, double gamma);
\ No newline at end of file
diff --git a/contrib/standalone/qasm_simulator.cpp b/contrib/standalone/qasm_simulator.cpp
old mode 100755
new mode 100644
index d0b8fa9c0a..fac82cb863
--- a/contrib/standalone/qasm_simulator.cpp
+++ b/contrib/standalone/qasm_simulator.cpp
@@ -27,32 +27,28 @@
 /*******************************************************************************
  *
  * EXIT CODES:
- * 
+ *
  * 0: The Qobj was succesfully executed.
  *    Returns full result JSON.
- * 
+ *
  * 1: Command line invalid or Qobj JSON cannot be loaded.
  *    Returns JSON:
  *    {"success": false, "status": "ERROR: Invalid input (error msg)"}
- * 
+ *
  * 2: Qobj failed to load or execute.
  *    Returns JSON:
  *    {"success": false, "status": "ERROR: Failed to execute qobj (error msg)"}
- * 
+ *
  * 3: At least one experiment in Qobj failed to execute successfully.
  *    Returns parial result JSON with failed experiments returning:
  *    "{"success": false, "status": "ERROR: error msg"}
  *
  ******************************************************************************/
 
-enum class CmdArguments {
-  SHOW_VERSION,
-  INPUT_CONFIG,
-  INPUT_DATA
-};
+enum class CmdArguments { SHOW_VERSION, INPUT_CONFIG, INPUT_DATA };
 
-inline CmdArguments parse_cmd_options(const std::string& argv){
-  if(argv == "-v" || argv == "--version")
+inline CmdArguments parse_cmd_options(const std::string &argv) {
+  if (argv == "-v" || argv == "--version")
     return CmdArguments::SHOW_VERSION;
 
   if (argv == "-c" || argv == "--config")
@@ -61,22 +57,20 @@ inline CmdArguments parse_cmd_options(const std::string& argv){
   return CmdArguments::INPUT_DATA;
 }
 
-inline void show_version(){
-  std::cout << "Qiskit Aer: "
-  << AER_MAJOR_VERSION << "."
-  << AER_MINOR_VERSION << "."
-  << AER_PATCH_VERSION << "\n";
+inline void show_version() {
+  std::cout << "Qiskit Aer: " << AER_MAJOR_VERSION << "." << AER_MINOR_VERSION
+            << "." << AER_PATCH_VERSION << "\n";
 }
 
 inline void failed(const std::string &msg, std::ostream &o = std::cout,
-            int indent = -1){
+                   int indent = -1) {
   json_t ret;
   ret["success"] = false;
   ret["status"] = std::string("ERROR: ") + msg;
   o << ret.dump(indent) << std::endl;
 }
 
-inline void usage(const std::string& command, std::ostream &out){
+inline void usage(const std::string &command, std::ostream &out) {
   failed("Invalid command line", out);
   // Print usage message
   std::cerr << "\n\n";
@@ -85,7 +79,8 @@ inline void usage(const std::string& command, std::ostream &out){
   std::cerr << "Usage: \n";
   std::cerr << command << " [-v] [-c <config>] <file>\n";
   std::cerr << "    -v          : Show version\n";
-  std::cerr << "    -c <config> : Configuration file\n";;
+  std::cerr << "    -c <config> : Configuration file\n";
+  ;
   std::cerr << "    file        : qobj file\n";
 }
 
@@ -95,51 +90,51 @@ int main(int argc, char **argv) {
   int indent = 4;
   json_t qobj;
   json_t config;
-  int myrank=0;
+  int myrank = 0;
 
 #ifdef AER_MPI
   int prov;
-  int nprocs=1;
-  MPI_Init_thread(&argc,&argv,MPI_THREAD_MULTIPLE,&prov);
-  MPI_Comm_size(MPI_COMM_WORLD,&nprocs);
-  MPI_Comm_rank(MPI_COMM_WORLD,&myrank);
+  int nprocs = 1;
+  MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &prov);
+  MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
+  MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
 #endif
 
-  if(argc == 1){ // NOLINT
+  if (argc == 1) {                    // NOLINT
     usage(std::string(argv[0]), out); // NOLINT
     return 1;
   }
 
   // Parse command line options
-  for(auto pos = 1UL; pos < static_cast<unsigned int>(argc); ++pos){ // NOLINT
-    auto option = parse_cmd_options(std::string(argv[pos])); // NOLINT
-    switch(option){
-      case CmdArguments::SHOW_VERSION:
-        show_version();
-        return 0;
-      case CmdArguments::INPUT_CONFIG:
-        if (++pos == static_cast<unsigned int>(argc)) {
-          failed("Invalid config (no file is specified.)", out, indent);
-          return 1;
-        }
-        try {
-          config = JSON::load(std::string(argv[pos]));
-        }catch(std::exception &e){
-          std::string msg = "Invalid config (" +  std::string(e.what()) + ")";
-          failed(msg, out, indent);
-          return 1;
-        }
-        break;
-      case CmdArguments::INPUT_DATA:
-        try {
-          qobj = JSON::load(std::string(argv[pos])); // NOLINT
-          pos = argc; //Exit from the loop
-        }catch(std::exception &e){
-          std::string msg = "Invalid input (" +  std::string(e.what()) + ")";
-          failed(msg, out, indent);
-          return 1;
-        }
-        break;
+  for (auto pos = 1UL; pos < static_cast<unsigned int>(argc); ++pos) { // NOLINT
+    auto option = parse_cmd_options(std::string(argv[pos]));           // NOLINT
+    switch (option) {
+    case CmdArguments::SHOW_VERSION:
+      show_version();
+      return 0;
+    case CmdArguments::INPUT_CONFIG:
+      if (++pos == static_cast<unsigned int>(argc)) {
+        failed("Invalid config (no file is specified.)", out, indent);
+        return 1;
+      }
+      try {
+        config = JSON::load(std::string(argv[pos]));
+      } catch (std::exception &e) {
+        std::string msg = "Invalid config (" + std::string(e.what()) + ")";
+        failed(msg, out, indent);
+        return 1;
+      }
+      break;
+    case CmdArguments::INPUT_DATA:
+      try {
+        qobj = JSON::load(std::string(argv[pos])); // NOLINT
+        pos = argc;                                // Exit from the loop
+      } catch (std::exception &e) {
+        std::string msg = "Invalid input (" + std::string(e.what()) + ")";
+        failed(msg, out, indent);
+        return 1;
+      }
+      break;
     }
   }
 
@@ -148,7 +143,7 @@ int main(int argc, char **argv) {
 
     // Check for command line config
     // and if present add to qobj config
-    json_t& config_all = qobj["config"];
+    json_t &config_all = qobj["config"];
     if (!config.empty()) // NOLINT
       config_all.update(config.begin(), config.end());
 
@@ -166,7 +161,7 @@ int main(int argc, char **argv) {
     // Initialize simulator
     AER::Controller sim;
     auto result = sim.execute(qobj).to_json();
-    if(myrank == 0){
+    if (myrank == 0) {
       out << result.dump(4) << std::endl;
     }
 
@@ -179,9 +174,9 @@ int main(int argc, char **argv) {
 #ifdef AER_MPI
       MPI_Finalize();
 #endif
-      if(status == "COMPLETED")
+      if (status == "COMPLETED")
         return 3; // The simulation was was completed unsuccesfully.
-      return 2; // Failed to execute the Qobj
+      return 2;   // Failed to execute the Qobj
     }
   } catch (std::exception &e) {
     std::stringstream msg;
diff --git a/qiskit_aer/backends/wrappers/bindings.cc b/qiskit_aer/backends/wrappers/bindings.cc
index 448868873a..1d2dfa8f30 100644
--- a/qiskit_aer/backends/wrappers/bindings.cc
+++ b/qiskit_aer/backends/wrappers/bindings.cc
@@ -9,146 +9,148 @@ DISABLE_WARNING_PUSH
 #include <pybind11/pybind11.h>
 DISABLE_WARNING_POP
 #if defined(_MSC_VER)
-    #undef snprintf
+#undef snprintf
 #endif
 
 #include "framework/matrix.hpp"
-#include "framework/python_parser.hpp"
 #include "framework/pybind_casts.hpp"
-#include "framework/types.hpp"
+#include "framework/python_parser.hpp"
 #include "framework/results/pybind_result.hpp"
+#include "framework/types.hpp"
 
 #include "controllers/aer_controller.hpp"
 #include "controllers/controller_execute.hpp"
 
 #include "controllers/state_controller.hpp"
 
-template<typename T>
-class ControllerExecutor {
+template <typename T> class ControllerExecutor {
 public:
-    ControllerExecutor() = default;
-    py::object operator()(const py::handle &qobj) {
+  ControllerExecutor() = default;
+  py::object operator()(const py::handle &qobj) {
 #ifdef TEST_JSON // Convert input qobj to json to test standalone data reading
-        return AerToPy::to_python(AER::controller_execute<T>(json_t(qobj)));
+    return AerToPy::to_python(AER::controller_execute<T>(json_t(qobj)));
 #else
-        return AerToPy::to_python(AER::controller_execute<T>(qobj));
+    return AerToPy::to_python(AER::controller_execute<T>(qobj));
 #endif
-    }
+  }
 };
 
 PYBIND11_MODULE(controller_wrappers, m) {
 
 #ifdef AER_MPI
   int prov;
-  MPI_Init_thread(nullptr,nullptr,MPI_THREAD_MULTIPLE,&prov);
+  MPI_Init_thread(nullptr, nullptr, MPI_THREAD_MULTIPLE, &prov);
 #endif
 
-    py::class_<ControllerExecutor<AER::Controller> > aer_ctrl (m, "aer_controller_execute");
-    aer_ctrl.def(py::init<>());
-    aer_ctrl.def("__call__", &ControllerExecutor<AER::Controller>::operator());
-    aer_ctrl.def("__reduce__", [aer_ctrl](const ControllerExecutor<AER::Controller> &self) {
-        return py::make_tuple(aer_ctrl, py::tuple());
-    });
-
-    py::class_<AER::AerState> aer_state(m, "AerStateWrapper");
-
-    aer_state.def(py::init<>(), "constructor");
-
-    aer_state.def("__repr__", [](const AER::AerState &state) {
-      std::stringstream ss;
-      ss << "AerStateWrapper("
-          << "initialized=" << state.is_initialized()
-          << ", num_of_qubits=" << state.num_of_qubits();
-      ss << ")";
-      return ss.str();
-    });
-
-    aer_state.def("configure",  &AER::AerState::configure);
-    aer_state.def("allocate_qubits",  &AER::AerState::allocate_qubits);
-    aer_state.def("reallocate_qubits",  &AER::AerState::reallocate_qubits);
-    aer_state.def("clear",  &AER::AerState::clear);
-    aer_state.def("num_of_qubits",  &AER::AerState::num_of_qubits);
-
-    aer_state.def("initialize",  &AER::AerState::initialize);
-    aer_state.def("initialize_statevector", [aer_state](AER::AerState &state,
-                                                        int num_of_qubits,
-                                                        py::array_t<std::complex<double>> &values,
-                                                        bool copy) {
-      std::complex<double>* data_ptr = reinterpret_cast<std::complex<double>*>(values.mutable_data(0));
-      state.configure("method", "statevector");
-      state.initialize_statevector(num_of_qubits, data_ptr, copy);
-      return true;
-    });
-
-    aer_state.def("move_to_buffer",  [aer_state](AER::AerState &state) {
-      return state.move_to_vector().move_to_buffer();
-    });
-
-    aer_state.def("move_to_ndarray", [aer_state](AER::AerState &state) {
-      auto vec = state.move_to_vector();
-
-      std::complex<double>* data_ptr = vec.data();
-      auto ret = AerToPy::to_numpy(std::move(vec));
-      return ret;
-    });
-
-    aer_state.def("flush",  &AER::AerState::flush_ops);
-
-    aer_state.def("last_result",  [aer_state](AER::AerState &state) {
-      return AerToPy::to_python(state.last_result().to_json());
-    });
-
-
-    aer_state.def("apply_initialize",  &AER::AerState::apply_initialize);
-    aer_state.def("apply_global_phase",  &AER::AerState::apply_global_phase);
-    aer_state.def("apply_unitary", [aer_state](AER::AerState &state,
-                                                   const reg_t &qubits,
-                                                   const py::array_t<std::complex<double>> &values) {
-      size_t mat_len = (1UL << qubits.size());
-      auto ptr = values.unchecked<2>();
-      AER::cmatrix_t mat(mat_len, mat_len);
-      for (auto i = 0; i < mat_len; ++i)
-        for (auto j = 0; j < mat_len; ++j)
-          mat(i, j) = ptr(i, j);
-      state.apply_unitary(qubits, mat);
-    });
-
-    aer_state.def("apply_multiplexer", [aer_state](AER::AerState &state,
-                                                       const reg_t &control_qubits,
-                                                       const reg_t &target_qubits,
-                                                       const py::array_t<std::complex<double>> &values) {
-      size_t mat_len = (1UL << target_qubits.size());
-      size_t mat_size = (1UL << control_qubits.size());
-      auto ptr = values.unchecked<3>();
-      std::vector<AER::cmatrix_t> mats;
-      for (auto i = 0; i < mat_size; ++i) {
-        AER::cmatrix_t mat(mat_len, mat_len);
-        for (auto j = 0; j < mat_len; ++j)
-          for (auto k = 0; k < mat_len; ++k)
-            mat(j, k) = ptr(i, j, k);
-        mats.push_back(mat);
-      }
-      state.apply_multiplexer(control_qubits, target_qubits, mats);
-    });
-
-    aer_state.def("apply_diagonal",  &AER::AerState::apply_diagonal_matrix);
-    aer_state.def("apply_mcx",  &AER::AerState::apply_mcx);
-    aer_state.def("apply_mcy",  &AER::AerState::apply_mcy);
-    aer_state.def("apply_mcz",  &AER::AerState::apply_mcz);
-    aer_state.def("apply_mcphase",  &AER::AerState::apply_mcphase);
-    aer_state.def("apply_mcu",  &AER::AerState::apply_mcu);
-    aer_state.def("apply_mcswap",  &AER::AerState::apply_mcswap);
-    aer_state.def("apply_measure",  &AER::AerState::apply_measure);
-    aer_state.def("apply_reset",  &AER::AerState::apply_reset);
-    aer_state.def("probability",  &AER::AerState::probability);
-    aer_state.def("probabilities", [aer_state](AER::AerState &state,
-                                                   const reg_t qubits) {
-      if (qubits.empty())
-        return state.probabilities();
-      else
-        return state.probabilities(qubits);
-    }, py::arg("qubits") = reg_t());
-    aer_state.def("sample_memory",  &AER::AerState::sample_memory);
-    aer_state.def("sample_counts",  &AER::AerState::sample_counts);
-
+  py::class_<ControllerExecutor<AER::Controller>> aer_ctrl(
+      m, "aer_controller_execute");
+  aer_ctrl.def(py::init<>());
+  aer_ctrl.def("__call__", &ControllerExecutor<AER::Controller>::operator());
+  aer_ctrl.def("__reduce__",
+               [aer_ctrl](const ControllerExecutor<AER::Controller> &self) {
+                 return py::make_tuple(aer_ctrl, py::tuple());
+               });
+
+  py::class_<AER::AerState> aer_state(m, "AerStateWrapper");
+
+  aer_state.def(py::init<>(), "constructor");
+
+  aer_state.def("__repr__", [](const AER::AerState &state) {
+    std::stringstream ss;
+    ss << "AerStateWrapper("
+       << "initialized=" << state.is_initialized()
+       << ", num_of_qubits=" << state.num_of_qubits();
+    ss << ")";
+    return ss.str();
+  });
+
+  aer_state.def("configure", &AER::AerState::configure);
+  aer_state.def("allocate_qubits", &AER::AerState::allocate_qubits);
+  aer_state.def("reallocate_qubits", &AER::AerState::reallocate_qubits);
+  aer_state.def("clear", &AER::AerState::clear);
+  aer_state.def("num_of_qubits", &AER::AerState::num_of_qubits);
+
+  aer_state.def("initialize", &AER::AerState::initialize);
+  aer_state.def(
+      "initialize_statevector",
+      [aer_state](AER::AerState &state, int num_of_qubits,
+                  py::array_t<std::complex<double>> &values, bool copy) {
+        std::complex<double> *data_ptr =
+            reinterpret_cast<std::complex<double> *>(values.mutable_data(0));
+        state.configure("method", "statevector");
+        state.initialize_statevector(num_of_qubits, data_ptr, copy);
+        return true;
+      });
+
+  aer_state.def("move_to_buffer", [aer_state](AER::AerState &state) {
+    return state.move_to_vector().move_to_buffer();
+  });
+
+  aer_state.def("move_to_ndarray", [aer_state](AER::AerState &state) {
+    auto vec = state.move_to_vector();
+
+    std::complex<double> *data_ptr = vec.data();
+    auto ret = AerToPy::to_numpy(std::move(vec));
+    return ret;
+  });
+
+  aer_state.def("flush", &AER::AerState::flush_ops);
+
+  aer_state.def("last_result", [aer_state](AER::AerState &state) {
+    return AerToPy::to_python(state.last_result().to_json());
+  });
+
+  aer_state.def("apply_initialize", &AER::AerState::apply_initialize);
+  aer_state.def("apply_global_phase", &AER::AerState::apply_global_phase);
+  aer_state.def("apply_unitary",
+                [aer_state](AER::AerState &state, const reg_t &qubits,
+                            const py::array_t<std::complex<double>> &values) {
+                  size_t mat_len = (1UL << qubits.size());
+                  auto ptr = values.unchecked<2>();
+                  AER::cmatrix_t mat(mat_len, mat_len);
+                  for (auto i = 0; i < mat_len; ++i)
+                    for (auto j = 0; j < mat_len; ++j)
+                      mat(i, j) = ptr(i, j);
+                  state.apply_unitary(qubits, mat);
+                });
+
+  aer_state.def("apply_multiplexer",
+                [aer_state](AER::AerState &state, const reg_t &control_qubits,
+                            const reg_t &target_qubits,
+                            const py::array_t<std::complex<double>> &values) {
+                  size_t mat_len = (1UL << target_qubits.size());
+                  size_t mat_size = (1UL << control_qubits.size());
+                  auto ptr = values.unchecked<3>();
+                  std::vector<AER::cmatrix_t> mats;
+                  for (auto i = 0; i < mat_size; ++i) {
+                    AER::cmatrix_t mat(mat_len, mat_len);
+                    for (auto j = 0; j < mat_len; ++j)
+                      for (auto k = 0; k < mat_len; ++k)
+                        mat(j, k) = ptr(i, j, k);
+                    mats.push_back(mat);
+                  }
+                  state.apply_multiplexer(control_qubits, target_qubits, mats);
+                });
+
+  aer_state.def("apply_diagonal", &AER::AerState::apply_diagonal_matrix);
+  aer_state.def("apply_mcx", &AER::AerState::apply_mcx);
+  aer_state.def("apply_mcy", &AER::AerState::apply_mcy);
+  aer_state.def("apply_mcz", &AER::AerState::apply_mcz);
+  aer_state.def("apply_mcphase", &AER::AerState::apply_mcphase);
+  aer_state.def("apply_mcu", &AER::AerState::apply_mcu);
+  aer_state.def("apply_mcswap", &AER::AerState::apply_mcswap);
+  aer_state.def("apply_measure", &AER::AerState::apply_measure);
+  aer_state.def("apply_reset", &AER::AerState::apply_reset);
+  aer_state.def("probability", &AER::AerState::probability);
+  aer_state.def(
+      "probabilities",
+      [aer_state](AER::AerState &state, const reg_t qubits) {
+        if (qubits.empty())
+          return state.probabilities();
+        else
+          return state.probabilities(qubits);
+      },
+      py::arg("qubits") = reg_t());
+  aer_state.def("sample_memory", &AER::AerState::sample_memory);
+  aer_state.def("sample_counts", &AER::AerState::sample_counts);
 }
diff --git a/src/controllers/aer_controller.hpp b/src/controllers/aer_controller.hpp
old mode 100755
new mode 100644
index b1a9880f23..722af89dc4
--- a/src/controllers/aer_controller.hpp
+++ b/src/controllers/aer_controller.hpp
@@ -80,11 +80,9 @@ class Controller {
 
   // Load a QOBJ from a JSON file and execute on the State type
   // class.
-  template <typename inputdata_t>
-  Result execute(const inputdata_t &qobj);
+  template <typename inputdata_t> Result execute(const inputdata_t &qobj);
 
-  Result execute(std::vector<Circuit> &circuits,
-                 Noise::NoiseModel &noise_model,
+  Result execute(std::vector<Circuit> &circuits, Noise::NoiseModel &noise_model,
                  const json_t &config);
 
   //-----------------------------------------------------------------------
@@ -121,15 +119,14 @@ class Controller {
   enum class Precision { Double, Single };
 
   const std::unordered_map<Method, std::string> method_names_ = {
-    {Method::automatic, "automatic"},
-    {Method::statevector, "statevector"},
-    {Method::density_matrix, "density_matrix"},
-    {Method::matrix_product_state, "matrix_product_state"},
-    {Method::stabilizer, "stabilizer"},
-    {Method::extended_stabilizer, "extended_stabilizer"},
-    {Method::unitary, "unitary"},
-    {Method::superop, "superop"}
-  };
+      {Method::automatic, "automatic"},
+      {Method::statevector, "statevector"},
+      {Method::density_matrix, "density_matrix"},
+      {Method::matrix_product_state, "matrix_product_state"},
+      {Method::stabilizer, "stabilizer"},
+      {Method::extended_stabilizer, "extended_stabilizer"},
+      {Method::unitary, "unitary"},
+      {Method::superop, "superop"}};
 
   //-----------------------------------------------------------------------
   // Config
@@ -165,7 +162,8 @@ class Controller {
   // This method must initialize a state and return output data for
   // the required number of shots.
   void run_circuit(const Circuit &circ, const Noise::NoiseModel &noise,
-                   const Method method,const json_t &config, ExperimentResult &result) const;
+                   const Method method, const json_t &config,
+                   ExperimentResult &result) const;
 
   //----------------------------------------------------------------
   // Run circuit helpers
@@ -174,7 +172,7 @@ class Controller {
   // Execute n-shots of a circuit on the input state
   template <class State_t>
   void run_circuit_helper(const Circuit &circ, const Noise::NoiseModel &noise,
-                          const json_t &config, const Method method, 
+                          const json_t &config, const Method method,
                           ExperimentResult &result) const;
 
   // Execute a single shot a of circuit by initializing the state vector,
@@ -188,12 +186,9 @@ class Controller {
   // running all ops in circ, and updating data with
   // simulation output.
   template <class State_t>
-  void run_with_sampling(const Circuit &circ,
-                         State_t &state,
-                         ExperimentResult &result,
-                         RngEngine &rng,
-                         const uint_t block_bits,
-                         const uint_t shots) const;
+  void run_with_sampling(const Circuit &circ, State_t &state,
+                         ExperimentResult &result, RngEngine &rng,
+                         const uint_t block_bits, const uint_t shots) const;
 
   // Execute multiple shots a of circuit by initializing the state vector,
   // running all ops in circ, and updating data with
@@ -208,8 +203,7 @@ class Controller {
   template <class State_t>
   void run_circuit_with_sampled_noise(const Circuit &circ,
                                       const Noise::NoiseModel &noise,
-                                      const json_t &config,
-                                      const Method method,
+                                      const json_t &config, const Method method,
                                       ExperimentResult &result) const;
 
   //----------------------------------------------------------------
@@ -221,7 +215,7 @@ class Controller {
   template <typename InputIterator, class State_t>
   void measure_sampler(InputIterator first_meas, InputIterator last_meas,
                        uint_t shots, State_t &state, ExperimentResult &result,
-                       RngEngine &rng , int_t shot_index = -1) const;
+                       RngEngine &rng, int_t shot_index = -1) const;
 
   // Check if measure sampling optimization is valid for the input circuit
   // for the given method. This checks if operation types before
@@ -239,11 +233,10 @@ class Controller {
   // If `throw_except` is true an exception will be thrown on the return false
   // case listing the invalid instructions in the circuit or noise model, or
   // the required memory.
-  bool validate_method(Method method,
-                       const Circuit &circ,
+  bool validate_method(Method method, const Circuit &circ,
                        const Noise::NoiseModel &noise,
                        bool throw_except = false) const;
-                            
+
   template <class state_t>
   bool validate_state(const state_t &state, const Circuit &circ,
                       const Noise::NoiseModel &noise,
@@ -257,7 +250,7 @@ class Controller {
   //----------------------------------------------------------------
   // Utility functions
   //----------------------------------------------------------------
-  
+
   // Return a vector of simulation methods for each circuit.
   // If the default method is automatic this will be computed based on the
   // circuit and noise model.
@@ -281,14 +274,13 @@ class Controller {
 
   // Return cache blocking transpiler pass
   Transpile::CacheBlocking
-  transpile_cache_blocking(Controller::Method method,
-                           const Circuit &circ,
+  transpile_cache_blocking(Controller::Method method, const Circuit &circ,
                            const Noise::NoiseModel &noise,
                            const json_t &config) const;
 
-  //return maximum number of qubits for matrix
+  // return maximum number of qubits for matrix
   int_t get_max_matrix_qubits(const Circuit &circ) const;
-  int_t get_matrix_bits(const Operations::Op& op) const;
+  int_t get_matrix_bits(const Operations::Op &op) const;
 
   //-----------------------------------------------------------------------
   // Parallelization Config
@@ -298,10 +290,9 @@ class Controller {
   void clear_parallelization();
 
   // Set parallelization for experiments
-  void
-  set_parallelization_experiments(const std::vector<Circuit> &circuits,
-                                  const Noise::NoiseModel &noise,
-                                  const std::vector<Method> &methods);
+  void set_parallelization_experiments(const std::vector<Circuit> &circuits,
+                                       const Noise::NoiseModel &noise,
+                                       const std::vector<Method> &methods);
 
   // Set circuit parallelization
   void set_parallelization_circuit(const Circuit &circ,
@@ -349,7 +340,8 @@ class Controller {
 
   bool parallel_nested_ = false;
 
-  //max number of states can be stored on memory for batched multi-shots/experiments optimization
+  // max number of states can be stored on memory for batched
+  // multi-shots/experiments optimization
   int max_batched_states_;
 
   // max number of qubits in given circuits
@@ -365,15 +357,18 @@ class Controller {
 
   uint_t cache_block_qubit_ = 0;
 
-  //multi-chunks are required to simulate circuits
+  // multi-chunks are required to simulate circuits
   bool multi_chunk_required_ = false;
 
-  //config setting for multi-shot parallelization
+  // config setting for multi-shot parallelization
   bool batched_shots_gpu_ = true;
-  int_t batched_shots_gpu_max_qubits_ = 16;   //multi-shot parallelization is applied if qubits is less than max qubits
-  bool enable_batch_multi_shots_ = false;   //multi-shot parallelization can be applied
+  int_t batched_shots_gpu_max_qubits_ =
+      16; // multi-shot parallelization is applied if qubits is less than max
+          // qubits
+  bool enable_batch_multi_shots_ =
+      false; // multi-shot parallelization can be applied
 
-  //settings for cuStateVec
+  // settings for cuStateVec
   bool cuStateVec_enable_ = false;
 };
 
@@ -456,17 +451,18 @@ void Controller::set_config(const json_t &config) {
     JSON::get_value(cache_block_qubit_, "blocking_qubits", config);
   }
 
-  //enable batched multi-shots/experiments optimization
-  if(JSON::check_key("batched_shots_gpu", config)) {
+  // enable batched multi-shots/experiments optimization
+  if (JSON::check_key("batched_shots_gpu", config)) {
     JSON::get_value(batched_shots_gpu_, "batched_shots_gpu", config);
   }
-  if(JSON::check_key("batched_shots_gpu_max_qubits", config)) {
-    JSON::get_value(batched_shots_gpu_max_qubits_, "batched_shots_gpu_max_qubits", config);
+  if (JSON::check_key("batched_shots_gpu_max_qubits", config)) {
+    JSON::get_value(batched_shots_gpu_max_qubits_,
+                    "batched_shots_gpu_max_qubits", config);
   }
 
-  //cuStateVec configs
+  // cuStateVec configs
   cuStateVec_enable_ = false;
-  if(JSON::check_key("cuStateVec_enable", config)) {
+  if (JSON::check_key("cuStateVec_enable", config)) {
     JSON::get_value(cuStateVec_enable_, "cuStateVec_enable", config);
   }
 
@@ -493,7 +489,7 @@ void Controller::set_config(const json_t &config) {
     }
   }
 
-  if(method_ == Method::density_matrix || method_ == Method::unitary)
+  if (method_ == Method::density_matrix || method_ == Method::unitary)
     batched_shots_gpu_max_qubits_ /= 2;
 
   // Override automatic simulation method with a fixed method
@@ -514,21 +510,20 @@ void Controller::set_config(const json_t &config) {
 #else
 
 #ifndef AER_CUSTATEVEC
-      if(cuStateVec_enable_){
-        //Aer is not built for cuStateVec
-        throw std::runtime_error(
-            "Simulation device \"GPU\" does not support cuStateVec on this system");
+      if (cuStateVec_enable_) {
+        // Aer is not built for cuStateVec
+        throw std::runtime_error("Simulation device \"GPU\" does not support "
+                                 "cuStateVec on this system");
       }
 #endif
       int nDev;
       if (cudaGetDeviceCount(&nDev) != cudaSuccess) {
-          cudaGetLastError();
-          throw std::runtime_error("No CUDA device available!");
+        cudaGetLastError();
+        throw std::runtime_error("No CUDA device available!");
       }
       sim_device_ = Device::GPU;
 #endif
-    }
-    else {
+    } else {
       throw std::runtime_error(std::string("Invalid simulation device (\"") +
                                sim_device_name_ + std::string("\")."));
     }
@@ -576,40 +571,41 @@ void Controller::clear_parallelization() {
 }
 
 void Controller::set_parallelization_experiments(
-    const std::vector<Circuit> &circuits,
-    const Noise::NoiseModel &noise,
-    const std::vector<Method> &methods) 
-{
+    const std::vector<Circuit> &circuits, const Noise::NoiseModel &noise,
+    const std::vector<Method> &methods) {
   std::vector<size_t> required_memory_mb_list(circuits.size());
   max_qubits_ = 0;
   for (size_t j = 0; j < circuits.size(); j++) {
-    if(circuits[j].num_qubits > max_qubits_)
+    if (circuits[j].num_qubits > max_qubits_)
       max_qubits_ = circuits[j].num_qubits;
-    required_memory_mb_list[j] = required_memory_mb(circuits[j], noise, methods[j]);
+    required_memory_mb_list[j] =
+        required_memory_mb(circuits[j], noise, methods[j]);
   }
   std::sort(required_memory_mb_list.begin(), required_memory_mb_list.end(),
             std::greater<>());
 
-  //set max batchable number of circuits
-  if(batched_shots_gpu_){
-    if(required_memory_mb_list[0] == 0 || max_qubits_ == 0)
+  // set max batchable number of circuits
+  if (batched_shots_gpu_) {
+    if (required_memory_mb_list[0] == 0 || max_qubits_ == 0)
       max_batched_states_ = 1;
-    else{
-      if(sim_device_ == Device::GPU){
-        max_batched_states_ = ((max_gpu_memory_mb_/num_gpus_*8/10) / required_memory_mb_list[0])*num_gpus_;
-      }
-      else{
-        max_batched_states_ = (max_memory_mb_*8/10) / required_memory_mb_list[0];
+    else {
+      if (sim_device_ == Device::GPU) {
+        max_batched_states_ = ((max_gpu_memory_mb_ / num_gpus_ * 8 / 10) /
+                               required_memory_mb_list[0]) *
+                              num_gpus_;
+      } else {
+        max_batched_states_ =
+            (max_memory_mb_ * 8 / 10) / required_memory_mb_list[0];
       }
     }
   }
-  if(max_qubits_ == 0)
+  if (max_qubits_ == 0)
     max_qubits_ = 1;
 
-  if(explicit_parallelization_ )
+  if (explicit_parallelization_)
     return;
 
-  if(circuits.size() == 1){
+  if (circuits.size() == 1) {
     parallel_experiments_ = 1;
     return;
   }
@@ -647,54 +643,55 @@ void Controller::set_parallelization_experiments(
 
 void Controller::set_parallelization_circuit(const Circuit &circ,
                                              const Noise::NoiseModel &noise,
-                                             const Method method)  
-{
+                                             const Method method) {
   enable_batch_multi_shots_ = false;
-  if(batched_shots_gpu_ && sim_device_ == Device::GPU && 
-     circ.shots > 1 && max_batched_states_ >= num_gpus_ && 
-     batched_shots_gpu_max_qubits_ >= circ.num_qubits ){
-      enable_batch_multi_shots_ = true;
+  if (batched_shots_gpu_ && sim_device_ == Device::GPU && circ.shots > 1 &&
+      max_batched_states_ >= num_gpus_ &&
+      batched_shots_gpu_max_qubits_ >= circ.num_qubits) {
+    enable_batch_multi_shots_ = true;
   }
 
-  if(sim_device_ == Device::GPU && cuStateVec_enable_){
-    enable_batch_multi_shots_ = false;    //cuStateVec does not support batch execution of multi-shots
+  if (sim_device_ == Device::GPU && cuStateVec_enable_) {
+    enable_batch_multi_shots_ =
+        false; // cuStateVec does not support batch execution of multi-shots
     return;
   }
 
-  if(explicit_parallelization_)
+  if (explicit_parallelization_)
     return;
 
   // Check for trivial parallelization conditions
   switch (method) {
-    case Method::statevector:
-    case Method::stabilizer:
-    case Method::unitary:
-    case Method::matrix_product_state: {
-      if (circ.shots == 1 || num_process_per_experiment_ > 1 ||
-          (!noise.has_quantum_errors() &&
-          check_measure_sampling_opt(circ, method))) {
-        parallel_shots_ = 1;
-        parallel_state_update_ =
-            std::max<int>({1, max_parallel_threads_ / parallel_experiments_});
-        return;
-      }
-      break;
+  case Method::statevector:
+  case Method::stabilizer:
+  case Method::unitary:
+  case Method::matrix_product_state: {
+    if (circ.shots == 1 || num_process_per_experiment_ > 1 ||
+        (!noise.has_quantum_errors() &&
+         check_measure_sampling_opt(circ, method))) {
+      parallel_shots_ = 1;
+      parallel_state_update_ =
+          std::max<int>({1, max_parallel_threads_ / parallel_experiments_});
+      return;
     }
-    case Method::density_matrix:
-    case Method::superop: {
-      if (circ.shots == 1 || num_process_per_experiment_ > 1 ||
-          check_measure_sampling_opt(circ, method)) {
-        parallel_shots_ = 1;
-        parallel_state_update_ =
-            std::max<int>({1, max_parallel_threads_ / parallel_experiments_});
-        return;
-      }
-      break;
+    break;
+  }
+  case Method::density_matrix:
+  case Method::superop: {
+    if (circ.shots == 1 || num_process_per_experiment_ > 1 ||
+        check_measure_sampling_opt(circ, method)) {
+      parallel_shots_ = 1;
+      parallel_state_update_ =
+          std::max<int>({1, max_parallel_threads_ / parallel_experiments_});
+      return;
     }
-    case Method::extended_stabilizer:
-      break;
-    default:
-      throw std::invalid_argument("Cannot set parallelization for unresolved method.");
+    break;
+  }
+  case Method::extended_stabilizer:
+    break;
+  default:
+    throw std::invalid_argument(
+        "Cannot set parallelization for unresolved method.");
   }
 
   // Use a local variable to not override stored maximum based
@@ -714,7 +711,8 @@ void Controller::set_parallelization_circuit(const Circuit &circ,
     // And assign the remaining threads to state update
     int circ_memory_mb =
         required_memory_mb(circ, noise, method) / num_process_per_experiment_;
-    size_t mem_size = (sim_device_ == Device::GPU) ? max_gpu_memory_mb_ : max_memory_mb_;
+    size_t mem_size =
+        (sim_device_ == Device::GPU) ? max_gpu_memory_mb_ : max_memory_mb_;
     if (mem_size < circ_memory_mb)
       throw std::runtime_error(
           "a circuit requires more memory than max_memory_mb.");
@@ -723,7 +721,7 @@ void Controller::set_parallelization_circuit(const Circuit &circ,
 
     int shots = circ.shots;
     parallel_shots_ = std::min<int>(
-        {static_cast<int>(mem_size/(circ_memory_mb*2)), max_shots, shots});
+        {static_cast<int>(mem_size / (circ_memory_mb * 2)), max_shots, shots});
   }
   parallel_state_update_ =
       (parallel_shots_ > 1)
@@ -733,21 +731,23 @@ void Controller::set_parallelization_circuit(const Circuit &circ,
 
 bool Controller::multiple_chunk_required(const Circuit &circ,
                                          const Noise::NoiseModel &noise,
-                                         const Method method) const 
-{
+                                         const Method method) const {
   if (circ.num_qubits < 3)
     return false;
   if (cache_block_qubit_ >= 2 && cache_block_qubit_ < circ.num_qubits)
     return true;
 
-  if(num_process_per_experiment_ == 1 && sim_device_ == Device::GPU && num_gpus_ > 0){
-    return (max_gpu_memory_mb_ / num_gpus_ < required_memory_mb(circ, noise, method));
+  if (num_process_per_experiment_ == 1 && sim_device_ == Device::GPU &&
+      num_gpus_ > 0) {
+    return (max_gpu_memory_mb_ / num_gpus_ <
+            required_memory_mb(circ, noise, method));
   }
-  if(num_process_per_experiment_ > 1){
+  if (num_process_per_experiment_ > 1) {
     size_t total_mem = max_memory_mb_;
-    if(sim_device_ == Device::GPU)
+    if (sim_device_ == Device::GPU)
       total_mem += max_gpu_memory_mb_;
-    if(total_mem*num_process_per_experiment_ > required_memory_mb(circ, noise, method))
+    if (total_mem * num_process_per_experiment_ >
+        required_memory_mb(circ, noise, method))
       return true;
   }
 
@@ -756,27 +756,24 @@ bool Controller::multiple_chunk_required(const Circuit &circ,
 
 bool Controller::multiple_shots_required(const Circuit &circ,
                                          const Noise::NoiseModel &noise,
-                                         const Method method) const 
-{
+                                         const Method method) const {
   if (circ.shots < 2)
     return false;
-  if (method == Method::density_matrix ||
-      method == Method::superop ||
+  if (method == Method::density_matrix || method == Method::superop ||
       method == Method::unitary) {
     return false;
   }
 
   bool can_sample = check_measure_sampling_opt(circ, method);
 
-  if (noise.is_ideal()){
-   return !can_sample;
+  if (noise.is_ideal()) {
+    return !can_sample;
   }
 
   return true;
 }
 
-size_t Controller::get_system_memory_mb() 
-{
+size_t Controller::get_system_memory_mb() {
   size_t total_physical_memory = Utils::get_system_memory_mb();
 #ifdef AER_MPI
   // get minimum memory size per process
@@ -820,19 +817,16 @@ size_t Controller::get_gpu_memory_mb() {
   return total_physical_memory >> 20;
 }
 
-
-Transpile::CacheBlocking
-Controller::transpile_cache_blocking(Controller::Method method, const Circuit &circ,
-                                     const Noise::NoiseModel &noise,
-                                     const json_t &config) const 
-{
+Transpile::CacheBlocking Controller::transpile_cache_blocking(
+    Controller::Method method, const Circuit &circ,
+    const Noise::NoiseModel &noise, const json_t &config) const {
   Transpile::CacheBlocking cache_block_pass;
 
-  const bool is_matrix = (method == Method::density_matrix
-                          || method == Method::unitary);
+  const bool is_matrix =
+      (method == Method::density_matrix || method == Method::unitary);
   const auto complex_size = (sim_precision_ == Precision::Single)
-                              ? sizeof(std::complex<float>)
-                              : sizeof(std::complex<double>);
+                                ? sizeof(std::complex<float>)
+                                : sizeof(std::complex<double>);
 
   cache_block_pass.set_num_processes(num_process_per_experiment_);
   cache_block_pass.set_config(config);
@@ -841,7 +835,7 @@ Controller::transpile_cache_blocking(Controller::Method method, const Circuit &c
     // if blocking is not set by config, automatically set if required
     if (multiple_chunk_required(circ, noise, method)) {
       int nplace = num_process_per_experiment_;
-      if(sim_device_ == Device::GPU && num_gpus_ > 0)
+      if (sim_device_ == Device::GPU && num_gpus_ > 0)
         nplace *= num_gpus_;
       cache_block_pass.set_blocking(circ.num_qubits, get_min_memory_mb() << 20,
                                     nplace, complex_size, is_matrix);
@@ -907,8 +901,7 @@ Result Controller::execute(const inputdata_t &input_qobj) {
 
 Result Controller::execute(std::vector<Circuit> &circuits,
                            Noise::NoiseModel &noise_model,
-                           const json_t &config) 
-{
+                           const json_t &config) {
   // Start QOBJ timer
   auto timer_start = myclock_t::now();
 
@@ -921,15 +914,15 @@ Result Controller::execute(std::vector<Circuit> &circuits,
 
   // Execute each circuit in a try block
   try {
-    //check if multi-chunk distribution is required
+    // check if multi-chunk distribution is required
     bool multi_chunk_required_ = false;
-    for (size_t j = 0; j < circuits.size(); j++){
-      if(circuits[j].num_qubits > 0){
-        if(multiple_chunk_required(circuits[j], noise_model, methods[j]))
+    for (size_t j = 0; j < circuits.size(); j++) {
+      if (circuits[j].num_qubits > 0) {
+        if (multiple_chunk_required(circuits[j], noise_model, methods[j]))
           multi_chunk_required_ = true;
       }
     }
-    if(multi_chunk_required_)
+    if (multi_chunk_required_)
       num_process_per_experiment_ = num_processes_;
     else
       num_process_per_experiment_ = 1;
@@ -954,7 +947,8 @@ Result Controller::execute(std::vector<Circuit> &circuits,
 
     // store rank and number of processes, if no distribution rank=0 procs=1 is
     // set
-    result.metadata.add(num_process_per_experiment_, "num_processes_per_experiments");
+    result.metadata.add(num_process_per_experiment_,
+                        "num_processes_per_experiments");
     result.metadata.add(num_processes_, "num_mpi_processes");
     result.metadata.add(myrank_, "mpi_rank");
 
@@ -965,7 +959,7 @@ Result Controller::execute(std::vector<Circuit> &circuits,
       // Nested parallel experiments
       parallel_nested_ = true;
 
-      //nested should be set to zero if num_threads clause will be used
+      // nested should be set to zero if num_threads clause will be used
       omp_set_nested(0);
 
       result.metadata.add(parallel_nested_, "omp_nested");
@@ -975,33 +969,35 @@ Result Controller::execute(std::vector<Circuit> &circuits,
 #endif
 
 #ifdef AER_MPI
-    //average random seed to set the same seed to each process (when seed_simulator is not set)
-    if(num_processes_ > 1){
+    // average random seed to set the same seed to each process (when
+    // seed_simulator is not set)
+    if (num_processes_ > 1) {
       reg_t seeds(circuits.size());
       reg_t avg_seeds(circuits.size());
-      for(int_t i=0;i<circuits.size();i++)
+      for (int_t i = 0; i < circuits.size(); i++)
         seeds[i] = circuits[i].seed;
-      MPI_Allreduce(seeds.data(), avg_seeds.data(), circuits.size(), MPI_UINT64_T, MPI_SUM, MPI_COMM_WORLD);
-      for(int_t i=0;i<circuits.size();i++)
-        circuits[i].seed = avg_seeds[i]/num_processes_;
+      MPI_Allreduce(seeds.data(), avg_seeds.data(), circuits.size(),
+                    MPI_UINT64_T, MPI_SUM, MPI_COMM_WORLD);
+      for (int_t i = 0; i < circuits.size(); i++)
+        circuits[i].seed = avg_seeds[i] / num_processes_;
     }
 #endif
 
     const int NUM_RESULTS = result.results.size();
-    //following looks very similar but we have to separate them to avoid omp nested loops that causes performance degradation
-    //(DO NOT use if statement in #pragma omp)
+    // following looks very similar but we have to separate them to avoid omp
+    // nested loops that causes performance degradation (DO NOT use if statement
+    // in #pragma omp)
     if (parallel_experiments_ == 1) {
       for (int j = 0; j < NUM_RESULTS; ++j) {
         set_parallelization_circuit(circuits[j], noise_model, methods[j]);
-        run_circuit(circuits[j], noise_model,methods[j],
-                    config, result.results[j]);
+        run_circuit(circuits[j], noise_model, methods[j], config,
+                    result.results[j]);
       }
-    }
-    else{
+    } else {
 #pragma omp parallel for num_threads(parallel_experiments_)
       for (int j = 0; j < NUM_RESULTS; ++j) {
-        run_circuit(circuits[j], noise_model,methods[j],
-                    config, result.results[j]);
+        run_circuit(circuits[j], noise_model, methods[j], config,
+                    result.results[j]);
       }
     }
 
@@ -1041,9 +1037,10 @@ Result Controller::execute(std::vector<Circuit> &circuits,
 //-------------------------------------------------------------------------
 // Base class override
 //-------------------------------------------------------------------------
-void Controller::run_circuit(const Circuit &circ, const Noise::NoiseModel &noise,
-                 const Method method,const json_t &config, ExperimentResult &result) const
-{
+void Controller::run_circuit(const Circuit &circ,
+                             const Noise::NoiseModel &noise,
+                             const Method method, const json_t &config,
+                             ExperimentResult &result) const {
   // Run the circuit
   switch (method) {
   case Method::statevector: {
@@ -1051,13 +1048,11 @@ void Controller::run_circuit(const Circuit &circ, const Noise::NoiseModel &noise
       // Chunk based simualtion
       if (sim_precision_ == Precision::Double) {
         // Double-precision Statevector simulation
-        return run_circuit_helper<
-            Statevector::State<QV::QubitVector<double>>>(
+        return run_circuit_helper<Statevector::State<QV::QubitVector<double>>>(
             circ, noise, config, Method::statevector, result);
       } else {
         // Single-precision Statevector simulation
-        return run_circuit_helper<
-            Statevector::State<QV::QubitVector<float>>>(
+        return run_circuit_helper<Statevector::State<QV::QubitVector<float>>>(
             circ, noise, config, Method::statevector, result);
       }
     } else {
@@ -1149,8 +1144,8 @@ void Controller::run_circuit(const Circuit &circ, const Noise::NoiseModel &noise
   case Method::stabilizer:
     // Stabilizer simulation
     // TODO: Stabilizer doesn't yet support custom state initialization
-    return run_circuit_helper<Stabilizer::State>(
-        circ, noise, config, Method::stabilizer, result);
+    return run_circuit_helper<Stabilizer::State>(circ, noise, config,
+                                                 Method::stabilizer, result);
   case Method::extended_stabilizer:
     return run_circuit_helper<ExtendedStabilizer::State>(
         circ, noise, config, Method::extended_stabilizer, result);
@@ -1246,7 +1241,7 @@ Transpile::Fusion Controller::transpile_fusion(Method method,
   }
   case Method::matrix_product_state: {
     fusion_pass.active = false;
-    return fusion_pass;  // Do not allow the config to set active for MPS
+    return fusion_pass; // Do not allow the config to set active for MPS
   }
   case Method::statevector: {
     if (fusion_pass.allow_kraus) {
@@ -1277,10 +1272,8 @@ Transpile::Fusion Controller::transpile_fusion(Method method,
 template <class State_t>
 void Controller::run_circuit_helper(const Circuit &circ,
                                     const Noise::NoiseModel &noise,
-                                    const json_t &config,
-                                    const Method method,
-                                    ExperimentResult &result) const
-{
+                                    const json_t &config, const Method method,
+                                    ExperimentResult &result) const {
   // Start individual circuit timer
   auto timer_start = myclock_t::now(); // state circuit timer
 
@@ -1316,7 +1309,7 @@ void Controller::run_circuit_helper(const Circuit &circ,
     result.metadata.add(false, "measure_sampling");
     result.metadata.add(false, "batched_shots_optimization");
 
-    if(circ.num_qubits > 0){  //do nothing for query steps
+    if (circ.num_qubits > 0) { // do nothing for query steps
       // Choose execution method based on noise and method
       Circuit opt_circ;
       bool noise_sampling = false;
@@ -1334,33 +1327,36 @@ void Controller::run_circuit_helper(const Circuit &circ,
       // Superop noise sampling
       else if (method == Method::density_matrix || method == Method::superop) {
         // Sample noise using SuperOp method
-        opt_circ = noise.sample_noise(circ, rng, Noise::NoiseModel::Method::superop);
+        opt_circ =
+            noise.sample_noise(circ, rng, Noise::NoiseModel::Method::superop);
         result.metadata.add("superop", "noise");
       }
       // Kraus noise sampling
       else if (noise.opset().contains(Operations::OpType::kraus) ||
                noise.opset().contains(Operations::OpType::superop)) {
-        opt_circ = noise.sample_noise(circ, rng, Noise::NoiseModel::Method::kraus);
+        opt_circ =
+            noise.sample_noise(circ, rng, Noise::NoiseModel::Method::kraus);
         result.metadata.add("kraus", "noise");
       }
       // General circuit noise sampling
       else {
-        if(enable_batch_multi_shots_ && !multi_chunk_required_){
-          //batched optimization samples noise at runtime
-          opt_circ = noise.sample_noise(circ, rng, Noise::NoiseModel::Method::circuit, true);
-        }
-        else{
+        if (enable_batch_multi_shots_ && !multi_chunk_required_) {
+          // batched optimization samples noise at runtime
+          opt_circ = noise.sample_noise(
+              circ, rng, Noise::NoiseModel::Method::circuit, true);
+        } else {
           noise_sampling = true;
         }
         result.metadata.add("circuit", "noise");
       }
 
-      if(noise_sampling){
-        run_circuit_with_sampled_noise<State_t>(circ, noise, config, method, result);
-      }
-      else{
+      if (noise_sampling) {
+        run_circuit_with_sampled_noise<State_t>(circ, noise, config, method,
+                                                result);
+      } else {
         // Run multishot simulation without noise sampling
-        run_circuit_without_sampled_noise<State_t>(opt_circ, noise, config, method, result);
+        run_circuit_without_sampled_noise<State_t>(opt_circ, noise, config,
+                                                   method, result);
       }
     }
 
@@ -1398,13 +1394,11 @@ void Controller::run_single_shot(const Circuit &circ, State_t &state,
 }
 
 template <class State_t>
-void Controller::run_with_sampling(const Circuit &circ,
-                                   State_t &state,
-                                   ExperimentResult &result,
-                                   RngEngine &rng,
+void Controller::run_with_sampling(const Circuit &circ, State_t &state,
+                                   ExperimentResult &result, RngEngine &rng,
                                    const uint_t block_bits,
                                    const uint_t shots) const {
-  auto& ops = circ.ops;
+  auto &ops = circ.ops;
   auto first_meas = circ.first_measure_pos; // Position of first measurement op
   bool final_ops = (first_meas == ops.size());
 
@@ -1415,22 +1409,22 @@ void Controller::run_with_sampling(const Circuit &circ,
   state.initialize_qreg(circ.num_qubits);
   state.initialize_creg(circ.num_memory, circ.num_registers);
 
-  state.apply_ops(ops.cbegin(), ops.cbegin() + first_meas, result, rng, final_ops);
+  state.apply_ops(ops.cbegin(), ops.cbegin() + first_meas, result, rng,
+                  final_ops);
 
   // Get measurement operations and set of measured qubits
-  measure_sampler(circ.ops.begin() + first_meas, circ.ops.end(), shots, state, result, rng);
+  measure_sampler(circ.ops.begin() + first_meas, circ.ops.end(), shots, state,
+                  result, rng);
 }
 
 template <class State_t>
-void Controller::run_circuit_without_sampled_noise(Circuit &circ,
-                                                   const Noise::NoiseModel &noise,
-                                                   const json_t &config,
-                                                   const Method method,
-                                                   ExperimentResult &result) const 
-{
+void Controller::run_circuit_without_sampled_noise(
+    Circuit &circ, const Noise::NoiseModel &noise, const json_t &config,
+    const Method method, ExperimentResult &result) const {
   State_t state;
 
-  // Validate gateset and memory requirements, raise exception if they're exceeded
+  // Validate gateset and memory requirements, raise exception if they're
+  // exceeded
   validate_state(state, circ, noise, true);
 
   // Set state config
@@ -1448,8 +1442,9 @@ void Controller::run_circuit_without_sampled_noise(Circuit &circ,
 
   // Cache blocking pass
   uint_t block_bits = circ.num_qubits;
-  if(state.multi_chunk_distribution_supported()){
-    auto cache_block_pass = transpile_cache_blocking(method, circ, dummy_noise, config);
+  if (state.multi_chunk_distribution_supported()) {
+    auto cache_block_pass =
+        transpile_cache_blocking(method, circ, dummy_noise, config);
     cache_block_pass.set_sample_measure(can_sample);
     cache_block_pass.optimize_circuit(circ, dummy_noise, state.opset(), result);
     if (cache_block_pass.enabled()) {
@@ -1475,8 +1470,8 @@ void Controller::run_circuit_without_sampled_noise(Circuit &circ,
 
 #pragma omp parallel for num_threads(parallel_shots_)
       for (int i = 0; i < parallel_shots_; i++) {
-        uint_t i_shot = circ.shots*i/parallel_shots_;
-        uint_t shot_end = circ.shots*(i+1)/parallel_shots_;
+        uint_t i_shot = circ.shots * i / parallel_shots_;
+        uint_t shot_end = circ.shots * (i + 1) / parallel_shots_;
         uint_t this_shot = shot_end - i_shot;
 
         State_t shot_state;
@@ -1490,7 +1485,8 @@ void Controller::run_circuit_without_sampled_noise(Circuit &circ,
         RngEngine rng;
         rng.set_seed(circ.seed + i);
 
-        run_with_sampling(circ, shot_state, par_results[i], rng, block_bits, this_shot);
+        run_with_sampling(circ, shot_state, par_results[i], rng, block_bits,
+                          this_shot);
 
         shot_state.add_metadata(par_results[i]);
       }
@@ -1498,8 +1494,8 @@ void Controller::run_circuit_without_sampled_noise(Circuit &circ,
         result.combine(std::move(res));
       }
 
-      if (sim_device_name_ == "GPU"){
-        if(parallel_shots_ >= num_gpus_)
+      if (sim_device_name_ == "GPU") {
+        if (parallel_shots_ >= num_gpus_)
           result.metadata.add(num_gpus_, "gpu_parallel_shots_");
         else
           result.metadata.add(parallel_shots_, "gpu_parallel_shots_");
@@ -1508,65 +1504,69 @@ void Controller::run_circuit_without_sampled_noise(Circuit &circ,
     // Add measure sampling metadata
     result.metadata.add(true, "measure_sampling");
 
-  }
-  else{
+  } else {
     // Perform standard execution if we cannot apply the
     // measurement sampling optimization
 
-    if(block_bits == circ.num_qubits && enable_batch_multi_shots_ && state.multi_shot_parallelization_supported()){
-      //apply batched multi-shots optimization (currenly only on GPU)
+    if (block_bits == circ.num_qubits && enable_batch_multi_shots_ &&
+        state.multi_shot_parallelization_supported()) {
+      // apply batched multi-shots optimization (currenly only on GPU)
       state.set_max_bached_shots(max_batched_states_);
       state.set_distribution(num_processes_);
       state.set_max_matrix_qubits(max_bits);
-      state.allocate(circ.num_qubits, circ.num_qubits, circ.shots);    //allocate multiple-shots
+      state.allocate(circ.num_qubits, circ.num_qubits,
+                     circ.shots); // allocate multiple-shots
 
-      //qreg is initialized inside state class
+      // qreg is initialized inside state class
       state.initialize_creg(circ.num_memory, circ.num_registers);
 
-      state.apply_ops_multi_shots(circ.ops.cbegin(), circ.ops.cend(), noise, result, circ.seed, true);
+      state.apply_ops_multi_shots(circ.ops.cbegin(), circ.ops.cend(), noise,
+                                  result, circ.seed, true);
 
       result.save_count_data(state.cregs(), save_creg_memory_);
 
       // Add batched multi-shots optimizaiton metadata
       result.metadata.add(true, "batched_shots_optimization");
-    }
-    else{
+    } else {
       std::vector<ExperimentResult> par_results(parallel_shots_);
       int_t par_shots = parallel_shots_;
-      if(block_bits != circ.num_qubits)
+      if (block_bits != circ.num_qubits)
         par_shots = 1;
 
-      auto run_circuit_without_sampled_noise_lambda = [this,&par_results,circ,noise,config,method,block_bits,max_bits,par_shots](int_t i){
-        uint_t i_shot,shot_end;
-        i_shot = circ.shots*i/par_shots;
-        shot_end = circ.shots*(i+1)/par_shots;
-
-        State_t par_state;
-        // Set state config
-        par_state.set_config(config);
-        par_state.set_parallelization(parallel_state_update_);
-        par_state.set_global_phase(circ.global_phase_angle);
-
-        par_state.set_distribution(num_process_per_experiment_);
-        par_state.set_max_matrix_qubits(max_bits );
-
-        // allocate qubit register
-        par_state.allocate(circ.num_qubits, block_bits);
-
-        for(;i_shot<shot_end;i_shot++){
-          RngEngine rng;
-          rng.set_seed(circ.seed + i_shot);
-          run_single_shot(circ, par_state, par_results[i], rng);
-        }
-        par_state.add_metadata(par_results[i]);
-      };
-      Utils::apply_omp_parallel_for((par_shots > 1),0,par_shots,run_circuit_without_sampled_noise_lambda);
+      auto run_circuit_without_sampled_noise_lambda =
+          [this, &par_results, circ, noise, config, method, block_bits,
+           max_bits, par_shots](int_t i) {
+            uint_t i_shot, shot_end;
+            i_shot = circ.shots * i / par_shots;
+            shot_end = circ.shots * (i + 1) / par_shots;
+
+            State_t par_state;
+            // Set state config
+            par_state.set_config(config);
+            par_state.set_parallelization(parallel_state_update_);
+            par_state.set_global_phase(circ.global_phase_angle);
+
+            par_state.set_distribution(num_process_per_experiment_);
+            par_state.set_max_matrix_qubits(max_bits);
+
+            // allocate qubit register
+            par_state.allocate(circ.num_qubits, block_bits);
+
+            for (; i_shot < shot_end; i_shot++) {
+              RngEngine rng;
+              rng.set_seed(circ.seed + i_shot);
+              run_single_shot(circ, par_state, par_results[i], rng);
+            }
+            par_state.add_metadata(par_results[i]);
+          };
+      Utils::apply_omp_parallel_for((par_shots > 1), 0, par_shots,
+                                    run_circuit_without_sampled_noise_lambda);
 
       for (auto &res : par_results) {
         result.combine(std::move(res));
       }
-      if (sim_device_name_ == "GPU"){
-        if(par_shots >= num_gpus_)
+      if (sim_device_name_ == "GPU") {
+        if (par_shots >= num_gpus_)
           result.metadata.add(num_gpus_, "gpu_parallel_shots_");
         else
           result.metadata.add(par_shots, "gpu_parallel_shots_");
@@ -1579,16 +1579,17 @@ void Controller::run_circuit_without_sampled_noise(Circuit &circ,
 template <class State_t>
 void Controller::run_circuit_with_sampled_noise(
     const Circuit &circ, const Noise::NoiseModel &noise, const json_t &config,
-    const Method method, ExperimentResult &result) const 
-{
+    const Method method, ExperimentResult &result) const {
   std::vector<ExperimentResult> par_results(parallel_shots_);
 
-  auto run_circuit_with_sampled_noise_lambda = [this,&par_results,circ,noise,config,method](int_t i){
+  auto run_circuit_with_sampled_noise_lambda = [this, &par_results, circ, noise,
+                                                config, method](int_t i) {
     State_t state;
-    uint_t i_shot,shot_end;
+    uint_t i_shot, shot_end;
     Noise::NoiseModel dummy_noise;
 
-    // Validate gateset and memory requirements, raise exception if they're exceeded
+    // Validate gateset and memory requirements, raise exception if they're
+    // exceeded
     validate_state(state, circ, noise, true);
 
     // Set state config
@@ -1598,12 +1599,13 @@ void Controller::run_circuit_with_sampled_noise(
 
     // Transpilation for circuit noise method
     auto fusion_pass = transpile_fusion(method, circ.opset(), config);
-    auto cache_block_pass = transpile_cache_blocking(method, circ, noise, config);
+    auto cache_block_pass =
+        transpile_cache_blocking(method, circ, noise, config);
 
-    i_shot = circ.shots*i/parallel_shots_;
-    shot_end = circ.shots*(i+1)/parallel_shots_;
+    i_shot = circ.shots * i / parallel_shots_;
+    shot_end = circ.shots * (i + 1) / parallel_shots_;
 
-    for(;i_shot<shot_end;i_shot++){
+    for (; i_shot < shot_end; i_shot++) {
       RngEngine rng;
       rng.set_seed(circ.seed + i_shot);
 
@@ -1614,16 +1616,16 @@ void Controller::run_circuit_with_sampled_noise(
       fusion_pass.optimize_circuit(noise_circ, dummy_noise, state.opset(),
                                    par_results[i]);
       uint_t block_bits = circ.num_qubits;
-      if(state.multi_chunk_distribution_supported()){
-        cache_block_pass.optimize_circuit(noise_circ, dummy_noise, state.opset(),
-                                          par_results[i]);
-       if (cache_block_pass.enabled()) {
-         block_bits = cache_block_pass.block_bits();
+      if (state.multi_chunk_distribution_supported()) {
+        cache_block_pass.optimize_circuit(noise_circ, dummy_noise,
+                                          state.opset(), par_results[i]);
+        if (cache_block_pass.enabled()) {
+          block_bits = cache_block_pass.block_bits();
         }
       }
 
       state.set_distribution(num_process_per_experiment_);
-      state.set_max_matrix_qubits(get_max_matrix_qubits(circ) );
+      state.set_max_matrix_qubits(get_max_matrix_qubits(circ));
       // allocate qubit register
       state.allocate(noise_circ.num_qubits, block_bits);
 
@@ -1631,14 +1633,15 @@ void Controller::run_circuit_with_sampled_noise(
     }
     state.add_metadata(par_results[i]);
   };
-  Utils::apply_omp_parallel_for((parallel_shots_ > 1),0,parallel_shots_,run_circuit_with_sampled_noise_lambda);
+  Utils::apply_omp_parallel_for((parallel_shots_ > 1), 0, parallel_shots_,
+                                run_circuit_with_sampled_noise_lambda);
 
   for (auto &res : par_results) {
     result.combine(std::move(res));
   }
 
-  if (sim_device_name_ == "GPU"){
-    if(parallel_shots_ >= num_gpus_)
+  if (sim_device_name_ == "GPU") {
+    if (parallel_shots_ >= num_gpus_)
       result.metadata.add(num_gpus_, "gpu_parallel_shots_");
     else
       result.metadata.add(parallel_shots_, "gpu_parallel_shots_");
@@ -1658,12 +1661,11 @@ bool Controller::check_measure_sampling_opt(const Circuit &circ,
 
   // If density matrix, unitary, superop method all supported instructions
   // allow sampling
-  if (method == Method::density_matrix ||
-      method == Method::superop ||
+  if (method == Method::density_matrix || method == Method::superop ||
       method == Method::unitary) {
     return true;
   }
-  
+
   // If circuit contains a non-initial initialize that is not a full width
   // instruction we can't sample
   if (circ.can_sample_initialize == false) {
@@ -1679,7 +1681,7 @@ bool Controller::check_measure_sampling_opt(const Circuit &circ,
       circ.opset().contains(Operations::OpType::kraus) ||
       circ.opset().contains(Operations::OpType::superop) ||
       circ.opset().contains(Operations::OpType::jump) ||
-      circ.opset().contains(Operations::OpType::mark )) {
+      circ.opset().contains(Operations::OpType::mark)) {
     return false;
   }
   // Otherwise true
@@ -1687,10 +1689,10 @@ bool Controller::check_measure_sampling_opt(const Circuit &circ,
 }
 
 template <typename InputIterator, class State_t>
-void Controller::measure_sampler(
-    InputIterator first_meas, InputIterator last_meas, uint_t shots,
-    State_t &state, ExperimentResult &result, RngEngine &rng, int_t shot_index) const 
-{
+void Controller::measure_sampler(InputIterator first_meas,
+                                 InputIterator last_meas, uint_t shots,
+                                 State_t &state, ExperimentResult &result,
+                                 RngEngine &rng, int_t shot_index) const {
   // Check if meas_circ is empty, and if so return initial creg
   if (first_meas == last_meas) {
     while (shots-- > 0) {
@@ -1721,7 +1723,7 @@ void Controller::measure_sampler(
 
   // Generate the samples
   uint_t shots_or_index;
-  if(shot_index < 0)
+  if (shot_index < 0)
     shots_or_index = shots;
   else
     shots_or_index = shot_index;
@@ -1752,8 +1754,10 @@ void Controller::measure_sampler(
   }
 
   // Process samples
-  uint_t num_memory = (memory_map.empty()) ? 0ULL : 1 + memory_map.rbegin()->first;
-  uint_t num_registers = (register_map.empty()) ? 0ULL : 1 + register_map.rbegin()->first;
+  uint_t num_memory =
+      (memory_map.empty()) ? 0ULL : 1 + memory_map.rbegin()->first;
+  uint_t num_registers =
+      (register_map.empty()) ? 0ULL : 1 + register_map.rbegin()->first;
   ClassicalRegister creg;
   while (!all_samples.empty()) {
     auto sample = all_samples.back();
@@ -1776,14 +1780,13 @@ void Controller::measure_sampler(
     }
 
     // Save count data
-      result.save_count_data(creg, save_creg_memory_);
+    result.save_count_data(creg, save_creg_memory_);
 
     // pop off processed sample
     all_samples.pop_back();
   }
 }
 
-
 //-------------------------------------------------------------------------
 // Validation
 //-------------------------------------------------------------------------
@@ -1792,22 +1795,25 @@ std::vector<Controller::Method>
 Controller::simulation_methods(std::vector<Circuit> &circuits,
                                Noise::NoiseModel &noise_model) const {
   // Does noise model contain kraus noise
-  bool kraus_noise = (noise_model.opset().contains(Operations::OpType::kraus) ||
-                      noise_model.opset().contains(Operations::OpType::superop));
+  bool kraus_noise =
+      (noise_model.opset().contains(Operations::OpType::kraus) ||
+       noise_model.opset().contains(Operations::OpType::superop));
 
   if (method_ == Method::automatic) {
     // Determine simulation methods for each circuit and noise model
     std::vector<Method> sim_methods;
     bool superop_enabled = false;
     bool kraus_enabled = false;
-    for (const auto& circ: circuits) {
+    for (const auto &circ : circuits) {
       auto method = automatic_simulation_method(circ, noise_model);
       sim_methods.push_back(method);
-      if (!superop_enabled && (method == Method::density_matrix || method == Method::superop)) {
+      if (!superop_enabled &&
+          (method == Method::density_matrix || method == Method::superop)) {
         noise_model.enable_superop_method(max_parallel_threads_);
         superop_enabled = true;
       } else if (kraus_noise && !kraus_enabled &&
-                 (method == Method::statevector || method == Method::matrix_product_state)) {
+                 (method == Method::statevector ||
+                  method == Method::matrix_product_state)) {
         noise_model.enable_kraus_method(max_parallel_threads_);
         kraus_enabled = true;
       }
@@ -1819,17 +1825,15 @@ Controller::simulation_methods(std::vector<Circuit> &circuits,
   std::vector<Method> sim_methods(circuits.size(), method_);
   if (method_ == Method::density_matrix || method_ == Method::superop) {
     noise_model.enable_superop_method(max_parallel_threads_);
-  } else if (kraus_noise && (
-              method_ == Method::statevector
-              || method_ == Method::matrix_product_state)) {
+  } else if (kraus_noise && (method_ == Method::statevector ||
+                             method_ == Method::matrix_product_state)) {
     noise_model.enable_kraus_method(max_parallel_threads_);
   }
   return sim_methods;
 }
 
-Controller::Method
-Controller::automatic_simulation_method(const Circuit &circ,
-                                        const Noise::NoiseModel &noise_model) const {
+Controller::Method Controller::automatic_simulation_method(
+    const Circuit &circ, const Noise::NoiseModel &noise_model) const {
   // If circuit and noise model are Clifford run on Stabilizer simulator
   if (validate_method(Method::stabilizer, circ, noise_model, false)) {
     return Method::stabilizer;
@@ -1851,12 +1855,10 @@ Controller::automatic_simulation_method(const Circuit &circ,
   // operations only with preference given by memory requirements
   // statevector > density matrix > matrix product state > unitary > superop
   // typically any save state instructions will decide the method.
-  const std::vector<Method> methods({Method::statevector,
-                                     Method::density_matrix,
-                                     Method::matrix_product_state,
-                                     Method::unitary,
-                                     Method::superop});
-  for (const auto& method : methods) {
+  const std::vector<Method> methods(
+      {Method::statevector, Method::density_matrix,
+       Method::matrix_product_state, Method::unitary, Method::superop});
+  for (const auto &method : methods) {
     if (validate_method(method, circ, noise_model, false))
       return method;
   }
@@ -1868,32 +1870,37 @@ Controller::automatic_simulation_method(const Circuit &circ,
   return Method::statevector;
 }
 
-bool Controller::validate_method(Method method,
-                                 const Circuit &circ, 
+bool Controller::validate_method(Method method, const Circuit &circ,
                                  const Noise::NoiseModel &noise_model,
                                  bool throw_except) const {
   // Switch wrapper for templated function validate_state
   switch (method) {
-    case Method::stabilizer:
-      return validate_state(Stabilizer::State(), circ, noise_model, throw_except);
-    case Method::extended_stabilizer:
-      return validate_state(ExtendedStabilizer::State(), circ, noise_model, throw_except);
-    case Method::matrix_product_state:
-      return validate_state(MatrixProductState::State(), circ, noise_model, throw_except);
-    case Method::statevector:
-      return validate_state(Statevector::State<>(), circ, noise_model,  throw_except);
-    case Method::density_matrix:
-      return validate_state(DensityMatrix::State<>(), circ, noise_model, throw_except);
-    case Method::unitary:
-      return validate_state(QubitUnitary::State<>(), circ, noise_model, throw_except);
-    case Method::superop:
-      return validate_state(QubitSuperoperator::State<>(), circ, noise_model, throw_except);
-    case Method::automatic:
-      throw std::runtime_error("Cannot validate circuit for unresolved simulation method.");
+  case Method::stabilizer:
+    return validate_state(Stabilizer::State(), circ, noise_model, throw_except);
+  case Method::extended_stabilizer:
+    return validate_state(ExtendedStabilizer::State(), circ, noise_model,
+                          throw_except);
+  case Method::matrix_product_state:
+    return validate_state(MatrixProductState::State(), circ, noise_model,
+                          throw_except);
+  case Method::statevector:
+    return validate_state(Statevector::State<>(), circ, noise_model,
+                          throw_except);
+  case Method::density_matrix:
+    return validate_state(DensityMatrix::State<>(), circ, noise_model,
+                          throw_except);
+  case Method::unitary:
+    return validate_state(QubitUnitary::State<>(), circ, noise_model,
+                          throw_except);
+  case Method::superop:
+    return validate_state(QubitSuperoperator::State<>(), circ, noise_model,
+                          throw_except);
+  case Method::automatic:
+    throw std::runtime_error(
+        "Cannot validate circuit for unresolved simulation method.");
   }
 }
 
-
 template <class state_t>
 bool Controller::validate_state(const state_t &state, const Circuit &circ,
                                 const Noise::NoiseModel &noise,
@@ -1921,13 +1928,17 @@ bool Controller::validate_state(const state_t &state, const Circuit &circ,
   // Validate memory requirements
   bool memory_valid = true;
   if (max_memory_mb_ > 0) {
-    size_t required_mb = state.required_memory_mb(circ.num_qubits, circ.ops) / num_process_per_experiment_;                                        
-    size_t mem_size = (sim_device_ == Device::GPU) ? max_memory_mb_ + max_gpu_memory_mb_ : max_memory_mb_;
+    size_t required_mb = state.required_memory_mb(circ.num_qubits, circ.ops) /
+                         num_process_per_experiment_;
+    size_t mem_size = (sim_device_ == Device::GPU)
+                          ? max_memory_mb_ + max_gpu_memory_mb_
+                          : max_memory_mb_;
     memory_valid = (required_mb <= mem_size);
     if (throw_except && !memory_valid) {
       error_msg << "Insufficient memory to run circuit " << circ_name;
       error_msg << " using the " << state.name() << " simulator.";
-      error_msg << " Required memory: " << required_mb << "M, max memory: " << max_memory_mb_ << "M";
+      error_msg << " Required memory: " << required_mb
+                << "M, max memory: " << max_memory_mb_ << "M";
       if (sim_device_ == Device::GPU) {
         error_msg << " (Host) + " << max_gpu_memory_mb_ << "M (GPU)";
       }
@@ -1955,13 +1966,15 @@ void Controller::save_exception_to_results(Result &result,
   }
 }
 
-int_t Controller::get_matrix_bits(const Operations::Op& op) const
-{
+int_t Controller::get_matrix_bits(const Operations::Op &op) const {
   int_t bit = 1;
-  if(op.type == Operations::OpType::matrix || op.type == Operations::OpType::diagonal_matrix || op.type == Operations::OpType::initialize)
+  if (op.type == Operations::OpType::matrix ||
+      op.type == Operations::OpType::diagonal_matrix ||
+      op.type == Operations::OpType::initialize)
     bit = op.qubits.size();
-  else if(op.type == Operations::OpType::kraus || op.type == Operations::OpType::superop){
-    if(method_ == Method::density_matrix)
+  else if (op.type == Operations::OpType::kraus ||
+           op.type == Operations::OpType::superop) {
+    if (method_ == Method::density_matrix)
       bit = op.qubits.size() * 2;
     else
       bit = op.qubits.size();
@@ -1969,15 +1982,14 @@ int_t Controller::get_matrix_bits(const Operations::Op& op) const
   return bit;
 }
 
-int_t Controller::get_max_matrix_qubits(const Circuit &circ) const
-{
+int_t Controller::get_max_matrix_qubits(const Circuit &circ) const {
   int_t max_bits = 0;
   int_t i;
 
-  for(i=0;i<circ.ops.size();i++){
+  for (i = 0; i < circ.ops.size(); i++) {
     int_t bit = 1;
     bit = get_matrix_bits(circ.ops[i]);
-    max_bits = std::max(max_bits,bit);
+    max_bits = std::max(max_bits, bit);
   }
   return max_bits;
 }
diff --git a/src/controllers/controller_execute.hpp b/src/controllers/controller_execute.hpp
old mode 100755
new mode 100644
index acb4d59d28..f11cb4d997
--- a/src/controllers/controller_execute.hpp
+++ b/src/controllers/controller_execute.hpp
@@ -15,9 +15,9 @@
 #ifndef _aer_controller_execute_hpp_
 #define _aer_controller_execute_hpp_
 
-#include <string>
-#include "misc/hacks.hpp"
 #include "framework/results/result.hpp"
+#include "misc/hacks.hpp"
+#include <string>
 
 //=========================================================================
 // Controller Execute interface
@@ -26,20 +26,19 @@
 namespace AER {
 
 template <class controller_t, typename inputdata_t>
-Result controller_execute(const inputdata_t& qobj) {
+Result controller_execute(const inputdata_t &qobj) {
   controller_t controller;
 
   // Fix for MacOS and OpenMP library double initialization crash.
   // Issue: https://github.com/Qiskit/qiskit-aer/issues/1
   if (Parser<inputdata_t>::check_key("config", qobj)) {
-      std::string path;
-      const auto& config = Parser<inputdata_t>::get_value("config", qobj);
-      Parser<inputdata_t>::get_value(path, "library_dir", config);
-      Hacks::maybe_load_openmp(path);
+    std::string path;
+    const auto &config = Parser<inputdata_t>::get_value("config", qobj);
+    Parser<inputdata_t>::get_value(path, "library_dir", config);
+    Hacks::maybe_load_openmp(path);
   }
   return controller.execute(qobj);
 }
 
-
 } // end namespace AER
 #endif
diff --git a/src/controllers/state_controller.hpp b/src/controllers/state_controller.hpp
index 60f64ccb19..bbd424e640 100644
--- a/src/controllers/state_controller.hpp
+++ b/src/controllers/state_controller.hpp
@@ -15,11 +15,11 @@
 #ifndef _aer_state_hpp_
 #define _aer_state_hpp_
 
-#include <cstdint>
+#include <chrono>
 #include <complex>
+#include <cstdint>
 #include <string>
 #include <vector>
-#include <chrono>
 
 #include "framework/rng.hpp"
 #include "misc/warnings.hpp"
@@ -37,11 +37,11 @@ DISABLE_WARNING_PUSH
 DISABLE_WARNING_POP
 
 #include "framework/creg.hpp"
+#include "framework/linalg/vector.hpp"
 #include "framework/qobj.hpp"
 #include "framework/results/experiment_result.hpp"
 #include "framework/results/result.hpp"
 #include "framework/rng.hpp"
-#include "framework/linalg/vector.hpp"
 
 #include "noise/noise_model.hpp"
 
@@ -56,8 +56,8 @@ DISABLE_WARNING_POP
 #include "simulators/statevector/qubitvector.hpp"
 #include "simulators/statevector/statevector_state.hpp"
 #include "simulators/superoperator/superoperator_state.hpp"
-#include "simulators/unitary/unitarymatrix.hpp"
 #include "simulators/unitary/unitary_state.hpp"
+#include "simulators/unitary/unitarymatrix.hpp"
 
 #ifdef AER_THRUST_SUPPORTED
 #include "simulators/density_matrix/densitymatrix_thrust.hpp"
@@ -66,7 +66,7 @@ DISABLE_WARNING_POP
 #endif
 
 using int_t = int_fast64_t;
-using uint_t = uint_fast64_t; 
+using uint_t = uint_fast64_t;
 using complex_t = std::complex<double>;
 using complexf_t = std::complex<float>;
 using cvector_t = std::vector<complex_t>;
@@ -103,39 +103,39 @@ class AerState {
   //-----------------------------------------------------------------------
   AerState() = default;
 
-  virtual ~AerState() { };
+  virtual ~AerState(){};
 
   //-----------------------------------------------------------------------
   // Configuration
   //-----------------------------------------------------------------------
-  
-  // set configuration. 
+
+  // set configuration.
   // All of the configuration must be done before calling any gate operations.
-  virtual void configure(const std::string& key, const std::string& value);
+  virtual void configure(const std::string &key, const std::string &value);
 
   // configure a method.
-  virtual bool set_method(const std::string& name);
+  virtual bool set_method(const std::string &name);
 
   // configure a device.
-  virtual bool set_device(const std::string& name);
+  virtual bool set_device(const std::string &name);
 
   // configure a precision.
-  virtual bool set_precision(const std::string& name);
+  virtual bool set_precision(const std::string &name);
 
   // configure custatevec enabled or not
-  virtual bool set_custatevec(const bool& enabled);
+  virtual bool set_custatevec(const bool &enabled);
 
   // configure seed
-  virtual bool set_seed_simulator(const int& seed);
+  virtual bool set_seed_simulator(const int &seed);
 
   // configure number of threads to update state
-  virtual bool set_parallel_state_update(const uint_t& parallel_state_update);
+  virtual bool set_parallel_state_update(const uint_t &parallel_state_update);
 
   // configure max number of qubits for a gate
-  virtual bool set_max_gate_qubits(const uint_t& max_gate_qubits);
+  virtual bool set_max_gate_qubits(const uint_t &max_gate_qubits);
 
   // configure cache blocking qubits
-  virtual bool set_blocking_qubits(const uint_t& blocking_qubits);
+  virtual bool set_blocking_qubits(const uint_t &blocking_qubits);
 
   // Return true if gate operations have been performed and no configuration
   // is permitted.
@@ -155,7 +155,7 @@ class AerState {
   // Clear all the configurations
   virtual void clear();
 
-  virtual ExperimentResult& last_result() { return last_result_; };
+  virtual ExperimentResult &last_result() { return last_result_; };
 
   //-----------------------------------------------------------------------
   // Initialization
@@ -165,9 +165,10 @@ class AerState {
   void initialize();
 
   // Allocate qubits with inputted complex array
-  // method must be statevector and the length of the array must be 2^{num_qubits}
-  // given data will not be freed in this class
-  virtual reg_t initialize_statevector(uint_t num_qubits, complex_t* data, bool copy);
+  // method must be statevector and the length of the array must be
+  // 2^{num_qubits} given data will not be freed in this class
+  virtual reg_t initialize_statevector(uint_t num_qubits, complex_t *data,
+                                       bool copy);
 
   // Release internal statevector
   // The caller must free the returned pointer
@@ -190,8 +191,11 @@ class AerState {
   // Apply a N-qubit matrix to the state vector.
   virtual void apply_unitary(const reg_t &qubits, const cmatrix_t &mat);
 
-  // Apply a stacked set of 2^control_count target_count--qubit matrix to the state vector.
-  virtual void apply_multiplexer(const reg_t &control_qubits, const reg_t &target_qubits, const std::vector<cmatrix_t> &mats);
+  // Apply a stacked set of 2^control_count target_count--qubit matrix to the
+  // state vector.
+  virtual void apply_multiplexer(const reg_t &control_qubits,
+                                 const reg_t &target_qubits,
+                                 const std::vector<cmatrix_t> &mats);
 
   // Apply a N-qubit diagonal matrix to the state vector.
   virtual void apply_diagonal_matrix(const reg_t &qubits, const cvector_t &mat);
@@ -223,13 +227,15 @@ class AerState {
   // If N=1 this implements an optimized single-qubit phase gate
   // If N=2 this implements an optimized CPhase gate
   // If N=3 this implements an optimized CCPhase gate
-  virtual void apply_mcphase(const reg_t &qubits, const std::complex<double> phase);
+  virtual void apply_mcphase(const reg_t &qubits,
+                             const std::complex<double> phase);
 
   // Apply a general multi-controlled single-qubit unitary gate
   // If N=1 this implements an optimized single-qubit U gate
   // If N=2 this implements an optimized CU gate
   // If N=3 this implements an optimized CCU gate
-  virtual void apply_mcu(const reg_t &qubits, const double theta, const double phi, const double lambda);
+  virtual void apply_mcu(const reg_t &qubits, const double theta,
+                         const double phi, const double lambda);
 
   // Apply a general multi-controlled SWAP gate
   // If N=2 this implements an optimized SWAP  gate
@@ -293,19 +299,21 @@ class AerState {
   // The input is a length M list of random reals between [0, 1) used for
   // generating samples.
   // The returned value is unordered sampled outcomes
-  virtual std::vector<std::string> sample_memory(const reg_t &qubits, uint_t shots);
+  virtual std::vector<std::string> sample_memory(const reg_t &qubits,
+                                                 uint_t shots);
 
   // Return M sampled outcomes for Z-basis measurement of specified qubits
   // The input is a length M list of random reals between [0, 1) used for
   // generating samples.
   // The returned value is a map from outcome to its number of samples.
-  virtual std::unordered_map<uint_t, uint_t> sample_counts(const reg_t &qubits, uint_t shots);
+  virtual std::unordered_map<uint_t, uint_t> sample_counts(const reg_t &qubits,
+                                                           uint_t shots);
 
   //-----------------------------------------------------------------------
   // Operation management
   //-----------------------------------------------------------------------
   // Buffer Operations::Op
-  virtual void buffer_op(const Operations::Op&& op);
+  virtual void buffer_op(const Operations::Op &&op);
 
   // Flush buffered Operations::Op
   virtual void flush_ops();
@@ -334,22 +342,20 @@ class AerState {
   Method method_ = Method::statevector;
 
   const std::unordered_map<Method, std::string> method_names_ = {
-    {Method::statevector, "statevector"},
-    {Method::density_matrix, "density_matrix"},
-    {Method::matrix_product_state, "matrix_product_state"},
-    {Method::stabilizer, "stabilizer"},
-    {Method::extended_stabilizer, "extended_stabilizer"},
-    {Method::unitary, "unitary"},
-    {Method::superop, "superop"}
-  };
+      {Method::statevector, "statevector"},
+      {Method::density_matrix, "density_matrix"},
+      {Method::matrix_product_state, "matrix_product_state"},
+      {Method::stabilizer, "stabilizer"},
+      {Method::extended_stabilizer, "extended_stabilizer"},
+      {Method::unitary, "unitary"},
+      {Method::superop, "superop"}};
 
   Device device_ = Device::CPU;
 
   const std::unordered_map<Device, std::string> device_names_ = {
-    {Device::CPU, "CPU"},
-    {Device::GPU, "GPU"},
-    {Device::ThrustCPU, "ThrustCPU"}
-  };
+      {Device::CPU, "CPU"},
+      {Device::GPU, "GPU"},
+      {Device::ThrustCPU, "ThrustCPU"}};
 
   Precision precision_ = Precision::Double;
 
@@ -378,27 +384,29 @@ class AerState {
 bool AerState::is_gpu(bool raise_error) const {
 #ifndef AER_THRUST_CUDA
   if (raise_error)
-    throw std::runtime_error("Simulation device \"GPU\" is not supported on this system");
+    throw std::runtime_error(
+        "Simulation device \"GPU\" is not supported on this system");
   else
     return false;
 #else
   int nDev;
   if (cudaGetDeviceCount(&nDev) != cudaSuccess) {
-      if (raise_error) {
-        cudaGetLastError();
-        throw std::runtime_error("No CUDA device available!");
-      } else return false;
+    if (raise_error) {
+      cudaGetLastError();
+      throw std::runtime_error("No CUDA device available!");
+    } else
+      return false;
   }
 #endif
   return true;
 }
 
-void AerState::configure(const std::string& _key, const std::string& _value) {
+void AerState::configure(const std::string &_key, const std::string &_value) {
 
   std::string key = _key;
-  std::transform(key.begin(), key.end(), key.begin(), ::tolower);  
+  std::transform(key.begin(), key.end(), key.begin(), ::tolower);
   std::string value = _value;
-  std::transform(value.begin(), value.end(), value.begin(), ::tolower);  
+  std::transform(value.begin(), value.end(), value.begin(), ::tolower);
 
   bool error = false;
   if (key == "method") {
@@ -425,44 +433,67 @@ void AerState::configure(const std::string& _key, const std::string& _value) {
     throw std::runtime_error(msg.str());
   }
 
-  static std::unordered_set<std::string> str_config = { "method", "device", "precision", "extended_stabilizer_sampling_method",
-                                                        "mps_sample_measure_algorithm", "mps_log_data", "mps_swap_direction"};
-  static std::unordered_set<std::string> int_config = { "seed_simulator", "max_parallel_threads", "max_memory_mb", "parallel_state_update",
-                                                        "blocking_qubits", "batched_shots_gpu_max_qubits", "statevector_parallel_threshold", 
-                                                        "statevector_sample_measure_opt", "stabilizer_max_snapshot_probabilities",
-                                                        "extended_stabilizer_metropolis_mixing_time", "extended_stabilizer_norm_estimation_samples",
-                                                        "extended_stabilizer_norm_estimation_repetitions", "extended_stabilizer_parallel_threshold",
-                                                        "extended_stabilizer_probabilities_snapshot_samples", "matrix_product_state_max_bond_dimension",
-                                                        "fusion_max_qubit", "fusion_threshold"};
-  static std::unordered_set<std::string> double_config = { "extended_stabilizer_approximation_error", "matrix_product_state_truncation_threshold",
-                                                           };
-  static std::unordered_set<std::string> bool_config = { "custatevec_enable", "blocking_enable", "batched_shots_gpu", "fusion_enable", "fusion_verbose"};
-
-  if (str_config.find(key) != str_config.end() ) {
+  static std::unordered_set<std::string> str_config = {
+      "method",
+      "device",
+      "precision",
+      "extended_stabilizer_sampling_method",
+      "mps_sample_measure_algorithm",
+      "mps_log_data",
+      "mps_swap_direction"};
+  static std::unordered_set<std::string> int_config = {
+      "seed_simulator",
+      "max_parallel_threads",
+      "max_memory_mb",
+      "parallel_state_update",
+      "blocking_qubits",
+      "batched_shots_gpu_max_qubits",
+      "statevector_parallel_threshold",
+      "statevector_sample_measure_opt",
+      "stabilizer_max_snapshot_probabilities",
+      "extended_stabilizer_metropolis_mixing_time",
+      "extended_stabilizer_norm_estimation_samples",
+      "extended_stabilizer_norm_estimation_repetitions",
+      "extended_stabilizer_parallel_threshold",
+      "extended_stabilizer_probabilities_snapshot_samples",
+      "matrix_product_state_max_bond_dimension",
+      "fusion_max_qubit",
+      "fusion_threshold"};
+  static std::unordered_set<std::string> double_config = {
+      "extended_stabilizer_approximation_error",
+      "matrix_product_state_truncation_threshold",
+  };
+  static std::unordered_set<std::string> bool_config = {
+      "custatevec_enable", "blocking_enable", "batched_shots_gpu",
+      "fusion_enable", "fusion_verbose"};
+
+  if (str_config.find(key) != str_config.end()) {
     configs_[_key] = _value;
-  } else if (int_config.find(key) != int_config.end() ) {
+  } else if (int_config.find(key) != int_config.end()) {
     configs_[_key] = std::stoi(value);
-  } else if (bool_config.find(key) != bool_config.end() ) {
+  } else if (bool_config.find(key) != bool_config.end()) {
     configs_[_key] = "true" == value;
-  } else if (double_config.find(key) != double_config.end() ) {
+  } else if (double_config.find(key) != double_config.end()) {
     configs_[_key] = std::stod(value);
   } else {
     std::stringstream msg;
     msg << "not supported configuration: " << key << "=" << value << std::endl;
     throw std::runtime_error(msg.str());
   }
-
 };
 
-bool AerState::set_method(const std::string& method_name) {
+bool AerState::set_method(const std::string &method_name) {
   assert_not_initialized();
-  auto it = find_if(method_names_.begin(), method_names_.end(), [method_name](const auto& vt) { return vt.second == method_name; });
-  if (it == method_names_.end()) return false;
+  auto it = find_if(
+      method_names_.begin(), method_names_.end(),
+      [method_name](const auto &vt) { return vt.second == method_name; });
+  if (it == method_names_.end())
+    return false;
   method_ = it->first;
   return true;
 };
 
-bool AerState::set_device(const std::string& device_name) {
+bool AerState::set_device(const std::string &device_name) {
   assert_not_initialized();
   if (device_name == "cpu")
     device_ = Device::CPU;
@@ -475,7 +506,7 @@ bool AerState::set_device(const std::string& device_name) {
   return true;
 };
 
-bool AerState::set_precision(const std::string& precision_name) {
+bool AerState::set_precision(const std::string &precision_name) {
   assert_not_initialized();
   if (precision_name == "single")
     precision_ = Precision::Single;
@@ -486,32 +517,31 @@ bool AerState::set_precision(const std::string& precision_name) {
   return true;
 };
 
-bool AerState::set_custatevec(const bool& enabled) {
+bool AerState::set_custatevec(const bool &enabled) {
   assert_not_initialized();
   cuStateVec_enable_ = enabled;
   return true;
 };
 
-bool AerState::set_seed_simulator(const int& seed) {
+bool AerState::set_seed_simulator(const int &seed) {
   assert_not_initialized();
   seed_ = seed;
   return true;
 };
 
-bool AerState::set_parallel_state_update(const uint_t& parallel_state_update) {
+bool AerState::set_parallel_state_update(const uint_t &parallel_state_update) {
   assert_not_initialized();
   parallel_state_update_ = parallel_state_update;
   return true;
 };
 
-bool AerState::set_max_gate_qubits(const uint_t& max_gate_qubits) {
+bool AerState::set_max_gate_qubits(const uint_t &max_gate_qubits) {
   assert_not_initialized();
   max_gate_qubits_ = max_gate_qubits;
   return true;
 };
 
-bool AerState::set_blocking_qubits(const uint_t& blocking_qubits)
-{
+bool AerState::set_blocking_qubits(const uint_t &blocking_qubits) {
   assert_not_initialized();
   cache_block_qubits_ = blocking_qubits;
   return true;
@@ -545,73 +575,93 @@ void AerState::initialize() {
   if (method_ == Method::statevector) {
     if (device_ == Device::CPU)
       if (precision_ == Precision::Double)
-        state_ = std::make_shared<Statevector::State<QV::QubitVector<double>>>();
+        state_ =
+            std::make_shared<Statevector::State<QV::QubitVector<double>>>();
       else
         state_ = std::make_shared<Statevector::State<QV::QubitVector<float>>>();
     else // if (device_ == Device::GPU)
 #ifdef AER_THRUST_SUPPORTED
-      if (precision_ == Precision::Double)
-        state_ = std::make_shared<Statevector::State<QV::QubitVectorThrust<double>>>();
-      else
-        state_ = std::make_shared<Statevector::State<QV::QubitVectorThrust<float>>>();
+        if (precision_ == Precision::Double)
+      state_ =
+          std::make_shared<Statevector::State<QV::QubitVectorThrust<double>>>();
+    else
+      state_ =
+          std::make_shared<Statevector::State<QV::QubitVectorThrust<float>>>();
 #else
-      throw std::runtime_error("specified method does not support non-CPU device: method=statevector");
+      throw std::runtime_error("specified method does not support non-CPU "
+                               "device: method=statevector");
 #endif
   } else if (method_ == Method::density_matrix) {
     if (device_ == Device::CPU)
       if (precision_ == Precision::Double)
-        state_ = std::make_shared<DensityMatrix::State<QV::DensityMatrix<double>>>();
+        state_ =
+            std::make_shared<DensityMatrix::State<QV::DensityMatrix<double>>>();
       else
-        state_ = std::make_shared<DensityMatrix::State<QV::DensityMatrix<float>>>();
+        state_ =
+            std::make_shared<DensityMatrix::State<QV::DensityMatrix<float>>>();
     else // if (device_ == Device::GPU)
 #ifdef AER_THRUST_SUPPORTED
-      if (precision_ == Precision::Double)
-        state_ = std::make_shared<DensityMatrix::State<QV::DensityMatrixThrust<double>>>();
-      else
-        state_ = std::make_shared<DensityMatrix::State<QV::DensityMatrixThrust<float>>>();
+        if (precision_ == Precision::Double)
+      state_ = std::make_shared<
+          DensityMatrix::State<QV::DensityMatrixThrust<double>>>();
+    else
+      state_ = std::make_shared<
+          DensityMatrix::State<QV::DensityMatrixThrust<float>>>();
 #else
-      throw std::runtime_error("specified method does not support non-CPU device: method=density_matrix");
+      throw std::runtime_error("specified method does not support non-CPU "
+                               "device: method=density_matrix");
 #endif
   } else if (method_ == Method::unitary) {
     if (device_ == Device::CPU)
       if (precision_ == Precision::Double)
-        state_ = std::make_shared<QubitUnitary::State<QV::UnitaryMatrix<double>>>();
+        state_ =
+            std::make_shared<QubitUnitary::State<QV::UnitaryMatrix<double>>>();
       else
-        state_ = std::make_shared<QubitUnitary::State<QV::UnitaryMatrix<float>>>();
+        state_ =
+            std::make_shared<QubitUnitary::State<QV::UnitaryMatrix<float>>>();
     else // if (device_ == Device::GPU)
 #ifdef AER_THRUST_SUPPORTED
-      if (precision_ == Precision::Double)
-        state_ = std::make_shared<QubitUnitary::State<QV::UnitaryMatrixThrust<double>>>();
-      else
-        state_ = std::make_shared<QubitUnitary::State<QV::UnitaryMatrixThrust<float>>>();
+        if (precision_ == Precision::Double)
+      state_ = std::make_shared<
+          QubitUnitary::State<QV::UnitaryMatrixThrust<double>>>();
+    else
+      state_ = std::make_shared<
+          QubitUnitary::State<QV::UnitaryMatrixThrust<float>>>();
 #else
-      throw std::runtime_error("specified method does not support non-CPU device: method=unitary");
+      throw std::runtime_error(
+          "specified method does not support non-CPU device: method=unitary");
 #endif
   } else if (method_ == Method::matrix_product_state) {
     if (device_ == Device::CPU)
       state_ = std::make_shared<MatrixProductState::State>();
     else // if (device_ == Device::GPU)
-        throw std::runtime_error("specified method does not support non-CPU device: method=matrix_product_state");
+      throw std::runtime_error("specified method does not support non-CPU "
+                               "device: method=matrix_product_state");
   } else if (method_ == Method::stabilizer) {
     if (device_ == Device::CPU)
       state_ = std::make_shared<Stabilizer::State>();
     else // if (device_ == Device::GPU)
-        throw std::runtime_error("specified method does not support non-CPU device: method=stabilizer");
+      throw std::runtime_error("specified method does not support non-CPU "
+                               "device: method=stabilizer");
   } else if (method_ == Method::extended_stabilizer) {
     if (device_ == Device::CPU)
       state_ = std::make_shared<ExtendedStabilizer::State>();
     else // if (device_ == Device::GPU)
-        throw std::runtime_error("specified method does not support non-CPU device: method=extended_stabilizer");
+      throw std::runtime_error("specified method does not support non-CPU "
+                               "device: method=extended_stabilizer");
   } else if (method_ == Method::superop) {
     if (device_ == Device::CPU)
       if (precision_ == Precision::Double)
-        state_ = std::make_shared<QubitSuperoperator::State<QV::Superoperator<double>>>();
+        state_ = std::make_shared<
+            QubitSuperoperator::State<QV::Superoperator<double>>>();
       else
-        state_ = std::make_shared<QubitSuperoperator::State<QV::Superoperator<float>>>();
+        state_ = std::make_shared<
+            QubitSuperoperator::State<QV::Superoperator<float>>>();
     else // if (device_ == Device::GPU)
-        throw std::runtime_error("specified method does not support non-CPU device: method=superop");
+      throw std::runtime_error(
+          "specified method does not support non-CPU device: method=superop");
   } else {
-      throw std::runtime_error("not supported method.");
+    throw std::runtime_error("not supported method.");
   }
 
 #ifdef _OPENMP
@@ -623,7 +673,8 @@ void AerState::initialize() {
   uint_t block_qubits = cache_block_qubits_;
   cache_block_pass_.set_num_processes(num_process_per_experiment_);
   cache_block_pass_.set_config(configs_);
-  if(!cache_block_pass_.enabled() || !state_->multi_chunk_distribution_supported())
+  if (!cache_block_pass_.enabled() ||
+      !state_->multi_chunk_distribution_supported())
     block_qubits = num_of_qubits_;
 
   state_->set_config(configs_);
@@ -645,7 +696,7 @@ reg_t AerState::allocate_qubits(uint_t num_qubits) {
   assert_not_initialized();
   reg_t ret;
   for (auto i = 0; i < num_qubits; ++i)
-      ret.push_back(num_of_qubits_++);
+    ret.push_back(num_of_qubits_++);
   return ret;
 };
 
@@ -655,7 +706,8 @@ reg_t AerState::reallocate_qubits(uint_t num_qubits) {
   return allocate_qubits(num_qubits);
 };
 
-reg_t AerState::initialize_statevector(uint_t num_of_qubits, complex_t* data, bool copy) {
+reg_t AerState::initialize_statevector(uint_t num_of_qubits, complex_t *data,
+                                       bool copy) {
   assert_not_initialized();
 #ifdef AER_MPI
   MPI_Comm_size(MPI_COMM_WORLD, &num_processes_);
@@ -667,18 +719,21 @@ reg_t AerState::initialize_statevector(uint_t num_of_qubits, complex_t* data, bo
   cache_block_pass_.set_config(configs_);
 
   if (device_ != Device::CPU)
-    throw std::runtime_error("only CPU device supports initialize_statevector()");
+    throw std::runtime_error(
+        "only CPU device supports initialize_statevector()");
   if (precision_ != Precision::Double)
-    throw std::runtime_error("only Double precision supports initialize_statevector()");
+    throw std::runtime_error(
+        "only Double precision supports initialize_statevector()");
   num_of_qubits_ = num_of_qubits;
   auto state = std::make_shared<Statevector::State<QV::QubitVector<double>>>();
   state->set_config(configs_);
   state->set_distribution(num_process_per_experiment_);
   state->set_max_matrix_qubits(max_gate_qubits_);
-  
-  if(!cache_block_pass_.enabled() || !state->multi_chunk_distribution_supported())
+
+  if (!cache_block_pass_.enabled() ||
+      !state->multi_chunk_distribution_supported())
     block_qubits = num_of_qubits_;
-  
+
   state->allocate(num_of_qubits_, block_qubits);
   auto qv = QV::QubitVector<double>(num_of_qubits_, data, copy);
   state->initialize_qreg(num_of_qubits_);
@@ -720,7 +775,10 @@ AER::Vector<complex_t> AerState::move_to_vector() {
   ExperimentResult ret;
   state_->apply_op(op, ret, rng_, true);
 
-  auto sv = std::move(static_cast<DataMap<SingleData, Vector<complex_t>>>(std::move(ret).data).value()["s"].value());
+  auto sv = std::move(
+      static_cast<DataMap<SingleData, Vector<complex_t>>>(std::move(ret).data)
+          .value()["s"]
+          .value());
   clear();
 
   return std::move(sv);
@@ -730,7 +788,7 @@ AER::Vector<complex_t> AerState::move_to_vector() {
 // Apply Initialization
 //-----------------------------------------------------------------------
 
-void AerState::apply_initialize(const reg_t &qubits, cvector_t && vec) {
+void AerState::apply_initialize(const reg_t &qubits, cvector_t &&vec) {
   assert_initialized();
   Operations::Op op;
   op.type = Operations::OpType::initialize;
@@ -763,7 +821,8 @@ void AerState::apply_unitary(const reg_t &qubits, const cmatrix_t &mat) {
   buffer_op(std::move(op));
 }
 
-void AerState::apply_diagonal_matrix(const reg_t &qubits, const cvector_t &mat) {
+void AerState::apply_diagonal_matrix(const reg_t &qubits,
+                                     const cvector_t &mat) {
   assert_initialized();
   Operations::Op op;
   op.type = Operations::OpType::diagonal_matrix;
@@ -774,7 +833,9 @@ void AerState::apply_diagonal_matrix(const reg_t &qubits, const cvector_t &mat)
   buffer_op(std::move(op));
 }
 
-void AerState::apply_multiplexer(const reg_t &control_qubits, const reg_t &target_qubits, const std::vector<cmatrix_t> &mats) {
+void AerState::apply_multiplexer(const reg_t &control_qubits,
+                                 const reg_t &target_qubits,
+                                 const std::vector<cmatrix_t> &mats) {
   assert_initialized();
 
   if (mats.empty())
@@ -846,7 +907,8 @@ void AerState::apply_mcz(const reg_t &qubits) {
   buffer_op(std::move(op));
 }
 
-void AerState::apply_mcphase(const reg_t &qubits, const std::complex<double> phase) {
+void AerState::apply_mcphase(const reg_t &qubits,
+                             const std::complex<double> phase) {
   assert_initialized();
 
   Operations::Op op;
@@ -858,7 +920,8 @@ void AerState::apply_mcphase(const reg_t &qubits, const std::complex<double> pha
   buffer_op(std::move(op));
 }
 
-void AerState::apply_mcu(const reg_t &qubits, const double theta, const double phi, const double lambda) {
+void AerState::apply_mcu(const reg_t &qubits, const double theta,
+                         const double phi, const double lambda) {
   assert_initialized();
 
   Operations::Op op;
@@ -938,7 +1001,7 @@ uint_t AerState::apply_measure(const reg_t &qubits) {
 
   uint_t bitstring = 0;
   uint_t bit = 1;
-  for (const auto& qubit: qubits) {
+  for (const auto &qubit : qubits) {
     if (state_->creg().creg_memory()[qubit] == '1')
       bitstring |= bit;
     bit <<= 1;
@@ -979,7 +1042,9 @@ double AerState::probability(const uint_t outcome) {
   last_result_ = ExperimentResult();
   state_->apply_op(op, last_result_, rng_);
 
-  return ((DataMap<ListData, rvector_t>)last_result_.data).value()["s"].value()[0][0];
+  return ((DataMap<ListData, rvector_t>)last_result_.data)
+      .value()["s"]
+      .value()[0][0];
 }
 
 // Return the probability amplitude for outcome in [0, 2^num_qubits - 1]
@@ -998,7 +1063,9 @@ complex_t AerState::amplitude(const uint_t outcome) {
   last_result_ = ExperimentResult();
   state_->apply_op(op, last_result_, rng_);
 
-  return ((DataMap<ListData, Vector<complex_t>>)last_result_.data).value()["s"].value()[0][0];
+  return ((DataMap<ListData, Vector<complex_t>>)last_result_.data)
+      .value()["s"]
+      .value()[0][0];
 };
 
 std::vector<double> AerState::probabilities() {
@@ -1015,7 +1082,9 @@ std::vector<double> AerState::probabilities() {
   last_result_ = ExperimentResult();
   state_->apply_op(op, last_result_, rng_);
 
-  return ((DataMap<ListData, rvector_t>)last_result_.data).value()["s"].value()[0];
+  return ((DataMap<ListData, rvector_t>)last_result_.data)
+      .value()["s"]
+      .value()[0];
 }
 
 std::vector<double> AerState::probabilities(const reg_t &qubits) {
@@ -1033,10 +1102,13 @@ std::vector<double> AerState::probabilities(const reg_t &qubits) {
   last_result_ = ExperimentResult();
   state_->apply_op(op, last_result_, rng_);
 
-  return ((DataMap<ListData, rvector_t>)last_result_.data).value()["s"].value()[0];
+  return ((DataMap<ListData, rvector_t>)last_result_.data)
+      .value()["s"]
+      .value()[0];
 }
 
-std::vector<std::string> AerState::sample_memory(const reg_t &qubits, uint_t shots) {
+std::vector<std::string> AerState::sample_memory(const reg_t &qubits,
+                                                 uint_t shots) {
   assert_initialized();
 
   flush_ops();
@@ -1044,24 +1116,27 @@ std::vector<std::string> AerState::sample_memory(const reg_t &qubits, uint_t sho
   std::vector<std::string> ret;
   ret.reserve(shots);
   std::vector<reg_t> samples = state_->sample_measure(qubits, shots, rng_);
-  for (auto& sample : samples) {
-    ret.push_back(Utils::int2string(Utils::reg2int(sample, 2), 2, qubits.size()));
+  for (auto &sample : samples) {
+    ret.push_back(
+        Utils::int2string(Utils::reg2int(sample, 2), 2, qubits.size()));
   }
   return ret;
 }
 
-std::unordered_map<uint_t, uint_t> AerState::sample_counts(const reg_t &qubits, uint_t shots) {
+std::unordered_map<uint_t, uint_t> AerState::sample_counts(const reg_t &qubits,
+                                                           uint_t shots) {
   assert_initialized();
 
   flush_ops();
 
   std::vector<reg_t> samples = state_->sample_measure(qubits, shots, rng_);
   std::unordered_map<uint_t, uint_t> ret;
-  for(const auto & sample: samples) {
+  for (const auto &sample : samples) {
     uint_t sample_u = 0ULL;
     uint_t mask = 1ULL;
-    for (const auto b: sample) {
-      if (b) sample_u |= mask;
+    for (const auto b : sample) {
+      if (b)
+        sample_u |= mask;
       mask <<= 1;
     }
     if (ret.find(sample_u) == ret.end())
@@ -1075,7 +1150,7 @@ std::unordered_map<uint_t, uint_t> AerState::sample_counts(const reg_t &qubits,
 //-----------------------------------------------------------------------
 // Operation management
 //-----------------------------------------------------------------------
-void AerState::buffer_op(const Operations::Op&& op) {
+void AerState::buffer_op(const Operations::Op &&op) {
   assert_initialized();
   buffer_.ops.push_back(std::move(op));
 };
@@ -1085,11 +1160,12 @@ void AerState::initialize_experiment_result() {
   last_result_.legacy_data.set_config(configs_);
   last_result_.set_config(configs_);
   last_result_.metadata.add(method_names_.at(method_), "method");
-  if (method_ == Method::statevector || method_ == Method::density_matrix || method_ == Method::unitary)
+  if (method_ == Method::statevector || method_ == Method::density_matrix ||
+      method_ == Method::unitary)
     last_result_.metadata.add(device_names_.at(device_), "device");
   else
     last_result_.metadata.add("CPU", "device");
-  
+
   last_result_.metadata.add(num_of_qubits_, "num_qubits");
   last_result_.header = buffer_.header;
   last_result_.shots = 1;
@@ -1098,14 +1174,16 @@ void AerState::initialize_experiment_result() {
 };
 
 void AerState::finalize_experiment_result(bool success, double time_taken) {
-  last_result_.status = success? ExperimentResult::Status::completed : ExperimentResult::Status::error;
+  last_result_.status = success ? ExperimentResult::Status::completed
+                                : ExperimentResult::Status::error;
   last_result_.time_taken = time_taken;
 };
 
 void AerState::flush_ops() {
   assert_initialized();
 
-  if (buffer_.ops.empty()) return;
+  if (buffer_.ops.empty())
+    return;
 
   auto timer_start = myclock_t::now();
 
@@ -1114,8 +1192,10 @@ void AerState::flush_ops() {
   buffer_.set_params(false);
   transpile_ops();
   state_->apply_ops(buffer_.ops.begin(), buffer_.ops.end(), last_result_, rng_);
-  
-  finalize_experiment_result(true, std::chrono::duration<double>(myclock_t::now() - timer_start).count());
+
+  finalize_experiment_result(
+      true,
+      std::chrono::duration<double>(myclock_t::now() - timer_start).count());
   clear_ops();
 };
 
@@ -1126,7 +1206,7 @@ void AerState::clear_ops() {
 
 void AerState::transpile_ops() {
   fusion_pass_ = Transpile::Fusion();
-  
+
   fusion_pass_.set_parallelization(parallel_state_update_);
 
   if (buffer_.opset().contains(Operations::OpType::superop))
@@ -1163,11 +1243,14 @@ void AerState::transpile_ops() {
   }
   // Override default fusion settings with custom config
   fusion_pass_.set_config(configs_);
-  fusion_pass_.optimize_circuit(buffer_, noise_model_, state_->opset(), last_result_);
-
-  //cache blocking
-  if(cache_block_pass_.enabled() && state_->multi_chunk_distribution_supported()){
-    cache_block_pass_.optimize_circuit(buffer_, noise_model_, state_->opset(), last_result_);
+  fusion_pass_.optimize_circuit(buffer_, noise_model_, state_->opset(),
+                                last_result_);
+
+  // cache blocking
+  if (cache_block_pass_.enabled() &&
+      state_->multi_chunk_distribution_supported()) {
+    cache_block_pass_.optimize_circuit(buffer_, noise_model_, state_->opset(),
+                                       last_result_);
   }
 }
 
@@ -1175,5 +1258,3 @@ void AerState::transpile_ops() {
 } // end namespace AER
 //-------------------------------------------------------------------------
 #endif
-
-
diff --git a/src/framework/avx2_detect.hpp b/src/framework/avx2_detect.hpp
index 49f5d73955..2287782f38 100644
--- a/src/framework/avx2_detect.hpp
+++ b/src/framework/avx2_detect.hpp
@@ -16,63 +16,59 @@
 #define _aer_controller_avx2_detect_hpp_
 
 #include <array>
-#include <vector>
 #include <bitset>
+#include <vector>
 
 #include "misc/common_macros.hpp"
 #if defined(_MSC_VER)
-    #include <intrin.h>
+#include <intrin.h>
 #elif defined(GNUC_AVX2)
-    #include <cpuid.h>
+#include <cpuid.h>
 #endif
 
-
 namespace {
-inline void ccpuid(int cpu_info[4], int function_id){
+inline void ccpuid(int cpu_info[4], int function_id) {
 #if defined(_MSC_VER)
   __cpuid(cpu_info, function_id);
 #elif defined(GNUC_AVX2)
-  __cpuid(function_id,
-    cpu_info[0],
-    cpu_info[1],
-    cpu_info[2],
-    cpu_info[3]);
+  __cpuid(function_id, cpu_info[0], cpu_info[1], cpu_info[2], cpu_info[3]);
 #else // We don't support this platform intrinsics
   cpu_info[0] = cpu_info[1] = cpu_info[2] = cpu_info[3] = 0;
 #endif
 }
 
-inline void cpuidex(int cpu_info[4], int function_id, int subfunction_id){
+inline void cpuidex(int cpu_info[4], int function_id, int subfunction_id) {
 #if defined(_MSC_VER)
   __cpuidex(cpu_info, function_id, subfunction_id);
 #elif defined(GNUC_AVX2)
-  __cpuid_count(function_id, subfunction_id, cpu_info[0], cpu_info[1], cpu_info[2], cpu_info[3]);
+  __cpuid_count(function_id, subfunction_id, cpu_info[0], cpu_info[1],
+                cpu_info[2], cpu_info[3]);
 #else // We don't support this platform intrinsics
-   cpu_info[0] = cpu_info[1] = cpu_info[2] = cpu_info[3] = 0;
+  cpu_info[0] = cpu_info[1] = cpu_info[2] = cpu_info[3] = 0;
 #endif
 }
-}
+} // namespace
 
 namespace AER {
 
-inline bool is_avx2_supported(){
+inline bool is_avx2_supported() {
 #if defined(GNUC_AVX2) || defined(_MSC_VER)
   static bool cached = false;
   static bool is_supported = false;
-  if(cached)
+  if (cached)
     return is_supported;
 
   std::array<int, 4> cpui;
   ccpuid(cpui.data(), 0);
   auto num_ids = cpui[0];
-  if(num_ids < 7){
+  if (num_ids < 7) {
     cached = true;
     is_supported = false;
     return false;
   }
 
   std::vector<std::array<int, 4>> data;
-  for (int i = 0; i <= num_ids; ++i){
+  for (int i = 0; i <= num_ids; ++i) {
     cpuidex(cpui.data(), i, 0);
     data.push_back(cpui);
   }
@@ -87,11 +83,9 @@ inline bool is_avx2_supported(){
   is_supported = is_fma_supported && is_avx2_supported;
   return is_supported;
 #else
-    return false;
+  return false;
 #endif
 }
 // end namespace AER
-}
+} // namespace AER
 #endif
-
-
diff --git a/src/framework/blas_protos.hpp b/src/framework/blas_protos.hpp
old mode 100755
new mode 100644
index d2803c66eb..dc17a25ac8
--- a/src/framework/blas_protos.hpp
+++ b/src/framework/blas_protos.hpp
@@ -19,10 +19,10 @@
 #ifndef _aer_framework_blas_protos_hpp
 #define _aer_framework_blas_protos_hpp
 
+#include <array>
 #include <complex>
 #include <iostream>
 #include <vector>
-#include <array>
 
 #ifdef __cplusplus
 extern "C" {
@@ -79,45 +79,43 @@ void zgemm_(const char *TransA, const char *TransB, const size_t *M,
             const std::complex<double> *beta, std::complex<double> *C,
             size_t *ldc);
 
-// Reduces a Single-Precison Complex Hermitian matrix A to real symmetric tridiagonal form
-void chetrd_(char *TRANS, int *N, std::complex<float> *A,
-             int *LDA, float *d, float *e, std::complex<float> *tau,
-             std::complex<float> *work, int *lwork, int *info);
+// Reduces a Single-Precison Complex Hermitian matrix A to real symmetric
+// tridiagonal form
+void chetrd_(char *TRANS, int *N, std::complex<float> *A, int *LDA, float *d,
+             float *e, std::complex<float> *tau, std::complex<float> *work,
+             int *lwork, int *info);
 
-// Reduces a Double-Precison Complex Hermitian matrix A to real symmetric tridiagonal form T
-void zhetrd_(char *TRANS, int *N, std::complex<double> *A,
-             int *LDA, double *d, double *e, std::complex<double> *tau,
-             std::complex<double> *work, int *lwork, int *info);
+// Reduces a Double-Precison Complex Hermitian matrix A to real symmetric
+// tridiagonal form T
+void zhetrd_(char *TRANS, int *N, std::complex<double> *A, int *LDA, double *d,
+             double *e, std::complex<double> *tau, std::complex<double> *work,
+             int *lwork, int *info);
 
 // Computes all eigenvalues and, optionally, eigenvectors of a
 // Single-Precison Complex symmetric positive definite tridiagonal matrix
-void cpteqr_(char* compz, int *n, float *d, float *e,
-             std::complex<float> *z, int* ldz,
-             std::complex<float> *work, int *info);
+void cpteqr_(char *compz, int *n, float *d, float *e, std::complex<float> *z,
+             int *ldz, std::complex<float> *work, int *info);
 
 // Computes all eigenvalues and, optionally, eigenvectors of a
 // Double-Precison Complex symmetric positive definite tridiagonal matrix
-void zpteqr_(char* compz, int *n, double *d, double *e,
-             std::complex<double> *z, int* ldz,
-             std::complex<double> *work, int *info);
+void zpteqr_(char *compz, int *n, double *d, double *e, std::complex<double> *z,
+             int *ldz, std::complex<double> *work, int *info);
 
 // Computes selected eigenvalues and, optionally, eigenvectors
 // of a Single-Precison Complex Hermitian matrix A
 void cheevx_(char *jobz, char *range, char *uplo, int *n,
-             std::complex<float> *a, int *lda, float *vl,
-             float *vu, int *il, int *iu, float *abstol,
-             int *m, float *w, std::complex<float> *z, int *ldz,
-             std::complex<float> *work, int *lwork, float *rwork,
+             std::complex<float> *a, int *lda, float *vl, float *vu, int *il,
+             int *iu, float *abstol, int *m, float *w, std::complex<float> *z,
+             int *ldz, std::complex<float> *work, int *lwork, float *rwork,
              int *iwork, int *ifail, int *info);
 
 // Computes selected eigenvalues and, optionally, eigenvectors
 // of a Double-Precison Complex Hermitian matrix A
 void zheevx_(char *jobz, char *range, char *uplo, int *n,
-             std::complex<double> *a, int *lda, double *vl,
-             double *vu, int *il, int *iu, double *abstol,
-             int *m, double *w, std::complex<double> *z, int *ldz,
-             std::complex<double> *work, int *lwork, double *rwork,
-             int *iwork, int *ifail, int *info);
+             std::complex<double> *a, int *lda, double *vl, double *vu, int *il,
+             int *iu, double *abstol, int *m, double *w,
+             std::complex<double> *z, int *ldz, std::complex<double> *work,
+             int *lwork, double *rwork, int *iwork, int *ifail, int *info);
 
 // Determines Single-Precision machine parameters.
 float slamch_(char *cmach);
diff --git a/src/framework/circuit.hpp b/src/framework/circuit.hpp
old mode 100755
new mode 100644
index 3ad21966cd..0e8e577d8e
--- a/src/framework/circuit.hpp
+++ b/src/framework/circuit.hpp
@@ -37,59 +37,62 @@ class Circuit {
   std::vector<Op> ops;
 
   // Circuit parameters updated by from ops by set_params
-  uint_t num_qubits = 0;        // maximum number of qubits needed for ops
-  uint_t num_memory = 0;        // maximum number of memory clbits needed for ops
-  uint_t num_registers = 0;     // maximum number of registers clbits needed for ops
-  
+  uint_t num_qubits = 0;    // maximum number of qubits needed for ops
+  uint_t num_memory = 0;    // maximum number of memory clbits needed for ops
+  uint_t num_registers = 0; // maximum number of registers clbits needed for ops
+
   // Measurement params
-  bool has_conditional = false;      // True if any ops are conditional
-  bool can_sample = true;            // True if circuit tail contains measure, roerror, barrier.
-  size_t first_measure_pos = 0;      // Position of first measure instruction
-  bool can_sample_initialize = true; // True if circuit contains at most 1 initialize
-                                     // and it is the first instruction in the circuit
+  bool has_conditional = false; // True if any ops are conditional
+  bool can_sample =
+      true; // True if circuit tail contains measure, roerror, barrier.
+  size_t first_measure_pos = 0; // Position of first measure instruction
+  bool can_sample_initialize =
+      true; // True if circuit contains at most 1 initialize
+            // and it is the first instruction in the circuit
 
   // Circuit metadata constructed from json QobjExperiment
   uint_t shots = 1;
   uint_t seed;
   json_t header;
   double global_phase_angle = 0;
-  bool remapped_qubits = false;      // True if qubits have been remapped
+  bool remapped_qubits = false; // True if qubits have been remapped
 
   // Constructor
-  // The constructor automatically calculates the num_qubits, num_memory, num_registers
-  // parameters by scanning the input list of ops.
-  Circuit() {set_random_seed();}
+  // The constructor automatically calculates the num_qubits, num_memory,
+  // num_registers parameters by scanning the input list of ops.
+  Circuit() { set_random_seed(); }
   Circuit(const std::vector<Op> &_ops, bool truncation = false);
   Circuit(std::vector<Op> &&_ops, bool truncation = false);
 
   // Construct a circuit from JSON
-  template<typename inputdata_t>
-  Circuit(const inputdata_t& circ, bool truncation = false);
+  template <typename inputdata_t>
+  Circuit(const inputdata_t &circ, bool truncation = false);
 
-  template<typename inputdata_t>
-  Circuit(const inputdata_t& circ, const json_t& qobj_config, bool truncation = false);
+  template <typename inputdata_t>
+  Circuit(const inputdata_t &circ, const json_t &qobj_config,
+          bool truncation = false);
 
   //-----------------------------------------------------------------------
   // Set containers
   //-----------------------------------------------------------------------
 
   // Return the opset for the circuit
-  inline const auto& opset() const {return opset_;}
+  inline const auto &opset() const { return opset_; }
 
   // Return the used qubits for the circuit
-  inline const auto& qubits() const {return qubitset_;}
+  inline const auto &qubits() const { return qubitset_; }
 
   // Return the used memory for the circuit
-  inline const auto& memory() const {return memoryset_;}
+  inline const auto &memory() const { return memoryset_; }
 
   // Return the used registers for the circuit
-  inline const auto& registers() const {return registerset_;}
+  inline const auto &registers() const { return registerset_; }
 
   // Return the mapping of input op qubits to circuit qubits
-  inline const auto& qubit_map() const {return qubitmap_;}
+  inline const auto &qubit_map() const { return qubitmap_; }
 
   //-----------------------------------------------------------------------
-  // Utility methods 
+  // Utility methods
   //-----------------------------------------------------------------------
 
   // Automatically set the number of qubits, memory, registers, and check
@@ -101,7 +104,7 @@ class Circuit {
   void set_params(bool truncation = false);
 
   // Set the circuit rng seed to random value
-  inline void set_random_seed() {seed = std::random_device()();}
+  inline void set_random_seed() { seed = std::random_device()(); }
 
 private:
   Operations::OpSet opset_;       // Set of operation types contained in circuit
@@ -114,23 +117,21 @@ class Circuit {
   std::unordered_map<uint_t, uint_t> qubitmap_;
 
   // Add type, qubit, memory, conditional metadata information from op
-  void add_op_metadata(const Op& op);
+  void add_op_metadata(const Op &op);
 
   // Reset circuit metadata
   void reset_metadata();
 
   // Helper function for optimized set params
-  bool check_result_ancestor(const Op& op,
-                             std::unordered_set<uint_t>& ancestor_qubits) const;
-  
+  bool check_result_ancestor(const Op &op,
+                             std::unordered_set<uint_t> &ancestor_qubits) const;
+
   // Helper function for optimized set params
-  void remap_qubits(Op& op) const;
+  void remap_qubits(Op &op) const;
 };
 
-
 // Json conversion function
-inline void from_json(const json_t& js, Circuit &circ) {circ = Circuit(js);}
-
+inline void from_json(const json_t &js, Circuit &circ) { circ = Circuit(js); }
 
 //============================================================================
 // Implementation: Circuit methods
@@ -146,11 +147,14 @@ Circuit::Circuit(std::vector<Op> &&_ops, bool truncation) : Circuit() {
   set_params(truncation);
 }
 
-template<typename inputdata_t>
-Circuit::Circuit(const inputdata_t &circ, bool truncation) : Circuit(circ, json_t(), truncation) {}
+template <typename inputdata_t>
+Circuit::Circuit(const inputdata_t &circ, bool truncation)
+    : Circuit(circ, json_t(), truncation) {}
 
-template<typename inputdata_t>
-Circuit::Circuit(const inputdata_t &circ, const json_t &qobj_config, bool truncation) : Circuit() {
+template <typename inputdata_t>
+Circuit::Circuit(const inputdata_t &circ, const json_t &qobj_config,
+                 bool truncation)
+    : Circuit() {
   // Get config
   json_t config = qobj_config;
   if (Parser<inputdata_t>::check_key("config", circ)) {
@@ -160,7 +164,7 @@ Circuit::Circuit(const inputdata_t &circ, const json_t &qobj_config, bool trunca
       config[it.key()] = it.value(); // overwrite circuit level config values
     }
   }
-  
+
   // Load metadata
   Parser<inputdata_t>::get_value(header, "header", circ);
   Parser<json_t>::get_value(shots, "shots", config);
@@ -168,16 +172,17 @@ Circuit::Circuit(const inputdata_t &circ, const json_t &qobj_config, bool trunca
 
   // Load instructions
   if (Parser<inputdata_t>::check_key("instructions", circ) == false) {
-    throw std::invalid_argument("Invalid Qobj experiment: no \"instructions\" field.");
+    throw std::invalid_argument(
+        "Invalid Qobj experiment: no \"instructions\" field.");
   }
   const auto input_ops = Parser<inputdata_t>::get_list("instructions", circ);
-  
+
   // Convert to Ops
-  // TODO: If parser could support reverse iteration through the list of ops without
-  // conversion we could call `get_reversed_ops` on the inputdata without first
-  // converting. 
+  // TODO: If parser could support reverse iteration through the list of ops
+  // without conversion we could call `get_reversed_ops` on the inputdata
+  // without first converting.
   std::vector<Op> converted_ops;
-  for(auto the_op: input_ops){
+  for (auto the_op : input_ops) {
     converted_ops.emplace_back(Operations::input_to_op(the_op));
   }
   ops = std::move(converted_ops);
@@ -187,7 +192,8 @@ Circuit::Circuit(const inputdata_t &circ, const json_t &qobj_config, bool trunca
   uint_t memory_slots = 0;
   Parser<json_t>::get_value(memory_slots, "memory_slots", config);
   if (memory_slots < num_memory) {
-    throw std::invalid_argument("Invalid Qobj experiment: not enough memory slots.");
+    throw std::invalid_argument(
+        "Invalid Qobj experiment: not enough memory slots.");
   }
   // override memory slot number
   num_memory = memory_slots;
@@ -198,7 +204,8 @@ Circuit::Circuit(const inputdata_t &circ, const json_t &qobj_config, bool trunca
     uint_t n_qubits;
     Parser<json_t>::get_value(n_qubits, "n_qubits", config);
     if (n_qubits < num_qubits) {
-      throw std::invalid_argument("Invalid Qobj experiment: n_qubits < instruction qubits.");
+      throw std::invalid_argument(
+          "Invalid Qobj experiment: n_qubits < instruction qubits.");
     }
     if (!truncation) {
       // Override minimal circuit qubit number with qobj number if truncation
@@ -224,14 +231,14 @@ void Circuit::reset_metadata() {
   num_qubits = 0;
   num_memory = 0;
   num_registers = 0;
-  
+
   has_conditional = false;
   can_sample = true;
   first_measure_pos = 0;
   can_sample_initialize = true;
 }
 
-void Circuit::add_op_metadata(const Op& op) {
+void Circuit::add_op_metadata(const Op &op) {
   has_conditional |= op.conditional;
   opset_.insert(op);
   qubitset_.insert(op.qubits.begin(), op.qubits.end());
@@ -248,11 +255,11 @@ void Circuit::add_op_metadata(const Op& op) {
   }
 }
 
-
 void Circuit::set_params(bool truncation) {
-  // Clear current circuit metadata  
+  // Clear current circuit metadata
   reset_metadata();
-  if (ops.empty()) return;
+  if (ops.empty())
+    return;
 
   // Analyze input ops from tail to head to get locations of ancestor,
   // first measurement position and last initialize position
@@ -266,11 +273,11 @@ void Circuit::set_params(bool truncation) {
   bool ops_to_remove = false;
 
   std::unordered_set<uint_t> ancestor_qubits;
-  for (size_t i = 0; i < size; ++ i) {
+  for (size_t i = 0; i < size; ++i) {
     const size_t rpos = size - i - 1;
-    const auto& op = ops[rpos];
+    const auto &op = ops[rpos];
     if (op.type == OpType::mark && last_ancestor_pos == 0)
-        last_ancestor_pos = rpos;
+      last_ancestor_pos = rpos;
     if (!truncation || check_result_ancestor(op, ancestor_qubits)) {
       add_op_metadata(op);
       ancestor[rpos] = true;
@@ -284,7 +291,7 @@ void Circuit::set_params(bool truncation) {
       if (last_ancestor_pos == 0) {
         last_ancestor_pos = rpos;
       }
-    } else if (truncation && !ops_to_remove){
+    } else if (truncation && !ops_to_remove) {
       ops_to_remove = true;
     }
   }
@@ -294,7 +301,7 @@ void Circuit::set_params(bool truncation) {
   if (truncation) {
     // Generate mapping of original qubits to ancestor set
     uint_t idx = 0;
-    for (const auto& qubit: qubitset_) {
+    for (const auto &qubit : qubitset_) {
       if (!remapped_qubits && idx != qubit) {
         // qubits will be remapped
         remapped_qubits = true;
@@ -333,48 +340,47 @@ void Circuit::set_params(bool truncation) {
         continue;
       }
 
-      const auto& op = ops[pos];
+      const auto &op = ops[pos];
       if (op.conditional) {
         can_sample = false;
         break;
       }
 
       switch (op.type) {
-        case OpType::measure:
-        case OpType::roerror: {
-          meas_qubits.insert(op.qubits.begin(), op.qubits.end());
-          tail_meas_ops.push_back(op);
-          break;  
-        }
-        case OpType::snapshot:
-        case OpType::save_state:
-        case OpType::save_expval:
-        case OpType::save_expval_var:
-        case OpType::save_statevec:
-        case OpType::save_statevec_dict:
-        case OpType::save_densmat:
-        case OpType::save_probs:
-        case OpType::save_probs_ket:
-        case OpType::save_amps:
-        case OpType::save_amps_sq:
-        case OpType::save_stabilizer:
-        case OpType::save_clifford:
-        case OpType::save_unitary:
-        case OpType::save_mps:
-        case OpType::save_superop: 
-        {
-          can_sample = false;
-          break;
-        }
-        default: {
-          for (const auto &qubit : op.qubits) {
-            if (meas_qubits.find(qubit) != meas_qubits.end()) {
-              can_sample = false;
-              break;
-            }
+      case OpType::measure:
+      case OpType::roerror: {
+        meas_qubits.insert(op.qubits.begin(), op.qubits.end());
+        tail_meas_ops.push_back(op);
+        break;
+      }
+      case OpType::snapshot:
+      case OpType::save_state:
+      case OpType::save_expval:
+      case OpType::save_expval_var:
+      case OpType::save_statevec:
+      case OpType::save_statevec_dict:
+      case OpType::save_densmat:
+      case OpType::save_probs:
+      case OpType::save_probs_ket:
+      case OpType::save_amps:
+      case OpType::save_amps_sq:
+      case OpType::save_stabilizer:
+      case OpType::save_clifford:
+      case OpType::save_unitary:
+      case OpType::save_mps:
+      case OpType::save_superop: {
+        can_sample = false;
+        break;
+      }
+      default: {
+        for (const auto &qubit : op.qubits) {
+          if (meas_qubits.find(qubit) != meas_qubits.end()) {
+            can_sample = false;
+            break;
           }
-          tail_pos.push_back(pos);
         }
+        tail_pos.push_back(pos);
+      }
       }
       if (!can_sample) {
         break;
@@ -393,7 +399,8 @@ void Circuit::set_params(bool truncation) {
     head_end = last_ancestor_pos + 1;
   }
   for (size_t pos = 0; pos < head_end; ++pos) {
-    if (ops_to_remove && !ancestor[pos] && ops[pos].type != OpType::mark && ops[pos].type != OpType::jump) {
+    if (ops_to_remove && !ancestor[pos] && ops[pos].type != OpType::mark &&
+        ops[pos].type != OpType::jump) {
       // Skip if not ancestor
       continue;
     }
@@ -406,10 +413,11 @@ void Circuit::set_params(bool truncation) {
     if (ops[op_idx].type == OpType::jump) {
       dests.insert(ops[op_idx].string_params[0]);
     } else if (ops[op_idx].type == OpType::mark) {
-      auto& mark_name = ops[op_idx].string_params[0];
+      auto &mark_name = ops[op_idx].string_params[0];
       if (marks.find(mark_name) != marks.end()) {
         std::stringstream msg;
-        msg << "Duplicated mark destination:\"" << mark_name << "\"." << std::endl;
+        msg << "Duplicated mark destination:\"" << mark_name << "\"."
+            << std::endl;
         throw std::runtime_error(msg.str());
       }
       marks.insert(mark_name);
@@ -435,7 +443,7 @@ void Circuit::set_params(bool truncation) {
       if (!ops_to_remove && !ancestor[tpos]) {
         continue;
       }
-      auto& op = ops[tpos];
+      auto &op = ops[tpos];
       if (remapped_qubits) {
         remap_qubits(ops[tpos]);
       }
@@ -446,7 +454,7 @@ void Circuit::set_params(bool truncation) {
     }
     // Now add remaining delayed measure ops
     first_measure_pos = op_idx;
-    for (auto & op : tail_meas_ops) {
+    for (auto &op : tail_meas_ops) {
       if (remapped_qubits) {
         remap_qubits(op);
       }
@@ -461,56 +469,55 @@ void Circuit::set_params(bool truncation) {
   ops.resize(op_idx);
 }
 
-
-void Circuit::remap_qubits(Op& op) const {
+void Circuit::remap_qubits(Op &op) const {
   reg_t new_qubits;
-  for (auto& qubit : op.qubits) {
+  for (auto &qubit : op.qubits) {
     new_qubits.push_back(qubitmap_.at(qubit));
   }
   op.qubits = std::move(new_qubits);
 }
 
-
-bool Circuit::check_result_ancestor(const Op& op, std::unordered_set<uint_t>& ancestor_qubits) const {
+bool Circuit::check_result_ancestor(
+    const Op &op, std::unordered_set<uint_t> &ancestor_qubits) const {
   switch (op.type) {
-    case OpType::barrier:
-    case OpType::nop: {
-      return false;
-    }
-    case OpType::bfunc: {
-      return true;
-    }
-    // Result generating types
-    case OpType::measure:
-    case OpType::roerror:
-    case OpType::snapshot:
-    case OpType::save_state:
-    case OpType::save_expval:
-    case OpType::save_expval_var:
-    case OpType::save_statevec:
-    case OpType::save_statevec_dict:
-    case OpType::save_densmat:
-    case OpType::save_probs:
-    case OpType::save_probs_ket:
-    case OpType::save_amps:
-    case OpType::save_amps_sq:
-    case OpType::save_stabilizer:
-    case OpType::save_clifford:
-    case OpType::save_unitary:
-    case OpType::save_mps:
-    case OpType::save_superop: {
-      ancestor_qubits.insert(op.qubits.begin(), op.qubits.end());
-      return true;
-    }
-    default: {
-      for (const auto& qubit : op.qubits) {
-        if (ancestor_qubits.find(qubit) != ancestor_qubits.end()) {
-          ancestor_qubits.insert(op.qubits.begin(), op.qubits.end());
-          return true;
-        }
+  case OpType::barrier:
+  case OpType::nop: {
+    return false;
+  }
+  case OpType::bfunc: {
+    return true;
+  }
+  // Result generating types
+  case OpType::measure:
+  case OpType::roerror:
+  case OpType::snapshot:
+  case OpType::save_state:
+  case OpType::save_expval:
+  case OpType::save_expval_var:
+  case OpType::save_statevec:
+  case OpType::save_statevec_dict:
+  case OpType::save_densmat:
+  case OpType::save_probs:
+  case OpType::save_probs_ket:
+  case OpType::save_amps:
+  case OpType::save_amps_sq:
+  case OpType::save_stabilizer:
+  case OpType::save_clifford:
+  case OpType::save_unitary:
+  case OpType::save_mps:
+  case OpType::save_superop: {
+    ancestor_qubits.insert(op.qubits.begin(), op.qubits.end());
+    return true;
+  }
+  default: {
+    for (const auto &qubit : op.qubits) {
+      if (ancestor_qubits.find(qubit) != ancestor_qubits.end()) {
+        ancestor_qubits.insert(op.qubits.begin(), op.qubits.end());
+        return true;
       }
-      return false;
     }
+    return false;
+  }
   }
 }
 
diff --git a/src/framework/creg.hpp b/src/framework/creg.hpp
old mode 100755
new mode 100644
index 2a79a0e871..1a0d012865
--- a/src/framework/creg.hpp
+++ b/src/framework/creg.hpp
@@ -16,8 +16,8 @@
 #define _aer_framework_creg_hpp_
 
 #include "framework/operations.hpp"
-#include "framework/utils.hpp"
 #include "framework/rng.hpp"
+#include "framework/utils.hpp"
 
 namespace AER {
 
@@ -29,39 +29,39 @@ namespace AER {
 class ClassicalRegister {
 
 public:
-
   // Return the current value of the memory as little-endian hex-string
-  inline std::string memory_hex() const {return Utils::bin2hex(creg_memory_);}
+  inline std::string memory_hex() const { return Utils::bin2hex(creg_memory_); }
 
   // Return the current value of the memory as little-endian bit-string
-  inline std::string memory_bin() const {return "0b" + creg_memory_;}
+  inline std::string memory_bin() const { return "0b" + creg_memory_; }
 
   // Return the current value of the memory as little-endian hex-string
-  inline std::string register_hex() const {return Utils::bin2hex(creg_register_);}
+  inline std::string register_hex() const {
+    return Utils::bin2hex(creg_register_);
+  }
 
   // Return the current value of the memory as little-endian bit-string
-  inline std::string register_bin() const {return "0b" + creg_register_;}
+  inline std::string register_bin() const { return "0b" + creg_register_; }
 
   // Return the size of the memory bits
-  size_t memory_size() const {return creg_memory_.size();}
+  size_t memory_size() const { return creg_memory_.size(); }
 
   // Return the size of the register bits
-  size_t register_size() const {return creg_register_.size();}
+  size_t register_size() const { return creg_register_.size(); }
 
   // Return a reference to the current value of the memory
   // this is a bit-string without the "0b" prefix.
-  inline auto& creg_memory() {return creg_memory_;}
+  inline auto &creg_memory() { return creg_memory_; }
 
   // Return a reference to the current value of the memory
   // this is a bit-string without the "0b" prefix.
-  inline auto& creg_register() {return creg_register_;}
+  inline auto &creg_register() { return creg_register_; }
 
   // Initialize the memory and register bits to default values (all 0)
   void initialize(size_t num_memory, size_t num_registers);
 
   // Initialize the memory and register bits to specific values
-  void initialize(size_t num_memory,
-                  size_t num_registers,
+  void initialize(size_t num_memory, size_t num_registers,
                   const std::string &memory_hex,
                   const std::string &register_hex);
 
@@ -76,17 +76,18 @@ class ClassicalRegister {
   // Apply readout error instruction to classical registers
   void apply_roerror(const Operations::Op &op, RngEngine &rng);
 
-  // Store a measurement outcome in the specified memory and register bit locations
-  void store_measure(const reg_t &outcome, const reg_t &memory, const reg_t &registers);
+  // Store a measurement outcome in the specified memory and register bit
+  // locations
+  void store_measure(const reg_t &outcome, const reg_t &memory,
+                     const reg_t &registers);
 
 protected:
-
   // Classical registers
   std::string creg_memory_;   // standard classical bit memory
   std::string creg_register_; // optional classical bit register
 
   // Measurement config settings
-  bool return_hex_strings_ = true;       // Set to false for bit-string output
+  bool return_hex_strings_ = true; // Set to false for bit-string output
 };
 
 //============================================================================
@@ -99,9 +100,7 @@ void ClassicalRegister::initialize(size_t num_memory, size_t num_register) {
   creg_register_ = std::string(num_register, '0');
 }
 
-
-void ClassicalRegister::initialize(size_t num_memory,
-                                   size_t num_register,
+void ClassicalRegister::initialize(size_t num_memory, size_t num_register,
                                    const std::string &memory_hex,
                                    const std::string &register_hex) {
   // Convert to bit-string for internal storage
@@ -109,74 +108,77 @@ void ClassicalRegister::initialize(size_t num_memory,
   creg_memory_ = std::move(Utils::padleft_inplace(memory_bin, '0', num_memory));
 
   std::string register_bin = Utils::hex2bin(register_hex, false);
-  creg_register_ = std::move(Utils::padleft_inplace(memory_bin, '0', num_register));
+  creg_register_ =
+      std::move(Utils::padleft_inplace(memory_bin, '0', num_register));
 }
 
-
-void ClassicalRegister::store_measure(const reg_t &outcome,
-                                      const reg_t &memory,
+void ClassicalRegister::store_measure(const reg_t &outcome, const reg_t &memory,
                                       const reg_t &registers) {
   // Assumes memory and registers are either empty or same size as outcome!
   bool use_mem = !memory.empty();
   bool use_reg = !registers.empty();
-  for (size_t j=0; j < outcome.size(); j++) {
+  for (size_t j = 0; j < outcome.size(); j++) {
     if (use_mem) {
       // least significant bit first ordering
-      const size_t pos = creg_memory_.size() - memory[j] - 1; 
+      const size_t pos = creg_memory_.size() - memory[j] - 1;
       creg_memory_[pos] = std::to_string(outcome[j])[0]; // int->string->char
     }
     if (use_reg) {
       // least significant bit first ordering
-      const size_t pos = creg_register_.size() - registers[j] - 1; 
-      creg_register_[pos] = std::to_string(outcome[j])[0];  // int->string->char
+      const size_t pos = creg_register_.size() - registers[j] - 1;
+      creg_register_[pos] = std::to_string(outcome[j])[0]; // int->string->char
     }
   }
 }
 
-
 bool ClassicalRegister::check_conditional(const Operations::Op &op) const {
   // Check if op is conditional
   if (op.conditional)
-    return (creg_register_[creg_register_.size() - op.conditional_reg - 1] == '1');
+    return (creg_register_[creg_register_.size() - op.conditional_reg - 1] ==
+            '1');
 
   // Op is not conditional
   return true;
 }
 
-
 void ClassicalRegister::apply_bfunc(const Operations::Op &op) {
 
   // Check input is boolean function op
   if (op.type != Operations::OpType::bfunc) {
-    throw std::invalid_argument("ClassicalRegister::apply_bfunc: Input is not a bfunc op.");
+    throw std::invalid_argument(
+        "ClassicalRegister::apply_bfunc: Input is not a bfunc op.");
   }
 
   const std::string &mask = op.string_params[0];
   const std::string &target_val = op.string_params[1];
-  int_t compared; // if equal this should be 0, if less than -1, if greater than +1
+  int_t compared; // if equal this should be 0, if less than -1, if greater than
+                  // +1
 
   // Check if register size fits into a 64-bit integer
   if (creg_register_.size() <= 64) {
-    uint_t reg_int = std::stoull(creg_register_, nullptr, 2); // stored as bitstring
+    uint_t reg_int =
+        std::stoull(creg_register_, nullptr, 2);      // stored as bitstring
     uint_t mask_int = std::stoull(mask, nullptr, 16); // stored as hexstring
-    uint_t target_int = std::stoull(target_val, nullptr, 16); // stored as hexstring
+    uint_t target_int =
+        std::stoull(target_val, nullptr, 16); // stored as hexstring
     compared = (reg_int & mask_int) - target_int;
   } else {
-    // We need to use big ints so we implement the bit-mask via the binary string
-    // representation rather than using a big integer class
+    // We need to use big ints so we implement the bit-mask via the binary
+    // string representation rather than using a big integer class
     std::string mask_bin = Utils::hex2bin(mask, false);
     size_t length = std::min(mask_bin.size(), creg_register_.size());
     std::string masked_val = std::string(length, '0');
     for (size_t rev_pos = 0; rev_pos < length; rev_pos++) {
-      masked_val[length - 1 - rev_pos] = (mask_bin[mask_bin.size() - 1 - rev_pos] 
-                                          & creg_register_[creg_register_.size() - 1 - rev_pos]);
+      masked_val[length - 1 - rev_pos] =
+          (mask_bin[mask_bin.size() - 1 - rev_pos] &
+           creg_register_[creg_register_.size() - 1 - rev_pos]);
     }
     // remove leading 0's
     size_t end_i = masked_val.find('1');
     if (end_i == std::string::npos)
-        masked_val = "0";
+      masked_val = "0";
     else
-        masked_val.erase(0, end_i);
+      masked_val.erase(0, end_i);
 
     masked_val = Utils::bin2hex(masked_val); // convert to hex string
     // Using string comparison to compare to target value
@@ -185,51 +187,53 @@ void ClassicalRegister::apply_bfunc(const Operations::Op &op) {
   // check value of compared integer for different comparison operations
   bool outcome;
   switch (op.bfunc) {
-    case Operations::RegComparison::Equal:
-      outcome = (compared == 0);
-      break;
-    case Operations::RegComparison::NotEqual:
-      outcome = (compared != 0);
-      break;
-    case Operations::RegComparison::Less:
-      outcome = (compared < 0);
-      break;
-    case Operations::RegComparison::LessEqual:
-      outcome = (compared <= 0);
-      break;
-    case Operations::RegComparison::Greater:
-      outcome = (compared > 0);
-      break;
-    case Operations::RegComparison::GreaterEqual:
-      outcome = (compared >= 0);
-      break;
-    default:
-      // we shouldn't ever get here
-      throw std::invalid_argument("Invalid boolean function relation.");
+  case Operations::RegComparison::Equal:
+    outcome = (compared == 0);
+    break;
+  case Operations::RegComparison::NotEqual:
+    outcome = (compared != 0);
+    break;
+  case Operations::RegComparison::Less:
+    outcome = (compared < 0);
+    break;
+  case Operations::RegComparison::LessEqual:
+    outcome = (compared <= 0);
+    break;
+  case Operations::RegComparison::Greater:
+    outcome = (compared > 0);
+    break;
+  case Operations::RegComparison::GreaterEqual:
+    outcome = (compared >= 0);
+    break;
+  default:
+    // we shouldn't ever get here
+    throw std::invalid_argument("Invalid boolean function relation.");
   }
   // Store outcome in register
   if (op.registers.size() > 0) {
-    const size_t pos = creg_register_.size() - op.registers[0] - 1; 
+    const size_t pos = creg_register_.size() - op.registers[0] - 1;
     creg_register_[pos] = (outcome) ? '1' : '0';
   }
   // Optionally store outcome in memory
   if (op.memory.size() > 0) {
-    const size_t pos = creg_memory_.size() - op.memory[0] - 1; 
+    const size_t pos = creg_memory_.size() - op.memory[0] - 1;
     creg_memory_[pos] = (outcome) ? '1' : '0';
   }
 }
 
 // Apply readout error instruction to classical registers
-void ClassicalRegister::apply_roerror(const Operations::Op &op, RngEngine &rng) {
-  
+void ClassicalRegister::apply_roerror(const Operations::Op &op,
+                                      RngEngine &rng) {
+
   // Check input is readout error op
   if (op.type != Operations::OpType::roerror) {
-    throw std::invalid_argument("ClassicalRegister::apply_roerror Input is not a readout error op.");
+    throw std::invalid_argument(
+        "ClassicalRegister::apply_roerror Input is not a readout error op.");
   }
-  
+
   // Get current classical bit (and optionally register bit) values
   std::string mem_str;
-  
+
   // Get values of bits as binary string
   // We iterate from the end of the list of memory bits
   for (auto it = op.memory.rbegin(); it < op.memory.rend(); ++it) {
@@ -241,12 +245,14 @@ void ClassicalRegister::apply_roerror(const Operations::Op &op, RngEngine &rng)
   auto noise_str = Utils::int2string(outcome, 2, op.memory.size());
   for (size_t pos = 0; pos < op.memory.size(); ++pos) {
     auto bit = op.memory[pos];
-    creg_memory_[creg_memory_.size() - 1 - bit] = noise_str[noise_str.size() - 1 - pos];
+    creg_memory_[creg_memory_.size() - 1 - bit] =
+        noise_str[noise_str.size() - 1 - pos];
   }
   // and the same error to register classical bits if they are used
   for (size_t pos = 0; pos < op.registers.size(); ++pos) {
     auto bit = op.registers[pos];
-    creg_register_[creg_register_.size() - 1 - bit] = noise_str[noise_str.size() - 1 - pos];
+    creg_register_[creg_register_.size() - 1 - bit] =
+        noise_str[noise_str.size() - 1 - pos];
   }
 }
 
diff --git a/src/framework/json.hpp b/src/framework/json.hpp
old mode 100755
new mode 100644
index 945a0aee01..7e5a7e70c2
--- a/src/framework/json.hpp
+++ b/src/framework/json.hpp
@@ -47,7 +47,7 @@ namespace JSON {
  * @param name: file name to load.
  * @returns: the loaded json.
  */
-inline json_t load(const std::string& name);
+inline json_t load(const std::string &name);
 
 /**
  * Check if a key exists in a json_t object.
@@ -55,7 +55,7 @@ inline json_t load(const std::string& name);
  * @param js: the json_t to search for key.
  * @returns: true if the key exists, false otherwise.
  */
-inline bool check_key(const std::string& key, const json_t &js);
+inline bool check_key(const std::string &key, const json_t &js);
 
 /**
  * Check if all keys exists in a json_t object.
@@ -63,7 +63,7 @@ inline bool check_key(const std::string& key, const json_t &js);
  * @param js: the json_t to search for keys.
  * @returns: true if all keys exists, false otherwise.
  */
-inline bool check_keys(const std::vector<std::string>& keys, const json_t &js);
+inline bool check_keys(const std::vector<std::string> &keys, const json_t &js);
 
 /**
  * Load a json_t object value into a variable if the key name exists.
@@ -72,9 +72,10 @@ inline bool check_keys(const std::vector<std::string>& keys, const json_t &js);
  * @param js: the json_t to search for key.
  * @returns: true if the keys exists and val was set, false otherwise.
  */
-template <typename T> bool get_value(T &var, const std::string& key, const json_t &js);
+template <typename T>
+bool get_value(T &var, const std::string &key, const json_t &js);
 
-const json_t& get_value(const std::string& key, const json_t &js);
+const json_t &get_value(const std::string &key, const json_t &js);
 
 } // end namespace JSON
 
@@ -140,10 +141,8 @@ void to_json(json_t &js, const std::map<uint64_t, T1, T2> &map);
  * @param js a json_t object to contain converted type.
  * @param mat a matrix to convert.
  */
-template<class T> 
-void from_json(const json_t &js, matrix<T> &mat);
-template<class T>
-void to_json(json_t &js, const matrix<T> &mat);
+template <class T> void from_json(const json_t &js, matrix<T> &mat);
+template <class T> void to_json(json_t &js, const matrix<T> &mat);
 
 /*******************************************************************************
  *
@@ -155,7 +154,7 @@ void to_json(json_t &js, const matrix<T> &mat);
 // JSON Helper Functions
 //------------------------------------------------------------------------------
 
-json_t JSON::load(const std::string& name) {
+json_t JSON::load(const std::string &name) {
   if (name == "") {
     json_t js;
     return js; // Return empty node if no config file
@@ -176,7 +175,7 @@ json_t JSON::load(const std::string& name) {
   return js;
 }
 
-bool JSON::check_key(const std::string& key, const json_t &js) {
+bool JSON::check_key(const std::string &key, const json_t &js) {
   // returns false if the value is 'null'
   if (js.find(key) != js.end() && !js[key].is_null())
     return true;
@@ -184,15 +183,15 @@ bool JSON::check_key(const std::string& key, const json_t &js) {
     return false;
 }
 
-bool JSON::check_keys(const std::vector<std::string>& keys, const json_t &js) {
+bool JSON::check_keys(const std::vector<std::string> &keys, const json_t &js) {
   bool pass = true;
-  for (const auto& s : keys)
+  for (const auto &s : keys)
     pass &= check_key(s, js);
   return pass;
 }
 
 template <typename T>
-bool JSON::get_value(T &var, const std::string& key, const json_t &js) {
+bool JSON::get_value(T &var, const std::string &key, const json_t &js) {
   if (check_key(key, js)) {
     var = js[key].get<T>();
     return true;
@@ -201,8 +200,8 @@ bool JSON::get_value(T &var, const std::string& key, const json_t &js) {
   }
 }
 
-const json_t& JSON::get_value(const std::string& key, const json_t &js){
-    return js[key];
+const json_t &JSON::get_value(const std::string &key, const json_t &js) {
+  return js[key];
 }
 
 //------------------------------------------------------------------------------
@@ -221,8 +220,7 @@ void std::from_json(const json_t &js, std::complex<RealType> &z) {
   else if (js.is_array() && js.size() == 2) {
     z = std::complex<RealType>{js[0].get<RealType>(), js[1].get<RealType>()};
   } else {
-    throw std::invalid_argument(
-        std::string("JSON: invalid complex number"));
+    throw std::invalid_argument(std::string("JSON: invalid complex number"));
   }
 }
 
@@ -236,16 +234,15 @@ void std::to_json(json_t &js, const std::vector<std::complex<RealType>> &vec) {
 }
 
 template <typename RealType>
-void std::from_json(const json_t &js, std::vector<std::complex<RealType>> &vec) {
+void std::from_json(const json_t &js,
+                    std::vector<std::complex<RealType>> &vec) {
   std::vector<std::complex<RealType>> ret;
   if (js.is_array()) {
     for (auto &elt : js)
       ret.push_back(elt);
     vec = ret;
-  } 
-  else {
-    throw std::invalid_argument(
-        std::string("JSON: invalid complex vector."));
+  } else {
+    throw std::invalid_argument(std::string("JSON: invalid complex vector."));
   }
 }
 
@@ -286,15 +283,14 @@ template <typename T> void to_json(json_t &js, const matrix<T> &mat) {
   }
 }
 
-
 template <typename T> void from_json(const json_t &js, matrix<T> &mat) {
   // Check JSON is an array
-  if(!js.is_array()) {
+  if (!js.is_array()) {
     throw std::invalid_argument(
         std::string("JSON: invalid matrix (not array)."));
   }
   // Check JSON isn't empty
-  if(js.empty()) {
+  if (js.empty()) {
     throw std::invalid_argument(
         std::string("JSON: invalid matrix (empty array)."));
   }
@@ -305,7 +301,7 @@ template <typename T> void from_json(const json_t &js, matrix<T> &mat) {
   size_t nrows = js.size();
   for (auto &row : js)
     rows_valid &= (row.is_array() && row.size() == ncols);
-  if(!rows_valid) {
+  if (!rows_valid) {
     throw std::invalid_argument(
         std::string("JSON: invalid matrix (rows different sizes)."));
   }
diff --git a/src/framework/json_parser.hpp b/src/framework/json_parser.hpp
index 882af3efe0..68a265536d 100644
--- a/src/framework/json_parser.hpp
+++ b/src/framework/json_parser.hpp
@@ -17,72 +17,65 @@
 
 #include "json.hpp"
 
-
-namespace AER{
+namespace AER {
 // This structure is to avoid overload resolving to the wron function,
 // as py::objects can always be implicitly converted to json, though
 // can break at runtime, or even worse trasnform to json and then to c++
 // without notice.
-template <typename inputdata_t>
-struct Parser {};
+template <typename inputdata_t> struct Parser {};
 
-template <>
-struct Parser<json_t> {
-    Parser() = delete;
+template <> struct Parser<json_t> {
+  Parser() = delete;
 
-    template <typename T>
-    static bool get_value(T &var, const std::string& key, const json_t &js){
-        return JSON::get_value(var, key, js);
-    }
+  template <typename T>
+  static bool get_value(T &var, const std::string &key, const json_t &js) {
+    return JSON::get_value(var, key, js);
+  }
 
-    static bool check_key(const std::string& key, const json_t &js){
-        return JSON::check_key(key, js);
-    }
+  static bool check_key(const std::string &key, const json_t &js) {
+    return JSON::check_key(key, js);
+  }
 
-    static const json_t& get_value(const std::string& key, const json_t &js){
-        return JSON::get_value(key, js);
-    }
+  static const json_t &get_value(const std::string &key, const json_t &js) {
+    return JSON::get_value(key, js);
+  }
 
-    static bool check_keys(const std::vector<std::string>& keys, const json_t &js) {
-        return JSON::check_keys(keys, js);
-    }
+  static bool check_keys(const std::vector<std::string> &keys,
+                         const json_t &js) {
+    return JSON::check_keys(keys, js);
+  }
 
-    static bool is_array(const json_t &js){
-        return js.is_array();
-    }
+  static bool is_array(const json_t &js) { return js.is_array(); }
 
-    static bool is_array(const std::string& key, const json_t &js){
-        return js[key].is_array();
-    }
+  static bool is_array(const std::string &key, const json_t &js) {
+    return js[key].is_array();
+  }
 
-    static const json_t& get_as_list(const json_t& js){
-        if(!is_array(js)){
-            throw std::runtime_error("Object is not a list!");
-        }
-        return js;
+  static const json_t &get_as_list(const json_t &js) {
+    if (!is_array(js)) {
+      throw std::runtime_error("Object is not a list!");
     }
+    return js;
+  }
 
-    static const json_t& get_list(const std::string& key, const json_t &js){
-        if(!is_array(key, js)){
-            throw std::runtime_error("Object " + key + "is not a list!");
-        }
-        return JSON::get_value(key, js);
+  static const json_t &get_list(const std::string &key, const json_t &js) {
+    if (!is_array(key, js)) {
+      throw std::runtime_error("Object " + key + "is not a list!");
     }
+    return JSON::get_value(key, js);
+  }
 
+  static bool is_number(const std::string &key, const json_t &js) {
+    return js[key].is_number();
+  }
 
-    static bool is_number(const std::string& key, const json_t &js){
-        return js[key].is_number();
-    }
+  static std::string dump(const json_t &js) { return js.dump(); }
 
-    static std::string dump(const json_t& js){
-        return js.dump();
-    }
-
-    template <typename T>
-    static T get_list_elem(const json_t& js, unsigned int i){
-        return js[i];
-    }
+  template <typename T>
+  static T get_list_elem(const json_t &js, unsigned int i) {
+    return js[i];
+  }
 };
-}
+} // namespace AER
 
 #endif // _aer_framework_json_parser_hpp_
diff --git a/src/framework/linalg/almost_equal.hpp b/src/framework/linalg/almost_equal.hpp
old mode 100755
new mode 100644
index 387cd9d3bc..f4a645d455
--- a/src/framework/linalg/almost_equal.hpp
+++ b/src/framework/linalg/almost_equal.hpp
@@ -29,27 +29,28 @@ namespace Linalg {
 // If we have numbers closer to 0, then max_diff can be set to a value
 // way smaller than epsilon. For numbers larger than 1.0, epsilon will
 // scale (the bigger the number, the bigger the epsilon).
-template <typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value, T>::type >
-bool almost_equal(T f1, T f2,
-                  T max_diff = std::numeric_limits<T>::epsilon(),
+template <typename T, typename = typename std::enable_if<
+                          std::is_arithmetic<T>::value, T>::type>
+bool almost_equal(T f1, T f2, T max_diff = std::numeric_limits<T>::epsilon(),
                   T max_relative_diff = std::numeric_limits<T>::epsilon()) {
-    T diff = std::abs(f1 - f2);
-    if (diff <= max_diff) return true;
+  T diff = std::abs(f1 - f2);
+  if (diff <= max_diff)
+    return true;
 
-    return diff <= max_relative_diff * std::max(std::abs(f1), std::abs(f2));
+  return diff <= max_relative_diff * std::max(std::abs(f1), std::abs(f2));
 }
 
 template <typename T>
-bool almost_equal(const std::complex<T>& f1, const std::complex<T>& f2,
+bool almost_equal(const std::complex<T> &f1, const std::complex<T> &f2,
                   T max_diff = std::numeric_limits<T>::epsilon(),
                   T max_relative_diff = std::numeric_limits<T>::epsilon()) {
-    return almost_equal<T>(f1.real(), f2.real(), max_diff, max_relative_diff)
-         && almost_equal<T>(f1.imag(), f2.imag(), max_diff, max_relative_diff);
+  return almost_equal<T>(f1.real(), f2.real(), max_diff, max_relative_diff) &&
+         almost_equal<T>(f1.imag(), f2.imag(), max_diff, max_relative_diff);
 }
 
 //------------------------------------------------------------------------------
-}  // namespace Linalg
+} // namespace Linalg
 //------------------------------------------------------------------------------
-}  // end namespace AER
+} // end namespace AER
 //------------------------------------------------------------------------------
 #endif
diff --git a/src/framework/linalg/eigensystem.hpp b/src/framework/linalg/eigensystem.hpp
index da0cc10d58..5559006ea1 100644
--- a/src/framework/linalg/eigensystem.hpp
+++ b/src/framework/linalg/eigensystem.hpp
@@ -15,66 +15,62 @@
 #ifndef _aer_framework_linalg_eigensystem_hpp_
 #define _aer_framework_linalg_eigensystem_hpp_
 
-#include <type_traits>
 #include "framework/blas_protos.hpp"
 #include "framework/matrix.hpp"
-
+#include <type_traits>
 
 /**
  * Returns the eigenvalues and eigenvectors
  * of a Hermitian matrix.
  * Uses the blas function ?heevx
  * @param hermitian_matrix: The Hermitian matrix.
- * @param eigenvalues: On output: vector with the eignevalues of the matrix (input is overwritten)
- * @param eigenvectors: On output: matrix with the eigenvectors stored as columns.
+ * @param eigenvalues: On output: vector with the eignevalues of the matrix
+ * (input is overwritten)
+ * @param eigenvectors: On output: matrix with the eigenvectors stored as
+ * columns.
  *
  * @returns: void
  */
 template <class T>
-void eigensystem_hermitian(const matrix<std::complex<T>>& hermitian_matrix,
-               /* out */ std::vector<T>& eigenvalues,
-               /* out */ matrix<std::complex<T>>& eigenvectors);
+void eigensystem_hermitian(const matrix<std::complex<T>> &hermitian_matrix,
+                           /* out */ std::vector<T> &eigenvalues,
+                           /* out */ matrix<std::complex<T>> &eigenvectors);
 
+template <typename T> struct HeevxFuncs;
 
-template<typename T>
-struct HeevxFuncs;
-
-template<>
-struct HeevxFuncs<double>{
+template <> struct HeevxFuncs<double> {
   HeevxFuncs() = delete;
-  static decltype(zheevx_)& heevx;
-  static decltype(dlamch_)& lamch;
+  static decltype(zheevx_) &heevx;
+  static decltype(dlamch_) &lamch;
 };
 
-decltype(zheevx_)& HeevxFuncs<double>::heevx = zheevx_;
-decltype(dlamch_)& HeevxFuncs<double>::lamch = dlamch_;
+decltype(zheevx_) &HeevxFuncs<double>::heevx = zheevx_;
+decltype(dlamch_) &HeevxFuncs<double>::lamch = dlamch_;
 
-template<>
-struct HeevxFuncs<float>{
+template <> struct HeevxFuncs<float> {
   HeevxFuncs() = delete;
-  static decltype(cheevx_)& heevx;
-  static decltype(slamch_)& lamch;
+  static decltype(cheevx_) &heevx;
+  static decltype(slamch_) &lamch;
 };
 
-decltype(cheevx_)& HeevxFuncs<float>::heevx = cheevx_;
-decltype(slamch_)& HeevxFuncs<float>::lamch = slamch_;
-
+decltype(cheevx_) &HeevxFuncs<float>::heevx = cheevx_;
+decltype(slamch_) &HeevxFuncs<float>::lamch = slamch_;
 
 template <typename T>
-void eigensystem_hermitian(const matrix<std::complex<T>>& hermitian_matrix,
-                           std::vector<T>& eigenvalues,
-                           matrix<std::complex<T>>& eigenvectors) {
-  if ( hermitian_matrix.GetRows() != hermitian_matrix.GetColumns() ) {
+void eigensystem_hermitian(const matrix<std::complex<T>> &hermitian_matrix,
+                           std::vector<T> &eigenvalues,
+                           matrix<std::complex<T>> &eigenvectors) {
+  if (hermitian_matrix.GetRows() != hermitian_matrix.GetColumns()) {
     throw std::runtime_error("Input matrix in eigensystem_hermitian "
                              "function is not a square matrix.");
   }
 
   int n = static_cast<int>(hermitian_matrix.GetLD());
-  int ldz{n}, lda{n}, lwork{2*n};
-  int il{0}, iu{0}; // not referenced if range='A'
+  int ldz{n}, lda{n}, lwork{2 * n};
+  int il{0}, iu{0};   // not referenced if range='A'
   T vl{0.0}, vu{0.0}; // not referenced if range='A'
   char cmach{'S'};
-  T abstol{static_cast<T>(2.0*HeevxFuncs<T>::lamch(&cmach))};
+  T abstol{static_cast<T>(2.0 * HeevxFuncs<T>::lamch(&cmach))};
   int m{0}; // number of eigenvalues found
   int info{0};
 
@@ -83,18 +79,20 @@ void eigensystem_hermitian(const matrix<std::complex<T>>& hermitian_matrix,
   eigenvalues.resize(n);
   matrix<std::complex<T>> heevx_copy{hermitian_matrix};
   auto work = std::vector<std::complex<T>>(lwork, {0.0, 0.0});
-  auto rwork = std::vector<T>(7*n, 0.0);
-  auto iwork = std::vector<int>(5*n, 0);
+  auto rwork = std::vector<T>(7 * n, 0.0);
+  auto iwork = std::vector<int>(5 * n, 0);
   auto ifail = std::vector<int>(n, 0);
 
-  HeevxFuncs<T>::heevx(&AerBlas::Jobz[0], &AerBlas::Range[0], &AerBlas::UpLo[0], &n,
-                       heevx_copy.data(), &lda, &vl, &vu, &il, &iu,
-                       &abstol, &m, eigenvalues.data(), eigenvectors.data(), &ldz, work.data(),
-                       &lwork, rwork.data(), iwork.data(), ifail.data(), &info);
+  HeevxFuncs<T>::heevx(&AerBlas::Jobz[0], &AerBlas::Range[0], &AerBlas::UpLo[0],
+                       &n, heevx_copy.data(), &lda, &vl, &vu, &il, &iu, &abstol,
+                       &m, eigenvalues.data(), eigenvectors.data(), &ldz,
+                       work.data(), &lwork, rwork.data(), iwork.data(),
+                       ifail.data(), &info);
 
-  if(info){
-      throw std::runtime_error("Something went wrong in heevx call within eigensystem_hermitian funcion. "
-                               "Check that input matrix is really hermitian");
+  if (info) {
+    throw std::runtime_error("Something went wrong in heevx call within "
+                             "eigensystem_hermitian funcion. "
+                             "Check that input matrix is really hermitian");
   }
 }
 
diff --git a/src/framework/linalg/linops/linops_aer_vector.hpp b/src/framework/linalg/linops/linops_aer_vector.hpp
old mode 100755
new mode 100644
index ba6ebc190f..708d04cfae
--- a/src/framework/linalg/linops/linops_aer_vector.hpp
+++ b/src/framework/linalg/linops/linops_aer_vector.hpp
@@ -31,23 +31,23 @@ namespace Linalg {
 // Linear operations
 //----------------------------------------------------------------------------
 template <class T, typename = enable_if_numeric_t<T>>
-Vector<T> add(const Vector<T>& lhs, const Vector<T>& rhs) {
+Vector<T> add(const Vector<T> &lhs, const Vector<T> &rhs) {
   return lhs + rhs;
 }
 
 template <class T, typename = enable_if_numeric_t<T>>
-Vector<T>& iadd(Vector<T>& lhs, const Vector<T>& rhs) {
+Vector<T> &iadd(Vector<T> &lhs, const Vector<T> &rhs) {
   lhs += rhs;
   return lhs;
 }
 
 template <class T, typename = enable_if_numeric_t<T>>
-Vector<T> sub(const Vector<T>& lhs, const Vector<T>& rhs) {
+Vector<T> sub(const Vector<T> &lhs, const Vector<T> &rhs) {
   return lhs - rhs;
 }
 
 template <class T, typename = enable_if_numeric_t<T>>
-Vector<T>& isub(Vector<T>& lhs, const Vector<T>& rhs) {
+Vector<T> &isub(Vector<T> &lhs, const Vector<T> &rhs) {
   lhs -= rhs;
   return lhs;
 }
@@ -57,30 +57,29 @@ Vector<T>& isub(Vector<T>& lhs, const Vector<T>& rhs) {
 //----------------------------------------------------------------------------
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-Vector<T>& iadd(Vector<T>& data, const Scalar& val) {
+Vector<T> &iadd(Vector<T> &data, const Scalar &val) {
   const T cast_val(val);
   std::for_each(data.data(), data.data() + data.size(),
-                [&cast_val](T& a)->T{ a += cast_val; });
+                [&cast_val](T &a) -> T { a += cast_val; });
   return data;
 }
 
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-Vector<T> add(const Vector<T>& data, const Scalar& val) {
+Vector<T> add(const Vector<T> &data, const Scalar &val) {
   auto ret = data;
   return iadd(data, val);
 }
 
-
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-Vector<T> sub(const Vector<T>& data, const Scalar& val) {
+Vector<T> sub(const Vector<T> &data, const Scalar &val) {
   return add(data, -val);
 }
 
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-Vector<T>& isub(Vector<T>& data, const Scalar& val) {
+Vector<T> &isub(Vector<T> &data, const Scalar &val) {
   return iadd(data, -val);
 }
 
@@ -89,7 +88,7 @@ Vector<T>& isub(Vector<T>& data, const Scalar& val) {
 //----------------------------------------------------------------------------
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-Vector<T>& imul(Vector<T>& data, const Scalar& val) {
+Vector<T> &imul(Vector<T> &data, const Scalar &val) {
   if (almost_equal<Scalar>(val, 1)) {
     return data;
   }
@@ -99,14 +98,14 @@ Vector<T>& imul(Vector<T>& data, const Scalar& val) {
 
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-Vector<T> mul(const Vector<T>& data, const Scalar& val) {
+Vector<T> mul(const Vector<T> &data, const Scalar &val) {
   auto ret = data;
   return imul(ret, val);
 }
 
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-Vector<T>& idiv(Vector<T>& data, const Scalar& val) {
+Vector<T> &idiv(Vector<T> &data, const Scalar &val) {
   if (almost_equal<Scalar>(val, 1)) {
     return data;
   }
@@ -114,17 +113,16 @@ Vector<T>& idiv(Vector<T>& data, const Scalar& val) {
   return data;
 }
 
-
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-Vector<T> div(const Vector<T>& data, const Scalar& val) {
+Vector<T> div(const Vector<T> &data, const Scalar &val) {
   auto ret = data;
   return idiv(ret, val);
 }
 
 //------------------------------------------------------------------------------
-}  // end namespace Linalg
+} // end namespace Linalg
 //------------------------------------------------------------------------------
-}  // end namespace AER
+} // end namespace AER
 //------------------------------------------------------------------------------
 #endif
\ No newline at end of file
diff --git a/src/framework/linalg/linops/linops_array.hpp b/src/framework/linalg/linops/linops_array.hpp
old mode 100755
new mode 100644
index 1211cb7dbe..4c1df3bac0
--- a/src/framework/linalg/linops/linops_array.hpp
+++ b/src/framework/linalg/linops/linops_array.hpp
@@ -31,27 +31,27 @@ namespace Linalg {
 // Linear operations
 //----------------------------------------------------------------------------
 template <class T, size_t N, typename = enable_if_numeric_t<T>>
-std::array<T, N>& iadd(std::array<T, N>& lhs, const std::array<T, N>& rhs) {
+std::array<T, N> &iadd(std::array<T, N> &lhs, const std::array<T, N> &rhs) {
   std::transform(lhs.begin(), lhs.end(), rhs.begin(), lhs.begin(),
                  std::plus<T>());
   return lhs;
 }
 
 template <class T, size_t N, typename = enable_if_numeric_t<T>>
-std::array<T, N> add(const std::array<T, N>& lhs, const std::array<T, N>& rhs) {
+std::array<T, N> add(const std::array<T, N> &lhs, const std::array<T, N> &rhs) {
   std::array<T, N> result = lhs;
   return iadd(result, rhs);
 }
 
 template <class T, size_t N, typename = enable_if_numeric_t<T>>
-std::array<T, N>& isub(std::array<T, N>& lhs, const std::array<T, N>& rhs) {
+std::array<T, N> &isub(std::array<T, N> &lhs, const std::array<T, N> &rhs) {
   std::transform(lhs.begin(), lhs.end(), rhs.begin(), lhs.begin(),
                  std::minus<T>());
   return lhs;
 }
 
 template <class T, size_t N, typename = enable_if_numeric_t<T>>
-std::array<T, N> sub(const std::array<T, N>& lhs, const std::array<T, N>& rhs) {
+std::array<T, N> sub(const std::array<T, N> &lhs, const std::array<T, N> &rhs) {
   std::array<T, N> result = lhs;
   return isub(result, rhs);
 }
@@ -61,7 +61,7 @@ std::array<T, N> sub(const std::array<T, N>& lhs, const std::array<T, N>& rhs) {
 //----------------------------------------------------------------------------
 template <class T, size_t N, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-std::array<T, N>& iadd(std::array<T, N>& data, const Scalar& val) {
+std::array<T, N> &iadd(std::array<T, N> &data, const Scalar &val) {
   std::transform(data.begin(), data.end(), data.begin(),
                  std::bind(std::plus<T>(), std::placeholders::_1, val));
   return data;
@@ -69,14 +69,14 @@ std::array<T, N>& iadd(std::array<T, N>& data, const Scalar& val) {
 
 template <class T, size_t N, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-std::array<T, N> add(const std::array<T, N>& data, const Scalar& val) {
+std::array<T, N> add(const std::array<T, N> &data, const Scalar &val) {
   std::array<T, N> result = data;
   return iadd(result, val);
 }
 
 template <class T, size_t N, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-std::array<T, N>& isub(std::array<T, N>& data, const Scalar& val) {
+std::array<T, N> &isub(std::array<T, N> &data, const Scalar &val) {
   std::transform(data.begin(), data.end(), data.begin(),
                  std::bind(std::minus<T>(), std::placeholders::_1, val));
   return data;
@@ -84,7 +84,7 @@ std::array<T, N>& isub(std::array<T, N>& data, const Scalar& val) {
 
 template <class T, size_t N, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-std::array<T, N> sub(const std::array<T, N>& data, const Scalar& val) {
+std::array<T, N> sub(const std::array<T, N> &data, const Scalar &val) {
   std::array<T, N> result = data;
   return isub(result, val);
 }
@@ -94,7 +94,7 @@ std::array<T, N> sub(const std::array<T, N>& data, const Scalar& val) {
 //----------------------------------------------------------------------------
 template <class T, size_t N, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-std::array<T, N>& imul(std::array<T, N>& data, const Scalar& val) {
+std::array<T, N> &imul(std::array<T, N> &data, const Scalar &val) {
   std::transform(data.begin(), data.end(), data.begin(),
                  std::bind(std::multiplies<T>(), std::placeholders::_1, val));
   return data;
@@ -102,14 +102,14 @@ std::array<T, N>& imul(std::array<T, N>& data, const Scalar& val) {
 
 template <class T, size_t N, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-std::array<T, N> mul(const std::array<T, N>& data, const Scalar& val) {
+std::array<T, N> mul(const std::array<T, N> &data, const Scalar &val) {
   std::array<T, N> result = data;
   return imul(result, val);
 }
 
 template <class T, size_t N, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-std::array<T, N>& idiv(std::array<T, N>& data, const Scalar& val) {
+std::array<T, N> &idiv(std::array<T, N> &data, const Scalar &val) {
   std::transform(data.begin(), data.end(), data.begin(),
                  std::bind(std::divides<T>(), std::placeholders::_1, val));
   return data;
@@ -117,14 +117,14 @@ std::array<T, N>& idiv(std::array<T, N>& data, const Scalar& val) {
 
 template <class T, size_t N, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-std::array<T, N> div(const std::array<T, N>& data, const Scalar& val) {
+std::array<T, N> div(const std::array<T, N> &data, const Scalar &val) {
   std::array<T, N> result = data;
   return idiv(result, val);
 }
 
 //------------------------------------------------------------------------------
-}  // end namespace Linalg
+} // end namespace Linalg
 //------------------------------------------------------------------------------
-}  // end namespace AER
+} // end namespace AER
 //------------------------------------------------------------------------------
 #endif
\ No newline at end of file
diff --git a/src/framework/linalg/linops/linops_generic.hpp b/src/framework/linalg/linops/linops_generic.hpp
old mode 100755
new mode 100644
index f85b04e370..40d24f7493
--- a/src/framework/linalg/linops/linops_generic.hpp
+++ b/src/framework/linalg/linops/linops_generic.hpp
@@ -29,24 +29,20 @@ namespace Linalg {
 //----------------------------------------------------------------------------
 // Linear operations
 //----------------------------------------------------------------------------
-template <class T>
-T add(const T& lhs, const T& rhs) {
+template <class T> T add(const T &lhs, const T &rhs) {
   return std::plus<T>()(lhs, rhs);
 }
 
-template <class T>
-T& iadd(T& lhs, const T& rhs) {
+template <class T> T &iadd(T &lhs, const T &rhs) {
   lhs = std::plus<T>()(lhs, rhs);
   return lhs;
 }
 
-template <class T>
-T sub(const T& lhs, const T& rhs) {
+template <class T> T sub(const T &lhs, const T &rhs) {
   return std::minus<T>()(lhs, rhs);
 }
 
-template <class T>
-T& isub(T& lhs, const T& rhs) {
+template <class T> T &isub(T &lhs, const T &rhs) {
   lhs = std::minus<T>()(lhs, rhs);
   return lhs;
 }
@@ -55,23 +51,23 @@ T& isub(T& lhs, const T& rhs) {
 // Affine operations
 //----------------------------------------------------------------------------
 template <class T, class Scalar, typename = enable_if_numeric_t<Scalar>>
-T add(const T& data, const Scalar& val) {
+T add(const T &data, const Scalar &val) {
   return std::plus<T>()(data, val);
 }
 
 template <class T, class Scalar, typename = enable_if_numeric_t<Scalar>>
-T& iadd(T& data, const Scalar& val) {
+T &iadd(T &data, const Scalar &val) {
   data = std::plus<T>()(data, val);
   return data;
 }
 
 template <class T, class Scalar, typename = enable_if_numeric_t<Scalar>>
-T sub(const T& data, const Scalar& val) {
+T sub(const T &data, const Scalar &val) {
   return std::minus<T>()(data, val);
 }
 
 template <class T, class Scalar, typename = enable_if_numeric_t<Scalar>>
-T& isub(T& data, const Scalar& val) {
+T &isub(T &data, const Scalar &val) {
   data = std::minus<T>()(data, val);
   return data;
 }
@@ -80,7 +76,7 @@ T& isub(T& data, const Scalar& val) {
 // Scalar operations
 //----------------------------------------------------------------------------
 template <class T, class Scalar, typename = enable_if_numeric_t<Scalar>>
-T mul(const T& data, const Scalar& val) {
+T mul(const T &data, const Scalar &val) {
   if (almost_equal<Scalar>(val, 1)) {
     return data;
   }
@@ -88,7 +84,7 @@ T mul(const T& data, const Scalar& val) {
 }
 
 template <class T, class Scalar, typename = enable_if_numeric_t<Scalar>>
-T& imul(T& data, const Scalar& val) {
+T &imul(T &data, const Scalar &val) {
   if (!almost_equal<Scalar>(val, 1)) {
     data = std::multiplies<T>()(data, val);
   }
@@ -96,7 +92,7 @@ T& imul(T& data, const Scalar& val) {
 }
 
 template <class T, class Scalar, typename = enable_if_numeric_t<Scalar>>
-T div(const T& data, const Scalar& val) {
+T div(const T &data, const Scalar &val) {
   if (almost_equal<Scalar>(val, 1)) {
     return data;
   }
@@ -104,7 +100,7 @@ T div(const T& data, const Scalar& val) {
 }
 
 template <class T, class Scalar, typename = enable_if_numeric_t<Scalar>>
-T& idiv(T& data, const Scalar& val) {
+T &idiv(T &data, const Scalar &val) {
   if (!almost_equal<Scalar>(val, 1)) {
     data = std::divides<T>()(data, val);
   }
@@ -112,8 +108,8 @@ T& idiv(T& data, const Scalar& val) {
 }
 
 //------------------------------------------------------------------------------
-}  // end namespace Linalg
+} // end namespace Linalg
 //------------------------------------------------------------------------------
-}  // end namespace AER
+} // end namespace AER
 //------------------------------------------------------------------------------
 #endif
\ No newline at end of file
diff --git a/src/framework/linalg/linops/linops_json.hpp b/src/framework/linalg/linops/linops_json.hpp
old mode 100755
new mode 100644
index 8473bfbb82..cbdcefa604
--- a/src/framework/linalg/linops/linops_json.hpp
+++ b/src/framework/linalg/linops/linops_json.hpp
@@ -28,7 +28,7 @@ namespace Linalg {
 //----------------------------------------------------------------------------
 // Linear operations
 //----------------------------------------------------------------------------
-inline json_t& iadd(json_t& lhs, const json_t& rhs) {
+inline json_t &iadd(json_t &lhs, const json_t &rhs) {
   // Null case
   if (lhs.is_null()) {
     lhs = rhs;
@@ -57,12 +57,12 @@ inline json_t& iadd(json_t& lhs, const json_t& rhs) {
   return lhs;
 }
 
-inline json_t add(const json_t& lhs, const json_t& rhs) {
+inline json_t add(const json_t &lhs, const json_t &rhs) {
   json_t result = lhs;
   return iadd(result, rhs);
 }
 
-inline json_t& isub(json_t& lhs, const json_t& rhs) {
+inline json_t &isub(json_t &lhs, const json_t &rhs) {
   // Null case
   if (rhs.is_null()) {
     return lhs;
@@ -87,8 +87,7 @@ inline json_t& isub(json_t& lhs, const json_t& rhs) {
   return lhs;
 }
 
-template <class T>
-json_t sub(const T& lhs, const json_t& rhs) {
+template <class T> json_t sub(const T &lhs, const json_t &rhs) {
   json_t result = lhs;
   return isub(result, rhs);
 }
@@ -97,7 +96,7 @@ json_t sub(const T& lhs, const json_t& rhs) {
 // Affine operations
 //----------------------------------------------------------------------------
 template <class Scalar, typename = enable_if_numeric_t<Scalar>>
-json_t& iadd(json_t& data, const Scalar& val) {
+json_t &iadd(json_t &data, const Scalar &val) {
   // Null case
   if (val == 0) {
     return data;
@@ -123,13 +122,13 @@ json_t& iadd(json_t& data, const Scalar& val) {
 }
 
 template <class Scalar, typename = enable_if_numeric_t<Scalar>>
-json_t add(const json_t& data, const Scalar& val) {
+json_t add(const json_t &data, const Scalar &val) {
   json_t result = data;
   return iadd(result, val);
 }
 
 template <class Scalar, typename = enable_if_numeric_t<Scalar>>
-json_t& isub(json_t& data, const Scalar& val) {
+json_t &isub(json_t &data, const Scalar &val) {
   // Null case
   if (val == 0) {
     return data;
@@ -156,7 +155,7 @@ json_t& isub(json_t& data, const Scalar& val) {
 }
 
 template <class Scalar, typename = enable_if_numeric_t<Scalar>>
-json_t sub(const json_t& data, const Scalar& val) {
+json_t sub(const json_t &data, const Scalar &val) {
   json_t result = data;
   return isub(result, val);
 }
@@ -166,7 +165,7 @@ json_t sub(const json_t& data, const Scalar& val) {
 //----------------------------------------------------------------------------
 
 template <class Scalar, typename = enable_if_numeric_t<Scalar>>
-json_t& imul(json_t& data, const Scalar& val) {
+json_t &imul(json_t &data, const Scalar &val) {
   // Trival case
   if (almost_equal<Scalar>(val, 1)) {
     return data;
@@ -194,14 +193,14 @@ json_t& imul(json_t& data, const Scalar& val) {
 }
 
 template <class Scalar, typename = enable_if_numeric_t<Scalar>>
-json_t mul(const json_t& data, const Scalar& val) {
+json_t mul(const json_t &data, const Scalar &val) {
   // Null case
   json_t result = data;
   return imul(result, val);
 }
 
 template <class Scalar, typename = enable_if_numeric_t<Scalar>>
-json_t& idiv(json_t& data, const Scalar& val) {
+json_t &idiv(json_t &data, const Scalar &val) {
   // Trival case
   if (almost_equal<Scalar>(val, 1)) {
     return data;
@@ -228,15 +227,15 @@ json_t& idiv(json_t& data, const Scalar& val) {
 }
 
 template <class Scalar, typename = enable_if_numeric_t<Scalar>>
-json_t div(const json_t& data, const Scalar& val) {
+json_t div(const json_t &data, const Scalar &val) {
   // Null case
   json_t result = data;
   return idiv(result, val);
 }
 
 //------------------------------------------------------------------------------
-}  // end namespace Linalg
+} // end namespace Linalg
 //------------------------------------------------------------------------------
-}  // end namespace AER
+} // end namespace AER
 //------------------------------------------------------------------------------
 #endif
\ No newline at end of file
diff --git a/src/framework/linalg/linops/linops_map.hpp b/src/framework/linalg/linops/linops_map.hpp
old mode 100755
new mode 100644
index f42cb80c6c..f69c8a675d
--- a/src/framework/linalg/linops/linops_map.hpp
+++ b/src/framework/linalg/linops/linops_map.hpp
@@ -15,10 +15,10 @@
 #ifndef _aer_framework_linalg_linops_map_hpp_
 #define _aer_framework_linalg_linops_map_hpp_
 
-#include <functional>
-#include <map>
 #include "framework/linalg/almost_equal.hpp"
 #include "framework/linalg/enable_if_numeric.hpp"
+#include <functional>
+#include <map>
 
 namespace AER {
 namespace Linalg {
@@ -31,8 +31,8 @@ namespace Linalg {
 //----------------------------------------------------------------------------
 template <class T1, class T2, class T3, class T4,
           typename = enable_if_numeric_t<T2>>
-std::map<T1, T2, T3, T4> add(const std::map<T1, T2, T3, T4>& lhs,
-                             const std::map<T1, T2, T3, T4>& rhs) {
+std::map<T1, T2, T3, T4> add(const std::map<T1, T2, T3, T4> &lhs,
+                             const std::map<T1, T2, T3, T4> &rhs) {
   std::map<T1, T2, T3, T4> result = lhs;
   for (const auto &pair : rhs) {
     result[pair.first] = std::plus<T2>()(result[pair.first], pair.second);
@@ -42,8 +42,8 @@ std::map<T1, T2, T3, T4> add(const std::map<T1, T2, T3, T4>& lhs,
 
 template <class T1, class T2, class T3, class T4,
           typename = enable_if_numeric_t<T2>>
-std::map<T1, T2, T3, T4>& iadd(std::map<T1, T2, T3, T4>& lhs,
-                               const std::map<T1, T2, T3, T4>& rhs) {
+std::map<T1, T2, T3, T4> &iadd(std::map<T1, T2, T3, T4> &lhs,
+                               const std::map<T1, T2, T3, T4> &rhs) {
   for (const auto &pair : rhs) {
     lhs[pair.first] = std::plus<T2>()(lhs[pair.first], pair.second);
   }
@@ -52,8 +52,8 @@ std::map<T1, T2, T3, T4>& iadd(std::map<T1, T2, T3, T4>& lhs,
 
 template <class T1, class T2, class T3, class T4,
           typename = enable_if_numeric_t<T2>>
-std::map<T1, T2, T3, T4> sub(const std::map<T1, T2, T3, T4>& lhs,
-                             const std::map<T1, T2, T3, T4>& rhs) {
+std::map<T1, T2, T3, T4> sub(const std::map<T1, T2, T3, T4> &lhs,
+                             const std::map<T1, T2, T3, T4> &rhs) {
   std::map<T1, T2, T3, T4> result = lhs;
   for (const auto &pair : rhs) {
     result[pair.first] = std::minus<T2>()(result[pair.first], pair.second);
@@ -63,8 +63,8 @@ std::map<T1, T2, T3, T4> sub(const std::map<T1, T2, T3, T4>& lhs,
 
 template <class T1, class T2, class T3, class T4,
           typename = enable_if_numeric_t<T2>>
-std::map<T1, T2, T3, T4>& isub(std::map<T1, T2, T3, T4>& lhs,
-                               const std::map<T1, T2, T3, T4>& rhs) {
+std::map<T1, T2, T3, T4> &isub(std::map<T1, T2, T3, T4> &lhs,
+                               const std::map<T1, T2, T3, T4> &rhs) {
   for (const auto &pair : rhs) {
     lhs[pair.first] = std::minus<T2>()(lhs[pair.first], pair.second);
   }
@@ -77,8 +77,8 @@ std::map<T1, T2, T3, T4>& isub(std::map<T1, T2, T3, T4>& lhs,
 template <class T1, class T2, class T3, class T4, class Scalar,
           typename = enable_if_numeric_t<T2>,
           typename = enable_if_numeric_t<Scalar>>
-std::map<T1, T2, T3, T4> add(const std::map<T1, T2, T3, T4>& data,
-                             const Scalar& val) {
+std::map<T1, T2, T3, T4> add(const std::map<T1, T2, T3, T4> &data,
+                             const Scalar &val) {
   std::map<T1, T2, T3, T4> result;
   for (const auto &pair : data) {
     result[pair.first] = std::plus<T2>()(pair.second, val);
@@ -89,8 +89,8 @@ std::map<T1, T2, T3, T4> add(const std::map<T1, T2, T3, T4>& data,
 template <class T1, class T2, class T3, class T4, class Scalar,
           typename = enable_if_numeric_t<T2>,
           typename = enable_if_numeric_t<Scalar>>
-std::map<T1, T2, T3, T4>& iadd(std::map<T1, T2, T3, T4>& data,
-                               const Scalar& val) {
+std::map<T1, T2, T3, T4> &iadd(std::map<T1, T2, T3, T4> &data,
+                               const Scalar &val) {
   for (const auto &pair : data) {
     data[pair.first] = std::plus<T2>()(data[pair.first], val);
   }
@@ -100,8 +100,8 @@ std::map<T1, T2, T3, T4>& iadd(std::map<T1, T2, T3, T4>& data,
 template <class T1, class T2, class T3, class T4, class Scalar,
           typename = enable_if_numeric_t<T2>,
           typename = enable_if_numeric_t<Scalar>>
-std::map<T1, T2, T3, T4> sub(const std::map<T1, T2, T3, T4>& data,
-                             const Scalar& val) {
+std::map<T1, T2, T3, T4> sub(const std::map<T1, T2, T3, T4> &data,
+                             const Scalar &val) {
   std::map<T1, T2, T3, T4> result;
   for (const auto &pair : data) {
     result[pair.first] = std::minus<T2>()(pair.second, val);
@@ -112,8 +112,8 @@ std::map<T1, T2, T3, T4> sub(const std::map<T1, T2, T3, T4>& data,
 template <class T1, class T2, class T3, class T4, class Scalar,
           typename = enable_if_numeric_t<T2>,
           typename = enable_if_numeric_t<Scalar>>
-std::map<T1, T2, T3, T4>& isub(std::map<T1, T2, T3, T4>& data,
-                               const Scalar& val) {
+std::map<T1, T2, T3, T4> &isub(std::map<T1, T2, T3, T4> &data,
+                               const Scalar &val) {
   for (const auto &pair : data) {
     data[pair.first] = std::plus<T2>()(data[pair.first], val);
   }
@@ -127,8 +127,8 @@ std::map<T1, T2, T3, T4>& isub(std::map<T1, T2, T3, T4>& data,
 template <class T1, class T2, class T3, class T4, class Scalar,
           typename = enable_if_numeric_t<T2>,
           typename = enable_if_numeric_t<Scalar>>
-std::map<T1, T2, T3, T4> mul(const std::map<T1, T2, T3, T4>& data,
-                             const Scalar& val) {
+std::map<T1, T2, T3, T4> mul(const std::map<T1, T2, T3, T4> &data,
+                             const Scalar &val) {
   if (almost_equal<Scalar>(val, 1)) {
     return data;
   }
@@ -142,8 +142,8 @@ std::map<T1, T2, T3, T4> mul(const std::map<T1, T2, T3, T4>& data,
 template <class T1, class T2, class T3, class T4, class Scalar,
           typename = enable_if_numeric_t<T2>,
           typename = enable_if_numeric_t<Scalar>>
-std::map<T1, T2, T3, T4>& imul(std::map<T1, T2, T3, T4>& data,
-                               const Scalar& val) {
+std::map<T1, T2, T3, T4> &imul(std::map<T1, T2, T3, T4> &data,
+                               const Scalar &val) {
   if (almost_equal<Scalar>(val, 1)) {
     return data;
   }
@@ -156,8 +156,8 @@ std::map<T1, T2, T3, T4>& imul(std::map<T1, T2, T3, T4>& data,
 template <class T1, class T2, class T3, class T4, class Scalar,
           typename = enable_if_numeric_t<T2>,
           typename = enable_if_numeric_t<Scalar>>
-std::map<T1, T2, T3, T4> div(const std::map<T1, T2, T3, T4>& data,
-                             const Scalar& val) {
+std::map<T1, T2, T3, T4> div(const std::map<T1, T2, T3, T4> &data,
+                             const Scalar &val) {
   if (almost_equal<Scalar>(val, 1)) {
     return data;
   }
@@ -171,8 +171,8 @@ std::map<T1, T2, T3, T4> div(const std::map<T1, T2, T3, T4>& data,
 template <class T1, class T2, class T3, class T4, class Scalar,
           typename = enable_if_numeric_t<T2>,
           typename = enable_if_numeric_t<Scalar>>
-std::map<T1, T2, T3, T4>& idiv(std::map<T1, T2, T3, T4>& data,
-                               const Scalar& val) {
+std::map<T1, T2, T3, T4> &idiv(std::map<T1, T2, T3, T4> &data,
+                               const Scalar &val) {
   if (almost_equal<Scalar>(val, 1)) {
     return data;
   }
@@ -183,8 +183,8 @@ std::map<T1, T2, T3, T4>& idiv(std::map<T1, T2, T3, T4>& data,
 }
 
 //------------------------------------------------------------------------------
-}  // end namespace Linalg
+} // end namespace Linalg
 //------------------------------------------------------------------------------
-}  // end namespace AER
+} // end namespace AER
 //------------------------------------------------------------------------------
 #endif
\ No newline at end of file
diff --git a/src/framework/linalg/linops/linops_matrix.hpp b/src/framework/linalg/linops/linops_matrix.hpp
old mode 100755
new mode 100644
index 4b510389c3..7fdac60fd7
--- a/src/framework/linalg/linops/linops_matrix.hpp
+++ b/src/framework/linalg/linops/linops_matrix.hpp
@@ -31,23 +31,23 @@ namespace Linalg {
 // Linear operations
 //----------------------------------------------------------------------------
 template <class T, typename = enable_if_numeric_t<T>>
-matrix<T> add(const matrix<T>& lhs, const matrix<T>& rhs) {
+matrix<T> add(const matrix<T> &lhs, const matrix<T> &rhs) {
   return lhs + rhs;
 }
 
 template <class T, typename = enable_if_numeric_t<T>>
-matrix<T>& iadd(matrix<T>& lhs, const matrix<T>& rhs) {
+matrix<T> &iadd(matrix<T> &lhs, const matrix<T> &rhs) {
   lhs = lhs + rhs;
   return lhs;
 }
 
 template <class T, typename = enable_if_numeric_t<T>>
-matrix<T> sub(const matrix<T>& lhs, const matrix<T>& rhs) {
+matrix<T> sub(const matrix<T> &lhs, const matrix<T> &rhs) {
   return lhs - rhs;
 }
 
 template <class T, typename = enable_if_numeric_t<T>>
-matrix<T>& isub(matrix<T>& lhs, const matrix<T>& rhs) {
+matrix<T> &isub(matrix<T> &lhs, const matrix<T> &rhs) {
   lhs = lhs - rhs;
   return lhs;
 }
@@ -57,7 +57,7 @@ matrix<T>& isub(matrix<T>& lhs, const matrix<T>& rhs) {
 //----------------------------------------------------------------------------
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-matrix<T>& iadd(matrix<T>& data, const Scalar& val) {
+matrix<T> &iadd(matrix<T> &data, const Scalar &val) {
   if (val == 0) {
     return data;
   }
@@ -69,20 +69,20 @@ matrix<T>& iadd(matrix<T>& data, const Scalar& val) {
 
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-matrix<T> add(const matrix<T>& data, const Scalar& val) {
+matrix<T> add(const matrix<T> &data, const Scalar &val) {
   matrix<T> result(data);
   return iadd(result, val);
 }
 
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-matrix<T> sub(const matrix<T>& data, const Scalar& val) {
+matrix<T> sub(const matrix<T> &data, const Scalar &val) {
   return add(data, -val);
 }
 
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-matrix<T>& isub(matrix<T>& data, const Scalar& val) {
+matrix<T> &isub(matrix<T> &data, const Scalar &val) {
   return iadd(data, -val);
 }
 
@@ -92,7 +92,7 @@ matrix<T>& isub(matrix<T>& data, const Scalar& val) {
 
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-matrix<T>& imul(matrix<T>& data, const Scalar& val) {
+matrix<T> &imul(matrix<T> &data, const Scalar &val) {
   if (almost_equal<Scalar>(val, 1)) {
     return data;
   }
@@ -104,7 +104,7 @@ matrix<T>& imul(matrix<T>& data, const Scalar& val) {
 
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-matrix<T> mul(const matrix<T>& data, const Scalar& val) {
+matrix<T> mul(const matrix<T> &data, const Scalar &val) {
   if (almost_equal<Scalar>(val, 1)) {
     return data;
   }
@@ -115,7 +115,7 @@ matrix<T> mul(const matrix<T>& data, const Scalar& val) {
 
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-matrix<T>& idiv(matrix<T>& data, const Scalar& val) {
+matrix<T> &idiv(matrix<T> &data, const Scalar &val) {
   if (almost_equal<Scalar>(val, 1)) {
     return data;
   }
@@ -127,7 +127,7 @@ matrix<T>& idiv(matrix<T>& data, const Scalar& val) {
 
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-matrix<T> div(const matrix<T>& data, const Scalar& val) {
+matrix<T> div(const matrix<T> &data, const Scalar &val) {
   if (almost_equal<Scalar>(val, 1)) {
     return data;
   }
@@ -137,8 +137,8 @@ matrix<T> div(const matrix<T>& data, const Scalar& val) {
 }
 
 //------------------------------------------------------------------------------
-}  // end namespace Linalg
+} // end namespace Linalg
 //------------------------------------------------------------------------------
-}  // end namespace AER
+} // end namespace AER
 //------------------------------------------------------------------------------
 #endif
\ No newline at end of file
diff --git a/src/framework/linalg/linops/linops_unordered_map.hpp b/src/framework/linalg/linops/linops_unordered_map.hpp
old mode 100755
new mode 100644
index 7df754b5de..2245172f0c
--- a/src/framework/linalg/linops/linops_unordered_map.hpp
+++ b/src/framework/linalg/linops/linops_unordered_map.hpp
@@ -31,9 +31,9 @@ namespace Linalg {
 //----------------------------------------------------------------------------
 template <class T1, class T2, class T3, class T4, class T5,
           typename = enable_if_numeric_t<T2>>
-std::unordered_map<T1, T2, T3, T4, T5> add(
-    const std::unordered_map<T1, T2, T3, T4, T5>& lhs,
-    const std::unordered_map<T1, T2, T3, T4, T5>& rhs) {
+std::unordered_map<T1, T2, T3, T4, T5>
+add(const std::unordered_map<T1, T2, T3, T4, T5> &lhs,
+    const std::unordered_map<T1, T2, T3, T4, T5> &rhs) {
   std::unordered_map<T1, T2, T3, T4, T5> result = lhs;
   for (const auto &pair : rhs) {
     result[pair.first] = std::plus<T2>()(result[pair.first], pair.second);
@@ -43,9 +43,9 @@ std::unordered_map<T1, T2, T3, T4, T5> add(
 
 template <class T1, class T2, class T3, class T4, class T5,
           typename = enable_if_numeric_t<T2>>
-std::unordered_map<T1, T2, T3, T4, T5>& iadd(
-    std::unordered_map<T1, T2, T3, T4, T5>& lhs,
-    const std::unordered_map<T1, T2, T3, T4, T5>& rhs) {
+std::unordered_map<T1, T2, T3, T4, T5> &
+iadd(std::unordered_map<T1, T2, T3, T4, T5> &lhs,
+     const std::unordered_map<T1, T2, T3, T4, T5> &rhs) {
   for (const auto &pair : rhs) {
     lhs[pair.first] = std::plus<T2>()(lhs[pair.first], pair.second);
   }
@@ -54,9 +54,9 @@ std::unordered_map<T1, T2, T3, T4, T5>& iadd(
 
 template <class T1, class T2, class T3, class T4, class T5,
           typename = enable_if_numeric_t<T2>>
-std::unordered_map<T1, T2, T3, T4, T5> sub(
-    const std::unordered_map<T1, T2, T3, T4, T5>& lhs,
-    const std::unordered_map<T1, T2, T3, T4, T5>& rhs) {
+std::unordered_map<T1, T2, T3, T4, T5>
+sub(const std::unordered_map<T1, T2, T3, T4, T5> &lhs,
+    const std::unordered_map<T1, T2, T3, T4, T5> &rhs) {
   std::unordered_map<T1, T2, T3, T4, T5> result = lhs;
   for (const auto &pair : rhs) {
     result[pair.first] = std::minus<T2>()(result[pair.first], pair.second);
@@ -66,9 +66,9 @@ std::unordered_map<T1, T2, T3, T4, T5> sub(
 
 template <class T1, class T2, class T3, class T4, class T5,
           typename = enable_if_numeric_t<T2>>
-std::unordered_map<T1, T2, T3, T4, T5>& isub(
-    std::unordered_map<T1, T2, T3, T4, T5>& lhs,
-    const std::unordered_map<T1, T2, T3, T4, T5>& rhs) {
+std::unordered_map<T1, T2, T3, T4, T5> &
+isub(std::unordered_map<T1, T2, T3, T4, T5> &lhs,
+     const std::unordered_map<T1, T2, T3, T4, T5> &rhs) {
   for (const auto &pair : rhs) {
     lhs[pair.first] = std::minus<T2>()(lhs[pair.first], pair.second);
   }
@@ -81,8 +81,8 @@ std::unordered_map<T1, T2, T3, T4, T5>& isub(
 template <class T1, class T2, class T3, class T4, class T5, class Scalar,
           typename = enable_if_numeric_t<T2>,
           typename = enable_if_numeric_t<Scalar>>
-std::unordered_map<T1, T2, T3, T4, T5> add(
-    const std::unordered_map<T1, T2, T3, T4, T5>& data, const Scalar& val) {
+std::unordered_map<T1, T2, T3, T4, T5>
+add(const std::unordered_map<T1, T2, T3, T4, T5> &data, const Scalar &val) {
   std::unordered_map<T1, T2, T3, T4, T5> result;
   for (const auto &pair : data) {
     result[pair.first] = std::plus<T2>()(pair.second, val);
@@ -93,8 +93,8 @@ std::unordered_map<T1, T2, T3, T4, T5> add(
 template <class T1, class T2, class T3, class T4, class T5, class Scalar,
           typename = enable_if_numeric_t<T2>,
           typename = enable_if_numeric_t<Scalar>>
-std::unordered_map<T1, T2, T3, T4, T5>& iadd(
-    std::unordered_map<T1, T2, T3, T4, T5>& data, const Scalar& val) {
+std::unordered_map<T1, T2, T3, T4, T5> &
+iadd(std::unordered_map<T1, T2, T3, T4, T5> &data, const Scalar &val) {
   for (const auto &pair : data) {
     data[pair.first] = std::plus<T2>()(data[pair.first], val);
   }
@@ -104,8 +104,8 @@ std::unordered_map<T1, T2, T3, T4, T5>& iadd(
 template <class T1, class T2, class T3, class T4, class T5, class Scalar,
           typename = enable_if_numeric_t<T2>,
           typename = enable_if_numeric_t<Scalar>>
-std::unordered_map<T1, T2, T3, T4, T5> sub(
-    const std::unordered_map<T1, T2, T3, T4, T5>& data, const Scalar& val) {
+std::unordered_map<T1, T2, T3, T4, T5>
+sub(const std::unordered_map<T1, T2, T3, T4, T5> &data, const Scalar &val) {
   std::unordered_map<T1, T2, T3, T4, T5> result;
   for (const auto &pair : data) {
     result[pair.first] = std::minus<T2>()(pair.second, val);
@@ -116,8 +116,8 @@ std::unordered_map<T1, T2, T3, T4, T5> sub(
 template <class T1, class T2, class T3, class T4, class T5, class Scalar,
           typename = enable_if_numeric_t<T2>,
           typename = enable_if_numeric_t<Scalar>>
-std::unordered_map<T1, T2, T3, T4, T5>& isub(
-    std::unordered_map<T1, T2, T3, T4, T5>& data, const Scalar& val) {
+std::unordered_map<T1, T2, T3, T4, T5> &
+isub(std::unordered_map<T1, T2, T3, T4, T5> &data, const Scalar &val) {
   for (const auto &pair : data) {
     data[pair.first] = std::plus<T2>()(data[pair.first], val);
   }
@@ -131,8 +131,8 @@ std::unordered_map<T1, T2, T3, T4, T5>& isub(
 template <class T1, class T2, class T3, class T4, class T5, class Scalar,
           typename = enable_if_numeric_t<T2>,
           typename = enable_if_numeric_t<Scalar>>
-std::unordered_map<T1, T2, T3, T4, T5> mul(
-    const std::unordered_map<T1, T2, T3, T4, T5>& data, const Scalar& val) {
+std::unordered_map<T1, T2, T3, T4, T5>
+mul(const std::unordered_map<T1, T2, T3, T4, T5> &data, const Scalar &val) {
   if (almost_equal<Scalar>(val, 1)) {
     return data;
   }
@@ -146,8 +146,8 @@ std::unordered_map<T1, T2, T3, T4, T5> mul(
 template <class T1, class T2, class T3, class T4, class T5, class Scalar,
           typename = enable_if_numeric_t<T2>,
           typename = enable_if_numeric_t<Scalar>>
-std::unordered_map<T1, T2, T3, T4, T5>& imul(
-    std::unordered_map<T1, T2, T3, T4, T5>& data, const Scalar& val) {
+std::unordered_map<T1, T2, T3, T4, T5> &
+imul(std::unordered_map<T1, T2, T3, T4, T5> &data, const Scalar &val) {
   if (almost_equal<Scalar>(val, 1)) {
     return data;
   }
@@ -160,8 +160,8 @@ std::unordered_map<T1, T2, T3, T4, T5>& imul(
 template <class T1, class T2, class T3, class T4, class T5, class Scalar,
           typename = enable_if_numeric_t<T2>,
           typename = enable_if_numeric_t<Scalar>>
-std::unordered_map<T1, T2, T3, T4, T5> div(
-    const std::unordered_map<T1, T2, T3, T4, T5>& data, const Scalar& val) {
+std::unordered_map<T1, T2, T3, T4, T5>
+div(const std::unordered_map<T1, T2, T3, T4, T5> &data, const Scalar &val) {
   if (almost_equal<Scalar>(val, 1)) {
     return data;
   }
@@ -175,8 +175,8 @@ std::unordered_map<T1, T2, T3, T4, T5> div(
 template <class T1, class T2, class T3, class T4, class T5, class Scalar,
           typename = enable_if_numeric_t<T2>,
           typename = enable_if_numeric_t<Scalar>>
-std::unordered_map<T1, T2, T3, T4, T5>& idiv(
-    std::unordered_map<T1, T2, T3, T4, T5>& data, const Scalar& val) {
+std::unordered_map<T1, T2, T3, T4, T5> &
+idiv(std::unordered_map<T1, T2, T3, T4, T5> &data, const Scalar &val) {
   if (almost_equal<Scalar>(val, 1)) {
     return data;
   }
@@ -187,8 +187,8 @@ std::unordered_map<T1, T2, T3, T4, T5>& idiv(
 }
 
 //------------------------------------------------------------------------------
-}  // end namespace Linalg
+} // end namespace Linalg
 //------------------------------------------------------------------------------
-}  // end namespace AER
+} // end namespace AER
 //------------------------------------------------------------------------------
 #endif
\ No newline at end of file
diff --git a/src/framework/linalg/linops/linops_vector.hpp b/src/framework/linalg/linops/linops_vector.hpp
old mode 100755
new mode 100644
index 759442d9f4..c1b86d79d8
--- a/src/framework/linalg/linops/linops_vector.hpp
+++ b/src/framework/linalg/linops/linops_vector.hpp
@@ -31,7 +31,7 @@ namespace Linalg {
 // Linear operations
 //----------------------------------------------------------------------------
 template <class T, typename = enable_if_numeric_t<T>>
-std::vector<T> add(const std::vector<T>& lhs, const std::vector<T>& rhs) {
+std::vector<T> add(const std::vector<T> &lhs, const std::vector<T> &rhs) {
   if (lhs.size() != rhs.size()) {
     throw std::runtime_error("Cannot add two vectors of different sizes.");
   }
@@ -43,7 +43,7 @@ std::vector<T> add(const std::vector<T>& lhs, const std::vector<T>& rhs) {
 }
 
 template <class T, typename = enable_if_numeric_t<T>>
-std::vector<T>& iadd(std::vector<T>& lhs, const std::vector<T>& rhs) {
+std::vector<T> &iadd(std::vector<T> &lhs, const std::vector<T> &rhs) {
   if (lhs.size() != rhs.size()) {
     throw std::runtime_error("Cannot add two vectors of different sizes.");
   }
@@ -53,7 +53,7 @@ std::vector<T>& iadd(std::vector<T>& lhs, const std::vector<T>& rhs) {
 }
 
 template <class T, typename = enable_if_numeric_t<T>>
-std::vector<T> sub(const std::vector<T>& lhs, const std::vector<T>& rhs) {
+std::vector<T> sub(const std::vector<T> &lhs, const std::vector<T> &rhs) {
   if (lhs.size() != rhs.size()) {
     throw std::runtime_error("Cannot add two vectors of different sizes.");
   }
@@ -65,7 +65,7 @@ std::vector<T> sub(const std::vector<T>& lhs, const std::vector<T>& rhs) {
 }
 
 template <class T, typename = enable_if_numeric_t<T>>
-std::vector<T>& isub(std::vector<T>& lhs, const std::vector<T>& rhs) {
+std::vector<T> &isub(std::vector<T> &lhs, const std::vector<T> &rhs) {
   if (lhs.size() != rhs.size()) {
     throw std::runtime_error("Cannot add two vectors of different sizes.");
   }
@@ -79,7 +79,7 @@ std::vector<T>& isub(std::vector<T>& lhs, const std::vector<T>& rhs) {
 //----------------------------------------------------------------------------
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-std::vector<T> add(const std::vector<T>& data, const Scalar& val) {
+std::vector<T> add(const std::vector<T> &data, const Scalar &val) {
   std::vector<T> result;
   result.reserve(data.size());
   std::transform(data.begin(), data.end(), std::back_inserter(result),
@@ -89,7 +89,7 @@ std::vector<T> add(const std::vector<T>& data, const Scalar& val) {
 
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-std::vector<T>& iadd(std::vector<T>& data, const Scalar& val) {
+std::vector<T> &iadd(std::vector<T> &data, const Scalar &val) {
   std::transform(data.begin(), data.end(), data.begin(),
                  std::bind(std::plus<T>(), std::placeholders::_1, val));
   return data;
@@ -97,7 +97,7 @@ std::vector<T>& iadd(std::vector<T>& data, const Scalar& val) {
 
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-std::vector<T> sub(const std::vector<T>& data, const Scalar& val) {
+std::vector<T> sub(const std::vector<T> &data, const Scalar &val) {
   std::vector<T> result;
   result.reserve(data.size());
   std::transform(data.begin(), data.end(), std::back_inserter(result),
@@ -107,7 +107,7 @@ std::vector<T> sub(const std::vector<T>& data, const Scalar& val) {
 
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-std::vector<T>& isub(std::vector<T>& data, const Scalar& val) {
+std::vector<T> &isub(std::vector<T> &data, const Scalar &val) {
   std::transform(data.begin(), data.end(), data.begin(),
                  std::bind(std::minus<T>(), std::placeholders::_1, val));
   return data;
@@ -118,7 +118,7 @@ std::vector<T>& isub(std::vector<T>& data, const Scalar& val) {
 //----------------------------------------------------------------------------
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-std::vector<T> mul(const std::vector<T>& data, const Scalar& val) {
+std::vector<T> mul(const std::vector<T> &data, const Scalar &val) {
   if (almost_equal<Scalar>(val, 1)) {
     return data;
   }
@@ -131,7 +131,7 @@ std::vector<T> mul(const std::vector<T>& data, const Scalar& val) {
 
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-std::vector<T>& imul(std::vector<T>& data, const Scalar& val) {
+std::vector<T> &imul(std::vector<T> &data, const Scalar &val) {
   if (almost_equal<Scalar>(val, 1)) {
     return data;
   }
@@ -142,7 +142,7 @@ std::vector<T>& imul(std::vector<T>& data, const Scalar& val) {
 
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-std::vector<T> div(const std::vector<T>& data, const Scalar& val) {
+std::vector<T> div(const std::vector<T> &data, const Scalar &val) {
   if (almost_equal<Scalar>(val, 1)) {
     return data;
   }
@@ -155,7 +155,7 @@ std::vector<T> div(const std::vector<T>& data, const Scalar& val) {
 
 template <class T, class Scalar, typename = enable_if_numeric_t<T>,
           typename = enable_if_numeric_t<Scalar>>
-std::vector<T>& idiv(std::vector<T>& data, const Scalar& val) {
+std::vector<T> &idiv(std::vector<T> &data, const Scalar &val) {
   if (almost_equal<Scalar>(val, 1)) {
     return data;
   }
@@ -165,8 +165,8 @@ std::vector<T>& idiv(std::vector<T>& data, const Scalar& val) {
 }
 
 //------------------------------------------------------------------------------
-}  // end namespace Linalg
+} // end namespace Linalg
 //------------------------------------------------------------------------------
-}  // end namespace AER
+} // end namespace AER
 //------------------------------------------------------------------------------
 #endif
\ No newline at end of file
diff --git a/src/framework/linalg/matrix_utils.hpp b/src/framework/linalg/matrix_utils.hpp
old mode 100755
new mode 100644
index bd6903dde4..d557abd898
--- a/src/framework/linalg/matrix_utils.hpp
+++ b/src/framework/linalg/matrix_utils.hpp
@@ -16,7 +16,7 @@
 #define _aer_framework_linalg_matrix_utils_hpp_
 
 #include "framework/linalg/matrix_utils/matrix_defs.hpp"
-#include "framework/linalg/matrix_utils/vmatrix_defs.hpp"
 #include "framework/linalg/matrix_utils/smatrix_defs.hpp"
+#include "framework/linalg/matrix_utils/vmatrix_defs.hpp"
 
 #endif
\ No newline at end of file
diff --git a/src/framework/linalg/matrix_utils/matrix_defs.hpp b/src/framework/linalg/matrix_utils/matrix_defs.hpp
old mode 100755
new mode 100644
index 4b356399b5..aecae03d1b
--- a/src/framework/linalg/matrix_utils/matrix_defs.hpp
+++ b/src/framework/linalg/matrix_utils/matrix_defs.hpp
@@ -33,18 +33,18 @@ namespace Linalg {
 class Matrix {
 public:
   // Single-qubit gates
-  const static cmatrix_t I;   // name: "id"
-  const static cmatrix_t X;   // name: "x"
-  const static cmatrix_t Y;   // name: "y"
-  const static cmatrix_t Z;   // name: "z"
-  const static cmatrix_t H;   // name: "h"
-  const static cmatrix_t S;   // name: "s"
-  const static cmatrix_t SDG; // name: "sdg"
-  const static cmatrix_t T;   // name: "t"
-  const static cmatrix_t TDG; // name: "tdg"
-  const static cmatrix_t SX;  // name: "sx"
-  const static cmatrix_t SXDG;// name: "sxdg"
-  const static cmatrix_t X90; // name: "x90"
+  const static cmatrix_t I;    // name: "id"
+  const static cmatrix_t X;    // name: "x"
+  const static cmatrix_t Y;    // name: "y"
+  const static cmatrix_t Z;    // name: "z"
+  const static cmatrix_t H;    // name: "h"
+  const static cmatrix_t S;    // name: "s"
+  const static cmatrix_t SDG;  // name: "sdg"
+  const static cmatrix_t T;    // name: "t"
+  const static cmatrix_t TDG;  // name: "tdg"
+  const static cmatrix_t SX;   // name: "sx"
+  const static cmatrix_t SXDG; // name: "sxdg"
+  const static cmatrix_t X90;  // name: "x90"
 
   // Two-qubit gates
   const static cmatrix_t CX;   // name: "cx"
@@ -91,8 +91,10 @@ class Matrix {
   static cmatrix_t u3(complex_t theta, complex_t phi, complex_t lam) {
     return u3(std::real(theta), std::real(phi), std::real(lam));
   };
-  static cmatrix_t u4(complex_t theta, complex_t phi, complex_t lam, complex_t gamma) {
-    return u4(std::real(theta), std::real(phi), std::real(lam), std::real(gamma));
+  static cmatrix_t u4(complex_t theta, complex_t phi, complex_t lam,
+                      complex_t gamma) {
+    return u4(std::real(theta), std::real(phi), std::real(lam),
+              std::real(gamma));
   };
   static cmatrix_t r(complex_t theta, complex_t phi) {
     return r(std::real(theta), std::real(phi));
@@ -105,11 +107,17 @@ class Matrix {
   static cmatrix_t rzz(complex_t theta) { return rzz(std::real(theta)); }
   static cmatrix_t rzx(complex_t theta) { return rzx(std::real(theta)); }
   static cmatrix_t phase(complex_t theta) { return phase(std::real(theta)); }
-  static cmatrix_t phase_diag(complex_t theta) { return phase_diag(std::real(theta)); }
+  static cmatrix_t phase_diag(complex_t theta) {
+    return phase_diag(std::real(theta));
+  }
   static cmatrix_t cphase(complex_t theta) { return cphase(std::real(theta)); }
-  static cmatrix_t cphase_diag(complex_t theta) { return cphase_diag(std::real(theta)); }
-  static cmatrix_t cu(complex_t theta, complex_t phi, complex_t lam, complex_t gamma) {
-    return cu(std::real(theta), std::real(phi), std::real(lam), std::real(gamma));
+  static cmatrix_t cphase_diag(complex_t theta) {
+    return cphase_diag(std::real(theta));
+  }
+  static cmatrix_t cu(complex_t theta, complex_t phi, complex_t lam,
+                      complex_t gamma) {
+    return cu(std::real(theta), std::real(phi), std::real(lam),
+              std::real(gamma));
   }
 
   // Return the matrix for a named matrix string
@@ -182,7 +190,7 @@ const cmatrix_t Matrix::CY =
                                    {{0, 0}, {0, 0}, {0, 0}, {0, -1}},
                                    {{0, 0}, {0, 0}, {1, 0}, {0, 0}},
                                    {{0, 0}, {0, 1}, {0, 0}, {0, 0}}});
-                     
+
 const cmatrix_t Matrix::CZ =
     Utils::make_matrix<complex_t>({{{1, 0}, {0, 0}, {0, 0}, {0, 0}},
                                    {{0, 0}, {1, 0}, {0, 0}, {0, 0}},
@@ -197,12 +205,12 @@ const cmatrix_t Matrix::SWAP =
 
 // Lookup table
 const stringmap_t<const cmatrix_t *> Matrix::label_map_ = {
-    {"id", &Matrix::I},     {"x", &Matrix::X},   {"y", &Matrix::Y},
-    {"z", &Matrix::Z},      {"h", &Matrix::H},   {"s", &Matrix::S},
-    {"sdg", &Matrix::SDG},  {"t", &Matrix::T},   {"tdg", &Matrix::TDG},
-    {"x90", &Matrix::X90},  {"cx", &Matrix::CX}, {"cy", &Matrix::CY},
-    {"cz", &Matrix::CZ},    {"swap", &Matrix::SWAP}, {"sx", &Matrix::SX},
-    {"sxdg", &Matrix::SXDG},  {"delay", &Matrix::I}};
+    {"id", &Matrix::I},      {"x", &Matrix::X},       {"y", &Matrix::Y},
+    {"z", &Matrix::Z},       {"h", &Matrix::H},       {"s", &Matrix::S},
+    {"sdg", &Matrix::SDG},   {"t", &Matrix::T},       {"tdg", &Matrix::TDG},
+    {"x90", &Matrix::X90},   {"cx", &Matrix::CX},     {"cy", &Matrix::CY},
+    {"cz", &Matrix::CZ},     {"swap", &Matrix::SWAP}, {"sx", &Matrix::SX},
+    {"sxdg", &Matrix::SXDG}, {"delay", &Matrix::I}};
 
 cmatrix_t Matrix::identity(size_t dim) {
   cmatrix_t mat(dim, dim);
@@ -211,9 +219,7 @@ cmatrix_t Matrix::identity(size_t dim) {
   return mat;
 }
 
-cmatrix_t Matrix::u1(double lambda) {
-  return phase(lambda);
-}
+cmatrix_t Matrix::u1(double lambda) { return phase(lambda); }
 
 cmatrix_t Matrix::u2(double phi, double lambda) {
   cmatrix_t mat(2, 2);
diff --git a/src/framework/linalg/matrix_utils/smatrix_defs.hpp b/src/framework/linalg/matrix_utils/smatrix_defs.hpp
old mode 100755
new mode 100644
index 2d3a73cc46..1f8a34260b
--- a/src/framework/linalg/matrix_utils/smatrix_defs.hpp
+++ b/src/framework/linalg/matrix_utils/smatrix_defs.hpp
@@ -34,18 +34,18 @@ namespace Linalg {
 class SMatrix {
 public:
   // Single-qubit gates
-  const static cmatrix_t I;   // name: "id"
-  const static cmatrix_t X;   // name: "x"
-  const static cmatrix_t Y;   // name: "y"
-  const static cmatrix_t Z;   // name: "z"
-  const static cmatrix_t H;   // name: "h"
-  const static cmatrix_t S;   // name: "s"
-  const static cmatrix_t SDG; // name: "sdg"
-  const static cmatrix_t T;   // name: "t"
-  const static cmatrix_t TDG; // name: "tdg"
-  const static cmatrix_t SX;  // name: "sx"
-  const static cmatrix_t SXDG;// name: "sxdg"
-  const static cmatrix_t X90; // name: "x90"
+  const static cmatrix_t I;    // name: "id"
+  const static cmatrix_t X;    // name: "x"
+  const static cmatrix_t Y;    // name: "y"
+  const static cmatrix_t Z;    // name: "z"
+  const static cmatrix_t H;    // name: "h"
+  const static cmatrix_t S;    // name: "s"
+  const static cmatrix_t SDG;  // name: "sdg"
+  const static cmatrix_t T;    // name: "t"
+  const static cmatrix_t TDG;  // name: "tdg"
+  const static cmatrix_t SX;   // name: "sx"
+  const static cmatrix_t SXDG; // name: "sxdg"
+  const static cmatrix_t X90;  // name: "x90"
 
   // Two-qubit gates
   const static cmatrix_t CX;   // name: "cx"
@@ -92,8 +92,10 @@ class SMatrix {
   static cmatrix_t u3(complex_t theta, complex_t phi, complex_t lam) {
     return u3(std::real(theta), std::real(phi), std::real(lam));
   };
-  static cmatrix_t u4(complex_t theta, complex_t phi, complex_t lam, complex_t gamma) {
-    return u4(std::real(theta), std::real(phi), std::real(lam), std::real(gamma));
+  static cmatrix_t u4(complex_t theta, complex_t phi, complex_t lam,
+                      complex_t gamma) {
+    return u4(std::real(theta), std::real(phi), std::real(lam),
+              std::real(gamma));
   }
   static cmatrix_t r(complex_t theta, complex_t phi) {
     return r(std::real(theta), std::real(phi));
@@ -106,11 +108,17 @@ class SMatrix {
   static cmatrix_t rzz(complex_t theta) { return rzz(std::real(theta)); }
   static cmatrix_t rzx(complex_t theta) { return rzx(std::real(theta)); }
   static cmatrix_t phase(complex_t theta) { return phase(std::real(theta)); }
-  static cmatrix_t phase_diag(complex_t theta) { return phase_diag(std::real(theta)); }
+  static cmatrix_t phase_diag(complex_t theta) {
+    return phase_diag(std::real(theta));
+  }
   static cmatrix_t cphase(complex_t theta) { return cphase(std::real(theta)); }
-  static cmatrix_t cphase_diag(complex_t theta) { return cphase_diag(std::real(theta)); }
-  static cmatrix_t cu(complex_t theta, complex_t phi, complex_t lam, complex_t gamma) {
-    return cu(std::real(theta), std::real(phi), std::real(lam), std::real(gamma));
+  static cmatrix_t cphase_diag(complex_t theta) {
+    return cphase_diag(std::real(theta));
+  }
+  static cmatrix_t cu(complex_t theta, complex_t phi, complex_t lam,
+                      complex_t gamma) {
+    return cu(std::real(theta), std::real(phi), std::real(lam),
+              std::real(gamma));
   }
 
   // Return superoperator matrix for reset instruction
@@ -173,18 +181,16 @@ const cmatrix_t SMatrix::SWAP = Utils::unitary_superop(Matrix::SWAP);
 
 // Lookup table
 const stringmap_t<const cmatrix_t *> SMatrix::label_map_ = {
-    {"id", &SMatrix::I},     {"x", &SMatrix::X},   {"y", &SMatrix::Y},
-    {"z", &SMatrix::Z},      {"h", &SMatrix::H},   {"s", &SMatrix::S},
-    {"sdg", &SMatrix::SDG},  {"t", &SMatrix::T},   {"tdg", &SMatrix::TDG},
-    {"x90", &SMatrix::X90},  {"cx", &SMatrix::CX}, {"cy", &SMatrix::CY},
-    {"cz", &SMatrix::CZ},    {"swap", &SMatrix::SWAP}, {"sx", &SMatrix::SX},
+    {"id", &SMatrix::I},      {"x", &SMatrix::X},       {"y", &SMatrix::Y},
+    {"z", &SMatrix::Z},       {"h", &SMatrix::H},       {"s", &SMatrix::S},
+    {"sdg", &SMatrix::SDG},   {"t", &SMatrix::T},       {"tdg", &SMatrix::TDG},
+    {"x90", &SMatrix::X90},   {"cx", &SMatrix::CX},     {"cy", &SMatrix::CY},
+    {"cz", &SMatrix::CZ},     {"swap", &SMatrix::SWAP}, {"sx", &SMatrix::SX},
     {"sxdg", &SMatrix::SXDG}, {"delay", &SMatrix::I}};
 
 cmatrix_t SMatrix::identity(size_t dim) { return Matrix::identity(dim * dim); }
 
-cmatrix_t SMatrix::u1(double lambda) {
-  return phase(lambda);
-}
+cmatrix_t SMatrix::u1(double lambda) { return phase(lambda); }
 
 cmatrix_t SMatrix::u2(double phi, double lambda) {
   return Utils::tensor_product(Matrix::u2(-phi, -lambda),
diff --git a/src/framework/linalg/matrix_utils/vmatrix_defs.hpp b/src/framework/linalg/matrix_utils/vmatrix_defs.hpp
old mode 100755
new mode 100644
index bc4e68c617..cef6a69308
--- a/src/framework/linalg/matrix_utils/vmatrix_defs.hpp
+++ b/src/framework/linalg/matrix_utils/vmatrix_defs.hpp
@@ -34,18 +34,18 @@ namespace Linalg {
 class VMatrix {
 public:
   // Single-qubit gates
-  const static cvector_t I;   // name: "id"
-  const static cvector_t X;   // name: "x"
-  const static cvector_t Y;   // name: "y"
-  const static cvector_t Z;   // name: "z"
-  const static cvector_t H;   // name: "h"
-  const static cvector_t S;   // name: "s"
-  const static cvector_t SDG; // name: "sdg"
-  const static cvector_t T;   // name: "t"
-  const static cvector_t TDG; // name: "tdg"
-  const static cvector_t SX;  // name: "sx"
-  const static cvector_t SXDG;// name: "sxdg"
-  const static cvector_t X90; // name: "x90"
+  const static cvector_t I;    // name: "id"
+  const static cvector_t X;    // name: "x"
+  const static cvector_t Y;    // name: "y"
+  const static cvector_t Z;    // name: "z"
+  const static cvector_t H;    // name: "h"
+  const static cvector_t S;    // name: "s"
+  const static cvector_t SDG;  // name: "sdg"
+  const static cvector_t T;    // name: "t"
+  const static cvector_t TDG;  // name: "tdg"
+  const static cvector_t SX;   // name: "sx"
+  const static cvector_t SXDG; // name: "sxdg"
+  const static cvector_t X90;  // name: "x90"
 
   // Two-qubit gates
   const static cvector_t CX;   // name: "cx"
@@ -73,7 +73,7 @@ class VMatrix {
   static cvector_t rxx(double theta);
   static cvector_t ryy(double theta);
   static cvector_t rzz(double theta);
-  static cvector_t rzx(double theta); // rotation around Tensor(X, Z)
+  static cvector_t rzx(double theta);      // rotation around Tensor(X, Z)
   static cvector_t rzz_diag(double theta); // return the matrix diagonal
 
   // Phase Gates
@@ -94,8 +94,10 @@ class VMatrix {
   static cvector_t u3(complex_t theta, complex_t phi, complex_t lam) {
     return u3(std::real(theta), std::real(phi), std::real(lam));
   };
-  static cvector_t u4(complex_t theta, complex_t phi, complex_t lam, complex_t gamma) {
-    return u4(std::real(theta), std::real(phi), std::real(lam), std::real(gamma));
+  static cvector_t u4(complex_t theta, complex_t phi, complex_t lam,
+                      complex_t gamma) {
+    return u4(std::real(theta), std::real(phi), std::real(lam),
+              std::real(gamma));
   };
   static cvector_t r(complex_t theta, complex_t phi) {
     return r(std::real(theta), std::real(phi));
@@ -103,18 +105,28 @@ class VMatrix {
   static cvector_t rx(complex_t theta) { return rx(std::real(theta)); }
   static cvector_t ry(complex_t theta) { return ry(std::real(theta)); }
   static cvector_t rz(complex_t theta) { return rz(std::real(theta)); }
-  static cvector_t rz_diag(complex_t theta) { return rz_diag(std::real(theta)); }
+  static cvector_t rz_diag(complex_t theta) {
+    return rz_diag(std::real(theta));
+  }
   static cvector_t rxx(complex_t theta) { return rxx(std::real(theta)); }
   static cvector_t ryy(complex_t theta) { return ryy(std::real(theta)); }
   static cvector_t rzz(complex_t theta) { return rzz(std::real(theta)); }
-  static cvector_t rzz_diag(complex_t theta) { return rzz_diag(std::real(theta)); }
+  static cvector_t rzz_diag(complex_t theta) {
+    return rzz_diag(std::real(theta));
+  }
   static cvector_t rzx(complex_t theta) { return rzx(std::real(theta)); }
   static cvector_t phase(complex_t theta) { return phase(std::real(theta)); }
-  static cvector_t phase_diag(complex_t theta) { return phase_diag(std::real(theta)); }
+  static cvector_t phase_diag(complex_t theta) {
+    return phase_diag(std::real(theta));
+  }
   static cvector_t cphase(complex_t theta) { return cphase(std::real(theta)); }
-  static cvector_t cphase_diag(complex_t theta) { return cphase_diag(std::real(theta)); }
-  static cvector_t cu(complex_t theta, complex_t phi, complex_t lam, complex_t gamma) {
-    return cu(std::real(theta), std::real(phi), std::real(lam), std::real(gamma));
+  static cvector_t cphase_diag(complex_t theta) {
+    return cphase_diag(std::real(theta));
+  }
+  static cvector_t cu(complex_t theta, complex_t phi, complex_t lam,
+                      complex_t gamma) {
+    return cu(std::real(theta), std::real(phi), std::real(lam),
+              std::real(gamma));
   }
 
   // Return the matrix for a named matrix string
@@ -172,12 +184,12 @@ const cvector_t VMatrix::SWAP = Utils::vectorize_matrix(Matrix::SWAP);
 
 // Lookup table
 const stringmap_t<const cvector_t *> VMatrix::label_map_ = {
-    {"id", &VMatrix::I},     {"x", &VMatrix::X},   {"y", &VMatrix::Y},
-    {"z", &VMatrix::Z},      {"h", &VMatrix::H},   {"s", &VMatrix::S},
-    {"sdg", &VMatrix::SDG},  {"t", &VMatrix::T},   {"tdg", &VMatrix::TDG},
-    {"x90", &VMatrix::X90},  {"cx", &VMatrix::CX}, {"cy", &VMatrix::CY},
-    {"cz", &VMatrix::CZ},    {"swap", &VMatrix::SWAP}, {"sx", &VMatrix::SX},
-    {"sxdg", &VMatrix::SXDG},    {"delay", &VMatrix::I}};
+    {"id", &VMatrix::I},      {"x", &VMatrix::X},       {"y", &VMatrix::Y},
+    {"z", &VMatrix::Z},       {"h", &VMatrix::H},       {"s", &VMatrix::S},
+    {"sdg", &VMatrix::SDG},   {"t", &VMatrix::T},       {"tdg", &VMatrix::TDG},
+    {"x90", &VMatrix::X90},   {"cx", &VMatrix::CX},     {"cy", &VMatrix::CY},
+    {"cz", &VMatrix::CZ},     {"swap", &VMatrix::SWAP}, {"sx", &VMatrix::SX},
+    {"sxdg", &VMatrix::SXDG}, {"delay", &VMatrix::I}};
 
 cvector_t VMatrix::identity(size_t dim) {
   cvector_t mat(dim * dim);
@@ -186,9 +198,7 @@ cvector_t VMatrix::identity(size_t dim) {
   return mat;
 }
 
-cvector_t VMatrix::u1(double lambda) {
-  return phase(lambda);
-}
+cvector_t VMatrix::u1(double lambda) { return phase(lambda); }
 
 cvector_t VMatrix::u2(double phi, double lambda) {
   cvector_t mat(2 * 2);
@@ -312,7 +322,7 @@ cvector_t VMatrix::rzz_diag(double theta) {
   const complex_t i(0., 1.);
   const complex_t exp_p = std::exp(i * 0.5 * theta);
   const complex_t exp_m = std::exp(-i * 0.5 * theta);
-  return cvector_t({exp_m, exp_p,  exp_p,  exp_m});
+  return cvector_t({exp_m, exp_p, exp_p, exp_m});
 }
 
 cvector_t VMatrix::rzx(double theta) {
diff --git a/src/framework/linalg/square.hpp b/src/framework/linalg/square.hpp
old mode 100755
new mode 100644
index 6baae7054f..9760fe442c
--- a/src/framework/linalg/square.hpp
+++ b/src/framework/linalg/square.hpp
@@ -22,10 +22,10 @@
 #include <vector>
 
 #include "framework/json.hpp"
-#include "framework/matrix.hpp"
+#include "framework/linalg/enable_if_numeric.hpp"
 #include "framework/linalg/vector.hpp"
+#include "framework/matrix.hpp"
 #include "framework/types.hpp"
-#include "framework/linalg/enable_if_numeric.hpp"
 
 namespace AER {
 namespace Linalg {
@@ -39,14 +39,14 @@ namespace Linalg {
 
 // Return entrywise square of a vector
 template <class T, size_t N, typename = enable_if_numeric_t<T>>
-std::array<T, N> square(const std::array<T, N>& data) {
+std::array<T, N> square(const std::array<T, N> &data) {
   std::array<T, N> result = data;
   return isquare(result);
 }
 
 // Return inplace entrywise square of a vector
 template <class T, size_t N, typename = enable_if_numeric_t<T>>
-std::array<T, N>& isquare(std::array<T, N>& data) {
+std::array<T, N> &isquare(std::array<T, N> &data) {
   std::transform(data.begin(), data.end(), data.begin(), data.begin(),
                  std::multiplies<T>());
   return data;
@@ -58,17 +58,17 @@ std::array<T, N>& isquare(std::array<T, N>& data) {
 
 // Return entrywise square of a vector
 template <class T, typename = enable_if_numeric_t<T>>
-std::vector<T> square(const std::vector<T>& data) {
+std::vector<T> square(const std::vector<T> &data) {
   std::vector<T> result;
   result.reserve(data.size());
-  std::transform(data.begin(), data.end(), data.begin(), std::back_inserter(result),
-                 std::multiplies<T>());
+  std::transform(data.begin(), data.end(), data.begin(),
+                 std::back_inserter(result), std::multiplies<T>());
   return result;
 }
 
 // Return inplace entrywise square of a vector
 template <class T, typename = enable_if_numeric_t<T>>
-std::vector<T>& isquare(std::vector<T>& data) {
+std::vector<T> &isquare(std::vector<T> &data) {
   std::transform(data.begin(), data.end(), data.begin(), data.begin(),
                  std::multiplies<T>());
   return data;
@@ -78,18 +78,20 @@ std::vector<T>& isquare(std::vector<T>& data) {
 // Entrywise square of std::map
 //----------------------------------------------------------------------------
 
-template <class T1, class T2, class T3, class T4, typename = enable_if_numeric_t<T2>>
-std::map<T1, T2, T3, T4> square(const std::map<T1, T2, T3, T4>& data) {
+template <class T1, class T2, class T3, class T4,
+          typename = enable_if_numeric_t<T2>>
+std::map<T1, T2, T3, T4> square(const std::map<T1, T2, T3, T4> &data) {
   std::map<T1, T2, T3, T4> result;
-  for (const auto& pair : data) {
+  for (const auto &pair : data) {
     result[pair.first] = pair.second * pair.second;
   }
   return result;
 }
 
-template <class T1, class T2, class T3, class T4, typename = enable_if_numeric_t<T2>>
-std::map<T1, T2, T3, T4>& isquare(std::map<T1, T2, T3, T4>& data) {
-  for (auto& pair : data) {
+template <class T1, class T2, class T3, class T4,
+          typename = enable_if_numeric_t<T2>>
+std::map<T1, T2, T3, T4> &isquare(std::map<T1, T2, T3, T4> &data) {
+  for (auto &pair : data) {
     pair.second *= pair.second;
   }
   return data;
@@ -99,19 +101,22 @@ std::map<T1, T2, T3, T4>& isquare(std::map<T1, T2, T3, T4>& data) {
 // Entrywise square of std::unordered_map
 //----------------------------------------------------------------------------
 
-template <class T1, class T2, class T3, class T4, class T5, typename = enable_if_numeric_t<T2>>
-std::unordered_map<T1, T2, T3, T4, T5> square(
-    const std::unordered_map<T1, T2, T3, T4, T5>& data) {
+template <class T1, class T2, class T3, class T4, class T5,
+          typename = enable_if_numeric_t<T2>>
+std::unordered_map<T1, T2, T3, T4, T5>
+square(const std::unordered_map<T1, T2, T3, T4, T5> &data) {
   std::unordered_map<T1, T2, T3, T4, T5> result;
-  for (const auto& pair : data) {
+  for (const auto &pair : data) {
     result[pair.first] = pair.second * pair.second;
   }
   return result;
 }
 
-template <class T1, class T2, class T3, class T4, class T5, typename = enable_if_numeric_t<T2>>
-std::unordered_map<T1, T2, T3, T4, T5>& isquare(std::unordered_map<T1, T2, T3, T4, T5>& data) {
-  for (auto& pair : data) {
+template <class T1, class T2, class T3, class T4, class T5,
+          typename = enable_if_numeric_t<T2>>
+std::unordered_map<T1, T2, T3, T4, T5> &
+isquare(std::unordered_map<T1, T2, T3, T4, T5> &data) {
+  for (auto &pair : data) {
     pair.second *= pair.second;
   }
   return data;
@@ -122,7 +127,7 @@ std::unordered_map<T1, T2, T3, T4, T5>& isquare(std::unordered_map<T1, T2, T3, T
 //----------------------------------------------------------------------------
 
 template <class T, typename = enable_if_numeric_t<T>>
-matrix<T>& isquare(matrix<T>& data) {
+matrix<T> &isquare(matrix<T> &data) {
   for (size_t j = 0; j < data.size(); j++) {
     data[j] *= data[j];
   }
@@ -130,7 +135,7 @@ matrix<T>& isquare(matrix<T>& data) {
 }
 
 template <class T, typename = enable_if_numeric_t<T>>
-matrix<T> square(const matrix<T>& data) {
+matrix<T> square(const matrix<T> &data) {
   matrix<T> result = data;
   return isquare(result);
 }
@@ -140,16 +145,17 @@ matrix<T> square(const matrix<T>& data) {
 //----------------------------------------------------------------------------
 
 template <class T, typename = enable_if_numeric_t<T>>
-Vector<T>& isquare(Vector<T>& vec) {
-  std::for_each(vec.data(), vec.data() + vec.size(), [](T&val) { val *= val; });
+Vector<T> &isquare(Vector<T> &vec) {
+  std::for_each(vec.data(), vec.data() + vec.size(),
+                [](T &val) { val *= val; });
   return vec;
 }
 
 template <class T, typename = enable_if_numeric_t<T>>
-Vector<T> square(const Vector<T>& vec) {
+Vector<T> square(const Vector<T> &vec) {
   Vector<T> ret(vec.size(), false);
   std::transform(vec.data(), vec.data() + vec.size(), ret.data(),
-                 [](const T&val) { return val * val; });
+                 [](const T &val) { return val * val; });
   return ret;
 }
 
@@ -157,7 +163,7 @@ Vector<T> square(const Vector<T>& vec) {
 // Entrywise square of JSON
 //----------------------------------------------------------------------------
 
-inline json_t& isquare(json_t& data) {
+inline json_t &isquare(json_t &data) {
   // Terminating case
   if (data.is_number()) {
     double val = data;
@@ -170,7 +176,7 @@ inline json_t& isquare(json_t& data) {
       isquare(data[pos]);
     }
     return data;
-  } 
+  }
   if (data.is_object()) {
     for (auto it = data.begin(); it != data.end(); ++it) {
       isquare(data[it.key()]);
@@ -180,7 +186,7 @@ inline json_t& isquare(json_t& data) {
   throw std::invalid_argument("Input JSONs cannot be squared.");
 }
 
-inline json_t square(const json_t& data) {
+inline json_t square(const json_t &data) {
   json_t result = data;
   return isquare(result);
 }
@@ -189,20 +195,16 @@ inline json_t square(const json_t& data) {
 // Square of general type
 //----------------------------------------------------------------------------
 
-template <class T>
-T square(const T& data) {
-  return data * data;
-}
+template <class T> T square(const T &data) { return data * data; }
 
-template <class T>
-T& isquare(T& data) {
+template <class T> T &isquare(T &data) {
   data *= data;
   return data;
 }
 
 //------------------------------------------------------------------------------
-}  // end namespace Linalg
+} // end namespace Linalg
 //------------------------------------------------------------------------------
-}  // end namespace AER
+} // end namespace AER
 //------------------------------------------------------------------------------
 #endif
\ No newline at end of file
diff --git a/src/framework/linalg/vector.hpp b/src/framework/linalg/vector.hpp
old mode 100755
new mode 100644
index e5f0d59e01..59fe4ba1b9
--- a/src/framework/linalg/vector.hpp
+++ b/src/framework/linalg/vector.hpp
@@ -60,8 +60,7 @@ template <class T> class Vector {
   Vector(Vector<T> &&other) noexcept;
 
   // Destructor
-  virtual ~Vector() { 
-    free(data_); }
+  virtual ~Vector() { free(data_); }
 
   //-----------------------------------------------------------------------
   // Assignment
@@ -192,7 +191,8 @@ template <class T> class Vector {
 
 template <class T>
 Vector<T>::Vector(size_t sz, bool fill)
-    : size_(sz), data_((fill) ? calloc_array<T>(size_) : malloc_array<T>(size_)) {}
+    : size_(sz),
+      data_((fill) ? calloc_array<T>(size_) : malloc_array<T>(size_)) {}
 
 template <class T>
 Vector<T>::Vector(const Vector<T> &other)
@@ -257,8 +257,7 @@ Vector<T> Vector<T>::copy_from_buffer(size_t sz, const T *buffer) {
   return ret;
 }
 
-template <class T>
-Vector<T> Vector<T>::move_from_buffer(size_t sz, T *buffer) {
+template <class T> Vector<T> Vector<T>::move_from_buffer(size_t sz, T *buffer) {
   Vector<T> ret;
   ret.size_ = sz;
   ret.data_ = buffer;
@@ -364,8 +363,7 @@ template <class T> Vector<T> Vector<T>::operator*(const T &other) const {
 }
 
 template <class T> Vector<T> &Vector<T>::operator*=(const T &other) {
-  std::for_each(data_, data_ + size_,
-                 [&other](T &a) { a *= other; });
+  std::for_each(data_, data_ + size_, [&other](T &a) { a *= other; });
   return *this;
 }
 
@@ -383,7 +381,6 @@ template <class T> Vector<T> &Vector<T>::operator/=(const T &other) {
   return *this;
 }
 
-
 //------------------------------------------------------------------------------
 } // end Namespace AER
 //------------------------------------------------------------------------------
diff --git a/src/framework/linalg/vector_json.hpp b/src/framework/linalg/vector_json.hpp
old mode 100755
new mode 100644
index 8f3f8d2a67..11f2e50e76
--- a/src/framework/linalg/vector_json.hpp
+++ b/src/framework/linalg/vector_json.hpp
@@ -24,7 +24,6 @@ namespace AER {
 // Implementation: JSON Conversion
 //------------------------------------------------------------------------------
 
-  
 template <typename T> void to_json(nlohmann::json &js, const Vector<T> &vec) {
   js = nlohmann::json();
   for (size_t i = 0; i < vec.size(); i++) {
@@ -32,15 +31,14 @@ template <typename T> void to_json(nlohmann::json &js, const Vector<T> &vec) {
   }
 }
 
-
 template <typename T> void from_json(const nlohmann::json &js, Vector<T> &vec) {
   // Check JSON is an array
-  if(!js.is_array()) {
+  if (!js.is_array()) {
     throw std::invalid_argument(
         std::string("JSON: invalid Vector (not array)."));
   }
   // Check if JSON is empty
-  if(js.empty()) {
+  if (js.empty()) {
     return;
   }
 
diff --git a/src/framework/matrix.hpp b/src/framework/matrix.hpp
old mode 100755
new mode 100644
index 54a8365950..ab5a0b23c3
--- a/src/framework/matrix.hpp
+++ b/src/framework/matrix.hpp
@@ -31,10 +31,10 @@ Multiplication is done with the C wrapper of the fortran blas library.
 #ifndef _aer_framework_matrix_hpp
 #define _aer_framework_matrix_hpp
 
+#include <array>
 #include <complex>
 #include <iostream>
 #include <vector>
-#include <array>
 
 #include "framework/blas_protos.hpp"
 #include "framework/linalg/enable_if_numeric.hpp"
@@ -45,17 +45,14 @@ Multiplication is done with the C wrapper of the fortran blas library.
  *
  ******************************************************************************/
 
-template <class T>
-T* malloc_array(size_t size) {
-  return reinterpret_cast<T*>(malloc(sizeof(T) * size));
+template <class T> T *malloc_array(size_t size) {
+  return reinterpret_cast<T *>(malloc(sizeof(T) * size));
 }
 
-template <class T>
-T* calloc_array(size_t size) {
-  return reinterpret_cast<T*>(calloc(size, sizeof(T)));
+template <class T> T *calloc_array(size_t size) {
+  return reinterpret_cast<T *>(calloc(size, sizeof(T)));
 }
 
-
 template <class T> // define a class template
 class matrix {
   // friend functions get to use the private variables of the class as well as
@@ -139,7 +136,7 @@ class matrix {
   matrix(const matrix<T> &other);
 
   // Move construct a matrix
-  matrix(matrix<T>&& other) noexcept;
+  matrix(matrix<T> &&other) noexcept;
 
   // Destructor
   virtual ~matrix() { free(data_); }
@@ -155,8 +152,7 @@ class matrix {
   matrix<T> &operator=(matrix<T> &&other) noexcept;
 
   // Copy and cast assignment
-  template <class S>
-  matrix<T> &operator=(const matrix<S> &other);
+  template <class S> matrix<T> &operator=(const matrix<S> &other);
 
   //-----------------------------------------------------------------------
   // Buffer conversion
@@ -164,33 +160,33 @@ class matrix {
 
   // Copy construct a matrix from C-array buffer
   // The buffer should have size = rows * cols.
-  static matrix<T> copy_from_buffer(size_t rows, size_t cols, const T* buffer);
+  static matrix<T> copy_from_buffer(size_t rows, size_t cols, const T *buffer);
 
   // Move construct a matrix from C-array buffer
   // The buffer should have size = rows * cols.
-  static matrix<T> move_from_buffer(size_t rows, size_t cols, T* buffer);
+  static matrix<T> move_from_buffer(size_t rows, size_t cols, T *buffer);
 
   // Copy matrix to a new C-array
-  T* copy_to_buffer() const;
+  T *copy_to_buffer() const;
 
   // Move matrix to a C-array
-  T* move_to_buffer();
+  T *move_to_buffer();
 
   //-----------------------------------------------------------------------
   // Element access
   //-----------------------------------------------------------------------
 
   // Addressing elements by vector representation
-  T& operator[](size_t element);
-  const T& operator[](size_t element) const;
+  T &operator[](size_t element);
+  const T &operator[](size_t element) const;
 
   // Addressing elements by matrix representation
-  T& operator()(size_t row, size_t col);
-  const T& operator()(size_t row, size_t col) const;
+  T &operator()(size_t row, size_t col);
+  const T &operator()(size_t row, size_t col) const;
 
   // Access the array data pointer
-  const T* data() const noexcept { return data_; }
-  T* data() noexcept { return data_; }
+  const T *data() const noexcept { return data_; }
+  T *data() noexcept { return data_; }
 
   //-----------------------------------------------------------------------
   // Other methods
@@ -206,7 +202,7 @@ class matrix {
   void clear();
 
   // Fill with constant value
-  void fill(const T& val);
+  void fill(const T &val);
 
   // Resize the matrix and reset to zero if different size
   void initialize(size_t row, size_t col);
@@ -242,7 +238,7 @@ class matrix {
   // to rows
 
   // the ptr to the vector containing the matrix
-  T* data_ = nullptr;
+  T *data_ = nullptr;
 };
 
 /*******************************************************************************
@@ -261,14 +257,15 @@ matrix<T>::matrix(size_t rows, size_t cols, bool fill)
       data_((fill) ? calloc_array<T>(size_) : malloc_array<T>(size_)) {}
 
 template <class T>
-matrix<T>::matrix(const matrix<T> &other) : matrix(other.rows_, other.cols_, false) {
+matrix<T>::matrix(const matrix<T> &other)
+    : matrix(other.rows_, other.cols_, false) {
   std::copy(other.data_, other.data_ + other.size_, data_);
 }
 
 template <class T>
-matrix<T>::matrix(matrix<T>&& other) noexcept
-  : rows_(other.rows_), cols_(other.cols_), size_(other.size_), LD_(rows_),
-    data_(other.data_) {
+matrix<T>::matrix(matrix<T> &&other) noexcept
+    : rows_(other.rows_), cols_(other.cols_), size_(other.size_), LD_(rows_),
+      data_(other.data_) {
   other.data_ = nullptr;
 }
 
@@ -276,8 +273,7 @@ matrix<T>::matrix(matrix<T>&& other) noexcept
 // Assignment
 //-----------------------------------------------------------------------
 
-template <class T>
-matrix<T>& matrix<T>::operator=(matrix<T>&& other) noexcept {
+template <class T> matrix<T> &matrix<T>::operator=(matrix<T> &&other) noexcept {
   free(data_);
   rows_ = other.rows_;
   cols_ = other.cols_;
@@ -288,8 +284,7 @@ matrix<T>& matrix<T>::operator=(matrix<T>&& other) noexcept {
   return *this;
 }
 
-template <class T>
-matrix<T> &matrix<T>::operator=(const matrix<T> &other) {
+template <class T> matrix<T> &matrix<T>::operator=(const matrix<T> &other) {
   if (rows_ != other.rows_ || cols_ != other.cols_) {
     // size delete re-construct
     // the matrix
@@ -308,8 +303,7 @@ template <class T>
 template <class S>
 inline matrix<T> &matrix<T>::operator=(const matrix<S> &other) {
 
-  if (rows_ != other.GetRows() ||
-      cols_ != other.GetColumns()) {
+  if (rows_ != other.GetRows() || cols_ != other.GetColumns()) {
     free(data_);
     rows_ = other.GetRows();
     cols_ = other.GetColumns();
@@ -328,7 +322,8 @@ inline matrix<T> &matrix<T>::operator=(const matrix<S> &other) {
 //-----------------------------------------------------------------------
 
 template <class T>
-matrix<T> matrix<T>::copy_from_buffer(size_t rows, size_t cols, const T* buffer) {
+matrix<T> matrix<T>::copy_from_buffer(size_t rows, size_t cols,
+                                      const T *buffer) {
   matrix<T> ret;
   ret.size_ = rows * cols;
   ret.rows_ = rows;
@@ -340,7 +335,7 @@ matrix<T> matrix<T>::copy_from_buffer(size_t rows, size_t cols, const T* buffer)
 }
 
 template <class T>
-matrix<T> matrix<T>::move_from_buffer(size_t rows, size_t cols, T* buffer) {
+matrix<T> matrix<T>::move_from_buffer(size_t rows, size_t cols, T *buffer) {
   matrix<T> ret;
   ret.size_ = rows * cols;
   ret.rows_ = rows;
@@ -350,16 +345,14 @@ matrix<T> matrix<T>::move_from_buffer(size_t rows, size_t cols, T* buffer) {
   return ret;
 }
 
-template <class T>
-T* matrix<T>::copy_to_buffer() const {
-  T* buffer = malloc_array<T>(size_);
+template <class T> T *matrix<T>::copy_to_buffer() const {
+  T *buffer = malloc_array<T>(size_);
   std::copy(data_, data_ + size_, buffer);
   return buffer;
 }
 
-template <class T>
-T* matrix<T>::move_to_buffer() {
-  T* buffer = data_;
+template <class T> T *matrix<T>::move_to_buffer() {
+  T *buffer = data_;
   data_ = nullptr;
   size_ = 0;
   rows_ = 0;
@@ -371,8 +364,7 @@ T* matrix<T>::move_to_buffer() {
 // Element access
 //-----------------------------------------------------------------------
 
-template <class T>
-T& matrix<T>::operator[](size_t p) {
+template <class T> T &matrix<T>::operator[](size_t p) {
 #ifdef DEBUG
   if (p >= size_) {
     std::cerr
@@ -383,8 +375,7 @@ T& matrix<T>::operator[](size_t p) {
 #endif
   return data_[p];
 }
-template <class T>
-const T& matrix<T>::operator[](size_t p) const {
+template <class T> const T &matrix<T>::operator[](size_t p) const {
 #ifdef DEBUG
   if (p >= size_) {
     std::cerr << "Error: matrix class operator [] const: Matrix subscript out "
@@ -396,8 +387,7 @@ const T& matrix<T>::operator[](size_t p) const {
   return data_[p];
 }
 
-template <class T>
-T& matrix<T>::operator()(size_t i, size_t j) {
+template <class T> T &matrix<T>::operator()(size_t i, size_t j) {
 #ifdef DEBUG
   if (i >= rows_ || j >= cols_) {
     std::cerr
@@ -409,8 +399,7 @@ T& matrix<T>::operator()(size_t i, size_t j) {
   return data_[j * rows_ + i];
 }
 
-template <class T>
-const T& matrix<T>::operator()(size_t i, size_t j) const {
+template <class T> const T &matrix<T>::operator()(size_t i, size_t j) const {
 #ifdef DEBUG
   if (i >= rows_ || j >= cols_) {
     std::cerr << "Error: matrix class operator ()   const: Matrices subscript "
@@ -422,8 +411,7 @@ const T& matrix<T>::operator()(size_t i, size_t j) const {
   return data_[j * rows_ + i];
 }
 
-template <class T>
-void matrix<T>::clear() {
+template <class T> void matrix<T>::clear() {
   if (!data_ || !size_)
     return;
   rows_ = cols_ = size_ = 0;
@@ -441,13 +429,11 @@ template <class T> inline void matrix<T>::initialize(size_t rows, size_t cols) {
   }
 }
 
-template <class T>
-void matrix<T>::fill(const T& val) {
+template <class T> void matrix<T>::fill(const T &val) {
   std::fill(data_, data_ + size_, val);
 }
 
-template <class T>
-void matrix<T>::resize(size_t rows, size_t cols) {
+template <class T> void matrix<T>::resize(size_t rows, size_t cols) {
   if (rows_ == rows && cols_ == cols)
     return;
   size_ = rows * cols;
@@ -465,33 +451,35 @@ void matrix<T>::resize(size_t rows, size_t cols) {
 }
 
 // Addressing elements by row or column
-template <class T> inline std::vector<T> matrix<T>::row_index(size_t row) const {
+template <class T>
+inline std::vector<T> matrix<T>::row_index(size_t row) const {
 #ifdef DEBUG
   if (row >= rows_) {
-    std::cerr << "Error: matrix class operator row_index out of bounds "
-              << row << " >= " << rows_ << std::endl;
+    std::cerr << "Error: matrix class operator row_index out of bounds " << row
+              << " >= " << rows_ << std::endl;
     exit(1);
   }
 #endif
   std::vector<T> ret;
   ret.reserve(cols_);
-  for(size_t i = 0; i < cols_; i++)
+  for (size_t i = 0; i < cols_; i++)
     ret.emplace_back(data_[i * rows_ + row]);
   // Allow for Named Return Value Optimization (NRVO) by not using std::move
   return ret;
 }
-template <class T> inline std::vector<T> matrix<T>::col_index(size_t col) const {
+template <class T>
+inline std::vector<T> matrix<T>::col_index(size_t col) const {
 #ifdef DEBUG
   if (col >= cols_) {
-    std::cerr << "Error: matrix class operator col_index out of bounds "
-              << col << " >= " << cols_ << std::endl;
+    std::cerr << "Error: matrix class operator col_index out of bounds " << col
+              << " >= " << cols_ << std::endl;
     exit(1);
   }
 #endif
   std::vector<T> ret;
   ret.reserve(rows_);
   // we want the elements for all rows i..rows_ and column col
-  for(size_t i = 0; i < rows_; i++)
+  for (size_t i = 0; i < rows_; i++)
     ret.emplace_back(data_[col * rows_ + i]);
   // Allow for Named Return Value Optimization (NRVO) by not using std::move
   return ret;
@@ -678,8 +666,8 @@ inline matrix<double> operator*(const matrix<double> &A,
   // C-> alpha*op(A)*op(B) +beta C
   matrix<double> C(A.rows_, B.cols_);
   double alpha = 1.0, beta = 0.0;
-  dgemm_(&AerBlas::Trans[0], &AerBlas::Trans[0], &A.rows_, &B.cols_, &A.cols_, &alpha, A.data_,
-         &A.LD_, B.data_, &B.LD_, &beta, C.data_, &C.LD_);
+  dgemm_(&AerBlas::Trans[0], &AerBlas::Trans[0], &A.rows_, &B.cols_, &A.cols_,
+         &alpha, A.data_, &A.LD_, B.data_, &B.LD_, &beta, C.data_, &C.LD_);
   // cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, A.rows_, B.cols_,
   // A.cols_, 1.0, A.data_, A.LD_, B.data_, B.LD_, 0.0, C.data_, C.LD_);
   return C;
@@ -690,8 +678,8 @@ inline matrix<float> operator*(const matrix<float> &A, const matrix<float> &B) {
   // C-> alpha*op(A)*op(B) +beta C
   matrix<float> C(A.rows_, B.cols_);
   float alpha = 1.0, beta = 0.0;
-  sgemm_(&AerBlas::Trans[0], &AerBlas::Trans[0], &A.rows_, &B.cols_, &A.cols_, &alpha, A.data_,
-         &A.LD_, B.data_, &B.LD_, &beta, C.data_, &C.LD_);
+  sgemm_(&AerBlas::Trans[0], &AerBlas::Trans[0], &A.rows_, &B.cols_, &A.cols_,
+         &alpha, A.data_, &A.LD_, B.data_, &B.LD_, &beta, C.data_, &C.LD_);
   // cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, A.rows_, B.cols_,
   // A.cols_, 1.0, A.data_, A.LD_, B.data_, B.LD_, 0.0, C.data_, C.LD_);
   return C;
@@ -704,8 +692,8 @@ operator*(const matrix<std::complex<float>> &A,
   // C-> alpha*op(A)*op(B) +beta C
   matrix<std::complex<float>> C(A.rows_, B.cols_);
   std::complex<float> alpha = 1.0, beta = 0.0;
-  cgemm_(&AerBlas::Trans[0], &AerBlas::Trans[0], &A.rows_, &B.cols_, &A.cols_, &alpha, A.data_,
-         &A.LD_, B.data_, &B.LD_, &beta, C.data_, &C.LD_);
+  cgemm_(&AerBlas::Trans[0], &AerBlas::Trans[0], &A.rows_, &B.cols_, &A.cols_,
+         &alpha, A.data_, &A.LD_, B.data_, &B.LD_, &beta, C.data_, &C.LD_);
   // cblas_zgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, A.rows_, B.cols_,
   // A.cols_, &alpha, A.data_, A.LD_, B.data_, B.LD_, &beta, C.data_, C.LD_);
   return C;
@@ -718,8 +706,8 @@ operator*(const matrix<std::complex<double>> &A,
   // C-> alpha*op(A)*op(B) +beta C
   matrix<std::complex<double>> C(A.rows_, B.cols_);
   std::complex<double> alpha = 1.0, beta = 0.0;
-  zgemm_(&AerBlas::Trans[0], &AerBlas::Trans[0], &A.rows_, &B.cols_, &A.cols_, &alpha, A.data_,
-         &A.LD_, B.data_, &B.LD_, &beta, C.data_, &C.LD_);
+  zgemm_(&AerBlas::Trans[0], &AerBlas::Trans[0], &A.rows_, &B.cols_, &A.cols_,
+         &alpha, A.data_, &A.LD_, B.data_, &B.LD_, &beta, C.data_, &C.LD_);
   // cblas_zgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, A.rows_, B.cols_,
   // A.cols_, &alpha, A.data_, A.LD_, B.data_, B.LD_, &beta, C.data_, C.LD_);
   return C;
@@ -732,8 +720,8 @@ operator*(const matrix<float> &A, const matrix<std::complex<float>> &B) {
   matrix<std::complex<float>> C(A.rows_, B.cols_), Ac(A.rows_, A.cols_);
   Ac = A;
   std::complex<float> alpha = 1.0, beta = 0.0;
-  cgemm_(&AerBlas::Trans[0], &AerBlas::Trans[0], &Ac.rows_, &B.cols_, &Ac.cols_, &alpha, Ac.data_,
-         &Ac.LD_, B.data_, &B.LD_, &beta, C.data_, &C.LD_);
+  cgemm_(&AerBlas::Trans[0], &AerBlas::Trans[0], &Ac.rows_, &B.cols_, &Ac.cols_,
+         &alpha, Ac.data_, &Ac.LD_, B.data_, &B.LD_, &beta, C.data_, &C.LD_);
   // cblas_zgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, Ac.rows_, B.cols_,
   // Ac.cols_, &alpha, Ac.data_, Ac.LD_, B.data_, B.LD_, &beta, C.data_, C.LD_);
   return C;
@@ -746,8 +734,8 @@ operator*(const matrix<double> &A, const matrix<std::complex<double>> &B) {
   matrix<std::complex<double>> C(A.rows_, B.cols_), Ac(A.rows_, A.cols_);
   Ac = A;
   std::complex<double> alpha = 1.0, beta = 0.0;
-  zgemm_(&AerBlas::Trans[0], &AerBlas::Trans[0], &Ac.rows_, &B.cols_, &Ac.cols_, &alpha, Ac.data_,
-         &Ac.LD_, B.data_, &B.LD_, &beta, C.data_, &C.LD_);
+  zgemm_(&AerBlas::Trans[0], &AerBlas::Trans[0], &Ac.rows_, &B.cols_, &Ac.cols_,
+         &alpha, Ac.data_, &Ac.LD_, B.data_, &B.LD_, &beta, C.data_, &C.LD_);
   // cblas_zgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, Ac.rows_, B.cols_,
   // Ac.cols_, &alpha, Ac.data_, Ac.LD_, B.data_, B.LD_, &beta, C.data_, C.LD_);
   return C;
@@ -760,8 +748,8 @@ operator*(const matrix<std::complex<float>> &A, const matrix<float> &B) {
   matrix<std::complex<float>> C(A.rows_, B.cols_), Bc(B.rows_, B.cols_);
   Bc = B;
   std::complex<float> alpha = 1.0, beta = 0.0;
-  cgemm_(&AerBlas::Trans[0], &AerBlas::Trans[0], &A.rows_, &Bc.cols_, &A.cols_, &alpha, A.data_,
-         &A.LD_, Bc.data_, &Bc.LD_, &beta, C.data_, &C.LD_);
+  cgemm_(&AerBlas::Trans[0], &AerBlas::Trans[0], &A.rows_, &Bc.cols_, &A.cols_,
+         &alpha, A.data_, &A.LD_, Bc.data_, &Bc.LD_, &beta, C.data_, &C.LD_);
   // cblas_zgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, A.rows_, Bc.cols_,
   // A.cols_, &alpha, A.data_, A.LD_, Bc.data_, Bc.LD_, &beta, C.data_, C.LD_);
   return C;
@@ -774,8 +762,8 @@ operator*(const matrix<std::complex<double>> &A, const matrix<double> &B) {
   matrix<std::complex<double>> C(A.rows_, B.cols_), Bc(B.rows_, B.cols_);
   Bc = B;
   std::complex<double> alpha = 1.0, beta = 0.0;
-  zgemm_(&AerBlas::Trans[0], &AerBlas::Trans[0], &A.rows_, &Bc.cols_, &A.cols_, &alpha, A.data_,
-         &A.LD_, Bc.data_, &Bc.LD_, &beta, C.data_, &C.LD_);
+  zgemm_(&AerBlas::Trans[0], &AerBlas::Trans[0], &A.rows_, &Bc.cols_, &A.cols_,
+         &alpha, A.data_, &A.LD_, Bc.data_, &Bc.LD_, &beta, C.data_, &C.LD_);
   // cblas_zgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, A.rows_, Bc.cols_,
   // A.cols_, &alpha, A.data_, A.LD_, Bc.data_, Bc.LD_, &beta, C.data_, C.LD_);
   return C;
@@ -788,8 +776,8 @@ inline std::vector<float> operator*(const matrix<float> &A,
   std::vector<float> y(A.rows_);
   float alpha = 1.0, beta = 0.0;
   const size_t incx = 1, incy = 1;
-  sgemv_(&AerBlas::Trans[0], &A.rows_, &A.cols_, &alpha, A.data_, &A.LD_, x.data(), &incx,
-         &beta, y.data(), &incy);
+  sgemv_(&AerBlas::Trans[0], &A.rows_, &A.cols_, &alpha, A.data_, &A.LD_,
+         x.data(), &incx, &beta, y.data(), &incy);
   return y;
 }
 // Double-Precision Real
@@ -799,8 +787,8 @@ inline std::vector<double> operator*(const matrix<double> &A,
   std::vector<double> y(A.rows_);
   double alpha = 1.0, beta = 0.0;
   const size_t incx = 1, incy = 1;
-  dgemv_(&AerBlas::Trans[0], &A.rows_, &A.cols_, &alpha, A.data_, &A.LD_, x.data(), &incx,
-         &beta, y.data(), &incy);
+  dgemv_(&AerBlas::Trans[0], &A.rows_, &A.cols_, &alpha, A.data_, &A.LD_,
+         x.data(), &incx, &beta, y.data(), &incy);
   return y;
 }
 // Single-Precision Complex
@@ -811,8 +799,8 @@ operator*(const matrix<std::complex<float>> &A,
   std::vector<std::complex<float>> y(A.rows_);
   std::complex<float> alpha = 1.0, beta = 0.0;
   const size_t incx = 1, incy = 1;
-  cgemv_(&AerBlas::Trans[0], &A.rows_, &A.cols_, &alpha, A.data_, &A.LD_, x.data(), &incx,
-         &beta, y.data(), &incy);
+  cgemv_(&AerBlas::Trans[0], &A.rows_, &A.cols_, &alpha, A.data_, &A.LD_,
+         x.data(), &incx, &beta, y.data(), &incy);
   return y;
 }
 // Double-Precision Complex
@@ -823,8 +811,8 @@ operator*(const matrix<std::complex<double>> &A,
   std::vector<std::complex<double>> y(A.rows_);
   std::complex<double> alpha = 1.0, beta = 0.0;
   const size_t incx = 1, incy = 1;
-  zgemv_(&AerBlas::Trans[0], &A.rows_, &A.cols_, &alpha, A.data_, &A.LD_, x.data(), &incx,
-         &beta, y.data(), &incy);
+  zgemv_(&AerBlas::Trans[0], &A.rows_, &A.cols_, &alpha, A.data_, &A.LD_,
+         x.data(), &incx, &beta, y.data(), &incy);
   return y;
 }
 
diff --git a/src/framework/noise_utils.hpp b/src/framework/noise_utils.hpp
index eb3947fbd3..3a2bc4fbe4 100644
--- a/src/framework/noise_utils.hpp
+++ b/src/framework/noise_utils.hpp
@@ -25,29 +25,29 @@ namespace Utils {
 //=========================================================================
 
 // Transform a superoperator matrix to a Choi matrix
-template <class T>
-matrix<T> superop2choi(const matrix<T>& superop, size_t dim);
+template <class T> matrix<T> superop2choi(const matrix<T> &superop, size_t dim);
 
 // Transform a superoperator matrix to a set of Kraus matrices
 template <class T>
-std::vector<matrix<T>> superop2kraus(const matrix<T>& superop, size_t dim, double threshold = 1e-10);
+std::vector<matrix<T>> superop2kraus(const matrix<T> &superop, size_t dim,
+                                     double threshold = 1e-10);
 
 // Transform a Choi matrix to a superoperator matrix
-template <class T>
-matrix<T> choi2superop(const matrix<T>& choi, size_t dim);
+template <class T> matrix<T> choi2superop(const matrix<T> &choi, size_t dim);
 
 // Transform a Choi matrix to a set of Kraus matrices
 template <class T>
 std::vector<matrix<std::complex<T>>>
-choi2kraus(const matrix<std::complex<T>>& choi, size_t dim, double threshold = 1e-10);
+choi2kraus(const matrix<std::complex<T>> &choi, size_t dim,
+           double threshold = 1e-10);
 
 // Transform a set of Kraus matrices to a Choi matrix
 template <class T>
-matrix<T> kraus2choi(const std::vector<matrix<T>>& kraus, size_t dim);
+matrix<T> kraus2choi(const std::vector<matrix<T>> &kraus, size_t dim);
 
 // Transform a set of Kraus matrices to a superoperator matrix
 template <class T>
-matrix<T> kraus2superop(const std::vector<matrix<T>>& kraus, size_t dim);
+matrix<T> kraus2superop(const std::vector<matrix<T>> &kraus, size_t dim);
 
 // Reshuffle transformation
 // Transforms a matrix with dimension (d0 * d1, d2 * d3)
@@ -55,15 +55,15 @@ matrix<T> kraus2superop(const std::vector<matrix<T>>& kraus, size_t dim);
 // by transposition of bipartite indices
 // M[(i, j), (k, l)] -> M[(i, j), (k, i)]
 template <class T>
-matrix<T> reshuffle(const matrix<T> &mat, size_t d0, size_t d1, size_t d2, size_t d3);
-
+matrix<T> reshuffle(const matrix<T> &mat, size_t d0, size_t d1, size_t d2,
+                    size_t d3);
 
 //=========================================================================
 // Implementations
 //=========================================================================
 
 template <class T>
-matrix<T> kraus2superop(const std::vector<matrix<T>>& kraus, size_t dim) {
+matrix<T> kraus2superop(const std::vector<matrix<T>> &kraus, size_t dim) {
   matrix<T> superop(dim * dim, dim * dim);
   for (const auto mat : kraus) {
     superop += Utils::tensor_product(Utils::conjugate(mat), mat);
@@ -72,28 +72,28 @@ matrix<T> kraus2superop(const std::vector<matrix<T>>& kraus, size_t dim) {
 }
 
 template <class T>
-matrix<T> kraus2choi(const std::vector<matrix<T>>& kraus, size_t dim) {
+matrix<T> kraus2choi(const std::vector<matrix<T>> &kraus, size_t dim) {
   return superop2choi(kraus2superop(kraus, dim), dim);
 }
 
 template <class T>
-matrix<T> superop2choi(const matrix<T>& superop, size_t dim) {
+matrix<T> superop2choi(const matrix<T> &superop, size_t dim) {
   return reshuffle(superop, dim, dim, dim, dim);
 }
 
 template <class T>
-std::vector<matrix<T>> superop2kraus(const matrix<T>& superop, size_t dim, double threshold) {
+std::vector<matrix<T>> superop2kraus(const matrix<T> &superop, size_t dim,
+                                     double threshold) {
   return choi2kraus(superop2choi(superop, dim), dim, threshold);
 }
 
-template <class T>
-matrix<T> choi2superop(const matrix<T>& choi, size_t dim) {
+template <class T> matrix<T> choi2superop(const matrix<T> &choi, size_t dim) {
   return reshuffle(choi, dim, dim, dim, dim);
 }
 
 template <class T>
 std::vector<matrix<std::complex<T>>>
-choi2kraus(const matrix<std::complex<T>>& choi, size_t dim, double threshold) {
+choi2kraus(const matrix<std::complex<T>> &choi, size_t dim, double threshold) {
   size_t dim2 = dim * dim;
 
   std::vector<T> evals;
@@ -108,7 +108,7 @@ choi2kraus(const matrix<std::complex<T>>& choi, size_t dim, double threshold) {
     const size_t idx = dim2 - 1 - i;
     const T eval = evals[idx];
     if (eval > 0.0 && !Linalg::almost_equal(eval, 0.0, threshold)) {
-      std::complex<T> coeff(std::sqrt(eval), 0.0); 
+      std::complex<T> coeff(std::sqrt(eval), 0.0);
       matrix<std::complex<T>> kmat(dim, dim);
       for (size_t col = 0; col < dim; col++)
         for (size_t row = 0; row < dim; row++) {
@@ -121,19 +121,20 @@ choi2kraus(const matrix<std::complex<T>>& choi, size_t dim, double threshold) {
 }
 
 template <class T>
-matrix<T> reshuffle(const matrix<T> &mat, size_t d0, size_t d1, size_t d2, size_t d3) {
+matrix<T> reshuffle(const matrix<T> &mat, size_t d0, size_t d1, size_t d2,
+                    size_t d3) {
   matrix<T> ret(d1 * d3, d0 * d2);
   for (size_t i0 = 0; i0 < d0; ++i0)
     for (size_t i1 = 0; i1 < d1; ++i1)
       for (size_t i2 = 0; i2 < d2; ++i2)
         for (size_t i3 = 0; i3 < d3; ++i3) {
-          ret(d1 * i3 + i1, d0 * i2 +  i0) = mat(d1 * i0 + i1, d3 * i2 + i3);
+          ret(d1 * i3 + i1, d0 * i2 + i0) = mat(d1 * i0 + i1, d3 * i2 + i3);
         }
   return ret;
 }
 
 //-------------------------------------------------------------------------
-} // end namespace Noise
+} // namespace Utils
 //-------------------------------------------------------------------------
 } // end namespace AER
 //-------------------------------------------------------------------------
diff --git a/src/framework/operations.hpp b/src/framework/operations.hpp
old mode 100755
new mode 100644
index 8069931a41..07f89a2c33
--- a/src/framework/operations.hpp
+++ b/src/framework/operations.hpp
@@ -16,15 +16,15 @@
 #define _aer_framework_operations_hpp_
 
 #include <algorithm>
-#include <stdexcept>
 #include <iostream>
 #include <sstream>
+#include <stdexcept>
 #include <tuple>
 
-#include "framework/types.hpp"
 #include "framework/json_parser.hpp"
-#include "framework/utils.hpp"
 #include "framework/linalg/almost_equal.hpp"
+#include "framework/types.hpp"
+#include "framework/utils.hpp"
 #include "simulators/stabilizer/clifford.hpp"
 
 namespace AER {
@@ -33,39 +33,82 @@ namespace Operations {
 // Comparisons enum class used for Boolean function operation.
 // these are used to compare two hexadecimal strings and return a bool
 // for now we only have one comparison Equal, but others will be added
-enum class RegComparison {Equal, NotEqual, Less, LessEqual, Greater, GreaterEqual};
+enum class RegComparison {
+  Equal,
+  NotEqual,
+  Less,
+  LessEqual,
+  Greater,
+  GreaterEqual
+};
 
 // Enum class for operation types
 enum class OpType {
-  gate, measure, reset, bfunc, barrier, qerror_loc, snapshot,
-  matrix, diagonal_matrix, multiplexer, initialize, sim_op, nop,
+  gate,
+  measure,
+  reset,
+  bfunc,
+  barrier,
+  qerror_loc,
+  snapshot,
+  matrix,
+  diagonal_matrix,
+  multiplexer,
+  initialize,
+  sim_op,
+  nop,
   // Noise instructions
-  kraus, superop, roerror, noise_switch,
+  kraus,
+  superop,
+  roerror,
+  noise_switch,
   // Save instructions
-  save_state, save_expval, save_expval_var, save_statevec, save_statevec_dict,
-  save_densmat, save_probs, save_probs_ket, save_amps, save_amps_sq,
-  save_stabilizer, save_clifford, save_unitary, save_mps, save_superop,
+  save_state,
+  save_expval,
+  save_expval_var,
+  save_statevec,
+  save_statevec_dict,
+  save_densmat,
+  save_probs,
+  save_probs_ket,
+  save_amps,
+  save_amps_sq,
+  save_stabilizer,
+  save_clifford,
+  save_unitary,
+  save_mps,
+  save_superop,
   // Set instructions
-  set_statevec, set_densmat, set_unitary, set_superop,
-  set_stabilizer, set_mps,
+  set_statevec,
+  set_densmat,
+  set_unitary,
+  set_superop,
+  set_stabilizer,
+  set_mps,
   // Control Flow
-  jump, mark
+  jump,
+  mark
 };
 
 enum class DataSubType {
-  single, c_single, list, c_list, accum, c_accum, average, c_average
+  single,
+  c_single,
+  list,
+  c_list,
+  accum,
+  c_accum,
+  average,
+  c_average
 };
 
 static const std::unordered_set<OpType> SAVE_TYPES = {
-  OpType::save_state, OpType::save_expval, OpType::save_expval_var,
-  OpType::save_statevec, OpType::save_statevec_dict,
-  OpType::save_densmat, OpType::save_probs, OpType::save_probs_ket,
-  OpType::save_amps, OpType::save_amps_sq, OpType::save_stabilizer,
-  OpType::save_clifford,
-  OpType::save_unitary, OpType::save_mps, OpType::save_superop
-};
+    OpType::save_state,    OpType::save_expval,        OpType::save_expval_var,
+    OpType::save_statevec, OpType::save_statevec_dict, OpType::save_densmat,
+    OpType::save_probs,    OpType::save_probs_ket,     OpType::save_amps,
+    OpType::save_amps_sq,  OpType::save_stabilizer,    OpType::save_clifford,
+    OpType::save_unitary,  OpType::save_mps,           OpType::save_superop};
 
-inline std::ostream& operator<<(std::ostream& stream, const OpType& type) {
+inline std::ostream &operator<<(std::ostream &stream, const OpType &type) {
   switch (type) {
   case OpType::gate:
     stream << "gate";
@@ -192,40 +235,39 @@ inline std::ostream& operator<<(std::ostream& stream, const OpType& type) {
   return stream;
 }
 
-
-inline std::ostream& operator<<(std::ostream& stream, const DataSubType& subtype) {
+inline std::ostream &operator<<(std::ostream &stream,
+                                const DataSubType &subtype) {
   switch (subtype) {
-    case DataSubType::single:
-      stream << "single";
-      break;
-    case DataSubType::c_single:
-      stream << "c_single";
-      break;
-    case DataSubType::list:
-      stream << "list";
-      break;
-    case DataSubType::c_list:
-      stream << "c_list";
-      break;
-    case DataSubType::accum:
-      stream << "accum";
-      break;
-    case DataSubType::c_accum:
-      stream << "c_accum";
-      break;
-    case DataSubType::average:
-      stream << "average";
-      break;
-    case DataSubType::c_average:
-      stream << "c_average";
-      break;
-    default:
-      stream << "unknown";
+  case DataSubType::single:
+    stream << "single";
+    break;
+  case DataSubType::c_single:
+    stream << "c_single";
+    break;
+  case DataSubType::list:
+    stream << "list";
+    break;
+  case DataSubType::c_list:
+    stream << "c_list";
+    break;
+  case DataSubType::accum:
+    stream << "accum";
+    break;
+  case DataSubType::c_accum:
+    stream << "c_accum";
+    break;
+  case DataSubType::average:
+    stream << "average";
+    break;
+  case DataSubType::c_average:
+    stream << "c_average";
+    break;
+  default:
+    stream << "unknown";
   }
   return stream;
 }
 
-
 //------------------------------------------------------------------------------
 // Op Class
 //------------------------------------------------------------------------------
@@ -237,17 +279,19 @@ struct Op {
   reg_t qubits;                   //  qubits operation acts on
   std::vector<reg_t> regs;        //  list of qubits for matrixes
   std::vector<complex_t> params;  // real or complex params for gates
-  std::vector<uint_t> int_params;  // integer parameters 
-  std::vector<std::string> string_params; // used for snapshot label, and boolean functions
+  std::vector<uint_t> int_params; // integer parameters
+  std::vector<std::string>
+      string_params; // used for snapshot label, and boolean functions
 
   // Conditional Operations
   bool conditional = false; // is gate conditional gate
-  uint_t conditional_reg;   // (opt) the (single) register location to look up for conditional
-  RegComparison bfunc;      // (opt) boolean function relation
+  uint_t conditional_reg; // (opt) the (single) register location to look up for
+                          // conditional
+  RegComparison bfunc;    // (opt) boolean function relation
 
   // Measurement
-  reg_t memory;             // (opt) register operation it acts on (measure)
-  reg_t registers;          // (opt) register locations it acts on (measure, conditional)
+  reg_t memory;    // (opt) register operation it acts on (measure)
+  reg_t registers; // (opt) register locations it acts on (measure, conditional)
 
   // Mat and Kraus
   std::vector<cmatrix_t> mats;
@@ -264,31 +308,41 @@ struct Op {
 
   // Legacy Snapshots
   DataSubType save_type = DataSubType::single;
-  using pauli_component_t = std::pair<complex_t, std::string>; // Pair (coeff, label_string)
-  using matrix_component_t = std::pair<complex_t, std::vector<std::pair<reg_t, cmatrix_t>>>; // vector of Pair(qubits, matrix), combined with coefficient
+  using pauli_component_t =
+      std::pair<complex_t, std::string>; // Pair (coeff, label_string)
+  using matrix_component_t =
+      std::pair<complex_t,
+                std::vector<std::pair<reg_t, cmatrix_t>>>; // vector of
+                                                           // Pair(qubits,
+                                                           // matrix), combined
+                                                           // with coefficient
   std::vector<pauli_component_t> params_expval_pauli;
-  std::vector<matrix_component_t> params_expval_matrix; // note that diagonal matrices are stored as
-                                                        // 1 x M row-matrices
-                                                        // Projector vectors are stored as
-                                                        // M x 1 column-matrices
+  std::vector<matrix_component_t>
+      params_expval_matrix; // note that diagonal matrices are stored as
+                            // 1 x M row-matrices
+                            // Projector vectors are stored as
+                            // M x 1 column-matrices
 };
 
-inline std::ostream& operator<<(std::ostream& s, const Op& op) {
+inline std::ostream &operator<<(std::ostream &s, const Op &op) {
   s << op.name << "[";
   bool first = true;
-  for (size_t qubit: op.qubits) {
-    if (!first) s << ",";
+  for (size_t qubit : op.qubits) {
+    if (!first)
+      s << ",";
     s << qubit;
     first = false;
   }
   s << "],[";
   first = true;
-  for (reg_t reg: op.regs) {
-    if (!first) s << ",";
+  for (reg_t reg : op.regs) {
+    if (!first)
+      s << ",";
     s << "[";
     bool first0 = true;
-    for (size_t qubit: reg) {
-      if (!first0) s << ",";
+    for (size_t qubit : reg) {
+      if (!first0)
+        s << ",";
       s << qubit;
       first0 = false;
     }
@@ -306,7 +360,8 @@ inline std::ostream& operator<<(std::ostream& s, const Op& op) {
 // Raise an exception if name string is empty
 inline void check_empty_name(const Op &op) {
   if (op.name.empty())
-    throw std::invalid_argument(R"(Invalid qobj instruction ("name" is empty).)");
+    throw std::invalid_argument(
+        R"(Invalid qobj instruction ("name" is empty).)");
 }
 
 // Raise an exception if qubits list is empty
@@ -326,8 +381,9 @@ inline void check_empty_params(const Op &op) {
 // Raise an exception if params is empty
 inline void check_length_params(const Op &op, const size_t size) {
   if (op.params.size() != size)
-    throw std::invalid_argument(R"(Invalid qobj ")" + op.name +
-                                R"(" instruction ("params" is incorrect length).)");
+    throw std::invalid_argument(
+        R"(Invalid qobj ")" + op.name +
+        R"(" instruction ("params" is incorrect length).)");
 }
 
 // Raise an exception if qubits list contains duplications
@@ -343,7 +399,8 @@ inline void check_duplicate_qubits(const Op &op) {
 // Generator functions
 //------------------------------------------------------------------------------
 
-inline Op make_unitary(const reg_t &qubits, const cmatrix_t &mat, std::string label = "") {
+inline Op make_unitary(const reg_t &qubits, const cmatrix_t &mat,
+                       std::string label = "") {
   Op op;
   op.type = OpType::matrix;
   op.name = "unitary";
@@ -354,7 +411,8 @@ inline Op make_unitary(const reg_t &qubits, const cmatrix_t &mat, std::string la
   return op;
 }
 
-inline Op make_unitary(const reg_t &qubits, cmatrix_t &&mat, std::string label = "") {
+inline Op make_unitary(const reg_t &qubits, cmatrix_t &&mat,
+                       std::string label = "") {
   Op op;
   op.type = OpType::matrix;
   op.name = "unitary";
@@ -366,7 +424,8 @@ inline Op make_unitary(const reg_t &qubits, cmatrix_t &&mat, std::string label =
   return op;
 }
 
-inline Op make_diagonal(const reg_t &qubits, cvector_t &&vec, std::string label = "") {
+inline Op make_diagonal(const reg_t &qubits, cvector_t &&vec,
+                        std::string label = "") {
   Op op;
   op.type = OpType::diagonal_matrix;
   op.name = "diagonal";
@@ -416,7 +475,8 @@ inline Op make_kraus(const reg_t &qubits, std::vector<cmatrix_t> &&mats) {
   return op;
 }
 
-inline Op make_roerror(const reg_t &memory, const std::vector<rvector_t> &probs) {
+inline Op make_roerror(const reg_t &memory,
+                       const std::vector<rvector_t> &probs) {
   Op op;
   op.type = OpType::roerror;
   op.name = "roerror";
@@ -467,7 +527,7 @@ inline Op make_u3(uint_t qubit, T theta, T phi, T lam) {
   return op;
 }
 
-inline Op make_reset(const reg_t & qubits, uint_t state = 0) {
+inline Op make_reset(const reg_t &qubits, uint_t state = 0) {
   Op op;
   op.type = OpType::reset;
   op.name = "reset";
@@ -533,103 +593,94 @@ inline Op make_multiplexer(const reg_t &qubits,
 //------------------------------------------------------------------------------
 
 // Main deserialization functions
-template<typename inputdata_t>
-Op input_to_op(const inputdata_t& input); // Partial TODO
-json_t op_to_json(const Op &op); // Partial TODO
+template <typename inputdata_t>
+Op input_to_op(const inputdata_t &input); // Partial TODO
+json_t op_to_json(const Op &op);          // Partial TODO
 
-inline void from_json(const json_t &js, Op &op) {op = input_to_op(js);}
+inline void from_json(const json_t &js, Op &op) { op = input_to_op(js); }
 
-inline void to_json(json_t &js, const Op &op) { js = op_to_json(op);}
+inline void to_json(json_t &js, const Op &op) { js = op_to_json(op); }
 
-void to_json(json_t &js, const DataSubType& type);
+void to_json(json_t &js, const DataSubType &type);
 
 // Standard operations
-template<typename inputdata_t>
-Op input_to_op_gate(const inputdata_t& input);
-template<typename inputdata_t>
-Op input_to_op_barrier(const inputdata_t& input);
-template<typename inputdata_t>
-Op input_to_op_measure(const inputdata_t& input);
-template<typename inputdata_t>
-Op input_to_op_reset(const inputdata_t& input);
-template<typename inputdata_t>
-Op input_to_op_bfunc(const inputdata_t& input);
-template<typename inputdata_t>
-Op input_to_op_initialize(const inputdata_t& input);
-template<typename inputdata_t>
-Op input_to_op_pauli(const inputdata_t& input);
+template <typename inputdata_t> Op input_to_op_gate(const inputdata_t &input);
+template <typename inputdata_t>
+Op input_to_op_barrier(const inputdata_t &input);
+template <typename inputdata_t>
+Op input_to_op_measure(const inputdata_t &input);
+template <typename inputdata_t> Op input_to_op_reset(const inputdata_t &input);
+template <typename inputdata_t> Op input_to_op_bfunc(const inputdata_t &input);
+template <typename inputdata_t>
+Op input_to_op_initialize(const inputdata_t &input);
+template <typename inputdata_t> Op input_to_op_pauli(const inputdata_t &input);
 
 // Set state
-template<typename inputdata_t>
-Op input_to_op_set_vector(const inputdata_t& input, OpType op_type);
+template <typename inputdata_t>
+Op input_to_op_set_vector(const inputdata_t &input, OpType op_type);
 
-template<typename inputdata_t>
-Op input_to_op_set_matrix(const inputdata_t& input, OpType op_type);
+template <typename inputdata_t>
+Op input_to_op_set_matrix(const inputdata_t &input, OpType op_type);
 
-template<typename inputdata_t>
-Op input_to_op_set_clifford(const inputdata_t& input, OpType op_type);
+template <typename inputdata_t>
+Op input_to_op_set_clifford(const inputdata_t &input, OpType op_type);
 
-template<typename inputdata_t>
-Op input_to_op_set_mps(const inputdata_t& input, OpType op_type);
+template <typename inputdata_t>
+Op input_to_op_set_mps(const inputdata_t &input, OpType op_type);
 
 // Save data
-template<typename inputdata_t>
-Op input_to_op_save_default(const inputdata_t& input, OpType op_type);
-template<typename inputdata_t>
-Op input_to_op_save_expval(const inputdata_t& input, bool variance);
-template<typename inputdata_t>
-Op input_to_op_save_amps(const inputdata_t& input, bool squared);
+template <typename inputdata_t>
+Op input_to_op_save_default(const inputdata_t &input, OpType op_type);
+template <typename inputdata_t>
+Op input_to_op_save_expval(const inputdata_t &input, bool variance);
+template <typename inputdata_t>
+Op input_to_op_save_amps(const inputdata_t &input, bool squared);
 
 // Snapshots
-template<typename inputdata_t>
-Op input_to_op_snapshot(const inputdata_t& input);
-template<typename inputdata_t>
-Op input_to_op_snapshot_default(const inputdata_t& input);
-template<typename inputdata_t>
-Op input_to_op_snapshot_matrix(const inputdata_t& input);
-template<typename inputdata_t>
-Op input_to_op_snapshot_pauli(const inputdata_t& input);
+template <typename inputdata_t>
+Op input_to_op_snapshot(const inputdata_t &input);
+template <typename inputdata_t>
+Op input_to_op_snapshot_default(const inputdata_t &input);
+template <typename inputdata_t>
+Op input_to_op_snapshot_matrix(const inputdata_t &input);
+template <typename inputdata_t>
+Op input_to_op_snapshot_pauli(const inputdata_t &input);
 
 // Control-Flow
-template<typename inputdata_t>
-Op input_to_op_jump(const inputdata_t& input);
-template<typename inputdata_t>
-Op input_to_op_mark(const inputdata_t& input);
+template <typename inputdata_t> Op input_to_op_jump(const inputdata_t &input);
+template <typename inputdata_t> Op input_to_op_mark(const inputdata_t &input);
 
 // Matrices
-template<typename inputdata_t>
-Op input_to_op_unitary(const inputdata_t& input);
-template<typename inputdata_t>
-Op input_to_op_diagonal(const inputdata_t& input);
-template<typename inputdata_t>
-Op input_to_op_superop(const inputdata_t& input);
-template<typename inputdata_t>
-Op input_to_op_multiplexer(const inputdata_t& input);
-template<typename inputdata_t>
-Op input_to_op_kraus(const inputdata_t& input);
-template<typename inputdata_t>
-Op input_to_op_noise_switch(const inputdata_t& input);
-template<typename inputdata_t>
-Op input_to_op_qerror_loc(const inputdata_t& input);
+template <typename inputdata_t>
+Op input_to_op_unitary(const inputdata_t &input);
+template <typename inputdata_t>
+Op input_to_op_diagonal(const inputdata_t &input);
+template <typename inputdata_t>
+Op input_to_op_superop(const inputdata_t &input);
+template <typename inputdata_t>
+Op input_to_op_multiplexer(const inputdata_t &input);
+template <typename inputdata_t> Op input_to_op_kraus(const inputdata_t &input);
+template <typename inputdata_t>
+Op input_to_op_noise_switch(const inputdata_t &input);
+template <typename inputdata_t>
+Op input_to_op_qerror_loc(const inputdata_t &input);
 
 // Classical bits
-template<typename inputdata_t>
-Op input_to_op_roerror(const inputdata_t& input);
+template <typename inputdata_t>
+Op input_to_op_roerror(const inputdata_t &input);
 
 // Optional instruction parameters
-enum class Allowed {Yes, No};
-
-template<typename inputdata_t>
-void add_conditional(const Allowed val, Op& op, const inputdata_t& input);
+enum class Allowed { Yes, No };
 
+template <typename inputdata_t>
+void add_conditional(const Allowed val, Op &op, const inputdata_t &input);
 
 //------------------------------------------------------------------------------
 // Implementation: JSON deserialization
 //------------------------------------------------------------------------------
 
 // TODO: convert if-else to switch
-template<typename inputdata_t>
-Op input_to_op(const inputdata_t& input) {
+template <typename inputdata_t> Op input_to_op(const inputdata_t &input) {
   // load operation identifier
   std::string name;
   Parser<inputdata_t>::get_value(name, "name", input);
@@ -715,7 +766,7 @@ Op input_to_op(const inputdata_t& input) {
   if (name == "pauli")
     return input_to_op_pauli(input);
 
-  //Control-flow
+  // Control-flow
   if (name == "jump")
     return input_to_op_jump(input);
   if (name == "mark")
@@ -746,32 +797,30 @@ json_t op_to_json(const Op &op) {
   return ret;
 }
 
-
-void to_json(json_t &js, const OpType& type) {
+void to_json(json_t &js, const OpType &type) {
   std::stringstream ss;
   ss << type;
   js = ss.str();
 }
 
-
-void to_json(json_t &js, const DataSubType& subtype) {
+void to_json(json_t &js, const DataSubType &subtype) {
   std::stringstream ss;
   ss << subtype;
   js = ss.str();
 }
 
-
 //------------------------------------------------------------------------------
 // Implementation: Gates, measure, reset deserialization
 //------------------------------------------------------------------------------
 
-template<typename inputdata_t>
-void add_conditional(const Allowed allowed, Op& op, const inputdata_t& input) {
+template <typename inputdata_t>
+void add_conditional(const Allowed allowed, Op &op, const inputdata_t &input) {
   // Check conditional
   if (Parser<inputdata_t>::check_key("conditional", input)) {
     // If instruction isn't allow to be conditional throw an exception
     if (allowed == Allowed::No) {
-      throw std::invalid_argument("Invalid instruction: \"" + op.name + "\" cannot be conditional.");
+      throw std::invalid_argument("Invalid instruction: \"" + op.name +
+                                  "\" cannot be conditional.");
     }
     // If instruction is allowed to be conditional add parameters
     Parser<inputdata_t>::get_value(op.conditional_reg, "conditional", input);
@@ -779,8 +828,7 @@ void add_conditional(const Allowed allowed, Op& op, const inputdata_t& input) {
   }
 }
 
-template<typename inputdata_t>
-Op input_to_op_gate(const inputdata_t& input) {
+template <typename inputdata_t> Op input_to_op_gate(const inputdata_t &input) {
   Op op;
   op.type = OpType::gate;
   Parser<inputdata_t>::get_value(op.name, "name", input);
@@ -791,7 +839,7 @@ Op input_to_op_gate(const inputdata_t& input) {
   // If label is not specified record the gate name as the label
   std::string label;
   Parser<inputdata_t>::get_value(label, "label", input);
-  if  (label != "") 
+  if (label != "")
     op.string_params = {label};
   else
     op.string_params = {op.name};
@@ -812,8 +860,8 @@ Op input_to_op_gate(const inputdata_t& input) {
   return op;
 }
 
-template<typename inputdata_t>
-Op input_to_op_qerror_loc(const inputdata_t& input) {
+template <typename inputdata_t>
+Op input_to_op_qerror_loc(const inputdata_t &input) {
   Op op;
   op.type = OpType::qerror_loc;
   Parser<inputdata_t>::get_value(op.name, "label", input);
@@ -822,7 +870,7 @@ Op input_to_op_qerror_loc(const inputdata_t& input) {
   return op;
 }
 
-template<typename inputdata_t>
+template <typename inputdata_t>
 Op input_to_op_barrier(const inputdata_t &input) {
   Op op;
   op.type = OpType::barrier;
@@ -833,8 +881,8 @@ Op input_to_op_barrier(const inputdata_t &input) {
   return op;
 }
 
-template<typename inputdata_t>
-Op input_to_op_measure(const inputdata_t& input) {
+template <typename inputdata_t>
+Op input_to_op_measure(const inputdata_t &input) {
   Op op;
   op.type = OpType::measure;
   op.name = "measure";
@@ -849,16 +897,18 @@ Op input_to_op_measure(const inputdata_t& input) {
   check_empty_qubits(op);
   check_duplicate_qubits(op);
   if (op.memory.empty() == false && op.memory.size() != op.qubits.size()) {
-    throw std::invalid_argument(R"(Invalid measure operation: "memory" and "qubits" are different lengths.)");
+    throw std::invalid_argument(
+        R"(Invalid measure operation: "memory" and "qubits" are different lengths.)");
   }
-  if (op.registers.empty() == false && op.registers.size() != op.qubits.size()) {
-    throw std::invalid_argument(R"(Invalid measure operation: "register" and "qubits" are different lengths.)");
+  if (op.registers.empty() == false &&
+      op.registers.size() != op.qubits.size()) {
+    throw std::invalid_argument(
+        R"(Invalid measure operation: "register" and "qubits" are different lengths.)");
   }
   return op;
 }
 
-template<typename inputdata_t>
-Op input_to_op_reset(const inputdata_t& input) {
+template <typename inputdata_t> Op input_to_op_reset(const inputdata_t &input) {
   Op op;
   op.type = OpType::reset;
   op.name = "reset";
@@ -873,8 +923,8 @@ Op input_to_op_reset(const inputdata_t& input) {
   return op;
 }
 
-template<typename inputdata_t>
-Op input_to_op_initialize(const inputdata_t& input) {
+template <typename inputdata_t>
+Op input_to_op_initialize(const inputdata_t &input) {
   Op op;
   op.type = OpType::initialize;
   op.name = "initialize";
@@ -890,8 +940,7 @@ Op input_to_op_initialize(const inputdata_t& input) {
   check_length_params(op, 1ULL << op.qubits.size());
   return op;
 }
-template<typename inputdata_t>
-Op input_to_op_pauli(const inputdata_t& input){
+template <typename inputdata_t> Op input_to_op_pauli(const inputdata_t &input) {
   Op op;
   op.type = OpType::gate;
   op.name = "pauli";
@@ -902,7 +951,7 @@ Op input_to_op_pauli(const inputdata_t& input){
   // If label is not specified record the gate name as the label
   std::string label;
   Parser<inputdata_t>::get_value(label, "label", input);
-  if  (label != "")
+  if (label != "")
     op.string_params.push_back(label);
   else
     op.string_params.push_back(op.name);
@@ -920,16 +969,18 @@ Op input_to_op_pauli(const inputdata_t& input){
 //------------------------------------------------------------------------------
 // Implementation: Boolean Functions
 //------------------------------------------------------------------------------
-template<typename inputdata_t>
-Op input_to_op_bfunc(const inputdata_t& input) {
+template <typename inputdata_t> Op input_to_op_bfunc(const inputdata_t &input) {
   Op op;
   op.type = OpType::bfunc;
   op.name = "bfunc";
   op.string_params.resize(2);
   std::string relation;
-  Parser<inputdata_t>::get_value(op.string_params[0], "mask", input); // mask hexadecimal string
-  Parser<inputdata_t>::get_value(op.string_params[1], "val", input);  // value hexadecimal string
-  Parser<inputdata_t>::get_value(relation, "relation", input); // relation string
+  Parser<inputdata_t>::get_value(op.string_params[0], "mask",
+                                 input); // mask hexadecimal string
+  Parser<inputdata_t>::get_value(op.string_params[1], "val",
+                                 input); // value hexadecimal string
+  Parser<inputdata_t>::get_value(relation, "relation",
+                                 input); // relation string
   // Load single register / memory bit for storing result
   uint_t tmp;
   if (Parser<inputdata_t>::get_value(tmp, "register", input)) {
@@ -938,24 +989,25 @@ Op input_to_op_bfunc(const inputdata_t& input) {
   if (Parser<inputdata_t>::get_value(tmp, "memory", input)) {
     op.memory.push_back(tmp);
   }
-  
+
   // Format hex strings
   Utils::format_hex_inplace(op.string_params[0]);
   Utils::format_hex_inplace(op.string_params[1]);
 
   const stringmap_t<RegComparison> comp_table({
-    {"==", RegComparison::Equal},
-    {"!=", RegComparison::NotEqual},
-    {"<", RegComparison::Less},
-    {"<=", RegComparison::LessEqual},
-    {">", RegComparison::Greater},
-    {">=", RegComparison::GreaterEqual},
+      {"==", RegComparison::Equal},
+      {"!=", RegComparison::NotEqual},
+      {"<", RegComparison::Less},
+      {"<=", RegComparison::LessEqual},
+      {">", RegComparison::Greater},
+      {">=", RegComparison::GreaterEqual},
   });
 
   auto it = comp_table.find(relation);
   if (it == comp_table.end()) {
     std::stringstream msg;
-    msg << "Invalid bfunc relation string :\"" << it->first << "\"." << std::endl;
+    msg << "Invalid bfunc relation string :\"" << it->first << "\"."
+        << std::endl;
     throw std::invalid_argument(msg.str());
   } else {
     op.bfunc = it->second;
@@ -966,13 +1018,14 @@ Op input_to_op_bfunc(const inputdata_t& input) {
 
   // Validation
   if (op.registers.empty()) {
-    throw std::invalid_argument("Invalid measure operation: \"register\" is empty.");
+    throw std::invalid_argument(
+        "Invalid measure operation: \"register\" is empty.");
   }
   return op;
 }
 
-template<typename inputdata_t>
-Op input_to_op_roerror(const inputdata_t& input) {
+template <typename inputdata_t>
+Op input_to_op_roerror(const inputdata_t &input) {
   Op op;
   op.type = OpType::roerror;
   op.name = "roerror";
@@ -987,8 +1040,8 @@ Op input_to_op_roerror(const inputdata_t& input) {
 //------------------------------------------------------------------------------
 // Implementation: Matrix and Kraus deserialization
 //------------------------------------------------------------------------------
-template<typename inputdata_t>
-Op input_to_op_unitary(const inputdata_t& input) {
+template <typename inputdata_t>
+Op input_to_op_unitary(const inputdata_t &input) {
   Op op;
   op.type = OpType::matrix;
   op.name = "unitary";
@@ -1014,8 +1067,8 @@ Op input_to_op_unitary(const inputdata_t& input) {
   add_conditional(Allowed::Yes, op, input);
   return op;
 }
-template<typename inputdata_t>
-Op input_to_op_diagonal(const inputdata_t& input) {
+template <typename inputdata_t>
+Op input_to_op_diagonal(const inputdata_t &input) {
   Op op;
   op.type = OpType::diagonal_matrix;
   op.name = "diagonal";
@@ -1043,8 +1096,8 @@ Op input_to_op_diagonal(const inputdata_t& input) {
   add_conditional(Allowed::Yes, op, input);
   return op;
 }
-template<typename inputdata_t>
-Op input_to_op_superop(const inputdata_t& input) {
+template <typename inputdata_t>
+Op input_to_op_superop(const inputdata_t &input) {
   // Warning: we don't check superoperator is valid!
   Op op;
   op.type = OpType::superop;
@@ -1061,8 +1114,8 @@ Op input_to_op_superop(const inputdata_t& input) {
   }
   return op;
 }
-template<typename inputdata_t>
-Op input_to_op_multiplexer(const inputdata_t& input) {
+template <typename inputdata_t>
+Op input_to_op_multiplexer(const inputdata_t &input) {
   // Parse parameters
   reg_t qubits;
   std::vector<cmatrix_t> mats;
@@ -1076,8 +1129,7 @@ Op input_to_op_multiplexer(const inputdata_t& input) {
   add_conditional(Allowed::Yes, op, input);
   return op;
 }
-template<typename inputdata_t>
-Op input_to_op_kraus(const inputdata_t& input) {
+template <typename inputdata_t> Op input_to_op_kraus(const inputdata_t &input) {
   Op op;
   op.type = OpType::kraus;
   op.name = "kraus";
@@ -1092,8 +1144,8 @@ Op input_to_op_kraus(const inputdata_t& input) {
   return op;
 }
 
-template<typename inputdata_t>
-Op input_to_op_noise_switch(const inputdata_t& input) {
+template <typename inputdata_t>
+Op input_to_op_noise_switch(const inputdata_t &input) {
   Op op;
   op.type = OpType::noise_switch;
   op.name = "noise_switch";
@@ -1106,48 +1158,53 @@ Op input_to_op_noise_switch(const inputdata_t& input) {
 //------------------------------------------------------------------------------
 // Implementation: Set state
 //------------------------------------------------------------------------------
-template<typename inputdata_t>
+template <typename inputdata_t>
 Op input_to_op_set_vector(const inputdata_t &input, OpType op_type) {
   Op op;
   op.type = op_type;
-  const inputdata_t& params = Parser<inputdata_t>::get_value("params", input);
-  op.params = Parser<inputdata_t>::template get_list_elem<std::vector<complex_t>>(params, 0);
+  const inputdata_t &params = Parser<inputdata_t>::get_value("params", input);
+  op.params =
+      Parser<inputdata_t>::template get_list_elem<std::vector<complex_t>>(
+          params, 0);
   Parser<inputdata_t>::get_value(op.name, "name", input);
   Parser<inputdata_t>::get_value(op.qubits, "qubits", input);
   add_conditional(Allowed::No, op, input);
   return op;
 }
 
-template<typename inputdata_t>
+template <typename inputdata_t>
 Op input_to_op_set_matrix(const inputdata_t &input, OpType op_type) {
   Op op;
   op.type = op_type;
-  const inputdata_t& params = Parser<inputdata_t>::get_value("params", input);
-  op.mats.push_back(Parser<inputdata_t>::template get_list_elem<cmatrix_t>(params, 0));
+  const inputdata_t &params = Parser<inputdata_t>::get_value("params", input);
+  op.mats.push_back(
+      Parser<inputdata_t>::template get_list_elem<cmatrix_t>(params, 0));
   Parser<inputdata_t>::get_value(op.name, "name", input);
   Parser<inputdata_t>::get_value(op.qubits, "qubits", input);
   add_conditional(Allowed::No, op, input);
   return op;
 }
 
-template<typename inputdata_t>
+template <typename inputdata_t>
 Op input_to_op_set_clifford(const inputdata_t &input, OpType op_type) {
   Op op;
   op.type = op_type;
-  const inputdata_t& params = Parser<inputdata_t>::get_value("params", input);
-  op.clifford = Parser<inputdata_t>::template get_list_elem<Clifford::Clifford>(params, 0);
+  const inputdata_t &params = Parser<inputdata_t>::get_value("params", input);
+  op.clifford = Parser<inputdata_t>::template get_list_elem<Clifford::Clifford>(
+      params, 0);
   Parser<inputdata_t>::get_value(op.name, "name", input);
   Parser<inputdata_t>::get_value(op.qubits, "qubits", input);
   add_conditional(Allowed::No, op, input);
   return op;
 }
 
-template<typename inputdata_t>
+template <typename inputdata_t>
 Op input_to_op_set_mps(const inputdata_t &input, OpType op_type) {
   Op op;
   op.type = op_type;
-  const inputdata_t& params = Parser<inputdata_t>::get_value("params", input);
-  op.mps = Parser<inputdata_t>::template get_list_elem<mps_container_t>(params, 0);
+  const inputdata_t &params = Parser<inputdata_t>::get_value("params", input);
+  op.mps =
+      Parser<inputdata_t>::template get_list_elem<mps_container_t>(params, 0);
 
   Parser<inputdata_t>::get_value(op.name, "name", input);
   Parser<inputdata_t>::get_value(op.qubits, "qubits", input);
@@ -1158,22 +1215,18 @@ Op input_to_op_set_mps(const inputdata_t &input, OpType op_type) {
 //------------------------------------------------------------------------------
 // Implementation: Save data deserialization
 //------------------------------------------------------------------------------
-template<typename inputdata_t>
-Op input_to_op_save_default(const inputdata_t& input, OpType op_type) {
+template <typename inputdata_t>
+Op input_to_op_save_default(const inputdata_t &input, OpType op_type) {
   Op op;
   op.type = op_type;
   Parser<inputdata_t>::get_value(op.name, "name", input);
 
   // Get subtype
-  static const std::unordered_map<std::string, DataSubType> subtypes {
-    {"single", DataSubType::single},
-    {"c_single", DataSubType::c_single},
-    {"average", DataSubType::average},
-    {"c_average", DataSubType::c_average},
-    {"list", DataSubType::list},
-    {"c_list", DataSubType::c_list},
-    {"accum", DataSubType::accum},
-    {"c_accum", DataSubType::c_accum},
+  static const std::unordered_map<std::string, DataSubType> subtypes{
+      {"single", DataSubType::single},   {"c_single", DataSubType::c_single},
+      {"average", DataSubType::average}, {"c_average", DataSubType::c_average},
+      {"list", DataSubType::list},       {"c_list", DataSubType::c_list},
+      {"accum", DataSubType::accum},     {"c_accum", DataSubType::c_accum},
   };
   std::string subtype;
   Parser<inputdata_t>::get_value(subtype, "snapshot_type", input);
@@ -1183,7 +1236,7 @@ Op input_to_op_save_default(const inputdata_t& input, OpType op_type) {
                              "\" in save data instruction.");
   }
   op.save_type = subtype_it->second;
- 
+
   // Get data key
   op.string_params.emplace_back("");
   Parser<inputdata_t>::get_value(op.string_params[0], "label", input);
@@ -1192,26 +1245,30 @@ Op input_to_op_save_default(const inputdata_t& input, OpType op_type) {
   Parser<inputdata_t>::get_value(op.qubits, "qubits", input);
   return op;
 }
-template<typename inputdata_t>
-Op input_to_op_save_expval(const inputdata_t& input, bool variance) {
+template <typename inputdata_t>
+Op input_to_op_save_expval(const inputdata_t &input, bool variance) {
   // Initialized default save instruction params
-  auto op_type = (variance) ? OpType::save_expval_var
-                            : OpType::save_expval;
+  auto op_type = (variance) ? OpType::save_expval_var : OpType::save_expval;
   Op op = input_to_op_save_default(input, op_type);
 
   // Parse Pauli operator components
   const auto threshold = 1e-12; // drop small components
   // Get components
-  if (Parser<inputdata_t>::check_key("params", input) && Parser<inputdata_t>::is_array("params", input)) {
+  if (Parser<inputdata_t>::check_key("params", input) &&
+      Parser<inputdata_t>::is_array("params", input)) {
     for (const auto &comp_ : Parser<inputdata_t>::get_value("params", input)) {
-      const auto& comp = Parser<inputdata_t>::get_as_list(comp_);
+      const auto &comp = Parser<inputdata_t>::get_as_list(comp_);
       // Get complex coefficient
-      std::vector<double> coeffs = Parser<inputdata_t>::template get_list_elem<std::vector<double>>(comp, 1);
+      std::vector<double> coeffs =
+          Parser<inputdata_t>::template get_list_elem<std::vector<double>>(comp,
+                                                                           1);
       if (std::abs(coeffs[0]) > threshold || std::abs(coeffs[1]) > threshold) {
-        std::string pauli = Parser<inputdata_t>::template get_list_elem<std::string>(comp, 0);
+        std::string pauli =
+            Parser<inputdata_t>::template get_list_elem<std::string>(comp, 0);
         if (pauli.size() != op.qubits.size()) {
-          throw std::invalid_argument(std::string("Invalid expectation value save instruction ") +
-                                      "(Pauli label does not match qubit number.).");
+          throw std::invalid_argument(
+              std::string("Invalid expectation value save instruction ") +
+              "(Pauli label does not match qubit number.).");
         }
         op.expval_params.emplace_back(pauli, coeffs[0], coeffs[1]);
       }
@@ -1230,11 +1287,10 @@ Op input_to_op_save_expval(const inputdata_t& input, bool variance) {
 
   return op;
 }
-template<typename inputdata_t>
-Op input_to_op_save_amps(const inputdata_t& input, bool squared) {
+template <typename inputdata_t>
+Op input_to_op_save_amps(const inputdata_t &input, bool squared) {
   // Initialized default save instruction params
-  auto op_type = (squared) ? OpType::save_amps_sq
-                           : OpType::save_amps;
+  auto op_type = (squared) ? OpType::save_amps_sq : OpType::save_amps;
   Op op = input_to_op_save_default(input, op_type);
   Parser<inputdata_t>::get_value(op.int_params, "params", input);
   return op;
@@ -1243,10 +1299,11 @@ Op input_to_op_save_amps(const inputdata_t& input, bool squared) {
 //------------------------------------------------------------------------------
 // Implementation: Snapshot deserialization
 //------------------------------------------------------------------------------
-template<typename inputdata_t>
-Op input_to_op_snapshot(const inputdata_t& input) {
+template <typename inputdata_t>
+Op input_to_op_snapshot(const inputdata_t &input) {
   std::string snapshot_type;
-  Parser<inputdata_t>::get_value(snapshot_type, "snapshot_type", input); // LEGACY: to remove in 0.3
+  Parser<inputdata_t>::get_value(snapshot_type, "snapshot_type",
+                                 input); // LEGACY: to remove in 0.3
   Parser<inputdata_t>::get_value(snapshot_type, "type", input);
   if (snapshot_type.find("expectation_value_pauli") != std::string::npos)
     return input_to_op_snapshot_pauli(input);
@@ -1259,11 +1316,12 @@ Op input_to_op_snapshot(const inputdata_t& input) {
   return op;
 }
 
-template<typename inputdata_t>
-Op input_to_op_snapshot_default(const inputdata_t& input) {
+template <typename inputdata_t>
+Op input_to_op_snapshot_default(const inputdata_t &input) {
   Op op;
   op.type = OpType::snapshot;
-  Parser<inputdata_t>::get_value(op.name, "type", input); // LEGACY: to remove in 0.3
+  Parser<inputdata_t>::get_value(op.name, "type",
+                                 input); // LEGACY: to remove in 0.3
   Parser<inputdata_t>::get_value(op.name, "snapshot_type", input);
   // If missing use "default" for label
   op.string_params.emplace_back("default");
@@ -1275,39 +1333,46 @@ Op input_to_op_snapshot_default(const inputdata_t& input) {
   return op;
 }
 
-template<typename inputdata_t>
-Op input_to_op_snapshot_pauli(const inputdata_t& input) {
+template <typename inputdata_t>
+Op input_to_op_snapshot_pauli(const inputdata_t &input) {
   Op op = input_to_op_snapshot_default(input);
 
   const auto threshold = 1e-15; // drop small components
   // Get components
-  if (Parser<inputdata_t>::check_key("params", input) && Parser<inputdata_t>::is_array("params", input)) {
+  if (Parser<inputdata_t>::check_key("params", input) &&
+      Parser<inputdata_t>::is_array("params", input)) {
     for (const auto &comp_ : Parser<inputdata_t>::get_value("params", input)) {
       // Check component is length-2 array
-      const auto& comp = Parser<inputdata_t>::get_as_list(comp_);
+      const auto &comp = Parser<inputdata_t>::get_as_list(comp_);
       if (comp.size() != 2)
-        throw std::invalid_argument("Invalid Pauli expval params (param component " + 
-                                    Parser<inputdata_t>::dump(comp) + " invalid).");
+        throw std::invalid_argument(
+            "Invalid Pauli expval params (param component " +
+            Parser<inputdata_t>::dump(comp) + " invalid).");
       // Get complex coefficient
-      complex_t coeff = Parser<inputdata_t>::template get_list_elem<complex_t>(comp, 0);
+      complex_t coeff =
+          Parser<inputdata_t>::template get_list_elem<complex_t>(comp, 0);
       // If coefficient is above threshold, get the Pauli operator string
       // This string may contain I, X, Y, Z
       // qubits are stored as a list where position is qubit number:
       // eq op.qubits = [a, b, c], a is qubit-0, b is qubit-1, c is qubit-2
       // Pauli string labels are stored in little-endian ordering:
-      // eg label = "CBA", A is the Pauli for qubit-0, B for qubit-1, C for qubit-2
+      // eg label = "CBA", A is the Pauli for qubit-0, B for qubit-1, C for
+      // qubit-2
       if (std::abs(coeff) > threshold) {
-        std::string pauli = Parser<inputdata_t>::template get_list_elem<std::string>(comp, 1);
+        std::string pauli =
+            Parser<inputdata_t>::template get_list_elem<std::string>(comp, 1);
         if (pauli.size() != op.qubits.size()) {
-          throw std::invalid_argument(std::string("Invalid Pauli expectation value snapshot ") +
-                                      "(Pauli label does not match qubit number.).");
+          throw std::invalid_argument(
+              std::string("Invalid Pauli expectation value snapshot ") +
+              "(Pauli label does not match qubit number.).");
         }
         // make tuple and add to components
         op.params_expval_pauli.emplace_back(coeff, pauli);
       } // end if > threshold
-    } // end component loop
+    }   // end component loop
   } else {
-    throw std::invalid_argument("Invalid Pauli expectation value value snapshot \"params\".");
+    throw std::invalid_argument(
+        "Invalid Pauli expectation value value snapshot \"params\".");
   }
   // Check edge case of all coefficients being empty
   // In this case the operator had all coefficients zero, or sufficiently close
@@ -1322,45 +1387,56 @@ Op input_to_op_snapshot_pauli(const inputdata_t& input) {
   return op;
 }
 
-template<typename inputdata_t>
-Op input_to_op_snapshot_matrix(const inputdata_t& input) {
+template <typename inputdata_t>
+Op input_to_op_snapshot_matrix(const inputdata_t &input) {
   // Load default snapshot parameters
   Op op = input_to_op_snapshot_default(input);
 
   const auto threshold = 1e-10; // drop small components
   // Get matrix operator components
   // TODO: fix repeated throw string
-  if (Parser<inputdata_t>::check_key("params", input) && Parser<inputdata_t>::is_array("params", input)) {
+  if (Parser<inputdata_t>::check_key("params", input) &&
+      Parser<inputdata_t>::is_array("params", input)) {
     for (const auto &comp_ : Parser<inputdata_t>::get_value("params", input)) {
-      const auto& comp = Parser<inputdata_t>::get_as_list(comp_);
+      const auto &comp = Parser<inputdata_t>::get_as_list(comp_);
       // Check component is length-2 array
       if (comp.size() != 2) {
-        throw std::invalid_argument("Invalid matrix expval snapshot (param component " +
-                                        Parser<inputdata_t>::dump(comp) + " invalid).");
+        throw std::invalid_argument(
+            "Invalid matrix expval snapshot (param component " +
+            Parser<inputdata_t>::dump(comp) + " invalid).");
       }
       // Get complex coefficient
-      complex_t coeff = Parser<inputdata_t>::template get_list_elem<complex_t>(comp, 0);
+      complex_t coeff =
+          Parser<inputdata_t>::template get_list_elem<complex_t>(comp, 0);
       std::vector<std::pair<reg_t, cmatrix_t>> mats;
       if (std::abs(coeff) > threshold) {
-        const inputdata_t& comp_list = comp[1];
+        const inputdata_t &comp_list = comp[1];
         if (!Parser<inputdata_t>::is_array(comp_list)) {
-          throw std::invalid_argument("Invalid matrix expval snapshot (param component " +
-                                          Parser<inputdata_t>::dump(comp) + " invalid).");
+          throw std::invalid_argument(
+              "Invalid matrix expval snapshot (param component " +
+              Parser<inputdata_t>::dump(comp) + " invalid).");
         }
         for (const auto &subcomp_ : comp_list) {
-          const auto& subcomp = Parser<inputdata_t>::get_as_list(subcomp_);
+          const auto &subcomp = Parser<inputdata_t>::get_as_list(subcomp_);
           if (subcomp.size() != 2) {
-            throw std::invalid_argument("Invalid matrix expval snapshot (param component " +
-                                            Parser<inputdata_t>::dump(comp) + " invalid).");
+            throw std::invalid_argument(
+                "Invalid matrix expval snapshot (param component " +
+                Parser<inputdata_t>::dump(comp) + " invalid).");
           }
-          reg_t comp_qubits = Parser<inputdata_t>::template get_list_elem<reg_t>(subcomp, 0);
-          cmatrix_t comp_matrix = Parser<inputdata_t>::template get_list_elem<cmatrix_t>(subcomp, 1);
+          reg_t comp_qubits =
+              Parser<inputdata_t>::template get_list_elem<reg_t>(subcomp, 0);
+          cmatrix_t comp_matrix =
+              Parser<inputdata_t>::template get_list_elem<cmatrix_t>(subcomp,
+                                                                     1);
           // Check qubits are ok
-          // TODO: check that qubits are in range from 0 to Num of Qubits - 1 for instr
-          std::unordered_set<uint_t> unique = {comp_qubits.begin(), comp_qubits.end()};
+          // TODO: check that qubits are in range from 0 to Num of Qubits - 1
+          // for instr
+          std::unordered_set<uint_t> unique = {comp_qubits.begin(),
+                                               comp_qubits.end()};
           if (unique.size() != comp_qubits.size()) {
-            throw std::invalid_argument("Invalid matrix expval snapshot (param component " +
-                                            Parser<inputdata_t>::dump(comp) + " invalid).");
+            throw std::invalid_argument(
+                "Invalid matrix expval snapshot (param component " +
+                Parser<inputdata_t>::dump(comp) + " invalid).");
           }
           mats.emplace_back(comp_qubits, comp_matrix);
         }
@@ -1368,21 +1444,22 @@ Op input_to_op_snapshot_matrix(const inputdata_t& input) {
       }
     } // end component loop
   } else {
-    throw std::invalid_argument(std::string("Invalid matrix expectation value snapshot ") +
-                                "(\"params\" field missing).");
+    throw std::invalid_argument(
+        std::string("Invalid matrix expectation value snapshot ") +
+        "(\"params\" field missing).");
   }
   return op;
 }
 
-template<typename inputdata_t>
-Op input_to_op_jump(const inputdata_t &input) {
+template <typename inputdata_t> Op input_to_op_jump(const inputdata_t &input) {
   Op op;
   op.type = OpType::jump;
   op.name = "jump";
   Parser<inputdata_t>::get_value(op.qubits, "qubits", input);
   Parser<inputdata_t>::get_value(op.string_params, "params", input);
   if (op.string_params.empty())
-    throw std::invalid_argument(std::string("Invalid jump (\"params\" field missing)."));
+    throw std::invalid_argument(
+        std::string("Invalid jump (\"params\" field missing)."));
 
   // Conditional
   add_conditional(Allowed::Yes, op, input);
@@ -1390,15 +1467,15 @@ Op input_to_op_jump(const inputdata_t &input) {
   return op;
 }
 
-template<typename inputdata_t>
-Op input_to_op_mark(const inputdata_t &input) {
+template <typename inputdata_t> Op input_to_op_mark(const inputdata_t &input) {
   Op op;
   op.type = OpType::mark;
   op.name = "mark";
   Parser<inputdata_t>::get_value(op.qubits, "qubits", input);
   Parser<inputdata_t>::get_value(op.string_params, "params", input);
   if (op.string_params.empty())
-    throw std::invalid_argument(std::string("Invalid mark (\"params\" field missing)."));
+    throw std::invalid_argument(
+        std::string("Invalid mark (\"params\" field missing)."));
 
   // Conditional
   add_conditional(Allowed::No, op, input);
@@ -1406,7 +1483,6 @@ Op input_to_op_mark(const inputdata_t &input) {
   return op;
 }
 
-
 //------------------------------------------------------------------------------
 } // end namespace Operations
 //------------------------------------------------------------------------------
diff --git a/src/framework/opset.hpp b/src/framework/opset.hpp
old mode 100755
new mode 100644
index 850b1e6bfd..c0d793647a
--- a/src/framework/opset.hpp
+++ b/src/framework/opset.hpp
@@ -15,8 +15,8 @@
 #ifndef _aer_framework_opset_hpp_
 #define _aer_framework_opset_hpp_
 
-#include <algorithm>
 #include "framework/operations.hpp"
+#include <algorithm>
 
 namespace AER {
 namespace Operations {
diff --git a/src/framework/pybind_basics.hpp b/src/framework/pybind_basics.hpp
old mode 100755
new mode 100644
index e32f214482..a27d9f7e0f
--- a/src/framework/pybind_basics.hpp
+++ b/src/framework/pybind_basics.hpp
@@ -44,14 +44,15 @@ template <typename T> py::object to_python(AER::Vector<T> &&obj);
 // Move a Vector to Python via recusivly calling to_python on elements
 template <typename T> py::object to_python(std::vector<T> &&obj);
 
-// Move an Unordered string map to Python object by calling to_python on elements
-template <typename T> py::object to_python(std::unordered_map<std::string, T> &&obj);
+// Move an Unordered string map to Python object by calling to_python on
+// elements
+template <typename T>
+py::object to_python(std::unordered_map<std::string, T> &&obj);
 
 // Move an Unordered string map into an existing Python dict
 template <typename T>
 void add_to_python(py::dict &pydata, std::unordered_map<std::string, T> &&obj);
 
-
 // Template specialization for moving numeric std::vectors to Numpy arrays
 template <> py::object to_python(std::vector<AER::int_t> &&obj);
 template <> py::object to_python(std::vector<AER::uint_t> &&obj);
@@ -73,12 +74,10 @@ template <typename T>
 py::array_t<T, py::array::f_style> to_numpy(matrix<T> &&obj);
 
 // Convert a Vector to a 1D Numpy array
-template <typename T>
-py::array_t<T> to_numpy(AER::Vector<T> &&obj);
+template <typename T> py::array_t<T> to_numpy(AER::Vector<T> &&obj);
 
 // Convert a vector to a 1D Numpy array
-template <typename T>
-py::array_t<T> to_numpy(std::vector<T> &&obj);
+template <typename T> py::array_t<T> to_numpy(std::vector<T> &&obj);
 
 //============================================================================
 // Implementation
@@ -88,13 +87,11 @@ py::array_t<T> to_numpy(std::vector<T> &&obj);
 // Basic Types
 //------------------------------------------------------------------------------
 
-template <typename T>
-py::object to_python(T &&obj) {
+template <typename T> py::object to_python(T &&obj) {
   return py::cast(obj, py::return_value_policy::move);
 }
 
-template <>
-py::object to_python(json_t &&obj) {
+template <> py::object to_python(json_t &&obj) {
   py::object pydata;
   from_json(obj, pydata);
   return pydata;
@@ -109,57 +106,48 @@ py::object to_python(std::unordered_map<std::string, T> &&obj) {
 
 template <typename T>
 void add_to_python(py::dict &pydata, std::unordered_map<std::string, T> &&obj) {
-  for(auto& elt : obj) {
+  for (auto &elt : obj) {
     pydata[elt.first.data()] = to_python(std::move(elt.second));
   }
 }
 
-template <typename T>
-py::object to_python(std::vector<T> &&obj) {
+template <typename T> py::object to_python(std::vector<T> &&obj) {
   py::list pydata;
-  for(auto& elt : obj) {
+  for (auto &elt : obj) {
     pydata.append(to_python(std::move(elt)));
   }
   return std::move(pydata);
 }
 
-template <typename T>
-py::object to_python(matrix<T> &&obj) {
+template <typename T> py::object to_python(matrix<T> &&obj) {
   return to_numpy(std::move(obj));
 }
 
-template <typename T>
-py::object to_python(AER::Vector<T> &&obj) {
+template <typename T> py::object to_python(AER::Vector<T> &&obj) {
   return to_numpy(std::move(obj));
 }
 
-template <>
-py::object to_python(std::vector<AER::int_t> &&obj) {
+template <> py::object to_python(std::vector<AER::int_t> &&obj) {
   return to_numpy(std::move(obj));
 }
 
-template <>
-py::object to_python(std::vector<AER::uint_t> &&obj) {
+template <> py::object to_python(std::vector<AER::uint_t> &&obj) {
   return to_numpy(std::move(obj));
 }
 
-template <>
-py::object to_python(std::vector<double> &&obj) {
+template <> py::object to_python(std::vector<double> &&obj) {
   return to_numpy(std::move(obj));
 }
 
-template <>
-py::object to_python(std::vector<float> &&obj) {
+template <> py::object to_python(std::vector<float> &&obj) {
   return to_numpy(std::move(obj));
 }
 
-template <>
-py::object to_python(std::vector<std::complex<double>> &&obj) {
+template <> py::object to_python(std::vector<std::complex<double>> &&obj) {
   return to_numpy(std::move(obj));
 }
 
-template <>
-py::object to_python(std::vector<std::complex<float>> &&obj) {
+template <> py::object to_python(std::vector<std::complex<float>> &&obj) {
   return to_numpy(std::move(obj));
 }
 
@@ -169,39 +157,37 @@ py::object to_python(std::vector<std::complex<float>> &&obj) {
 
 template <typename T>
 py::array_t<T, py::array::f_style> to_numpy(matrix<T> &&src) {
-  std::array<py::ssize_t, 2> shape {static_cast<py::ssize_t>(src.GetRows()),
-                                    static_cast<py::ssize_t>(src.GetColumns())};
-  matrix<T>* src_ptr = new matrix<T>(std::move(src));
-  auto capsule = py::capsule(src_ptr, [](void* p) { delete reinterpret_cast<matrix<T>*>(p); });
+  std::array<py::ssize_t, 2> shape{static_cast<py::ssize_t>(src.GetRows()),
+                                   static_cast<py::ssize_t>(src.GetColumns())};
+  matrix<T> *src_ptr = new matrix<T>(std::move(src));
+  auto capsule = py::capsule(
+      src_ptr, [](void *p) { delete reinterpret_cast<matrix<T> *>(p); });
   return py::array_t<T, py::array::f_style>(shape, src_ptr->data(), capsule);
 }
 
-template <typename T>
-py::array_t<T> to_numpy(AER::Vector<T> &&src) {
-  AER::Vector<T>* src_ptr = new AER::Vector<T>(std::move(src));
-  auto capsule = py::capsule(src_ptr, [](void* p) { 
-    delete reinterpret_cast<AER::Vector<T>*>(p);
-    });
+template <typename T> py::array_t<T> to_numpy(AER::Vector<T> &&src) {
+  AER::Vector<T> *src_ptr = new AER::Vector<T>(std::move(src));
+  auto capsule = py::capsule(
+      src_ptr, [](void *p) { delete reinterpret_cast<AER::Vector<T> *>(p); });
   return py::array_t<T>(
-    src_ptr->size(),  // shape of array
-    src_ptr->data(),  // c-style contiguous strides for vector
-    capsule           // numpy array references this parent
+      src_ptr->size(), // shape of array
+      src_ptr->data(), // c-style contiguous strides for vector
+      capsule          // numpy array references this parent
   );
 }
 
-
-template <typename T>
-py::array_t<T> to_numpy(std::vector<T> &&src) {
-  std::vector<T>* src_ptr = new std::vector<T>(std::move(src));
-  auto capsule = py::capsule(src_ptr, [](void* p) { delete reinterpret_cast<std::vector<T>*>(p); });
+template <typename T> py::array_t<T> to_numpy(std::vector<T> &&src) {
+  std::vector<T> *src_ptr = new std::vector<T>(std::move(src));
+  auto capsule = py::capsule(
+      src_ptr, [](void *p) { delete reinterpret_cast<std::vector<T> *>(p); });
   return py::array_t<T>(
-    src_ptr->size(),  // shape of array
-    src_ptr->data(),  // c-style contiguous strides for vector
-    capsule           // numpy array references this parent
+      src_ptr->size(), // shape of array
+      src_ptr->data(), // c-style contiguous strides for vector
+      capsule          // numpy array references this parent
   );
 }
 
 //------------------------------------------------------------------------------
-}  // end namespace AerToPy
+} // end namespace AerToPy
 //------------------------------------------------------------------------------
 #endif
diff --git a/src/framework/pybind_casts.hpp b/src/framework/pybind_casts.hpp
index de59f6de37..49119a6917 100644
--- a/src/framework/pybind_casts.hpp
+++ b/src/framework/pybind_casts.hpp
@@ -16,60 +16,67 @@
 #define _aer_framework_pybind_casts_hpp_
 
 #include "../simulators/stabilizer/clifford.hpp"
+#include <pybind11/numpy.h>
 
 namespace py = pybind11;
 
 namespace pybind11 {
 namespace detail {
-template <typename T> struct type_caster<matrix<T>>{
+template <typename T> struct type_caster<matrix<T>> {
   using base = type_caster_base<matrix<T>>;
+
 public:
   PYBIND11_TYPE_CASTER(matrix<T>, _("matrix_t"));
   // Conversion part 1 (Python->C++):
-  bool load(py::handle src, bool convert){
-      // TODO: Check if make sense have to flavors of matrix: F-style and C-style
-      auto py_matrix = py::cast<py::array_t<T>>(src);
-      auto c_order = py_matrix.attr("flags").attr("carray").template cast<bool>();
-      if(py_matrix.ndim() != 2){
-          throw std::invalid_argument(std::string("Python: invalid matrix (empty array)."));
-      }
-      size_t nrows = py_matrix.shape(0);
-      size_t ncols = py_matrix.shape(1);
-      // Matrix looks ok, now we parse it
-      auto raw_mat = py_matrix.template unchecked<2>();
-      if(c_order){
-          value = matrix<T>(nrows, ncols, false);
-          for (size_t r = 0; r < nrows; r++) {
-              for (size_t c = 0; c < ncols; c++) {
-                  value(r, c) = raw_mat(r, c);
-              }
-          }
-      } else {
-          value = matrix<T>::copy_from_buffer(nrows, ncols, static_cast<T *>(py_matrix.request().ptr));
+  bool load(py::handle src, bool convert) {
+    // TODO: Check if make sense have to flavors of matrix: F-style and C-style
+    auto py_matrix = py::cast<py::array_t<T>>(src);
+    auto c_order = py_matrix.attr("flags").attr("carray").template cast<bool>();
+    if (py_matrix.ndim() != 2) {
+      throw std::invalid_argument(
+          std::string("Python: invalid matrix (empty array)."));
+    }
+    size_t nrows = py_matrix.shape(0);
+    size_t ncols = py_matrix.shape(1);
+    // Matrix looks ok, now we parse it
+    auto raw_mat = py_matrix.template unchecked<2>();
+    if (c_order) {
+      value = matrix<T>(nrows, ncols, false);
+      for (size_t r = 0; r < nrows; r++) {
+        for (size_t c = 0; c < ncols; c++) {
+          value(r, c) = raw_mat(r, c);
+        }
       }
-      return true;
+    } else {
+      value = matrix<T>::copy_from_buffer(
+          nrows, ncols, static_cast<T *>(py_matrix.request().ptr));
+    }
+    return true;
   }
   // Conversion part 2 (C++ -> Python):
-  static py::handle cast(matrix<T>, py::return_value_policy policy, py::handle parent){
-      throw std::runtime_error("Casting from matrix to python not supported.");
+  static py::handle cast(matrix<T>, py::return_value_policy policy,
+                         py::handle parent) {
+    throw std::runtime_error("Casting from matrix to python not supported.");
   }
 };
 
-template <> struct type_caster<Clifford::Clifford>{
-    using base = type_caster_base<Clifford::Clifford>;
+template <> struct type_caster<Clifford::Clifford> {
+  using base = type_caster_base<Clifford::Clifford>;
+
 public:
-    PYBIND11_TYPE_CASTER(Clifford::Clifford, _("clifford"));
-    // Conversion part 1 (Python->C++):
-    bool load(py::handle src, bool convert){
-        Clifford::build_from(src, value);
-        return true;
-    }
-    // Conversion part 2 (C++ -> Python):
-    static py::handle cast(Clifford::Clifford, py::return_value_policy policy, py::handle parent){
-        throw std::runtime_error("Casting from Clifford to python not supported.");
-    }
+  PYBIND11_TYPE_CASTER(Clifford::Clifford, _("clifford"));
+  // Conversion part 1 (Python->C++):
+  bool load(py::handle src, bool convert) {
+    Clifford::build_from(src, value);
+    return true;
+  }
+  // Conversion part 2 (C++ -> Python):
+  static py::handle cast(Clifford::Clifford, py::return_value_policy policy,
+                         py::handle parent) {
+    throw std::runtime_error("Casting from Clifford to python not supported.");
+  }
 };
-}
-}
+} // namespace detail
+} // namespace pybind11
 
 #endif // _aer_framework_pybind_casts_hpp_
\ No newline at end of file
diff --git a/src/framework/pybind_json.hpp b/src/framework/pybind_json.hpp
old mode 100755
new mode 100644
index de06755d73..b747e75dc4
--- a/src/framework/pybind_json.hpp
+++ b/src/framework/pybind_json.hpp
@@ -26,18 +26,17 @@
 #include <fstream>
 #include <iostream>
 #include <map>
-#include <vector>
 #include <string>
-#include <iostream>
 #include <type_traits>
+#include <vector>
 
 #include "misc/warnings.hpp"
 DISABLE_WARNING_PUSH
-#include <pybind11/pybind11.h>
 #include <pybind11/cast.h>
-#include <pybind11/stl.h>
 #include <pybind11/complex.h>
 #include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
 
 #include <nlohmann/json.hpp>
 DISABLE_WARNING_POP
@@ -109,9 +108,9 @@ json_t numpy_to_json_2d(py::array_t<T, py::array::c_style> arr);
 template <typename T>
 json_t numpy_to_json_3d(py::array_t<T, py::array::c_style> arr);
 
-json_t iterable_to_json_list(const py::handle& obj);
+json_t iterable_to_json_list(const py::handle &obj);
 
-} //end namespace JSON
+} // end namespace JSON
 
 /*******************************************************************************
  *
@@ -125,187 +124,191 @@ json_t iterable_to_json_list(const py::handle& obj);
 
 template <typename T>
 json_t JSON::numpy_to_json_1d(py::array_t<T, py::array::c_style> arr) {
-    py::buffer_info buf = arr.request();
-    if (buf.ndim != 1) {
-        throw std::runtime_error("Number of dims must be 1");
-    }
+  py::buffer_info buf = arr.request();
+  if (buf.ndim != 1) {
+    throw std::runtime_error("Number of dims must be 1");
+  }
 
-    T *ptr = (T *) buf.ptr;
-    size_t D0 = buf.shape[0];
+  T *ptr = (T *)buf.ptr;
+  size_t D0 = buf.shape[0];
 
-    std::vector<T> tbr; // to be returned
-    for (size_t n0 = 0; n0 < D0; n0++)
-        tbr.push_back(ptr[n0]);
+  std::vector<T> tbr; // to be returned
+  for (size_t n0 = 0; n0 < D0; n0++)
+    tbr.push_back(ptr[n0]);
 
-    return std::move(tbr);
+  return std::move(tbr);
 }
 
 template <typename T>
 json_t JSON::numpy_to_json_2d(py::array_t<T, py::array::c_style> arr) {
-    py::buffer_info buf = arr.request();
-    if (buf.ndim != 2) {
-        throw std::runtime_error("Number of dims must be 2");
-    }
-
-    T *ptr = (T *) buf.ptr;
-    size_t D0 = buf.shape[0];
-    size_t D1 = buf.shape[1];
-
-    std::vector<std::vector<T > > tbr; // to be returned
-    for (size_t n0 = 0; n0 < D0; n0++) {
-        std::vector<T> tbr1;
-        for (size_t n1 = 0; n1 < D1; n1++) {
-            tbr1.push_back(ptr[n1 + D1*n0]);
-        }
-        tbr.push_back(tbr1);
+  py::buffer_info buf = arr.request();
+  if (buf.ndim != 2) {
+    throw std::runtime_error("Number of dims must be 2");
+  }
+
+  T *ptr = (T *)buf.ptr;
+  size_t D0 = buf.shape[0];
+  size_t D1 = buf.shape[1];
+
+  std::vector<std::vector<T>> tbr; // to be returned
+  for (size_t n0 = 0; n0 < D0; n0++) {
+    std::vector<T> tbr1;
+    for (size_t n1 = 0; n1 < D1; n1++) {
+      tbr1.push_back(ptr[n1 + D1 * n0]);
     }
+    tbr.push_back(tbr1);
+  }
 
-    return std::move(tbr);
-
+  return std::move(tbr);
 }
 
 template <typename T>
 json_t JSON::numpy_to_json_3d(py::array_t<T, py::array::c_style> arr) {
-    py::buffer_info buf = arr.request();
-    if (buf.ndim != 3) {
-        throw std::runtime_error("Number of dims must be 3");
-    }
-    T *ptr = (T *) buf.ptr;
-    size_t D0 = buf.shape[0];
-    size_t D1 = buf.shape[1];
-    size_t D2 = buf.shape[2];
-
-    // to be returned
-    std::vector<std::vector<std::vector<T > > > tbr;
-    for (size_t n0 = 0; n0 < D0; n0++) {
-        std::vector<std::vector<T> > tbr1;
-        for (size_t n1 = 0; n1 < D1; n1++) {
-            std::vector<T> tbr2;
-            for (size_t n2 = 0; n2 < D2; n2++) {
-                tbr2.push_back(ptr[n2 + D2*(n1 + D1*n0)]);
-            }
-            tbr1.push_back(tbr2);
-        }
-        tbr.push_back(tbr1);
+  py::buffer_info buf = arr.request();
+  if (buf.ndim != 3) {
+    throw std::runtime_error("Number of dims must be 3");
+  }
+  T *ptr = (T *)buf.ptr;
+  size_t D0 = buf.shape[0];
+  size_t D1 = buf.shape[1];
+  size_t D2 = buf.shape[2];
+
+  // to be returned
+  std::vector<std::vector<std::vector<T>>> tbr;
+  for (size_t n0 = 0; n0 < D0; n0++) {
+    std::vector<std::vector<T>> tbr1;
+    for (size_t n1 = 0; n1 < D1; n1++) {
+      std::vector<T> tbr2;
+      for (size_t n2 = 0; n2 < D2; n2++) {
+        tbr2.push_back(ptr[n2 + D2 * (n1 + D1 * n0)]);
+      }
+      tbr1.push_back(tbr2);
     }
+    tbr.push_back(tbr1);
+  }
 
-    return std::move(tbr);
-
+  return std::move(tbr);
 }
 
 template <typename T>
 json_t JSON::numpy_to_json(py::array_t<T, py::array::c_style> arr) {
-    py::buffer_info buf = arr.request();
-
-    if (buf.ndim == 1) {
-        return JSON::numpy_to_json_1d(arr);
-    } else if (buf.ndim == 2) {
-        return JSON::numpy_to_json_2d(arr);
-    } else if (buf.ndim == 3) {
-        return JSON::numpy_to_json_3d(arr);
-    } else {
-        throw std::runtime_error("Invalid number of dimensions!");
-    }
-    json_t tbr;
-    return tbr;
+  py::buffer_info buf = arr.request();
+
+  if (buf.ndim == 1) {
+    return JSON::numpy_to_json_1d(arr);
+  } else if (buf.ndim == 2) {
+    return JSON::numpy_to_json_2d(arr);
+  } else if (buf.ndim == 3) {
+    return JSON::numpy_to_json_3d(arr);
+  } else {
+    throw std::runtime_error("Invalid number of dimensions!");
+  }
+  json_t tbr;
+  return tbr;
 }
 
-json_t JSON::iterable_to_json_list(const py::handle& obj){
-    json_t js = nl::json::array();
-    for (py::handle value: obj) {
-        js.push_back(value);
-    }
-    return js;
+json_t JSON::iterable_to_json_list(const py::handle &obj) {
+  json_t js = nl::json::array();
+  for (py::handle value : obj) {
+    js.push_back(value);
+  }
+  return js;
 }
 
 void std::to_json(json_t &js, const py::handle &obj) {
-    static py::object PyNoiseModel = py::module::import("qiskit_aer.noise.noise_model").attr("NoiseModel");
-    static py::object PyQasmQobj = py::module::import("qiskit.qobj.qasm_qobj").attr("QasmQobj");
-    if (py::isinstance<py::float_>(obj)) {
-        js = obj.cast<nl::json::number_float_t>();
-    } else if (py::isinstance<py::bool_>(obj)) {
-        js = obj.cast<nl::json::boolean_t>();
-    } else if (py::isinstance<py::int_>(obj)) {
-        js = obj.cast<nl::json::number_integer_t>();
-    } else if (py::isinstance<py::str>(obj)) {
-        js = obj.cast<nl::json::string_t>();
-    } else if (py::isinstance<py::tuple>(obj) || py::isinstance<py::list>(obj)) {
-        js = JSON::iterable_to_json_list(obj);
-    } else if (py::isinstance<py::dict>(obj)) {
-        for (auto item : py::cast<py::dict>(obj)) {
-            js[item.first.cast<nl::json::string_t>()] = item.second;
-        }
-    } else if (py::isinstance<py::array_t<double> >(obj)) {
-        js = JSON::numpy_to_json(obj.cast<py::array_t<double, py::array::c_style> >());
-    } else if (py::isinstance<py::array_t<std::complex<double> > >(obj)) {
-        js = JSON::numpy_to_json(obj.cast<py::array_t<std::complex<double>, py::array::c_style> >());
-    } else if (obj.is_none()) {
-        return;
-    } else if (py::isinstance(obj, PyNoiseModel)){
-        std::to_json(js, obj.attr("to_dict")());
-    } else if (py::isinstance(obj, PyQasmQobj)){
-        std::to_json(js, obj.attr("to_dict")());
+  static py::object PyNoiseModel =
+      py::module::import("qiskit_aer.noise.noise_model").attr("NoiseModel");
+  static py::object PyQasmQobj =
+      py::module::import("qiskit.qobj.qasm_qobj").attr("QasmQobj");
+  if (py::isinstance<py::float_>(obj)) {
+    js = obj.cast<nl::json::number_float_t>();
+  } else if (py::isinstance<py::bool_>(obj)) {
+    js = obj.cast<nl::json::boolean_t>();
+  } else if (py::isinstance<py::int_>(obj)) {
+    js = obj.cast<nl::json::number_integer_t>();
+  } else if (py::isinstance<py::str>(obj)) {
+    js = obj.cast<nl::json::string_t>();
+  } else if (py::isinstance<py::tuple>(obj) || py::isinstance<py::list>(obj)) {
+    js = JSON::iterable_to_json_list(obj);
+  } else if (py::isinstance<py::dict>(obj)) {
+    for (auto item : py::cast<py::dict>(obj)) {
+      js[item.first.cast<nl::json::string_t>()] = item.second;
+    }
+  } else if (py::isinstance<py::array_t<double>>(obj)) {
+    js = JSON::numpy_to_json(
+        obj.cast<py::array_t<double, py::array::c_style>>());
+  } else if (py::isinstance<py::array_t<std::complex<double>>>(obj)) {
+    js = JSON::numpy_to_json(
+        obj.cast<py::array_t<std::complex<double>, py::array::c_style>>());
+  } else if (obj.is_none()) {
+    return;
+  } else if (py::isinstance(obj, PyNoiseModel)) {
+    std::to_json(js, obj.attr("to_dict")());
+  } else if (py::isinstance(obj, PyQasmQobj)) {
+    std::to_json(js, obj.attr("to_dict")());
+  } else {
+    auto type_str = std::string(py::str(obj.get_type()));
+    if (type_str == "<class \'complex\'>" ||
+        type_str == "<class \'numpy.complex64\'>" ||
+        type_str == "<class \'numpy.complex128\'>" ||
+        type_str == "<class \'numpy.complex_\'>") {
+      auto tmp = obj.cast<std::complex<double>>();
+      js.push_back(tmp.real());
+      js.push_back(tmp.imag());
+    } else if (type_str == "<class \'numpy.uint32\'>" ||
+               type_str == "<class \'numpy.uint64\'>" ||
+               type_str == "<class \'numpy.int32\'>" ||
+               type_str == "<class \'numpy.int64\'>") {
+      js = obj.cast<nl::json::number_integer_t>();
+    } else if (type_str == "<class \'numpy.float32\'>" ||
+               type_str == "<class \'numpy.float64\'>") {
+      js = obj.cast<nl::json::number_float_t>();
+    } else if (py::isinstance<py::iterable>(
+                   obj)) { // last one to avoid intercepting numpy arrays, etc
+      js = JSON::iterable_to_json_list(obj);
     } else {
-        auto type_str = std::string(py::str(obj.get_type()));
-        if ( type_str == "<class \'complex\'>"
-             || type_str == "<class \'numpy.complex64\'>"
-             || type_str == "<class \'numpy.complex128\'>"
-             || type_str == "<class \'numpy.complex_\'>" ) {
-            auto tmp = obj.cast<std::complex<double>>();
-            js.push_back(tmp.real());
-            js.push_back(tmp.imag());
-        } else if ( type_str == "<class \'numpy.uint32\'>"
-                    || type_str == "<class \'numpy.uint64\'>"
-                    || type_str == "<class \'numpy.int32\'>"
-                    || type_str == "<class \'numpy.int64\'>" ) {
-            js = obj.cast<nl::json::number_integer_t>();
-        } else if ( type_str == "<class \'numpy.float32\'>"
-                    || type_str == "<class \'numpy.float64\'>" ) {
-            js = obj.cast<nl::json::number_float_t>();
-        } else if ( py::isinstance<py::iterable>(obj) ){ // last one to avoid intercepting numpy arrays, etc
-            js = JSON::iterable_to_json_list(obj);
-        } else {
-            throw std::runtime_error("to_json not implemented for this type of object: " + std::string(py::str(obj.get_type())));
-        }
+      throw std::runtime_error(
+          "to_json not implemented for this type of object: " +
+          std::string(py::str(obj.get_type())));
     }
+  }
 }
 
 void std::from_json(const json_t &js, py::object &o) {
-    if (js.is_boolean()) {
-        o = py::bool_(js.get<nl::json::boolean_t>());
-    } else if (js.is_number()) {
-        if (js.is_number_float()) {
-            o = py::float_(js.get<nl::json::number_float_t>());
-        } else if (js.is_number_unsigned()) {
-            o = py::int_(js.get<nl::json::number_unsigned_t>());
-        } else {
-            o = py::int_(js.get<nl::json::number_integer_t>());
-        }
-    } else if (js.is_string()) {
-        o = py::str(js.get<nl::json::string_t>());
-    } else if (js.is_array()) {
-        std::vector<py::object> obj(js.size());
-        for (auto i = 0; i < js.size(); i++)
-        {
-            py::object tmp;
-            from_json(js[i], tmp);
-            obj[i] = tmp;
-        }
-        o = py::cast(obj);
-    } else if (js.is_object()) {
-        py::dict obj;
-        for (json_t::const_iterator it = js.cbegin(); it != js.cend(); ++it)
-        {
-            py::object tmp;
-            from_json(it.value(), tmp);
-            obj[py::str(it.key())] = tmp;
-        }
-        o = std::move(obj);
-    } else if (js.is_null()) {
-        o = py::none();
+  if (js.is_boolean()) {
+    o = py::bool_(js.get<nl::json::boolean_t>());
+  } else if (js.is_number()) {
+    if (js.is_number_float()) {
+      o = py::float_(js.get<nl::json::number_float_t>());
+    } else if (js.is_number_unsigned()) {
+      o = py::int_(js.get<nl::json::number_unsigned_t>());
     } else {
-        throw std::runtime_error("from_json not implemented for this json::type: " + js.dump());
+      o = py::int_(js.get<nl::json::number_integer_t>());
+    }
+  } else if (js.is_string()) {
+    o = py::str(js.get<nl::json::string_t>());
+  } else if (js.is_array()) {
+    std::vector<py::object> obj(js.size());
+    for (auto i = 0; i < js.size(); i++) {
+      py::object tmp;
+      from_json(js[i], tmp);
+      obj[i] = tmp;
+    }
+    o = py::cast(obj);
+  } else if (js.is_object()) {
+    py::dict obj;
+    for (json_t::const_iterator it = js.cbegin(); it != js.cend(); ++it) {
+      py::object tmp;
+      from_json(it.value(), tmp);
+      obj[py::str(it.key())] = tmp;
     }
+    o = std::move(obj);
+  } else if (js.is_null()) {
+    o = py::none();
+  } else {
+    throw std::runtime_error("from_json not implemented for this json::type: " +
+                             js.dump());
+  }
 }
 
 //------------------------------------------------------------------------------
diff --git a/src/framework/python_parser.hpp b/src/framework/python_parser.hpp
index e2867a8a0c..73f647a367 100644
--- a/src/framework/python_parser.hpp
+++ b/src/framework/python_parser.hpp
@@ -19,136 +19,138 @@
 #include "json_parser.hpp"
 #include "pybind_json.hpp"
 
-namespace AER{
-
-template <>
-struct Parser<py::handle> {
-    Parser() = delete;
-
-    static bool check_key(const std::string& key, const py::handle& po){
-        if(py::isinstance<py::dict>(po)){
-            return !py::cast<py::dict>(po)[key.c_str()].is_none();
-        }
-        return py::hasattr(po, key.c_str());
-    }
-
-    static bool check_keys(const std::vector<std::string>& keys, const py::handle& po) {
-        bool pass = true;
-        for (const auto &s : keys){
-            pass &= check_key(s, po);
-        }
-        return pass;
-    }
-
-    static py::object get_py_value(const std::string& key, const py::handle& po){
-        if(py::isinstance<py::dict>(po)){
-            return py::cast<py::dict>(po)[key.c_str()];
-        }
-        return po.attr(key.c_str());
-    }
-
-    static bool get_value(py::object& var, const std::string& key, const py::handle& po) {
-        if(check_key(key, po)) {
-            var = get_py_value(key, po);
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    template <typename T>
-    static bool get_value(T &var, const std::string& key, const py::handle& po){
-        if(check_key(key, po)) {
-            var = get_py_value(key, po).cast<T>();
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    static void convert_to_json(json_t &var, const py::handle& po){
-        if(py::hasattr(po, "to_dict")){
-            std::to_json(var, po.attr("to_dict")());
-        }else if(py::isinstance<py::list>(po)){
-            var = nl::json::array();
-            for(auto item: po){
-                json_t item_js;
-                convert_to_json(item_js, item);
-                var.push_back(item_js);
-            }
-        }else{
-            std::to_json(var, po);
-        }
-    }
-
-    static py::object get_value(const std::string& key, const py::handle& po){
-        return get_py_value(key, po);
-    }
-
-    static bool is_array(const py::handle& po){
-        return py::isinstance<py::list>(po) || py::isinstance<py::array>(po);
-    }
-
-    static bool is_array(const std::string& key, const py::handle& po) {
-        py::object the_list = get_py_value(key, po);
-        return is_array(the_list);
-    }
-
-    static bool is_list_like(const py::handle& po){
-        return is_array(po) || py::isinstance<py::tuple>(po);
-    }
-
-    static py::list get_as_list(const py::handle& po){
-        if(!is_list_like(po)){
-            throw std::runtime_error("Object is not list like!");
-        }
-        return  py::cast<py::list>(po);
-    }
-
-    static py::list get_list(const std::string& key, const py::handle& po){
-        py::object the_list = get_py_value(key, po);
-        if(!is_array(the_list)){
-            throw std::runtime_error("Object " + key + "is not a list!");
-        }
-        return py::cast<py::list>(the_list);
-    }
-
-    static bool is_number(const py::handle& po){
-        return py::isinstance<py::int_>(po) || py::isinstance<py::float_>(po);
-    }
-
-    static bool is_number(const std::string& key, const py::handle& po) {
-        py::object key_po = get_py_value(key, po);
-        return is_number(key_po);
-    }
-
-    template <typename T>
-    static T get_list_elem(const py::list& po, unsigned int i){
-        return py::cast<py::object>(po[i]).cast<T>();
-    }
-
-    template <typename T>
-    static T get_list_elem(const py::handle& po, unsigned int i){
-        auto py_list = get_as_list(po);
-        return get_list_elem<T>(py_list, i);
-    }
-
-    static std::string dump(const py::handle& po){
-        json_t js;
-        convert_to_json(js, po);
-        return js.dump();
-    }
+namespace AER {
+
+template <> struct Parser<py::handle> {
+  Parser() = delete;
+
+  static bool check_key(const std::string &key, const py::handle &po) {
+    if (py::isinstance<py::dict>(po)) {
+      return !py::cast<py::dict>(po)[key.c_str()].is_none();
+    }
+    return py::hasattr(po, key.c_str());
+  }
+
+  static bool check_keys(const std::vector<std::string> &keys,
+                         const py::handle &po) {
+    bool pass = true;
+    for (const auto &s : keys) {
+      pass &= check_key(s, po);
+    }
+    return pass;
+  }
+
+  static py::object get_py_value(const std::string &key, const py::handle &po) {
+    if (py::isinstance<py::dict>(po)) {
+      return py::cast<py::dict>(po)[key.c_str()];
+    }
+    return po.attr(key.c_str());
+  }
+
+  static bool get_value(py::object &var, const std::string &key,
+                        const py::handle &po) {
+    if (check_key(key, po)) {
+      var = get_py_value(key, po);
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  template <typename T>
+  static bool get_value(T &var, const std::string &key, const py::handle &po) {
+    if (check_key(key, po)) {
+      var = get_py_value(key, po).cast<T>();
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  static void convert_to_json(json_t &var, const py::handle &po) {
+    if (py::hasattr(po, "to_dict")) {
+      std::to_json(var, po.attr("to_dict")());
+    } else if (py::isinstance<py::list>(po)) {
+      var = nl::json::array();
+      for (auto item : po) {
+        json_t item_js;
+        convert_to_json(item_js, item);
+        var.push_back(item_js);
+      }
+    } else {
+      std::to_json(var, po);
+    }
+  }
+
+  static py::object get_value(const std::string &key, const py::handle &po) {
+    return get_py_value(key, po);
+  }
+
+  static bool is_array(const py::handle &po) {
+    return py::isinstance<py::list>(po) || py::isinstance<py::array>(po);
+  }
+
+  static bool is_array(const std::string &key, const py::handle &po) {
+    py::object the_list = get_py_value(key, po);
+    return is_array(the_list);
+  }
+
+  static bool is_list_like(const py::handle &po) {
+    return is_array(po) || py::isinstance<py::tuple>(po);
+  }
+
+  static py::list get_as_list(const py::handle &po) {
+    if (!is_list_like(po)) {
+      throw std::runtime_error("Object is not list like!");
+    }
+    return py::cast<py::list>(po);
+  }
+
+  static py::list get_list(const std::string &key, const py::handle &po) {
+    py::object the_list = get_py_value(key, po);
+    if (!is_array(the_list)) {
+      throw std::runtime_error("Object " + key + "is not a list!");
+    }
+    return py::cast<py::list>(the_list);
+  }
+
+  static bool is_number(const py::handle &po) {
+    return py::isinstance<py::int_>(po) || py::isinstance<py::float_>(po);
+  }
+
+  static bool is_number(const std::string &key, const py::handle &po) {
+    py::object key_po = get_py_value(key, po);
+    return is_number(key_po);
+  }
+
+  template <typename T>
+  static T get_list_elem(const py::list &po, unsigned int i) {
+    return py::cast<py::object>(po[i]).cast<T>();
+  }
+
+  template <typename T>
+  static T get_list_elem(const py::handle &po, unsigned int i) {
+    auto py_list = get_as_list(po);
+    return get_list_elem<T>(py_list, i);
+  }
+
+  static std::string dump(const py::handle &po) {
+    json_t js;
+    convert_to_json(js, po);
+    return js.dump();
+  }
 };
 
 template <>
-bool Parser<py::handle>::get_value<json_t>(json_t &var, const std::string& key, const py::handle& po){
-    py::object ret_po;
-    auto success = get_value<py::object>(ret_po, key, po);
-    if(success){
-        convert_to_json(var, ret_po);
-    }
-    return success;
-}
+bool Parser<py::handle>::get_value<json_t>(json_t &var, const std::string &key,
+                                           const py::handle &po) {
+  py::object ret_po;
+  auto success = get_value<py::object>(ret_po, key, po);
+  if (success) {
+    convert_to_json(var, ret_po);
+  }
+  return success;
 }
+} // namespace AER
 
 #endif // _aer_framework_python_parser_hpp_
diff --git a/src/framework/qobj.hpp b/src/framework/qobj.hpp
old mode 100755
new mode 100644
index 7eb7313a1b..00133af16f
--- a/src/framework/qobj.hpp
+++ b/src/framework/qobj.hpp
@@ -30,7 +30,7 @@ namespace AER {
 //============================================================================
 
 class Qobj {
- public:
+public:
   //----------------------------------------------------------------
   // Constructors
   //----------------------------------------------------------------
@@ -40,18 +40,17 @@ class Qobj {
   virtual ~Qobj() = default;
 
   // Deserialization constructor
-  template <typename inputdata_t>
-  Qobj(const inputdata_t &input);
+  template <typename inputdata_t> Qobj(const inputdata_t &input);
 
   //----------------------------------------------------------------
   // Data
   //----------------------------------------------------------------
-  std::string id;                 // qobj identifier passed to result
-  std::string type = "QASM";      // currently we only support QASM
-  std::vector<Circuit> circuits;  // List of circuits
-  json_t header;                  // (optional) passed through to result
-  json_t config;                  // (optional) qobj level config data
-  Noise::NoiseModel noise_model;  // (optional) noise model
+  std::string id;                // qobj identifier passed to result
+  std::string type = "QASM";     // currently we only support QASM
+  std::vector<Circuit> circuits; // List of circuits
+  json_t header;                 // (optional) passed through to result
+  json_t config;                 // (optional) qobj level config data
+  Noise::NoiseModel noise_model; // (optional) noise model
 };
 
 //============================================================================
@@ -61,13 +60,12 @@ class Qobj {
 // JSON deserialization
 inline void from_json(const json_t &js, Qobj &qobj) { qobj = Qobj(js); }
 
-template <typename inputdata_t>
-Qobj::Qobj(const inputdata_t &input) {
+template <typename inputdata_t> Qobj::Qobj(const inputdata_t &input) {
   // Check required fields
   if (Parser<inputdata_t>::get_value(id, "qobj_id", input) == false) {
     throw std::invalid_argument(R"(Invalid qobj: no "qobj_id" field)");
   };
-    Parser<inputdata_t>::get_value(type, "type", input);
+  Parser<inputdata_t>::get_value(type, "type", input);
   if (type != "QASM") {
     throw std::invalid_argument(R"(Invalid qobj: "type" != "QASM".)");
   };
@@ -100,12 +98,13 @@ Qobj::Qobj(const inputdata_t &input) {
   }
 
   // Check for fixed simulator seed
-  // If simulator seed is set, each experiment will be set to a fixed (but different) seed
-  // Otherwise a random seed will be chosen for each experiment
+  // If simulator seed is set, each experiment will be set to a fixed (but
+  // different) seed Otherwise a random seed will be chosen for each experiment
   int_t seed = -1;
   uint_t seed_shift = 0;
-  bool has_simulator_seed = Parser<json_t>::get_value(seed, "seed_simulator", config); // config always json
-  const auto& circs = Parser<inputdata_t>::get_list("experiments", input);
+  bool has_simulator_seed = Parser<json_t>::get_value(
+      seed, "seed_simulator", config); // config always json
+  const auto &circs = Parser<inputdata_t>::get_list("experiments", input);
   const size_t num_circs = circs.size();
 
   // Check if parameterized qobj
@@ -128,7 +127,7 @@ Qobj::Qobj(const inputdata_t &input) {
   }
 
   // Load circuits
-  for (size_t i=0; i<num_circs; i++) {
+  for (size_t i = 0; i < num_circs; i++) {
     if (param_table.empty() || param_table[i].empty()) {
       // Get base circuit from qobj
       Circuit circuit(static_cast<inputdata_t>(circs[i]), config, truncation);
@@ -141,7 +140,7 @@ Qobj::Qobj(const inputdata_t &input) {
       const auto circ_params = param_table[i];
       const size_t num_params = circ_params[0].second.size();
       const size_t num_instr = circuit.ops.size();
-      for (size_t j=0; j<num_params; j++) {
+      for (size_t j = 0; j < num_params; j++) {
         // Make a copy of the initial circuit
         Circuit param_circuit = circuit;
         for (const auto &params : circ_params) {
@@ -149,22 +148,26 @@ Qobj::Qobj(const inputdata_t &input) {
           const auto param_pos = params.first.second;
           // Validation
           if (instr_pos >= num_instr) {
-            throw std::invalid_argument(R"(Invalid parameterized qobj: instruction position out of range)");
+            throw std::invalid_argument(
+                R"(Invalid parameterized qobj: instruction position out of range)");
           }
           auto &op = param_circuit.ops[instr_pos];
           if (param_pos >= op.params.size()) {
-            throw std::invalid_argument(R"(Invalid parameterized qobj: instruction param position out of range)");
+            throw std::invalid_argument(
+                R"(Invalid parameterized qobj: instruction param position out of range)");
           }
           if (j >= params.second.size()) {
-            throw std::invalid_argument(R"(Invalid parameterized qobj: parameterization value out of range)");
+            throw std::invalid_argument(
+                R"(Invalid parameterized qobj: parameterization value out of range)");
           }
           // Update the param
           op.params[param_pos] = params.second[j];
         }
         // Run truncation.
-        // TODO: Truncation should be performed and parameters should be resolved after it.
-        // However, parameters are associated with indices of instructions, which can be changed in truncation.
-        // Therefore, current implementation performs truncation for each parameter set.
+        // TODO: Truncation should be performed and parameters should be
+        // resolved after it. However, parameters are associated with indices of
+        // instructions, which can be changed in truncation. Therefore, current
+        // implementation performs truncation for each parameter set.
         if (truncation)
           param_circuit.set_params(true);
         circuits.push_back(std::move(param_circuit));
@@ -177,13 +180,13 @@ Qobj::Qobj(const inputdata_t &input) {
   if (!has_simulator_seed) {
     seed = circuits[0].seed;
   }
-  for (auto& circuit : circuits) {
+  for (auto &circuit : circuits) {
     circuit.seed = seed + seed_shift;
-    seed_shift += 2113;  // Shift the seed
+    seed_shift += 2113; // Shift the seed
   }
 }
 
 //------------------------------------------------------------------------------
-}  // namespace AER
+} // namespace AER
 //------------------------------------------------------------------------------
 #endif
diff --git a/src/framework/results/data/data.hpp b/src/framework/results/data/data.hpp
index 878c117af0..82ccdd8650 100644
--- a/src/framework/results/data/data.hpp
+++ b/src/framework/results/data/data.hpp
@@ -16,22 +16,22 @@
 #define _aer_framework_results_data_hpp_
 
 // Data primatives
-#include "framework/results/data/subtypes/data_map.hpp"
 #include "framework/results/data/subtypes/accum_data.hpp"
 #include "framework/results/data/subtypes/average_data.hpp"
+#include "framework/results/data/subtypes/data_map.hpp"
 #include "framework/results/data/subtypes/list_data.hpp"
 #include "framework/results/data/subtypes/single_data.hpp"
 
 // Data Containers
-#include "framework/results/data/mixins/data_creg.hpp"
-#include "framework/results/data/mixins/data_rvalue.hpp"
-#include "framework/results/data/mixins/data_rvector.hpp"
-#include "framework/results/data/mixins/data_rdict.hpp"
+#include "framework/results/data/mixins/data_cdict.hpp"
 #include "framework/results/data/mixins/data_cmatrix.hpp"
+#include "framework/results/data/mixins/data_creg.hpp"
 #include "framework/results/data/mixins/data_cvector.hpp"
-#include "framework/results/data/mixins/data_cdict.hpp"
 #include "framework/results/data/mixins/data_json.hpp"
 #include "framework/results/data/mixins/data_mps.hpp"
+#include "framework/results/data/mixins/data_rdict.hpp"
+#include "framework/results/data/mixins/data_rvalue.hpp"
+#include "framework/results/data/mixins/data_rvector.hpp"
 
 namespace AER {
 
@@ -65,60 +65,60 @@ struct Data : public DataCreg,
   //----------------------------------------------------------------
   template <class T, typename... Args>
   void add_single(const T &data, const std::string &outer_key,
-                  const Args &... inner_keys);
+                  const Args &...inner_keys);
 
   template <class T, typename... Args>
   void add_single(T &data, const std::string &outer_key,
-                  const Args &... inner_keys);
+                  const Args &...inner_keys);
 
   template <class T, typename... Args>
   void add_single(T &&data, const std::string &outer_key,
-                  const Args &... inner_keys);
+                  const Args &...inner_keys);
 
   //----------------------------------------------------------------
   // Add list data
   //----------------------------------------------------------------
   template <class T, typename... Args>
   void add_list(const T &data, const std::string &outer_key,
-                const Args &... inner_keys);
+                const Args &...inner_keys);
 
   template <class T, typename... Args>
   void add_list(T &data, const std::string &outer_key,
-                const Args &... inner_keys);
+                const Args &...inner_keys);
 
   template <class T, typename... Args>
   void add_list(T &&data, const std::string &outer_key,
-                const Args &... inner_keys);
+                const Args &...inner_keys);
 
   //----------------------------------------------------------------
   // Add accum data
   //----------------------------------------------------------------
   template <class T, typename... Args>
   void add_accum(const T &data, const std::string &outer_key,
-                 const Args &... inner_keys);
+                 const Args &...inner_keys);
 
   template <class T, typename... Args>
   void add_accum(T &data, const std::string &outer_key,
-                 const Args &... inner_keys);
+                 const Args &...inner_keys);
 
   template <class T, typename... Args>
   void add_accum(T &&data, const std::string &outer_key,
-                 const Args &... inner_keys);
+                 const Args &...inner_keys);
 
   //----------------------------------------------------------------
   // Add average data
   //----------------------------------------------------------------
   template <class T, typename... Args>
   void add_average(const T &data, const std::string &outer_key,
-                   const Args &... inner_keys);
+                   const Args &...inner_keys);
 
   template <class T, typename... Args>
   void add_average(T &data, const std::string &outer_key,
-                   const Args &... inner_keys);
+                   const Args &...inner_keys);
 
   template <class T, typename... Args>
   void add_average(T &&data, const std::string &outer_key,
-                   const Args &... inner_keys);
+                   const Args &...inner_keys);
 
   //----------------------------------------------------------------
   // Utility and config
@@ -162,87 +162,86 @@ json_t Data::to_json() {
   return result;
 }
 
-
 template <class T, typename... Args>
 void Data::add_single(const T &data, const std::string &outer_key,
-                      const Args &... inner_keys) {
+                      const Args &...inner_keys) {
   DataMap<SingleData, T, sizeof...(Args) + 1>::add(data, outer_key,
                                                    inner_keys...);
 }
 
 template <class T, typename... Args>
 void Data::add_single(T &data, const std::string &outer_key,
-                      const Args &... inner_keys) {
+                      const Args &...inner_keys) {
   DataMap<SingleData, T, sizeof...(Args) + 1>::add(data, outer_key,
                                                    inner_keys...);
 }
 
 template <class T, typename... Args>
 void Data::add_single(T &&data, const std::string &outer_key,
-                      const Args &... inner_keys) {
+                      const Args &...inner_keys) {
   DataMap<SingleData, T, sizeof...(Args) + 1>::add(std::move(data), outer_key,
                                                    inner_keys...);
 }
 
 template <class T, typename... Args>
 void Data::add_list(const T &data, const std::string &outer_key,
-                    const Args &... inner_keys) {
+                    const Args &...inner_keys) {
   DataMap<ListData, T, sizeof...(Args) + 1>::add(data, outer_key,
                                                  inner_keys...);
 }
 
 template <class T, typename... Args>
 void Data::add_list(T &data, const std::string &outer_key,
-                    const Args &... inner_keys) {
+                    const Args &...inner_keys) {
   DataMap<ListData, T, sizeof...(Args) + 1>::add(data, outer_key,
                                                  inner_keys...);
 }
 
 template <class T, typename... Args>
 void Data::add_list(T &&data, const std::string &outer_key,
-                    const Args &... inner_keys) {
+                    const Args &...inner_keys) {
   DataMap<ListData, T, sizeof...(Args) + 1>::add(std::move(data), outer_key,
                                                  inner_keys...);
 }
 
 template <class T, typename... Args>
 void Data::add_accum(const T &data, const std::string &outer_key,
-                     const Args &... inner_keys) {
+                     const Args &...inner_keys) {
   DataMap<AccumData, T, sizeof...(Args) + 1>::add(data, outer_key,
                                                   inner_keys...);
 }
 
 template <class T, typename... Args>
 void Data::add_accum(T &data, const std::string &outer_key,
-                     const Args &... inner_keys) {
+                     const Args &...inner_keys) {
   DataMap<AccumData, T, sizeof...(Args) + 1>::add(data, outer_key,
                                                   inner_keys...);
 }
 
 template <class T, typename... Args>
 void Data::add_accum(T &&data, const std::string &outer_key,
-                     const Args &... inner_keys) {
+                     const Args &...inner_keys) {
   DataMap<AccumData, T, sizeof...(Args) + 1>::add(std::move(data), outer_key,
                                                   inner_keys...);
 }
 
 template <class T, typename... Args>
 void Data::add_average(const T &data, const std::string &outer_key,
-                       const Args &... inner_keys) {
+                       const Args &...inner_keys) {
   DataMap<AverageData, T, sizeof...(Args) + 1>::add(data, outer_key,
                                                     inner_keys...);
 }
 
 template <class T, typename... Args>
 void Data::add_average(T &data, const std::string &outer_key,
-                       const Args &... inner_keys) {
+                       const Args &...inner_keys) {
   DataMap<AverageData, T, sizeof...(Args) + 1>::add(data, outer_key,
                                                     inner_keys...);
 }
 
 template <class T, typename... Args>
 void Data::add_average(T &&data, const std::string &outer_key,
-                       const Args &... inner_keys) {
+                       const Args &...inner_keys) {
   DataMap<AverageData, T, sizeof...(Args) + 1>::add(std::move(data), outer_key,
                                                     inner_keys...);
 }
diff --git a/src/framework/results/data/metadata.hpp b/src/framework/results/data/metadata.hpp
index 969179ca3a..cf7cb39bb1 100644
--- a/src/framework/results/data/metadata.hpp
+++ b/src/framework/results/data/metadata.hpp
@@ -33,15 +33,15 @@ struct Metadata : public DataMap<SingleData, json_t, 1>,
   //----------------------------------------------------------------
   template <typename... Args>
   void add(const json_t &data, const std::string &outer_key,
-           const Args &... inner_keys);
+           const Args &...inner_keys);
 
   template <typename... Args>
   void add(json_t &data, const std::string &outer_key,
-           const Args &... inner_keys);
+           const Args &...inner_keys);
 
   template <typename... Args>
   void add(json_t &&data, const std::string &outer_key,
-           const Args &... inner_keys);
+           const Args &...inner_keys);
 
   //----------------------------------------------------------------
   // Add general metadata
@@ -51,13 +51,13 @@ struct Metadata : public DataMap<SingleData, json_t, 1>,
   //----------------------------------------------------------------
   template <typename T, typename... Args>
   void add(const T &data, const std::string &outer_key,
-           const Args &... inner_keys);
+           const Args &...inner_keys);
 
   template <typename T, typename... Args>
-  void add(T &data, const std::string &outer_key, const Args &... inner_keys);
+  void add(T &data, const std::string &outer_key, const Args &...inner_keys);
 
   template <typename T, typename... Args>
-  void add(T &&data, const std::string &outer_key, const Args &... inner_keys);
+  void add(T &&data, const std::string &outer_key, const Args &...inner_keys);
 
   // Serialize engine data to JSON
   json_t to_json();
@@ -87,7 +87,7 @@ json_t Metadata::to_json() {
 
 template <typename T, typename... Args>
 void Metadata::add(const T &data, const std::string &outer_key,
-                   const Args &... inner_keys) {
+                   const Args &...inner_keys) {
   json_t tmp = data;
   DataMap<SingleData, json_t, sizeof...(Args) + 1>::add(
       std::move(tmp), outer_key, inner_keys...);
@@ -95,7 +95,7 @@ void Metadata::add(const T &data, const std::string &outer_key,
 
 template <typename T, typename... Args>
 void Metadata::add(T &data, const std::string &outer_key,
-                   const Args &... inner_keys) {
+                   const Args &...inner_keys) {
   json_t tmp = data;
   DataMap<SingleData, json_t, sizeof...(Args) + 1>::add(
       std::move(tmp), outer_key, inner_keys...);
@@ -103,7 +103,7 @@ void Metadata::add(T &data, const std::string &outer_key,
 
 template <typename T, typename... Args>
 void Metadata::add(T &&data, const std::string &outer_key,
-                   const Args &... inner_keys) {
+                   const Args &...inner_keys) {
   json_t tmp = data;
   DataMap<SingleData, json_t, sizeof...(Args) + 1>::add(
       std::move(tmp), outer_key, inner_keys...);
@@ -111,21 +111,21 @@ void Metadata::add(T &&data, const std::string &outer_key,
 
 template <typename... Args>
 void Metadata::add(const json_t &data, const std::string &outer_key,
-                   const Args &... inner_keys) {
+                   const Args &...inner_keys) {
   DataMap<SingleData, json_t, sizeof...(Args) + 1>::add(data, outer_key,
                                                         inner_keys...);
 }
 
 template <typename... Args>
 void Metadata::add(json_t &data, const std::string &outer_key,
-                   const Args &... inner_keys) {
+                   const Args &...inner_keys) {
   DataMap<SingleData, json_t, sizeof...(Args) + 1>::add(data, outer_key,
                                                         inner_keys...);
 }
 
 template <typename... Args>
 void Metadata::add(json_t &&data, const std::string &outer_key,
-                   const Args &... inner_keys) {
+                   const Args &...inner_keys) {
   DataMap<SingleData, json_t, sizeof...(Args) + 1>::add(
       std::move(data), outer_key, inner_keys...);
 }
diff --git a/src/framework/results/data/mixins/data_cdict.hpp b/src/framework/results/data/mixins/data_cdict.hpp
index 16d1e3b8d7..69b4670c3b 100644
--- a/src/framework/results/data/mixins/data_cdict.hpp
+++ b/src/framework/results/data/mixins/data_cdict.hpp
@@ -29,10 +29,11 @@ namespace AER {
 // Result container for Qiskit-Aer
 //============================================================================
 
-struct DataCDict : public DataMap<SingleData, std::map<std::string, complex_t>, 1>,
-                   public DataMap<SingleData, std::map<std::string, complex_t>, 2>,
-                   public DataMap<ListData, std::map<std::string, complex_t>, 1>,
-                   public DataMap<ListData, std::map<std::string, complex_t>, 2> {
+struct DataCDict
+    : public DataMap<SingleData, std::map<std::string, complex_t>, 1>,
+      public DataMap<SingleData, std::map<std::string, complex_t>, 2>,
+      public DataMap<ListData, std::map<std::string, complex_t>, 1>,
+      public DataMap<ListData, std::map<std::string, complex_t>, 2> {
 
   // Serialize engine data to JSON
   void add_to_json(json_t &result);
@@ -46,10 +47,14 @@ struct DataCDict : public DataMap<SingleData, std::map<std::string, complex_t>,
 //------------------------------------------------------------------------------
 
 DataCDict &DataCDict::combine(DataCDict &&other) {
-  DataMap<SingleData, std::map<std::string, complex_t>, 1>::combine(std::move(other));
-  DataMap<SingleData, std::map<std::string, complex_t>, 2>::combine(std::move(other));
-  DataMap<ListData, std::map<std::string, complex_t>, 1>::combine(std::move(other));
-  DataMap<ListData, std::map<std::string, complex_t>, 2>::combine(std::move(other));
+  DataMap<SingleData, std::map<std::string, complex_t>, 1>::combine(
+      std::move(other));
+  DataMap<SingleData, std::map<std::string, complex_t>, 2>::combine(
+      std::move(other));
+  DataMap<ListData, std::map<std::string, complex_t>, 1>::combine(
+      std::move(other));
+  DataMap<ListData, std::map<std::string, complex_t>, 2>::combine(
+      std::move(other));
   return *this;
 }
 
diff --git a/src/framework/results/data/mixins/data_cmatrix.hpp b/src/framework/results/data/mixins/data_cmatrix.hpp
index 0aa1920603..f1e23b6707 100644
--- a/src/framework/results/data/mixins/data_cmatrix.hpp
+++ b/src/framework/results/data/mixins/data_cmatrix.hpp
@@ -15,9 +15,9 @@
 #ifndef _aer_framework_results_data_cmatrix_hpp_
 #define _aer_framework_results_data_cmatrix_hpp_
 
-#include "framework/results/data/subtypes/data_map.hpp"
 #include "framework/results/data/subtypes/accum_data.hpp"
 #include "framework/results/data/subtypes/average_data.hpp"
+#include "framework/results/data/subtypes/data_map.hpp"
 #include "framework/results/data/subtypes/list_data.hpp"
 #include "framework/results/data/subtypes/single_data.hpp"
 #include "framework/types.hpp"
@@ -28,23 +28,22 @@ namespace AER {
 // Result container for Qiskit-Aer
 //============================================================================
 
-struct DataCMatrix :
-    public DataMap<SingleData, matrix<complex_t>, 1>,
-    public DataMap<SingleData, matrix<complexf_t>, 1>,
-    public DataMap<SingleData, matrix<complex_t>, 2>,
-    public DataMap<SingleData, matrix<complexf_t>, 2>,
-    public DataMap<ListData, matrix<complex_t>, 1>,
-    public DataMap<ListData, matrix<complexf_t>, 1>,
-    public DataMap<ListData, matrix<complex_t>, 2>,
-    public DataMap<ListData, matrix<complexf_t>, 2>,
-    public DataMap<AccumData, matrix<complex_t>, 1>,
-    public DataMap<AccumData, matrix<complexf_t>, 1>,
-    public DataMap<AccumData, matrix<complex_t>, 2>,
-    public DataMap<AccumData, matrix<complexf_t>, 2>,
-    public DataMap<AverageData, matrix<complex_t>, 1>,
-    public DataMap<AverageData, matrix<complexf_t>, 1>,
-    public DataMap<AverageData, matrix<complex_t>, 2>,
-    public DataMap<AverageData, matrix<complexf_t>, 2> {
+struct DataCMatrix : public DataMap<SingleData, matrix<complex_t>, 1>,
+                     public DataMap<SingleData, matrix<complexf_t>, 1>,
+                     public DataMap<SingleData, matrix<complex_t>, 2>,
+                     public DataMap<SingleData, matrix<complexf_t>, 2>,
+                     public DataMap<ListData, matrix<complex_t>, 1>,
+                     public DataMap<ListData, matrix<complexf_t>, 1>,
+                     public DataMap<ListData, matrix<complex_t>, 2>,
+                     public DataMap<ListData, matrix<complexf_t>, 2>,
+                     public DataMap<AccumData, matrix<complex_t>, 1>,
+                     public DataMap<AccumData, matrix<complexf_t>, 1>,
+                     public DataMap<AccumData, matrix<complex_t>, 2>,
+                     public DataMap<AccumData, matrix<complexf_t>, 2>,
+                     public DataMap<AverageData, matrix<complex_t>, 1>,
+                     public DataMap<AverageData, matrix<complexf_t>, 1>,
+                     public DataMap<AverageData, matrix<complex_t>, 2>,
+                     public DataMap<AverageData, matrix<complexf_t>, 2> {
 
   // Serialize engine data to JSON
   void add_to_json(json_t &result);
diff --git a/src/framework/results/data/mixins/data_creg.hpp b/src/framework/results/data/mixins/data_creg.hpp
index 73a68acb11..f97b769ce6 100644
--- a/src/framework/results/data/mixins/data_creg.hpp
+++ b/src/framework/results/data/mixins/data_creg.hpp
@@ -26,8 +26,8 @@ namespace AER {
 // Result container for Qiskit-Aer
 //============================================================================
 
-struct DataCreg : public DataMap<AccumData, uint_t, 2>,     // Counts
-                  public DataMap<ListData, std::string, 1>  // Memory
+struct DataCreg : public DataMap<AccumData, uint_t, 2>,    // Counts
+                  public DataMap<ListData, std::string, 1> // Memory
 {
   // Serialize engine data to JSON
   void add_to_json(json_t &result);
diff --git a/src/framework/results/data/mixins/data_mps.hpp b/src/framework/results/data/mixins/data_mps.hpp
index 21e20619c6..281a91bf70 100644
--- a/src/framework/results/data/mixins/data_mps.hpp
+++ b/src/framework/results/data/mixins/data_mps.hpp
@@ -25,7 +25,7 @@ namespace AER {
 //============================================================================
 // Result container for Qiskit-Aer
 //============================================================================
-//using cmat = std::vector<std::vector<complex_t>>;
+// using cmat = std::vector<std::vector<complex_t>>;
 struct DataMPS : public DataMap<SingleData, mps_container_t, 1>,
                  public DataMap<SingleData, mps_container_t, 2>,
                  public DataMap<ListData, mps_container_t, 1>,
diff --git a/src/framework/results/data/mixins/data_rdict.hpp b/src/framework/results/data/mixins/data_rdict.hpp
index 8f9e0f55a2..9e470267b4 100644
--- a/src/framework/results/data/mixins/data_rdict.hpp
+++ b/src/framework/results/data/mixins/data_rdict.hpp
@@ -15,12 +15,12 @@
 #ifndef _aer_framework_results_data_rdict_hpp_
 #define _aer_framework_results_data_rdict_hpp_
 
-#include <map>
-#include "framework/results/data/subtypes/data_map.hpp"
-#include "framework/results/data/subtypes/list_data.hpp"
 #include "framework/results/data/subtypes/accum_data.hpp"
 #include "framework/results/data/subtypes/average_data.hpp"
+#include "framework/results/data/subtypes/data_map.hpp"
+#include "framework/results/data/subtypes/list_data.hpp"
 #include "framework/types.hpp"
+#include <map>
 
 namespace AER {
 
@@ -28,12 +28,13 @@ namespace AER {
 // Result container for Qiskit-Aer
 //============================================================================
 
-struct DataRDict : public DataMap<ListData, std::map<std::string, double>, 1>,
-                   public DataMap<ListData, std::map<std::string, double>, 2>,
-                   public DataMap<AccumData, std::map<std::string, double>, 1>,
-                   public DataMap<AccumData, std::map<std::string, double>, 2>,
-                   public DataMap<AverageData, std::map<std::string, double>, 1>,
-                   public DataMap<AverageData, std::map<std::string, double>, 2> {
+struct DataRDict
+    : public DataMap<ListData, std::map<std::string, double>, 1>,
+      public DataMap<ListData, std::map<std::string, double>, 2>,
+      public DataMap<AccumData, std::map<std::string, double>, 1>,
+      public DataMap<AccumData, std::map<std::string, double>, 2>,
+      public DataMap<AverageData, std::map<std::string, double>, 1>,
+      public DataMap<AverageData, std::map<std::string, double>, 2> {
 
   // Serialize engine data to JSON
   void add_to_json(json_t &result);
@@ -47,12 +48,18 @@ struct DataRDict : public DataMap<ListData, std::map<std::string, double>, 1>,
 //------------------------------------------------------------------------------
 
 DataRDict &DataRDict::combine(DataRDict &&other) {
-  DataMap<ListData, std::map<std::string, double>, 1>::combine(std::move(other));
-  DataMap<ListData, std::map<std::string, double>, 2>::combine(std::move(other));
-  DataMap<AccumData, std::map<std::string, double>, 1>::combine(std::move(other));
-  DataMap<AccumData, std::map<std::string, double>, 2>::combine(std::move(other));
-  DataMap<AverageData, std::map<std::string, double>, 1>::combine(std::move(other));
-  DataMap<AverageData, std::map<std::string, double>, 2>::combine(std::move(other));
+  DataMap<ListData, std::map<std::string, double>, 1>::combine(
+      std::move(other));
+  DataMap<ListData, std::map<std::string, double>, 2>::combine(
+      std::move(other));
+  DataMap<AccumData, std::map<std::string, double>, 1>::combine(
+      std::move(other));
+  DataMap<AccumData, std::map<std::string, double>, 2>::combine(
+      std::move(other));
+  DataMap<AverageData, std::map<std::string, double>, 1>::combine(
+      std::move(other));
+  DataMap<AverageData, std::map<std::string, double>, 2>::combine(
+      std::move(other));
   return *this;
 }
 
diff --git a/src/framework/results/data/mixins/data_rvalue.hpp b/src/framework/results/data/mixins/data_rvalue.hpp
index 901c84eb30..8f89412ea4 100644
--- a/src/framework/results/data/mixins/data_rvalue.hpp
+++ b/src/framework/results/data/mixins/data_rvalue.hpp
@@ -15,9 +15,9 @@
 #ifndef _aer_framework_results_data_rvalue_hpp_
 #define _aer_framework_results_data_rvalue_hpp_
 
-#include "framework/results/data/subtypes/data_map.hpp"
 #include "framework/results/data/subtypes/accum_data.hpp"
 #include "framework/results/data/subtypes/average_data.hpp"
+#include "framework/results/data/subtypes/data_map.hpp"
 #include "framework/results/data/subtypes/list_data.hpp"
 #include "framework/results/data/subtypes/single_data.hpp"
 #include "framework/types.hpp"
@@ -28,13 +28,12 @@ namespace AER {
 // Result container for Qiskit-Aer
 //============================================================================
 
-struct DataRValue :
-    public DataMap<ListData, double, 1>,
-    public DataMap<ListData, double, 2>,
-    public DataMap<AccumData, double, 1>,
-    public DataMap<AccumData, double, 2>,
-    public DataMap<AverageData, double, 1>,
-    public DataMap<AverageData, double, 2> {
+struct DataRValue : public DataMap<ListData, double, 1>,
+                    public DataMap<ListData, double, 2>,
+                    public DataMap<AccumData, double, 1>,
+                    public DataMap<AccumData, double, 2>,
+                    public DataMap<AverageData, double, 1>,
+                    public DataMap<AverageData, double, 2> {
 
   // Serialize engine data to JSON
   void add_to_json(json_t &result);
diff --git a/src/framework/results/data/mixins/data_rvector.hpp b/src/framework/results/data/mixins/data_rvector.hpp
index ab283f7ac1..6688b80db1 100644
--- a/src/framework/results/data/mixins/data_rvector.hpp
+++ b/src/framework/results/data/mixins/data_rvector.hpp
@@ -15,11 +15,11 @@
 #ifndef _aer_framework_results_data_rvector_hpp_
 #define _aer_framework_results_data_rvector_hpp_
 
+#include "framework/results/data/subtypes/accum_data.hpp"
+#include "framework/results/data/subtypes/average_data.hpp"
 #include "framework/results/data/subtypes/data_map.hpp"
 #include "framework/results/data/subtypes/list_data.hpp"
 #include "framework/results/data/subtypes/single_data.hpp"
-#include "framework/results/data/subtypes/accum_data.hpp"
-#include "framework/results/data/subtypes/average_data.hpp"
 #include "framework/types.hpp"
 
 namespace AER {
diff --git a/src/framework/results/data/mixins/pybind_data_cdict.hpp b/src/framework/results/data/mixins/pybind_data_cdict.hpp
old mode 100755
new mode 100644
index 7bcddf3cdc..9f025e39b2
--- a/src/framework/results/data/mixins/pybind_data_cdict.hpp
+++ b/src/framework/results/data/mixins/pybind_data_cdict.hpp
@@ -30,8 +30,7 @@ py::object to_python(AER::DataCDict &&data);
 // Move an DataCDict container object to an existing new Python dict
 void add_to_python(py::dict &pydata, AER::DataCDict &&data);
 
-} //end namespace AerToPy
-
+} // end namespace AerToPy
 
 //============================================================================
 // Implementations
@@ -44,10 +43,26 @@ py::object AerToPy::to_python(AER::DataCDict &&data) {
 }
 
 void AerToPy::add_to_python(py::dict &pydata, AER::DataCDict &&data) {
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::SingleData, std::map<std::string, AER::complex_t>, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::SingleData, std::map<std::string, AER::complex_t>, 2>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::ListData, std::map<std::string, AER::complex_t>, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::ListData, std::map<std::string, AER::complex_t>, 2>&&>(data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::SingleData,
+                               std::map<std::string, AER::complex_t>, 1> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::SingleData,
+                               std::map<std::string, AER::complex_t>, 2> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::ListData,
+                               std::map<std::string, AER::complex_t>, 1> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::ListData,
+                               std::map<std::string, AER::complex_t>, 2> &&>(
+          data));
 }
 
 #endif
diff --git a/src/framework/results/data/mixins/pybind_data_cmatrix.hpp b/src/framework/results/data/mixins/pybind_data_cmatrix.hpp
old mode 100755
new mode 100644
index 4b53de3c8a..994adc2e8b
--- a/src/framework/results/data/mixins/pybind_data_cmatrix.hpp
+++ b/src/framework/results/data/mixins/pybind_data_cmatrix.hpp
@@ -30,8 +30,7 @@ py::object to_python(AER::DataCMatrix &&data);
 // Move an DataCMatrix container object to an existing new Python dict
 void add_to_python(py::dict &pydata, AER::DataCMatrix &&data);
 
-} //end namespace AerToPy
-
+} // end namespace AerToPy
 
 //============================================================================
 // Implementations
@@ -44,22 +43,70 @@ py::object AerToPy::to_python(AER::DataCMatrix &&data) {
 }
 
 void AerToPy::add_to_python(py::dict &pydata, AER::DataCMatrix &&data) {
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::SingleData, matrix<AER::complex_t>, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::SingleData, matrix<AER::complexf_t>, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::SingleData, matrix<AER::complex_t>, 2>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::SingleData, matrix<AER::complexf_t>, 2>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::ListData, matrix<AER::complex_t>, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::ListData, matrix<AER::complexf_t>, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::ListData, matrix<AER::complex_t>, 2>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::ListData, matrix<AER::complexf_t>, 2>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::AccumData, matrix<AER::complex_t>, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::AccumData, matrix<AER::complexf_t>, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::AccumData, matrix<AER::complex_t>, 2>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::AccumData, matrix<AER::complexf_t>, 2>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::AverageData, matrix<AER::complex_t>, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::AverageData, matrix<AER::complexf_t>, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::AverageData, matrix<AER::complex_t>, 2>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::AverageData, matrix<AER::complexf_t>, 2>&&>(data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::SingleData, matrix<AER::complex_t>, 1> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::SingleData, matrix<AER::complexf_t>, 1> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::SingleData, matrix<AER::complex_t>, 2> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::SingleData, matrix<AER::complexf_t>, 2> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::ListData, matrix<AER::complex_t>, 1> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::ListData, matrix<AER::complexf_t>, 1> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::ListData, matrix<AER::complex_t>, 2> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::ListData, matrix<AER::complexf_t>, 2> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::AccumData, matrix<AER::complex_t>, 1> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::AccumData, matrix<AER::complexf_t>, 1> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::AccumData, matrix<AER::complex_t>, 2> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::AccumData, matrix<AER::complexf_t>, 2> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::AverageData, matrix<AER::complex_t>, 1> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<
+          AER::DataMap<AER::AverageData, matrix<AER::complexf_t>, 1> &&>(data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::AverageData, matrix<AER::complex_t>, 2> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<
+          AER::DataMap<AER::AverageData, matrix<AER::complexf_t>, 2> &&>(data));
 }
 
 #endif
diff --git a/src/framework/results/data/mixins/pybind_data_creg.hpp b/src/framework/results/data/mixins/pybind_data_creg.hpp
old mode 100755
new mode 100644
index 9585154c42..2156dd1d9b
--- a/src/framework/results/data/mixins/pybind_data_creg.hpp
+++ b/src/framework/results/data/mixins/pybind_data_creg.hpp
@@ -30,8 +30,7 @@ py::object to_python(AER::DataCreg &&data);
 // Move an DataCreg container object to an existing new Python dict
 void add_to_python(py::dict &pydata, AER::DataCreg &&data);
 
-} //end namespace AerToPy
-
+} // end namespace AerToPy
 
 //============================================================================
 // Implementations
@@ -44,8 +43,12 @@ py::object AerToPy::to_python(AER::DataCreg &&data) {
 }
 
 void AerToPy::add_to_python(py::dict &pydata, AER::DataCreg &&data) {
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::ListData, std::string, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::AccumData, AER::uint_t, 2>&&>(data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::ListData, std::string, 1> &&>(data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::AccumData, AER::uint_t, 2> &&>(data));
 }
 
 #endif
diff --git a/src/framework/results/data/mixins/pybind_data_cvector.hpp b/src/framework/results/data/mixins/pybind_data_cvector.hpp
old mode 100755
new mode 100644
index 3115cc8b09..15c7991780
--- a/src/framework/results/data/mixins/pybind_data_cvector.hpp
+++ b/src/framework/results/data/mixins/pybind_data_cvector.hpp
@@ -30,8 +30,7 @@ py::object to_python(AER::DataCVector &&data);
 // Move an DataCVector container object to an existing new Python dict
 void add_to_python(py::dict &pydata, AER::DataCVector &&data);
 
-} //end namespace AerToPy
-
+} // end namespace AerToPy
 
 //============================================================================
 // Implementations
@@ -44,14 +43,38 @@ py::object AerToPy::to_python(AER::DataCVector &&data) {
 }
 
 void AerToPy::add_to_python(py::dict &pydata, AER::DataCVector &&data) {
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::SingleData, AER::Vector<AER::complex_t>, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::SingleData, AER::Vector<AER::complexf_t>, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::SingleData, AER::Vector<AER::complex_t>, 2>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::SingleData, AER::Vector<AER::complexf_t>, 2>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::ListData, AER::Vector<AER::complex_t>, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::ListData, AER::Vector<AER::complexf_t>, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::ListData, AER::Vector<AER::complex_t>, 2>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::ListData, AER::Vector<AER::complexf_t>, 2>&&>(data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::SingleData, AER::Vector<AER::complex_t>, 1>
+                      &&>(data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::SingleData, AER::Vector<AER::complexf_t>, 1>
+                      &&>(data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::SingleData, AER::Vector<AER::complex_t>, 2>
+                      &&>(data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::SingleData, AER::Vector<AER::complexf_t>, 2>
+                      &&>(data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::ListData, AER::Vector<AER::complex_t>, 1>
+                      &&>(data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::ListData, AER::Vector<AER::complexf_t>, 1>
+                      &&>(data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::ListData, AER::Vector<AER::complex_t>, 2>
+                      &&>(data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::ListData, AER::Vector<AER::complexf_t>, 2>
+                      &&>(data));
 }
 
 #endif
diff --git a/src/framework/results/data/mixins/pybind_data_json.hpp b/src/framework/results/data/mixins/pybind_data_json.hpp
old mode 100755
new mode 100644
index 89759ed3ce..51bebb049b
--- a/src/framework/results/data/mixins/pybind_data_json.hpp
+++ b/src/framework/results/data/mixins/pybind_data_json.hpp
@@ -30,8 +30,7 @@ py::object to_python(AER::DataJSON &&data);
 // Move an DataJSON container object to an existing new Python dict
 void add_to_python(py::dict &pydata, AER::DataJSON &&data);
 
-} //end namespace AerToPy
-
+} // end namespace AerToPy
 
 //============================================================================
 // Implementations
@@ -44,10 +43,14 @@ py::object AerToPy::to_python(AER::DataJSON &&data) {
 }
 
 void AerToPy::add_to_python(py::dict &pydata, AER::DataJSON &&data) {
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::SingleData, json_t, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::SingleData, json_t, 2>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::ListData, json_t, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::ListData, json_t, 2>&&>(data));
+  AerToPy::add_to_python(
+      pydata, static_cast<AER::DataMap<AER::SingleData, json_t, 1> &&>(data));
+  AerToPy::add_to_python(
+      pydata, static_cast<AER::DataMap<AER::SingleData, json_t, 2> &&>(data));
+  AerToPy::add_to_python(
+      pydata, static_cast<AER::DataMap<AER::ListData, json_t, 1> &&>(data));
+  AerToPy::add_to_python(
+      pydata, static_cast<AER::DataMap<AER::ListData, json_t, 2> &&>(data));
 }
 
 #endif
diff --git a/src/framework/results/data/mixins/pybind_data_mps.hpp b/src/framework/results/data/mixins/pybind_data_mps.hpp
old mode 100755
new mode 100644
index 7196d884a4..758166f087
--- a/src/framework/results/data/mixins/pybind_data_mps.hpp
+++ b/src/framework/results/data/mixins/pybind_data_mps.hpp
@@ -33,8 +33,7 @@ py::object to_python(AER::DataMPS &&data);
 // Move an DataMPS container object to an existing new Python dict
 void add_to_python(py::dict &pydata, AER::DataMPS &&data);
 
-} //end namespace AerToPy
-
+} // end namespace AerToPy
 
 //============================================================================
 // Implementations
@@ -42,12 +41,12 @@ void add_to_python(py::dict &pydata, AER::DataMPS &&data);
 
 template <> py::object AerToPy::to_python(AER::mps_container_t &&data) {
   py::list mats;
-  for (auto& pair: data.first) {
+  for (auto &pair : data.first) {
     mats.append(py::make_tuple(AerToPy::to_python(std::move(pair.first)),
                                AerToPy::to_python(std::move(pair.second))));
   }
   py::list vecs;
-  for (auto&& vec: data.second) {
+  for (auto &&vec : data.second) {
     vecs.append(AerToPy::to_python(std::move(vec)));
   }
   return py::make_tuple(std::move(mats), std::move(vecs));
@@ -60,10 +59,22 @@ py::object AerToPy::to_python(AER::DataMPS &&data) {
 }
 
 void AerToPy::add_to_python(py::dict &pydata, AER::DataMPS &&data) {
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::SingleData, AER::mps_container_t, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::SingleData, AER::mps_container_t, 2>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::ListData, AER::mps_container_t, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::ListData, AER::mps_container_t, 2>&&>(data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::SingleData, AER::mps_container_t, 1> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::SingleData, AER::mps_container_t, 2> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::ListData, AER::mps_container_t, 1> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::ListData, AER::mps_container_t, 2> &&>(
+          data));
 }
 
 #endif
diff --git a/src/framework/results/data/mixins/pybind_data_rdict.hpp b/src/framework/results/data/mixins/pybind_data_rdict.hpp
old mode 100755
new mode 100644
index 03e2a0a30c..1a92571c63
--- a/src/framework/results/data/mixins/pybind_data_rdict.hpp
+++ b/src/framework/results/data/mixins/pybind_data_rdict.hpp
@@ -30,8 +30,7 @@ py::object to_python(AER::DataRDict &&data);
 // Move an DataRDict container object to an existing new Python dict
 void add_to_python(py::dict &pydata, AER::DataRDict &&data);
 
-} //end namespace AerToPy
-
+} // end namespace AerToPy
 
 //============================================================================
 // Implementations
@@ -44,12 +43,32 @@ py::object AerToPy::to_python(AER::DataRDict &&data) {
 }
 
 void AerToPy::add_to_python(py::dict &pydata, AER::DataRDict &&data) {
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::ListData, std::map<std::string, double>, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::ListData, std::map<std::string, double>, 2>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::AccumData, std::map<std::string, double>, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::AccumData, std::map<std::string, double>, 2>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::AverageData, std::map<std::string, double>, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::AverageData, std::map<std::string, double>, 2>&&>(data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::ListData, std::map<std::string, double>, 1>
+                      &&>(data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::ListData, std::map<std::string, double>, 2>
+                      &&>(data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::AccumData, std::map<std::string, double>, 1>
+                      &&>(data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::AccumData, std::map<std::string, double>, 2>
+                      &&>(data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<
+          AER::DataMap<AER::AverageData, std::map<std::string, double>, 1> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<
+          AER::DataMap<AER::AverageData, std::map<std::string, double>, 2> &&>(
+          data));
 }
 
 #endif
diff --git a/src/framework/results/data/mixins/pybind_data_rvalue.hpp b/src/framework/results/data/mixins/pybind_data_rvalue.hpp
old mode 100755
new mode 100644
index 15d9f18469..dfed06ea4c
--- a/src/framework/results/data/mixins/pybind_data_rvalue.hpp
+++ b/src/framework/results/data/mixins/pybind_data_rvalue.hpp
@@ -30,8 +30,7 @@ py::object to_python(AER::DataRValue &&data);
 // Move an DataRValue container object to an existing new Python dict
 void add_to_python(py::dict &pydata, AER::DataRValue &&data);
 
-} //end namespace AerToPy
-
+} // end namespace AerToPy
 
 //============================================================================
 // Implementations
@@ -44,12 +43,18 @@ py::object AerToPy::to_python(AER::DataRValue &&data) {
 }
 
 void AerToPy::add_to_python(py::dict &pydata, AER::DataRValue &&data) {
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::ListData, double, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::ListData, double, 2>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::AccumData, double, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::AccumData, double, 2>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::AverageData, double, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::AverageData, double, 2>&&>(data));
+  AerToPy::add_to_python(
+      pydata, static_cast<AER::DataMap<AER::ListData, double, 1> &&>(data));
+  AerToPy::add_to_python(
+      pydata, static_cast<AER::DataMap<AER::ListData, double, 2> &&>(data));
+  AerToPy::add_to_python(
+      pydata, static_cast<AER::DataMap<AER::AccumData, double, 1> &&>(data));
+  AerToPy::add_to_python(
+      pydata, static_cast<AER::DataMap<AER::AccumData, double, 2> &&>(data));
+  AerToPy::add_to_python(
+      pydata, static_cast<AER::DataMap<AER::AverageData, double, 1> &&>(data));
+  AerToPy::add_to_python(
+      pydata, static_cast<AER::DataMap<AER::AverageData, double, 2> &&>(data));
 }
 
 #endif
diff --git a/src/framework/results/data/mixins/pybind_data_rvector.hpp b/src/framework/results/data/mixins/pybind_data_rvector.hpp
old mode 100755
new mode 100644
index 58ca61ec9d..212bef99bb
--- a/src/framework/results/data/mixins/pybind_data_rvector.hpp
+++ b/src/framework/results/data/mixins/pybind_data_rvector.hpp
@@ -30,8 +30,7 @@ py::object to_python(AER::DataRVector &&data);
 // Move an DataRVector container object to an existing new Python dict
 void add_to_python(py::dict &pydata, AER::DataRVector &&data);
 
-} //end namespace AerToPy
-
+} // end namespace AerToPy
 
 //============================================================================
 // Implementations
@@ -44,12 +43,30 @@ py::object AerToPy::to_python(AER::DataRVector &&data) {
 }
 
 void AerToPy::add_to_python(py::dict &pydata, AER::DataRVector &&data) {
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::ListData, std::vector<double>, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::ListData, std::vector<double>, 2>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::AccumData, std::vector<double>, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::AccumData, std::vector<double>, 2>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::AverageData, std::vector<double>, 1>&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMap<AER::AverageData, std::vector<double>, 2>&&>(data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::ListData, std::vector<double>, 1> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::ListData, std::vector<double>, 2> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::AccumData, std::vector<double>, 1> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::AccumData, std::vector<double>, 2> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::AverageData, std::vector<double>, 1> &&>(
+          data));
+  AerToPy::add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::AverageData, std::vector<double>, 2> &&>(
+          data));
 }
 
 #endif
diff --git a/src/framework/results/data/pybind_data.hpp b/src/framework/results/data/pybind_data.hpp
old mode 100755
new mode 100644
index dcd25fb17f..23b617b4bd
--- a/src/framework/results/data/pybind_data.hpp
+++ b/src/framework/results/data/pybind_data.hpp
@@ -16,40 +16,38 @@
 #define _aer_framework_result_data_pybind_data_hpp_
 
 #include "framework/results/data/data.hpp"
-#include "framework/results/data/mixins/pybind_data_creg.hpp"
-#include "framework/results/data/mixins/pybind_data_rdict.hpp"
-#include "framework/results/data/mixins/pybind_data_rvalue.hpp"
-#include "framework/results/data/mixins/pybind_data_rvector.hpp"
+#include "framework/results/data/mixins/pybind_data_cdict.hpp"
 #include "framework/results/data/mixins/pybind_data_cmatrix.hpp"
+#include "framework/results/data/mixins/pybind_data_creg.hpp"
 #include "framework/results/data/mixins/pybind_data_cvector.hpp"
-#include "framework/results/data/mixins/pybind_data_cdict.hpp"
 #include "framework/results/data/mixins/pybind_data_json.hpp"
 #include "framework/results/data/mixins/pybind_data_mps.hpp"
+#include "framework/results/data/mixins/pybind_data_rdict.hpp"
+#include "framework/results/data/mixins/pybind_data_rvalue.hpp"
+#include "framework/results/data/mixins/pybind_data_rvector.hpp"
 
 namespace AerToPy {
 
 // Move an ExperimentResult data object to a Python dict
 template <> py::object to_python(AER::Data &&data);
 
-} //end namespace AerToPy
-
+} // end namespace AerToPy
 
 //============================================================================
 // Implementations
 //============================================================================
 
-template <>
-py::object AerToPy::to_python(AER::Data &&data) {
+template <> py::object AerToPy::to_python(AER::Data &&data) {
   py::dict pydata;
-  AerToPy::add_to_python(pydata, static_cast<AER::DataRValue&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataRVector&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataRDict&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataCVector&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataCMatrix&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataCDict&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataJSON&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataMPS&&>(data));
-  AerToPy::add_to_python(pydata, static_cast<AER::DataCreg&&>(data));
+  AerToPy::add_to_python(pydata, static_cast<AER::DataRValue &&>(data));
+  AerToPy::add_to_python(pydata, static_cast<AER::DataRVector &&>(data));
+  AerToPy::add_to_python(pydata, static_cast<AER::DataRDict &&>(data));
+  AerToPy::add_to_python(pydata, static_cast<AER::DataCVector &&>(data));
+  AerToPy::add_to_python(pydata, static_cast<AER::DataCMatrix &&>(data));
+  AerToPy::add_to_python(pydata, static_cast<AER::DataCDict &&>(data));
+  AerToPy::add_to_python(pydata, static_cast<AER::DataJSON &&>(data));
+  AerToPy::add_to_python(pydata, static_cast<AER::DataMPS &&>(data));
+  AerToPy::add_to_python(pydata, static_cast<AER::DataCreg &&>(data));
   return std::move(pydata);
 }
 
diff --git a/src/framework/results/data/pybind_metadata.hpp b/src/framework/results/data/pybind_metadata.hpp
old mode 100755
new mode 100644
index 244083d931..24c47a2c45
--- a/src/framework/results/data/pybind_metadata.hpp
+++ b/src/framework/results/data/pybind_metadata.hpp
@@ -23,19 +23,23 @@ namespace AerToPy {
 // Move an ExperimentResult metdata object to a Python dict
 template <> py::object to_python(AER::Metadata &&metadata);
 
-} //end namespace AerToPy
-
+} // end namespace AerToPy
 
 //============================================================================
 // Implementations
 //============================================================================
 
-template <>
-py::object AerToPy::to_python(AER::Metadata &&metadata) {
+template <> py::object AerToPy::to_python(AER::Metadata &&metadata) {
   py::dict pydata;
-  add_to_python(pydata, static_cast<AER::DataMap<AER::SingleData, json_t, 1>&&>(metadata));
-  add_to_python(pydata, static_cast<AER::DataMap<AER::SingleData, json_t, 2>&&>(metadata));
-  add_to_python(pydata, static_cast<AER::DataMap<AER::SingleData, json_t, 3>&&>(metadata));
+  add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::SingleData, json_t, 1> &&>(metadata));
+  add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::SingleData, json_t, 2> &&>(metadata));
+  add_to_python(
+      pydata,
+      static_cast<AER::DataMap<AER::SingleData, json_t, 3> &&>(metadata));
   return std::move(pydata);
 }
 
diff --git a/src/framework/results/data/subtypes/accum_data.hpp b/src/framework/results/data/subtypes/accum_data.hpp
old mode 100755
new mode 100644
index a424f8a107..a53063068b
--- a/src/framework/results/data/subtypes/accum_data.hpp
+++ b/src/framework/results/data/subtypes/accum_data.hpp
@@ -20,18 +20,18 @@
 
 namespace AER {
 
-template <typename T>
-class AccumData : public SingleData<T> {
-using Base = SingleData<T>;
+template <typename T> class AccumData : public SingleData<T> {
+  using Base = SingleData<T>;
+
 public:
   // Add data (copy)
-  void add(const T& data);
+  void add(const T &data);
 
   // Add data (move)
-  void add(T&& data);
+  void add(T &&data);
 
   // Combine data (move)
-  void combine(AccumData<T>&& other);
+  void combine(AccumData<T> &&other);
 
   // Clear all stored data
   void clear();
@@ -44,8 +44,7 @@ using Base = SingleData<T>;
 // Implementation
 //------------------------------------------------------------------------------
 
-template <typename T>
-void AccumData<T>::add(const T& data) {
+template <typename T> void AccumData<T>::add(const T &data) {
   if (empty_) {
     Base::data_ = data;
     empty_ = false;
@@ -54,8 +53,7 @@ void AccumData<T>::add(const T& data) {
   }
 }
 
-template <typename T>
-void AccumData<T>::add(T&& data) {
+template <typename T> void AccumData<T>::add(T &&data) {
   if (empty_) {
     Base::data_ = std::move(data);
     empty_ = false;
@@ -64,18 +62,16 @@ void AccumData<T>::add(T&& data) {
   }
 }
 
-template <typename T>
-void AccumData<T>::combine(AccumData<T>&& other) {
+template <typename T> void AccumData<T>::combine(AccumData<T> &&other) {
   add(std::move(other.data_));
 }
 
-template <typename T>
-void AccumData<T>::clear() {
+template <typename T> void AccumData<T>::clear() {
   Base::clear();
   empty_ = true;
 }
 
 //------------------------------------------------------------------------------
-}  // end namespace AER
+} // end namespace AER
 //------------------------------------------------------------------------------
 #endif
diff --git a/src/framework/results/data/subtypes/average_data.hpp b/src/framework/results/data/subtypes/average_data.hpp
old mode 100755
new mode 100644
index fea9a7c858..ceff37e462
--- a/src/framework/results/data/subtypes/average_data.hpp
+++ b/src/framework/results/data/subtypes/average_data.hpp
@@ -19,21 +19,21 @@
 
 namespace AER {
 
-template <typename T>
-class AverageData : public AccumData<T> {
-using Base = AccumData<T>;
+template <typename T> class AverageData : public AccumData<T> {
+  using Base = AccumData<T>;
+
 public:
   // Access data
-  T& value();
+  T &value();
 
   // Add data (copy)
-  void add(const T& data);
+  void add(const T &data);
 
   // Add data (move)
-  void add(T&& data);
+  void add(T &&data);
 
   // Add data
-  void combine(AverageData<T>&& other);
+  void combine(AverageData<T> &&other);
 
   // Clear all stored data
   void clear();
@@ -57,58 +57,51 @@ using Base = AccumData<T>;
 // Implementation
 //------------------------------------------------------------------------------
 
-template <typename T>
-void AverageData<T>::add(const T& data) {
+template <typename T> void AverageData<T>::add(const T &data) {
   denormalize();
   Base::add(data);
   count_ += 1;
 }
 
-template <typename T>
-void AverageData<T>::add(T&& data) {
+template <typename T> void AverageData<T>::add(T &&data) {
   denormalize();
   Base::add(std::move(data));
   count_ += 1;
 }
 
-template <typename T>
-void AverageData<T>::combine(AverageData<T>&& other) {
+template <typename T> void AverageData<T>::combine(AverageData<T> &&other) {
   denormalize();
   other.denormalize();
   Base::combine(std::move(other));
   count_ += other.count_;
 }
 
-template <typename T>
-void AverageData<T>::clear() {
+template <typename T> void AverageData<T>::clear() {
   Base::clear();
   count_ = 0;
   normalized_ = false;
 }
 
-template <typename T>
-void AverageData<T>::normalize() {
+template <typename T> void AverageData<T>::normalize() {
   if (normalized_)
     return;
   Linalg::idiv(Base::data_, double(count_));
   normalized_ = true;
 }
 
-template <typename T>
-void AverageData<T>::denormalize() {
+template <typename T> void AverageData<T>::denormalize() {
   if (!normalized_)
     return;
   Linalg::imul(Base::data_, double(count_));
   normalized_ = false;
 }
 
-template <typename T>
-T& AverageData<T>::value() {
+template <typename T> T &AverageData<T>::value() {
   normalize();
   return Base::data_;
 }
 
 //------------------------------------------------------------------------------
-}  // end namespace AER
+} // end namespace AER
 //------------------------------------------------------------------------------
 #endif
diff --git a/src/framework/results/data/subtypes/data_map.hpp b/src/framework/results/data/subtypes/data_map.hpp
old mode 100755
new mode 100644
index 7f0d4fb0a6..8edd20f47d
--- a/src/framework/results/data/subtypes/data_map.hpp
+++ b/src/framework/results/data/subtypes/data_map.hpp
@@ -21,27 +21,26 @@
 namespace AER {
 
 // Recursive nested data template class
-template <template <class> class Data, class T, size_t N = 1>
-class DataMap {
+template <template <class> class Data, class T, size_t N = 1> class DataMap {
 public:
   // Access data
-  auto& value() { return data_; }
+  auto &value() { return data_; }
 
   // The following protected functions are designed to be called via
-  // a mixin class that inherits this class. 
+  // a mixin class that inherits this class.
 
   // Add data (copy)
   template <typename... Args,
-            typename = typename std::enable_if<sizeof...(Args) == N-1>::type>
-  void add(const T &data, const std::string &key, const Args &... inner_keys);
+            typename = typename std::enable_if<sizeof...(Args) == N - 1>::type>
+  void add(const T &data, const std::string &key, const Args &...inner_keys);
 
   // Add data (move)
   template <typename... Args,
-            typename = typename std::enable_if<sizeof...(Args) == N-1>::type>
-  void add(T &&data, const std::string &key, const Args &... inner_keys);
+            typename = typename std::enable_if<sizeof...(Args) == N - 1>::type>
+  void add(T &&data, const std::string &key, const Args &...inner_keys);
 
   // Combine with another data object
-  void combine(DataMap<Data, T, N>&& other);
+  void combine(DataMap<Data, T, N> &&other);
 
   // Clear all stored data
   void clear();
@@ -59,13 +58,11 @@ class DataMap {
   stringmap_t<DataMap<Data, T, N - 1>> data_;
 };
 
-
 // Template specialization for N=1 case
-template <template <class> class Data, class T>
-class DataMap<Data, T, 1> {
+template <template <class> class Data, class T> class DataMap<Data, T, 1> {
 public:
   // Access data
-  auto& value() { return data_; }
+  auto &value() { return data_; }
 
   // Add data (copy)
   void add(const T &data, const std::string &key);
@@ -74,7 +71,7 @@ class DataMap<Data, T, 1> {
   void add(T &&data, const std::string &key);
 
   // Combine with another data object
-  void combine(DataMap<Data, T, 1>&& other);
+  void combine(DataMap<Data, T, 1> &&other);
 
   // Clear all stored data
   void clear();
@@ -92,7 +89,6 @@ class DataMap<Data, T, 1> {
   stringmap_t<Data<T>> data_;
 };
 
-
 //------------------------------------------------------------------------------
 // Implementation N
 //------------------------------------------------------------------------------
@@ -100,7 +96,7 @@ class DataMap<Data, T, 1> {
 template <template <class> class Data, class T, size_t N>
 template <typename... Args, typename>
 void DataMap<Data, T, N>::add(const T &data, const std::string &key,
-                              const Args &... inner_keys) {
+                              const Args &...inner_keys) {
   if (enabled) {
     data_[key].add(data, inner_keys...);
   }
@@ -109,17 +105,17 @@ void DataMap<Data, T, N>::add(const T &data, const std::string &key,
 template <template <class> class Data, class T, size_t N>
 template <typename... Args, typename>
 void DataMap<Data, T, N>::add(T &&data, const std::string &key,
-                              const Args &... inner_keys) {
+                              const Args &...inner_keys) {
   if (enabled) {
     data_[key].add(std::move(data), inner_keys...);
   }
 }
 
 template <template <class> class Data, class T, size_t N>
-void DataMap<Data, T, N>::combine(DataMap<Data, T, N>&& other) {
+void DataMap<Data, T, N>::combine(DataMap<Data, T, N> &&other) {
   if (enabled) {
-    for (auto& pair: other.data_) {
-      const auto& key = pair.first;
+    for (auto &pair : other.data_) {
+      const auto &key = pair.first;
       // If empty we copy data without accumulating
       if (data_.find(key) == data_.end()) {
         data_[key] = std::move(pair.second);
@@ -163,7 +159,7 @@ template <template <class> class Data, class T>
 void DataMap<Data, T, 1>::add(const T &data, const std::string &key) {
   if (enabled) {
     data_[key].add(data);
-    }
+  }
 }
 
 template <template <class> class Data, class T>
@@ -173,12 +169,11 @@ void DataMap<Data, T, 1>::add(T &&data, const std::string &key) {
   }
 }
 
-
 template <template <class> class Data, class T>
-void DataMap<Data, T, 1>::combine(DataMap<Data, T, 1>&& other) {
+void DataMap<Data, T, 1>::combine(DataMap<Data, T, 1> &&other) {
   if (enabled) {
-    for (auto& pair: other.data_) {
-      const auto& key = pair.first;
+    for (auto &pair : other.data_) {
+      const auto &key = pair.first;
       // If empty we copy data without accumulating
       if (data_.find(pair.first) == data_.end()) {
         data_[key] = std::move(pair.second);
diff --git a/src/framework/results/data/subtypes/list_data.hpp b/src/framework/results/data/subtypes/list_data.hpp
old mode 100755
new mode 100644
index ec33e63b49..9c709e3a99
--- a/src/framework/results/data/subtypes/list_data.hpp
+++ b/src/framework/results/data/subtypes/list_data.hpp
@@ -21,51 +21,44 @@
 
 namespace AER {
 
-template <typename T>
-class ListData : public SingleData<std::vector<T>> {
-using Base = SingleData<std::vector<T>>;
+template <typename T> class ListData : public SingleData<std::vector<T>> {
+  using Base = SingleData<std::vector<T>>;
+
 public:
   // Add data (copy)
-  void add(const T& data);
+  void add(const T &data);
 
   // Add data (move)
-  void add(T&& data);
+  void add(T &&data);
 
   // Add data
-  void combine(ListData<T>&& other);
+  void combine(ListData<T> &&other);
 
   // Combine with another data object
   void clear();
 };
 
-
 //------------------------------------------------------------------------------
 // Implementation
 //------------------------------------------------------------------------------
 
-template <typename T>
-void ListData<T>::add(const T& data) {
+template <typename T> void ListData<T>::add(const T &data) {
   Base::data_.push_back(data);
 }
 
-template <typename T>
-void ListData<T>::add(T&& data) {
+template <typename T> void ListData<T>::add(T &&data) {
   Base::data_.push_back(std::move(data));
 }
 
-template <typename T>
-void ListData<T>::combine(ListData<T>&& other) {
+template <typename T> void ListData<T>::combine(ListData<T> &&other) {
   Base::data_.insert(Base::data_.end(),
                      std::make_move_iterator(other.data_.begin()),
                      std::make_move_iterator(other.data_.end()));
 }
 
-template <typename T>
-void ListData<T>::clear() {
-  Base::data_.clear();
-}
+template <typename T> void ListData<T>::clear() { Base::data_.clear(); }
 
 //------------------------------------------------------------------------------
-}  // end namespace AER
+} // end namespace AER
 //------------------------------------------------------------------------------
 #endif
diff --git a/src/framework/results/data/subtypes/pybind_data_map.hpp b/src/framework/results/data/subtypes/pybind_data_map.hpp
old mode 100755
new mode 100644
index 460cadc4a9..9fa7f63a09
--- a/src/framework/results/data/subtypes/pybind_data_map.hpp
+++ b/src/framework/results/data/subtypes/pybind_data_map.hpp
@@ -15,8 +15,8 @@
 #ifndef _aer_framework_result_data_pybind_data_map_hpp_
 #define _aer_framework_result_data_pybind_data_map_hpp_
 
-#include "framework/results/data/subtypes/pybind_subtypes.hpp"
 #include "framework/results/data/subtypes/data_map.hpp"
+#include "framework/results/data/subtypes/pybind_subtypes.hpp"
 
 namespace AerToPy {
 
@@ -32,8 +32,7 @@ void add_to_python(py::dict &pydata, AER::DataMap<Data, T, N> &&src);
 template <template <class> class Data, class T>
 void add_to_python(py::dict &pydata, AER::DataMap<Data, T, 1> &&src);
 
-} //end namespace AerToPy
-
+} // end namespace AerToPy
 
 //============================================================================
 // Implementations
@@ -43,7 +42,7 @@ template <template <class> class Data, class T, size_t N>
 py::object AerToPy::to_python(AER::DataMap<Data, T, N> &&src) {
   py::dict pydata;
   if (src.enabled) {
-    for (auto& elt : src.value()) {
+    for (auto &elt : src.value()) {
       pydata[elt.first.data()] = AerToPy::to_python(std::move(elt.second));
     }
   }
@@ -53,11 +52,11 @@ py::object AerToPy::to_python(AER::DataMap<Data, T, N> &&src) {
 template <template <class> class Data, class T, size_t N>
 void AerToPy::add_to_python(py::dict &pydata, AER::DataMap<Data, T, N> &&src) {
   if (src.enabled) {
-    for (auto& elt : src.value()) {
-      auto& key = elt.first;
-      py::dict item = (pydata.contains(key.data())) 
-        ? std::move(pydata[key.data()])
-        : py::dict();
+    for (auto &elt : src.value()) {
+      auto &key = elt.first;
+      py::dict item = (pydata.contains(key.data()))
+                          ? std::move(pydata[key.data()])
+                          : py::dict();
       AerToPy::add_to_python(item, std::move(elt.second));
       pydata[key.data()] = std::move(item);
     }
@@ -67,7 +66,7 @@ void AerToPy::add_to_python(py::dict &pydata, AER::DataMap<Data, T, N> &&src) {
 template <template <class> class Data, class T>
 void AerToPy::add_to_python(py::dict &pydata, AER::DataMap<Data, T, 1> &&src) {
   if (src.enabled) {
-    for (auto& elt : src.value()) {
+    for (auto &elt : src.value()) {
       pydata[elt.first.data()] = AerToPy::to_python(std::move(elt.second));
     }
   }
diff --git a/src/framework/results/data/subtypes/pybind_subtypes.hpp b/src/framework/results/data/subtypes/pybind_subtypes.hpp
old mode 100755
new mode 100644
index 1f8463eb0b..592fecde58
--- a/src/framework/results/data/subtypes/pybind_subtypes.hpp
+++ b/src/framework/results/data/subtypes/pybind_subtypes.hpp
@@ -16,53 +16,44 @@
 #define _aer_framework_result_data_pybind_subtypes_hpp_
 
 #include "framework/pybind_basics.hpp"
-#include "framework/results/data/subtypes/single_data.hpp"
 #include "framework/results/data/subtypes/accum_data.hpp"
 #include "framework/results/data/subtypes/average_data.hpp"
 #include "framework/results/data/subtypes/list_data.hpp"
+#include "framework/results/data/subtypes/single_data.hpp"
 
 namespace AerToPy {
 
 // Move a SingleData object to python
-template <typename T>
-py::object to_python(AER::SingleData<T> &&src);
+template <typename T> py::object to_python(AER::SingleData<T> &&src);
 
 // Move an AccumData object to python
-template <typename T>
-py::object to_python(AER::AccumData<T> &&src);
+template <typename T> py::object to_python(AER::AccumData<T> &&src);
 
 // Move an AverageData object to python
-template <typename T>
-py::object to_python(AER::AverageData<T> &&src);
+template <typename T> py::object to_python(AER::AverageData<T> &&src);
 
 // Move an ListData object to python
-template <typename T>
-py::object to_python(AER::ListData<T> &&src);
-
-} //end namespace AerToPy
+template <typename T> py::object to_python(AER::ListData<T> &&src);
 
+} // end namespace AerToPy
 
 //============================================================================
 // Implementations
 //============================================================================
 
-template <typename T>
-py::object AerToPy::to_python(AER::SingleData<T> &&src) {
+template <typename T> py::object AerToPy::to_python(AER::SingleData<T> &&src) {
   return AerToPy::to_python(std::move(src.value()));
 }
 
-template <typename T>
-py::object AerToPy::to_python(AER::AccumData<T> &&src) {
+template <typename T> py::object AerToPy::to_python(AER::AccumData<T> &&src) {
   return AerToPy::to_python(std::move(src.value()));
 }
 
-template <typename T>
-py::object AerToPy::to_python(AER::AverageData<T> &&src) {
+template <typename T> py::object AerToPy::to_python(AER::AverageData<T> &&src) {
   return AerToPy::to_python(std::move(src.value()));
 }
 
-template <typename T>
-py::object AerToPy::to_python(AER::ListData<T> &&src) {
+template <typename T> py::object AerToPy::to_python(AER::ListData<T> &&src) {
   return AerToPy::to_python(std::move(src.value()));
 }
 
diff --git a/src/framework/results/data/subtypes/single_data.hpp b/src/framework/results/data/subtypes/single_data.hpp
old mode 100755
new mode 100644
index 2bf20edfbb..e08ccaaeb0
--- a/src/framework/results/data/subtypes/single_data.hpp
+++ b/src/framework/results/data/subtypes/single_data.hpp
@@ -19,20 +19,19 @@
 
 namespace AER {
 
-template <typename T>
-class SingleData {
+template <typename T> class SingleData {
 public:
   // Access data
-  T& value() { return data_; }
+  T &value() { return data_; }
 
   // Add data (copy)
-  void add(const T& data);
+  void add(const T &data);
 
   // Add data (move)
-  void add(T&& data);
+  void add(T &&data);
 
   // Combine with another data object
-  void combine(SingleData<T>&& other);
+  void combine(SingleData<T> &&other);
 
   // Clear all stored data
   void clear();
@@ -48,33 +47,24 @@ class SingleData {
 // Implementation
 //------------------------------------------------------------------------------
 
-template <typename T>
-void SingleData<T>::add(const T& data) {
-  data_ = data;
-}
+template <typename T> void SingleData<T>::add(const T &data) { data_ = data; }
 
-template <typename T>
-void SingleData<T>::add(T&& data) {
+template <typename T> void SingleData<T>::add(T &&data) {
   data_ = std::move(data);
 }
 
-template <typename T>
-void SingleData<T>::combine(SingleData<T>&& other) {
+template <typename T> void SingleData<T>::combine(SingleData<T> &&other) {
   data_ = std::move(other.data_);
 }
 
-template <typename T>
-void SingleData<T>::clear() {
-  data_ = T();
-}
+template <typename T> void SingleData<T>::clear() { data_ = T(); }
 
-template <typename T>
-json_t SingleData<T>::to_json() {
+template <typename T> json_t SingleData<T>::to_json() {
   json_t jsdata = value();
   return jsdata;
 }
 
 //------------------------------------------------------------------------------
-}  // end namespace AER
+} // end namespace AER
 //------------------------------------------------------------------------------
 #endif
diff --git a/src/framework/results/experiment_result.hpp b/src/framework/results/experiment_result.hpp
index 86d1671918..f36f5d4cea 100644
--- a/src/framework/results/experiment_result.hpp
+++ b/src/framework/results/experiment_result.hpp
@@ -15,11 +15,11 @@
 #ifndef _aer_framework_results_experiment_result_hpp_
 #define _aer_framework_results_experiment_result_hpp_
 
-#include "framework/results/legacy/snapshot_data.hpp"
-#include "framework/results/data/data.hpp"
-#include "framework/results/data/metadata.hpp"
 #include "framework/creg.hpp"
 #include "framework/opset.hpp"
+#include "framework/results/data/data.hpp"
+#include "framework/results/data/metadata.hpp"
+#include "framework/results/legacy/snapshot_data.hpp"
 
 namespace AER {
 
@@ -32,9 +32,8 @@ struct ExperimentResult {
   using DataSubType = Operations::DataSubType;
 
 public:
-
-  // Status 
-  enum class Status {empty, completed, error};
+  // Status
+  enum class Status { empty, completed, error };
 
   // Experiment data
   Data data;
@@ -58,54 +57,54 @@ struct ExperimentResult {
   void set_config(const json_t &config);
 
   // Combine stored data
-  ExperimentResult& combine(ExperimentResult &&other);
+  ExperimentResult &combine(ExperimentResult &&other);
 
-  //save creg as count data 
-  void save_count_data(const ClassicalRegister& creg, bool save_memory);
-  void save_count_data(const std::vector<ClassicalRegister>& cregs, bool save_memory);
+  // save creg as count data
+  void save_count_data(const ClassicalRegister &creg, bool save_memory);
+  void save_count_data(const std::vector<ClassicalRegister> &cregs,
+                       bool save_memory);
 
   // Save data type which can be averaged over all shots.
-  // This supports DataSubTypes: list, c_list, accum, c_accum, average, c_average
+  // This supports DataSubTypes: list, c_list, accum, c_accum, average,
+  // c_average
   template <class T>
-  void save_data_average(const ClassicalRegister& creg,
-                         const std::string &key, const T& datum, OpType type,
+  void save_data_average(const ClassicalRegister &creg, const std::string &key,
+                         const T &datum, OpType type,
                          DataSubType subtype = DataSubType::average);
 
   template <class T>
-  void save_data_average(const ClassicalRegister& creg,
-                         const std::string &key, T&& datum, OpType type,
+  void save_data_average(const ClassicalRegister &creg, const std::string &key,
+                         T &&datum, OpType type,
                          DataSubType subtype = DataSubType::average);
 
   // Save single shot data type. Typically this will be the value for the
   // last shot of the simulation
   template <class T>
-  void save_data_single(const ClassicalRegister& creg,
-                        const std::string &key, const T& datum, OpType type);
+  void save_data_single(const ClassicalRegister &creg, const std::string &key,
+                        const T &datum, OpType type);
 
   template <class T>
-  void save_data_single(const ClassicalRegister& creg,
-                        const std::string &key, T&& datum, OpType type);
+  void save_data_single(const ClassicalRegister &creg, const std::string &key,
+                        T &&datum, OpType type);
 
   // Save data type which is pershot and does not support accumulator or average
   // This supports DataSubTypes: single, c_single, list, c_list
   template <class T>
-  void save_data_pershot(const ClassicalRegister& creg,
-                         const std::string &key, const T& datum, OpType type,
+  void save_data_pershot(const ClassicalRegister &creg, const std::string &key,
+                         const T &datum, OpType type,
                          DataSubType subtype = DataSubType::list);
 
   template <class T>
-  void save_data_pershot(const ClassicalRegister& creg,
-                         const std::string &key, T&& datum, OpType type,
+  void save_data_pershot(const ClassicalRegister &creg, const std::string &key,
+                         T &&datum, OpType type,
                          DataSubType subtype = DataSubType::list);
-
-
- };
+};
 
 //------------------------------------------------------------------------------
 // Implementation
 //------------------------------------------------------------------------------
 
-ExperimentResult& ExperimentResult::combine(ExperimentResult &&other) {
+ExperimentResult &ExperimentResult::combine(ExperimentResult &&other) {
   legacy_data.combine(std::move(other.legacy_data));
   data.combine(std::move(other.data));
   metadata.combine(std::move(other.metadata));
@@ -128,14 +127,14 @@ json_t ExperimentResult::to_json() {
   result["seed_simulator"] = seed;
   result["success"] = (status == Status::completed);
   switch (status) {
-    case Status::completed:
-      result["status"] = std::string("DONE");
-      break;
-    case Status::error:
-      result["status"] = std::string("ERROR: ") + message;
-      break;
-    case Status::empty:
-      result["status"] = std::string("EMPTY");
+  case Status::completed:
+    result["status"] = std::string("DONE");
+    break;
+  case Status::error:
+    result["status"] = std::string("ERROR: ") + message;
+    break;
+  case Status::empty:
+    result["status"] = std::string("EMPTY");
   }
   result["time_taken"] = time_taken;
   if (header.empty() == false)
@@ -144,88 +143,89 @@ json_t ExperimentResult::to_json() {
   return result;
 }
 
-void ExperimentResult::save_count_data(const ClassicalRegister& creg, bool save_memory) {
+void ExperimentResult::save_count_data(const ClassicalRegister &creg,
+                                       bool save_memory) {
   if (creg.memory_size() > 0) {
     std::string memory_hex = creg.memory_hex();
     data.add_accum(static_cast<uint_t>(1ULL), "counts", memory_hex);
-    if(save_memory) {
+    if (save_memory) {
       data.add_list(std::move(memory_hex), "memory");
     }
   }
 }
 
-void ExperimentResult::save_count_data(const std::vector<ClassicalRegister>& cregs, bool save_memory) {
-  for(int_t i=0;i<cregs.size();i++)
+void ExperimentResult::save_count_data(
+    const std::vector<ClassicalRegister> &cregs, bool save_memory) {
+  for (int_t i = 0; i < cregs.size(); i++)
     save_count_data(cregs[i], save_memory);
 }
 
 template <class T>
-void ExperimentResult::save_data_average(const ClassicalRegister& creg,
-                                         const std::string &key,
-                                         const T& datum, OpType type,
-                                         DataSubType subtype) {
+void ExperimentResult::save_data_average(const ClassicalRegister &creg,
+                                         const std::string &key, const T &datum,
+                                         OpType type, DataSubType subtype) {
   switch (subtype) {
-    case DataSubType::list:
-      data.add_list(datum, key);
-      break;
-    case DataSubType::c_list:
-      data.add_list(datum, key, creg.memory_hex());
-      break;
-    case DataSubType::accum:
-      data.add_accum(datum, key);
-      break;
-    case DataSubType::c_accum:
-      data.add_accum(datum, key, creg.memory_hex());
-      break;
-    case DataSubType::average:
-      data.add_average(datum, key);
-      break;
-    case DataSubType::c_average:
-      data.add_average(datum, key, creg.memory_hex());
-      break;
-    default:
-      throw std::runtime_error("Invalid average data subtype for data key: " + key);
+  case DataSubType::list:
+    data.add_list(datum, key);
+    break;
+  case DataSubType::c_list:
+    data.add_list(datum, key, creg.memory_hex());
+    break;
+  case DataSubType::accum:
+    data.add_accum(datum, key);
+    break;
+  case DataSubType::c_accum:
+    data.add_accum(datum, key, creg.memory_hex());
+    break;
+  case DataSubType::average:
+    data.add_average(datum, key);
+    break;
+  case DataSubType::c_average:
+    data.add_average(datum, key, creg.memory_hex());
+    break;
+  default:
+    throw std::runtime_error("Invalid average data subtype for data key: " +
+                             key);
   }
   metadata.add(type, "result_types", key);
   metadata.add(subtype, "result_subtypes", key);
 }
 
 template <class T>
-void ExperimentResult::save_data_average(const ClassicalRegister& creg,
-                                         const std::string &key,
-                                         T&& datum, OpType type,
-                                         DataSubType subtype) {
+void ExperimentResult::save_data_average(const ClassicalRegister &creg,
+                                         const std::string &key, T &&datum,
+                                         OpType type, DataSubType subtype) {
   switch (subtype) {
-    case DataSubType::list:
-      data.add_list(std::move(datum), key);
-      break;
-    case DataSubType::c_list:
-      data.add_list(std::move(datum), key, creg.memory_hex());
-      break;
-    case DataSubType::accum:
-      data.add_accum(std::move(datum), key);
-      break;
-    case DataSubType::c_accum:
-      data.add_accum(std::move(datum), key, creg.memory_hex());
-      break;
-    case DataSubType::average:
-      data.add_average(std::move(datum), key);
-      break;
-    case DataSubType::c_average:
-      data.add_average(std::move(datum), key, creg.memory_hex());
-      break;
-    default:
-      throw std::runtime_error("Invalid average data subtype for data key: " + key);
+  case DataSubType::list:
+    data.add_list(std::move(datum), key);
+    break;
+  case DataSubType::c_list:
+    data.add_list(std::move(datum), key, creg.memory_hex());
+    break;
+  case DataSubType::accum:
+    data.add_accum(std::move(datum), key);
+    break;
+  case DataSubType::c_accum:
+    data.add_accum(std::move(datum), key, creg.memory_hex());
+    break;
+  case DataSubType::average:
+    data.add_average(std::move(datum), key);
+    break;
+  case DataSubType::c_average:
+    data.add_average(std::move(datum), key, creg.memory_hex());
+    break;
+  default:
+    throw std::runtime_error("Invalid average data subtype for data key: " +
+                             key);
   }
   metadata.add(type, "result_types", key);
   metadata.add(subtype, "result_subtypes", key);
 }
 
 template <class T>
-void ExperimentResult::save_data_pershot(const ClassicalRegister& creg,
-                                       const std::string &key,
-                                       const T& datum, OpType type,
-                                       DataSubType subtype) {
+void ExperimentResult::save_data_pershot(const ClassicalRegister &creg,
+                                         const std::string &key, const T &datum,
+                                         OpType type, DataSubType subtype) {
   switch (subtype) {
   case DataSubType::single:
     data.add_single(datum, key);
@@ -240,57 +240,56 @@ void ExperimentResult::save_data_pershot(const ClassicalRegister& creg,
     data.add_list(datum, key, creg.memory_hex());
     break;
   default:
-    throw std::runtime_error("Invalid pershot data subtype for data key: " + key);
+    throw std::runtime_error("Invalid pershot data subtype for data key: " +
+                             key);
   }
   metadata.add(type, "result_types", key);
   metadata.add(subtype, "result_subtypes", key);
 }
 
 template <class T>
-void ExperimentResult::save_data_pershot(const ClassicalRegister& creg, 
-                                         const std::string &key,
-                                         T&& datum, OpType type,
-                                         DataSubType subtype) {
+void ExperimentResult::save_data_pershot(const ClassicalRegister &creg,
+                                         const std::string &key, T &&datum,
+                                         OpType type, DataSubType subtype) {
   switch (subtype) {
-    case DataSubType::single:
-      data.add_single(std::move(datum), key);
-      break;
-    case DataSubType::c_single:
-      data.add_single(std::move(datum), key, creg.memory_hex());
-      break;
-    case DataSubType::list:
-      data.add_list(std::move(datum), key);
-      break;
-    case DataSubType::c_list:
-      data.add_list(std::move(datum), key, creg.memory_hex());
-      break;
-    default:
-      throw std::runtime_error("Invalid pershot data subtype for data key: " + key);
+  case DataSubType::single:
+    data.add_single(std::move(datum), key);
+    break;
+  case DataSubType::c_single:
+    data.add_single(std::move(datum), key, creg.memory_hex());
+    break;
+  case DataSubType::list:
+    data.add_list(std::move(datum), key);
+    break;
+  case DataSubType::c_list:
+    data.add_list(std::move(datum), key, creg.memory_hex());
+    break;
+  default:
+    throw std::runtime_error("Invalid pershot data subtype for data key: " +
+                             key);
   }
   metadata.add(type, "result_types", key);
   metadata.add(subtype, "result_subtypes", key);
 }
 
 template <class T>
-void ExperimentResult::save_data_single(const ClassicalRegister& creg,
-                                        const std::string &key,
-                                        const T& datum, OpType type) {
+void ExperimentResult::save_data_single(const ClassicalRegister &creg,
+                                        const std::string &key, const T &datum,
+                                        OpType type) {
   data.add_single(datum, key);
   metadata.add(type, "result_types", key);
   metadata.add(DataSubType::single, "result_subtypes", key);
 }
 
 template <class T>
-void ExperimentResult::save_data_single(const ClassicalRegister& creg,
-                                        const std::string &key,
-                                        T&& datum, OpType type) {
+void ExperimentResult::save_data_single(const ClassicalRegister &creg,
+                                        const std::string &key, T &&datum,
+                                        OpType type) {
   data.add_single(std::move(datum), key);
   metadata.add(type, "result_types", key);
   metadata.add(DataSubType::single, "result_subtypes", key);
 }
 
-
-
 //------------------------------------------------------------------------------
 } // end namespace AER
 //------------------------------------------------------------------------------
diff --git a/src/framework/results/legacy/average_data.hpp b/src/framework/results/legacy/average_data.hpp
old mode 100755
new mode 100644
index 87333bf689..ca2abfafaa
--- a/src/framework/results/legacy/average_data.hpp
+++ b/src/framework/results/legacy/average_data.hpp
@@ -21,18 +21,17 @@
 
 namespace AER {
 
-template <typename T>
-class LegacyAverageData {
- public:
+template <typename T> class LegacyAverageData {
+public:
   // Return the mean of the accumulated data:
   // mean = accum / count
   // Calling this method normalizes the data and returns a reference
-  T& mean();
+  T &mean();
 
   // Return the unbiased sample variance of the accumulated data:
   // var = (1 / (n - 1)) * (sum_i (data[i]^2 / n) - mean^2) for n > 1
   // Calling this method normalizes the data and returns a reference
-  T& variance();
+  T &variance();
 
   // Add a new datum to the snapshot at the specified key
   // Uses copy semantics
@@ -77,11 +76,11 @@ class LegacyAverageData {
   void normalize();
 
   // Convert container to JSON
-  // note that this method is not const Once it is converted it will 
+  // note that this method is not const Once it is converted it will
   // renormalized the data to compute the mean and variance
   json_t to_json();
 
- protected:
+protected:
   // Accumulated data
   T accum_;
 
@@ -103,21 +102,21 @@ class LegacyAverageData {
 //------------------------------------------------------------------------------
 // Implementation
 //------------------------------------------------------------------------------
-template <typename T>
-void LegacyAverageData<T>::normalize() {
+template <typename T> void LegacyAverageData<T>::normalize() {
   if (!normalized_ && count_ >= 1) {
     if (count_ > 1) {
       // Compute mean
       Linalg::idiv(accum_, double(count_));
       // Compute variance
       if (variance_) {
-        // var = (count / (count - 1)) * (accum_squared ** 2 / count - mean ** 2) for
-        // n > 1
-        Linalg::idiv(accum_squared_, double(count_));      // squared mean
-        Linalg::isub(accum_squared_, Linalg::square(accum_)); // squared mean - mean squared
+        // var = (count / (count - 1)) * (accum_squared ** 2 / count - mean **
+        // 2) for n > 1
+        Linalg::idiv(accum_squared_, double(count_)); // squared mean
+        Linalg::isub(accum_squared_,
+                     Linalg::square(accum_)); // squared mean - mean squared
         // Apply sample bias correction of counts / (counts - 1)
         Linalg::imul(accum_squared_, double(count_) / double(count_ - 1));
-      } 
+      }
     } else if (count_ == 1 && variance_) {
       Linalg::imul(accum_squared_, 0);
     }
@@ -125,14 +124,12 @@ void LegacyAverageData<T>::normalize() {
   }
 }
 
-template <typename T>
-T& LegacyAverageData<T>::mean() {
+template <typename T> T &LegacyAverageData<T>::mean() {
   normalize();
   return accum_;
 }
 
-template <typename T>
-T& LegacyAverageData<T>::variance() {
+template <typename T> T &LegacyAverageData<T>::variance() {
   normalize();
   return accum_squared_;
 }
@@ -185,8 +182,7 @@ void LegacyAverageData<T>::combine(LegacyAverageData<T> &&other) noexcept {
   other.clear();
 }
 
-template <typename T>
-void LegacyAverageData<T>::clear() {
+template <typename T> void LegacyAverageData<T>::clear() {
   // Clear stored data using default constructor of data type
   accum_ = T();
   accum_squared_ = T();
@@ -235,8 +231,7 @@ void LegacyAverageData<T>::add_data(T &&datum, bool compute_variance) noexcept {
   count_ += 1;
 }
 
-template <typename T>
-json_t LegacyAverageData<T>::to_json() {
+template <typename T> json_t LegacyAverageData<T>::to_json() {
   json_t js = json_t::object();
   js["value"] = mean();
   if (variance_) {
@@ -246,6 +241,6 @@ json_t LegacyAverageData<T>::to_json() {
 }
 
 //------------------------------------------------------------------------------
-}  // end namespace AER
+} // end namespace AER
 //------------------------------------------------------------------------------
 #endif
diff --git a/src/framework/results/legacy/average_snapshot.hpp b/src/framework/results/legacy/average_snapshot.hpp
old mode 100755
new mode 100644
index 84d93c3445..869631b5e1
--- a/src/framework/results/legacy/average_snapshot.hpp
+++ b/src/framework/results/legacy/average_snapshot.hpp
@@ -25,20 +25,19 @@ namespace AER {
 // Average Snapshot data storage class
 //------------------------------------------------------------------------------
 
-template <typename T>
-class AverageSnapshot {
+template <typename T> class AverageSnapshot {
   // Inner snapshot data map type
 
- public:
+public:
   // Add a new datum to the snapshot at the specified key
   // Uses copy semantics
   void add_data(const std::string &key, const std::string &memory,
                 const T &datum, bool variance = false);
-  
+
   // Add a new datum to the snapshot at the specified key
   // Uses move semantics
-  void add_data(const std::string &key, const std::string &memory,
-                T &&datum, bool variance = false) noexcept;
+  void add_data(const std::string &key, const std::string &memory, T &&datum,
+                bool variance = false) noexcept;
 
   // Combine with another average snapshot container
   // Uses copy semantics
@@ -64,9 +63,11 @@ class AverageSnapshot {
   stringmap_t<stringmap_t<LegacyAverageData<T>>> &data() { return data_; }
 
   // Return const data reference
-  const stringmap_t<stringmap_t<LegacyAverageData<T>>> &data() const { return data_; }
+  const stringmap_t<stringmap_t<LegacyAverageData<T>>> &data() const {
+    return data_;
+  }
 
- protected:
+protected:
   // Internal Storage
   // Outer map key is the snapshot label string
   // Inner map key is the memory value string
@@ -108,19 +109,19 @@ void AverageSnapshot<T>::combine(AverageSnapshot<T> &&other) noexcept {
     }
   }
   // Clear moved snapshot
-  other.clear();  
+  other.clear();
 }
 
-template <typename T>
-json_t AverageSnapshot<T>::to_json() {
+template <typename T> json_t AverageSnapshot<T>::to_json() {
   json_t js = json_t::object();
   for (auto &outer_pair : data_) {
     for (auto &inner_pair : outer_pair.second) {
       // Store mean and variance for snapshot
       json_t datum = inner_pair.second.to_json();
       // Add memory key if there are classical registers
-      auto& memory = inner_pair.first;
-      if (!memory.empty()) datum["memory"] = memory;
+      auto &memory = inner_pair.first;
+      if (!memory.empty())
+        datum["memory"] = memory;
       // Add to list of output
       js[outer_pair.first].emplace_back(std::move(datum));
     }
@@ -129,6 +130,6 @@ json_t AverageSnapshot<T>::to_json() {
 }
 
 //------------------------------------------------------------------------------
-}  // end namespace AER
+} // end namespace AER
 //------------------------------------------------------------------------------
 #endif
diff --git a/src/framework/results/legacy/data_container.hpp b/src/framework/results/legacy/data_container.hpp
old mode 100755
new mode 100644
index c5054ad859..a23e64aa01
--- a/src/framework/results/legacy/data_container.hpp
+++ b/src/framework/results/legacy/data_container.hpp
@@ -26,46 +26,36 @@ namespace AER {
 // DEPRECATED DataContainer Data class for Qiskit-Aer
 //============================================================================
 
-
-template <typename T>
-class DataContainer {
+template <typename T> class DataContainer {
 public:
-
   //----------------------------------------------------------------
   // Snapshot data
   //----------------------------------------------------------------
-  
+
   // Pershot snapshot
-  void add_pershot_snapshot(const std::string &type,
-                            const std::string &label,
+  void add_pershot_snapshot(const std::string &type, const std::string &label,
                             T &&datum);
-  void add_pershot_snapshot(const std::string &type,
-                            const std::string &label,
+  void add_pershot_snapshot(const std::string &type, const std::string &label,
                             T &datum);
-  void add_pershot_snapshot(const std::string &type,
-                            const std::string &label,
+  void add_pershot_snapshot(const std::string &type, const std::string &label,
                             const T &datum);
 
   // Average snapshot
-  void add_average_snapshot(const std::string &type,
-                            const std::string &label,
-                            const std::string &memory,
-                            T &&datum, bool variance);
-  void add_average_snapshot(const std::string &type,
-                            const std::string &label,
-                            const std::string &memory,
-                            T &datum, bool variance);
-  void add_average_snapshot(const std::string &type,
-                            const std::string &label,
-                            const std::string &memory,
-                            const T &datum, bool variance);
+  void add_average_snapshot(const std::string &type, const std::string &label,
+                            const std::string &memory, T &&datum,
+                            bool variance);
+  void add_average_snapshot(const std::string &type, const std::string &label,
+                            const std::string &memory, T &datum, bool variance);
+  void add_average_snapshot(const std::string &type, const std::string &label,
+                            const std::string &memory, const T &datum,
+                            bool variance);
 
   //----------------------------------------------------------------
   // Config
   //----------------------------------------------------------------
 
   // Enable data container
-  void enable(bool value) {enabled_ = value;}
+  void enable(bool value) { enabled_ = value; }
 
   // Empty engine of stored data
   void clear();
@@ -76,7 +66,7 @@ class DataContainer {
   // Combine engines for accumulating data
   // Second engine should no longer be used after combining
   // as this function should use move semantics to minimize copying
-  DataContainer<T> &combine(DataContainer<T> &&eng); // Move semantics
+  DataContainer<T> &combine(DataContainer<T> &&eng);      // Move semantics
   DataContainer<T> &combine(const DataContainer<T> &eng); // Copy semantics
 
   // Operator overload for combine
@@ -147,15 +137,16 @@ void DataContainer<T>::add_average_snapshot(const std::string &type,
                                             const std::string &memory,
                                             T &&datum, bool variance) {
   if (enabled_) {
-    average_snapshots_[type].add_data(label, memory, std::move(datum), variance);
+    average_snapshots_[type].add_data(label, memory, std::move(datum),
+                                      variance);
   }
 }
 
 template <typename T>
 void DataContainer<T>::add_average_snapshot(const std::string &type,
-                                         const std::string &label,
-                                         const std::string &memory,
-                                         const T &datum, bool variance) {
+                                            const std::string &label,
+                                            const std::string &memory,
+                                            const T &datum, bool variance) {
   if (enabled_) {
     average_snapshots_[type].add_data(label, memory, datum, variance);
   }
@@ -164,8 +155,8 @@ void DataContainer<T>::add_average_snapshot(const std::string &type,
 template <typename T>
 void DataContainer<T>::add_average_snapshot(const std::string &type,
                                             const std::string &label,
-                                            const std::string &memory,
-                                            T &datum, bool variance) {
+                                            const std::string &memory, T &datum,
+                                            bool variance) {
   if (enabled_) {
     average_snapshots_[type].add_data(label, memory, datum, variance);
   }
@@ -175,8 +166,7 @@ void DataContainer<T>::add_average_snapshot(const std::string &type,
 // Clear
 //------------------------------------------------------------------
 
-template <typename T>
-void DataContainer<T>::clear() {
+template <typename T> void DataContainer<T>::clear() {
   average_snapshots_.clear();
   pershot_snapshots_.clear();
 }
@@ -224,8 +214,7 @@ DataContainer<T> &DataContainer<T>::combine(DataContainer<T> &&other) {
 // JSON Serlialization
 //============================================================================
 
-template <typename T>
-void DataContainer<T>::add_to_json(json_t &js) {
+template <typename T> void DataContainer<T>::add_to_json(json_t &js) {
   // Add data to json
   // Note other data types may also be adding to same
   // JSON so we should not re-initialize it
@@ -244,6 +233,6 @@ void DataContainer<T>::add_to_json(json_t &js) {
 }
 
 //------------------------------------------------------------------------------
-}  // end namespace AER
+} // end namespace AER
 //------------------------------------------------------------------------------
 #endif
diff --git a/src/framework/results/legacy/pershot_data.hpp b/src/framework/results/legacy/pershot_data.hpp
old mode 100755
new mode 100644
index 847794f7e5..6b0a69f405
--- a/src/framework/results/legacy/pershot_data.hpp
+++ b/src/framework/results/legacy/pershot_data.hpp
@@ -20,31 +20,29 @@
 
 namespace AER {
 
-template <typename T>
-class PershotData {
- public:
-
+template <typename T> class PershotData {
+public:
   // Add a new shot of data by appending to data vector
   // Uses copy semantics
-  void add_data(const T& datum) { data_.push_back(datum); }
+  void add_data(const T &datum) { data_.push_back(datum); }
 
   // Add a new shot of data by appending to data vector
   // Uses move semantics
-  void add_data(T&& datum) noexcept { data_.push_back(std::move(datum)); }
+  void add_data(T &&datum) noexcept { data_.push_back(std::move(datum)); }
 
   // Combine with another pershot data by concatinating
   // Uses copy semantics
-  void combine(const PershotData<T>& other);
+  void combine(const PershotData<T> &other);
 
   // Combine with another pershot data by concatinating
   // Uses move semantics
-  void combine(PershotData<T>&& other) noexcept;
+  void combine(PershotData<T> &&other) noexcept;
 
   // Access data
-  std::vector<T>& data() { return data_; }
+  std::vector<T> &data() { return data_; }
 
   // Const access data
-  const std::vector<T>& data() const { return data_; }
+  const std::vector<T> &data() const { return data_; }
 
   // Get number of datum accumulated
   size_t size() const { return data_.size(); }
@@ -60,7 +58,7 @@ class PershotData {
   // Convert to JSON
   json_t to_json();
 
- protected:
+protected:
   // Internal Storage
   std::vector<T> data_;
 };
@@ -70,26 +68,25 @@ class PershotData {
 //------------------------------------------------------------------------------
 
 template <typename T>
-void PershotData<T>::combine(const PershotData<T>& other) {
+void PershotData<T>::combine(const PershotData<T> &other) {
   // Copy data from other container
   data_.reserve(data_.size() + other.data_.size());
   data_.insert(data_.end(), other.data_.begin(), other.data_.end());
 }
 
 template <typename T>
-void PershotData<T>::combine(PershotData<T>&& other) noexcept {
+void PershotData<T>::combine(PershotData<T> &&other) noexcept {
   // Move data from other container
   data_.insert(data_.end(), std::make_move_iterator(other.data_.begin()),
                std::make_move_iterator(other.data_.end()));
 }
 
-template <typename T>
-json_t PershotData<T>::to_json() {
+template <typename T> json_t PershotData<T>::to_json() {
   json_t js = data_;
   return js;
 }
 
 //------------------------------------------------------------------------------
-}  // end namespace AER
+} // end namespace AER
 //------------------------------------------------------------------------------
 #endif
diff --git a/src/framework/results/legacy/pershot_snapshot.hpp b/src/framework/results/legacy/pershot_snapshot.hpp
old mode 100755
new mode 100644
index e48a0e0f08..e3c2cbbb88
--- a/src/framework/results/legacy/pershot_snapshot.hpp
+++ b/src/framework/results/legacy/pershot_snapshot.hpp
@@ -25,11 +25,10 @@ namespace AER {
 // Pershot Snapshot data storage class
 //------------------------------------------------------------------------------
 
-template <typename T>
-class PershotSnapshot {
+template <typename T> class PershotSnapshot {
   // Inner snapshot data map type
 
- public:
+public:
   // Add a new datum to the snapshot at the specified key
   // Uses copy semantics
   void add_data(const std::string &key, const T &datum);
@@ -64,7 +63,7 @@ class PershotSnapshot {
   // Return const data reference
   const stringmap_t<PershotData<T>> &data() const { return data_; }
 
- private:
+private:
   // Internal Storage
   // Map key is the snapshot label string
   stringmap_t<PershotData<T>> data_;
@@ -100,8 +99,7 @@ void PershotSnapshot<T>::combine(PershotSnapshot<T> &&other) noexcept {
   other.clear();
 }
 
-template <typename T>
-json_t PershotSnapshot<T>::to_json() {
+template <typename T> json_t PershotSnapshot<T>::to_json() {
   json_t js = json_t::object();
   for (auto &pair : data_) {
     js[pair.first] = pair.second.to_json();
@@ -110,6 +108,6 @@ json_t PershotSnapshot<T>::to_json() {
 }
 
 //------------------------------------------------------------------------------
-}  // end namespace AER
+} // end namespace AER
 //------------------------------------------------------------------------------
 #endif
diff --git a/src/framework/results/legacy/pybind_data.hpp b/src/framework/results/legacy/pybind_data.hpp
old mode 100755
new mode 100644
index 8d451d5b98..30e3f9cd6f
--- a/src/framework/results/legacy/pybind_data.hpp
+++ b/src/framework/results/legacy/pybind_data.hpp
@@ -29,34 +29,32 @@ namespace AerToPy {
  * @param avg_data is an LegacyAverageData
  * @returns a py::dict
  */
-template<typename T>
+template <typename T>
 py::object from_avg_data(AER::LegacyAverageData<T> &&avg_data);
-template<typename T>
+template <typename T>
 py::object from_avg_data(AER::LegacyAverageData<T> &avg_data);
 
 // JSON specialization
-template<>
-py::object from_avg_data(AER::LegacyAverageData<json_t> &&avg_data);
+template <> py::object from_avg_data(AER::LegacyAverageData<json_t> &&avg_data);
 
 /**
  * Convert a LegacyAverageData to a python object
  * @param avg_data is an LegacyAverageData
  * @returns a py::dict
  */
-template<typename T>
+template <typename T>
 py::object from_avg_data(AER::LegacyAverageData<matrix<T>> &&avg_data);
-template<typename T>
+template <typename T>
 py::object from_avg_data(AER::LegacyAverageData<matrix<T>> &avg_data);
 
-
 /**
  * Convert a LegacyAverageData to a python object
  * @param avg_data is an LegacyAverageData
  * @returns a py::dict
  */
-template<typename T>
+template <typename T>
 py::object from_avg_data(AER::LegacyAverageData<AER::Vector<T>> &&avg_data);
-template<typename T>
+template <typename T>
 py::object from_avg_data(AER::LegacyAverageData<AER::Vector<T>> &avg_data);
 
 /**
@@ -64,9 +62,9 @@ py::object from_avg_data(AER::LegacyAverageData<AER::Vector<T>> &avg_data);
  * @param avg_data is an LegacyAverageData
  * @returns a py::dict
  */
-template<typename T>
+template <typename T>
 py::object from_avg_data(AER::LegacyAverageData<std::vector<T>> &&avg_data);
-template<typename T>
+template <typename T>
 py::object from_avg_data(AER::LegacyAverageData<std::vector<T>> &avg_data);
 
 /**
@@ -74,19 +72,19 @@ py::object from_avg_data(AER::LegacyAverageData<std::vector<T>> &avg_data);
  * @param avg_snap is an AverageSnapshot
  * @returns a py::dict
  */
-template<typename T>
+template <typename T>
 py::object from_avg_snap(AER::AverageSnapshot<T> &&avg_snap);
-template<typename T>
+template <typename T>
 py::object from_avg_snap(AER::AverageSnapshot<T> &avg_snap);
 
 /**
  * Convert a PershotSnapshot  to a python object
- * @param avg_snap is an PershotSnapshot 
+ * @param avg_snap is an PershotSnapshot
  * @returns a py::dict
  */
-template<typename T>
+template <typename T>
 py::object from_pershot_snap(AER::PershotSnapshot<T> &&snap);
-template<typename T>
+template <typename T>
 py::object from_pershot_snap(AER::PershotSnapshot<T> &snap);
 
 /**
@@ -94,34 +92,30 @@ py::object from_pershot_snap(AER::PershotSnapshot<T> &snap);
  * @param data is an PershotData
  * @returns a py::dict
  */
-template<typename T>
-py::object from_pershot_data(AER::PershotData<T> &&data);
-template<typename T>
-py::object from_pershot_data(AER::PershotData<T> &data);
+template <typename T> py::object from_pershot_data(AER::PershotData<T> &&data);
+template <typename T> py::object from_pershot_data(AER::PershotData<T> &data);
 
 // JSON specialization
-template<>
-py::object from_pershot_data(AER::PershotData<json_t> &&avg_data);
+template <> py::object from_pershot_data(AER::PershotData<json_t> &&avg_data);
 
 /**
  * Convert a PershotData to a python object
  * @param data is an PershotData
  * @returns a py::dict
  */
-template<typename T>
+template <typename T>
 py::object from_pershot_data(AER::PershotData<matrix<T>> &&data);
-template<typename T>
+template <typename T>
 py::object from_pershot_data(AER::PershotData<matrix<T>> &data);
 
-
 /**
  * Convert a PershotData to a python object
  * @param data is an PershotData
  * @returns a py::dict
  */
-template<typename T>
+template <typename T>
 py::object from_pershot_data(AER::PershotData<AER::Vector<T>> &&data);
-template<typename T>
+template <typename T>
 py::object from_pershot_data(AER::PershotData<AER::Vector<T>> &data);
 
 /**
@@ -129,9 +123,9 @@ py::object from_pershot_data(AER::PershotData<AER::Vector<T>> &data);
  * @param data is an PershotData
  * @returns a py::dict
  */
-template<typename T>
+template <typename T>
 py::object from_pershot_data(AER::PershotData<std::vector<T>> &&data);
-template<typename T>
+template <typename T>
 py::object from_pershot_data(AER::PershotData<std::vector<T>> &data);
 
 /**
@@ -142,8 +136,7 @@ py::object from_pershot_data(AER::PershotData<std::vector<T>> &data);
 py::dict from_snapshot(AER::SnapshotData &&result);
 py::dict from_snapshot(AER::SnapshotData &result);
 
-} //end namespace AerToPy
-
+} // end namespace AerToPy
 
 /*******************************************************************************
  *
@@ -155,12 +148,12 @@ py::dict from_snapshot(AER::SnapshotData &result);
 // Pybind Conversion for Simulator types
 //============================================================================
 
-template<typename T> 
+template <typename T>
 py::object AerToPy::from_avg_data(AER::LegacyAverageData<T> &avg_data) {
   return AerToPy::from_avg_data(std::move(avg_data));
 }
 
-template<typename T> 
+template <typename T>
 py::object AerToPy::from_avg_data(AER::LegacyAverageData<T> &&avg_data) {
   py::dict d;
   d["value"] = std::move(avg_data.mean());
@@ -170,7 +163,7 @@ py::object AerToPy::from_avg_data(AER::LegacyAverageData<T> &&avg_data) {
   return std::move(d);
 }
 
-template <> 
+template <>
 py::object AerToPy::from_avg_data(AER::LegacyAverageData<json_t> &&avg_data) {
   py::dict d;
   py::object py_mean;
@@ -184,13 +177,15 @@ py::object AerToPy::from_avg_data(AER::LegacyAverageData<json_t> &&avg_data) {
   return std::move(d);
 }
 
-template<typename T> 
-py::object AerToPy::from_avg_data(AER::LegacyAverageData<AER::Vector<T>> &avg_data) {
+template <typename T>
+py::object
+AerToPy::from_avg_data(AER::LegacyAverageData<AER::Vector<T>> &avg_data) {
   return AerToPy::from_avg_data(std::move(avg_data));
 }
 
-template<typename T> 
-py::object AerToPy::from_avg_data(AER::LegacyAverageData<AER::Vector<T>> &&avg_data) {
+template <typename T>
+py::object
+AerToPy::from_avg_data(AER::LegacyAverageData<AER::Vector<T>> &&avg_data) {
   py::dict d;
   d["value"] = AerToPy::to_numpy(std::move(avg_data.mean()));
   if (avg_data.has_variance()) {
@@ -199,13 +194,14 @@ py::object AerToPy::from_avg_data(AER::LegacyAverageData<AER::Vector<T>> &&avg_d
   return std::move(d);
 }
 
-template<typename T> 
+template <typename T>
 py::object AerToPy::from_avg_data(AER::LegacyAverageData<matrix<T>> &avg_data) {
   return AerToPy::from_avg_data(std::move(avg_data));
 }
 
-template<typename T> 
-py::object AerToPy::from_avg_data(AER::LegacyAverageData<matrix<T>> &&avg_data) {
+template <typename T>
+py::object
+AerToPy::from_avg_data(AER::LegacyAverageData<matrix<T>> &&avg_data) {
   py::dict d;
   d["value"] = AerToPy::to_numpy(std::move(avg_data.mean()));
   if (avg_data.has_variance()) {
@@ -214,13 +210,15 @@ py::object AerToPy::from_avg_data(AER::LegacyAverageData<matrix<T>> &&avg_data)
   return std::move(d);
 }
 
-template<typename T> 
-py::object AerToPy::from_avg_data(AER::LegacyAverageData<std::vector<T>> &avg_data) {
+template <typename T>
+py::object
+AerToPy::from_avg_data(AER::LegacyAverageData<std::vector<T>> &avg_data) {
   return AerToPy::from_avg_data(std::move(avg_data));
 }
 
-template<typename T> 
-py::object AerToPy::from_avg_data(AER::LegacyAverageData<std::vector<T>> &&avg_data) {
+template <typename T>
+py::object
+AerToPy::from_avg_data(AER::LegacyAverageData<std::vector<T>> &&avg_data) {
   py::dict d;
   d["value"] = AerToPy::to_numpy(std::move(avg_data.mean()));
   if (avg_data.has_variance()) {
@@ -229,12 +227,12 @@ py::object AerToPy::from_avg_data(AER::LegacyAverageData<std::vector<T>> &&avg_d
   return std::move(d);
 }
 
-template<typename T> 
+template <typename T>
 py::object AerToPy::from_avg_snap(AER::AverageSnapshot<T> &avg_snap) {
   return AerToPy::from_avg_snap(std::move(avg_snap));
 }
 
-template<typename T> 
+template <typename T>
 py::object AerToPy::from_avg_snap(AER::AverageSnapshot<T> &&avg_snap) {
   py::dict d;
   for (auto &outer_pair : avg_snap.data()) {
@@ -244,7 +242,7 @@ py::object AerToPy::from_avg_snap(AER::AverageSnapshot<T> &&avg_snap) {
       py::dict datum = AerToPy::from_avg_data(inner_pair.second);
       // Add memory key if there are classical registers
       auto memory = inner_pair.first;
-      if ( ! memory.empty()) {
+      if (!memory.empty()) {
         datum["memory"] = inner_pair.first;
       }
       // Add to list of output
@@ -255,11 +253,11 @@ py::object AerToPy::from_avg_snap(AER::AverageSnapshot<T> &&avg_snap) {
   return std::move(d);
 }
 
-template<typename T> 
+template <typename T>
 py::object AerToPy::from_pershot_snap(AER::PershotSnapshot<T> &snap) {
   return AerToPy::from_pershot_snap(std::move(snap));
 }
-template<typename T> 
+template <typename T>
 py::object AerToPy::from_pershot_snap(AER::PershotSnapshot<T> &&snap) {
   py::dict d;
   // string PershotData
@@ -268,24 +266,24 @@ py::object AerToPy::from_pershot_snap(AER::PershotSnapshot<T> &&snap) {
   return std::move(d);
 }
 
-template<typename T>
+template <typename T>
 py::object AerToPy::from_pershot_data(AER::PershotData<T> &&data) {
   return py::cast(data.data(), py::return_value_policy::move);
 }
 
-template<typename T>
+template <typename T>
 py::object AerToPy::from_pershot_data(AER::PershotData<T> &data) {
   return AerToPy::from_pershot_data(std::move(data));
 }
 
-template<>
+template <>
 py::object AerToPy::from_pershot_data(AER::PershotData<json_t> &&data) {
   py::object tmp;
   from_json(data.data(), tmp);
   return tmp;
 }
 
-template<typename T>
+template <typename T>
 py::object AerToPy::from_pershot_data(AER::PershotData<matrix<T>> &&data) {
   py::list l;
   for (auto &item : data.data()) {
@@ -294,14 +292,12 @@ py::object AerToPy::from_pershot_data(AER::PershotData<matrix<T>> &&data) {
   return std::move(l);
 }
 
-template<typename T>
+template <typename T>
 py::object AerToPy::from_pershot_data(AER::PershotData<matrix<T>> &data) {
   return AerToPy::from_pershot_data(std::move(data));
 }
 
-
-
-template<typename T>
+template <typename T>
 py::object AerToPy::from_pershot_data(AER::PershotData<AER::Vector<T>> &&data) {
   py::list l;
   for (auto &item : data.data()) {
@@ -310,14 +306,12 @@ py::object AerToPy::from_pershot_data(AER::PershotData<AER::Vector<T>> &&data) {
   return std::move(l);
 }
 
-template<typename T>
+template <typename T>
 py::object AerToPy::from_pershot_data(AER::PershotData<AER::Vector<T>> &data) {
   return AerToPy::from_pershot_data(std::move(data));
 }
 
-
-
-template<typename T>
+template <typename T>
 py::object AerToPy::from_pershot_data(AER::PershotData<std::vector<T>> &&data) {
   py::list l;
   for (auto &item : data.data()) {
@@ -326,12 +320,11 @@ py::object AerToPy::from_pershot_data(AER::PershotData<std::vector<T>> &&data) {
   return std::move(l);
 }
 
-template<typename T>
+template <typename T>
 py::object AerToPy::from_pershot_data(AER::PershotData<std::vector<T>> &data) {
   return AerToPy::from_pershot_data(std::move(data));
 }
 
-
 py::dict AerToPy::from_snapshot(AER::SnapshotData &datum) {
   return AerToPy::from_snapshot(std::move(datum));
 }
@@ -349,16 +342,20 @@ py::dict AerToPy::from_snapshot(AER::SnapshotData &&datum) {
     for (auto &pair : datum.average_snapshots<std::complex<double>>()) {
       snapshots[pair.first.data()] = AerToPy::from_avg_snap(pair.second);
     }
-    for (auto &pair : datum.average_snapshots<std::vector<std::complex<float>>>()) {
+    for (auto &pair :
+         datum.average_snapshots<std::vector<std::complex<float>>>()) {
       snapshots[pair.first.data()] = AerToPy::from_avg_snap(pair.second);
     }
-    for (auto &pair : datum.average_snapshots<std::vector<std::complex<double>>>()) {
+    for (auto &pair :
+         datum.average_snapshots<std::vector<std::complex<double>>>()) {
       snapshots[pair.first.data()] = AerToPy::from_avg_snap(pair.second);
     }
-    for (auto &pair : datum.average_snapshots<AER::Vector<std::complex<float>>>()) {
+    for (auto &pair :
+         datum.average_snapshots<AER::Vector<std::complex<float>>>()) {
       snapshots[pair.first.data()] = AerToPy::from_avg_snap(pair.second);
     }
-    for (auto &pair : datum.average_snapshots<AER::Vector<std::complex<double>>>()) {
+    for (auto &pair :
+         datum.average_snapshots<AER::Vector<std::complex<double>>>()) {
       snapshots[pair.first.data()] = AerToPy::from_avg_snap(pair.second);
     }
     for (auto &pair : datum.average_snapshots<matrix<std::complex<float>>>()) {
@@ -367,32 +364,38 @@ py::dict AerToPy::from_snapshot(AER::SnapshotData &&datum) {
     for (auto &pair : datum.average_snapshots<matrix<std::complex<double>>>()) {
       snapshots[pair.first.data()] = AerToPy::from_avg_snap(pair.second);
     }
-    for (auto &pair : datum.average_snapshots<std::map<std::string, std::complex<double>>>()) {
+    for (auto &pair : datum.average_snapshots<
+                      std::map<std::string, std::complex<double>>>()) {
       snapshots[pair.first.data()] = AerToPy::from_avg_snap(pair.second);
     }
-    for (auto &pair : datum.average_snapshots<std::map<std::string, double>>()) {
+    for (auto &pair :
+         datum.average_snapshots<std::map<std::string, double>>()) {
       snapshots[pair.first.data()] = AerToPy::from_avg_snap(pair.second);
     }
     // Singleshot snapshot data
     // Note these will override the average snapshots
     // if they share the same type string
-    
+
     for (auto &pair : datum.pershot_snapshots<json_t>()) {
       snapshots[pair.first.data()] = AerToPy::from_pershot_snap(pair.second);
     }
     for (auto &pair : datum.pershot_snapshots<std::complex<double>>()) {
       snapshots[pair.first.data()] = AerToPy::from_pershot_snap(pair.second);
     }
-    for (auto &pair : datum.pershot_snapshots<std::vector<std::complex<float>>>()) {
+    for (auto &pair :
+         datum.pershot_snapshots<std::vector<std::complex<float>>>()) {
       snapshots[pair.first.data()] = AerToPy::from_pershot_snap(pair.second);
     }
-    for (auto &pair : datum.pershot_snapshots<std::vector<std::complex<double>>>()) {
+    for (auto &pair :
+         datum.pershot_snapshots<std::vector<std::complex<double>>>()) {
       snapshots[pair.first.data()] = AerToPy::from_pershot_snap(pair.second);
     }
-    for (auto &pair : datum.pershot_snapshots<AER::Vector<std::complex<float>>>()) {
+    for (auto &pair :
+         datum.pershot_snapshots<AER::Vector<std::complex<float>>>()) {
       snapshots[pair.first.data()] = AerToPy::from_pershot_snap(pair.second);
     }
-    for (auto &pair : datum.pershot_snapshots<AER::Vector<std::complex<double>>>()) {
+    for (auto &pair :
+         datum.pershot_snapshots<AER::Vector<std::complex<double>>>()) {
       snapshots[pair.first.data()] = AerToPy::from_pershot_snap(pair.second);
     }
     for (auto &pair : datum.pershot_snapshots<matrix<std::complex<float>>>()) {
@@ -401,10 +404,12 @@ py::dict AerToPy::from_snapshot(AER::SnapshotData &&datum) {
     for (auto &pair : datum.pershot_snapshots<matrix<std::complex<double>>>()) {
       snapshots[pair.first.data()] = AerToPy::from_pershot_snap(pair.second);
     }
-    for (auto &pair : datum.pershot_snapshots<std::map<std::string, std::complex<double>>>()) {
+    for (auto &pair : datum.pershot_snapshots<
+                      std::map<std::string, std::complex<double>>>()) {
       snapshots[pair.first.data()] = AerToPy::from_pershot_snap(pair.second);
     }
-    for (auto &pair : datum.pershot_snapshots<std::map<std::string, double>>()) {
+    for (auto &pair :
+         datum.pershot_snapshots<std::map<std::string, double>>()) {
       snapshots[pair.first.data()] = AerToPy::from_pershot_snap(pair.second);
     }
   }
diff --git a/src/framework/results/legacy/snapshot_data.hpp b/src/framework/results/legacy/snapshot_data.hpp
old mode 100755
new mode 100644
index fc227e4b7e..776e63f9b7
--- a/src/framework/results/legacy/snapshot_data.hpp
+++ b/src/framework/results/legacy/snapshot_data.hpp
@@ -69,7 +69,7 @@ class SnapshotData : public DataContainer<json_t>,
   using DataContainer<matrix<std::complex<double>>>::add_pershot_snapshot;
   using DataContainer<std::map<std::string, complex_t>>::add_pershot_snapshot;
   using DataContainer<std::map<std::string, double>>::add_pershot_snapshot;
-  
+
   //----------------------------------------------------------------
   // Average snapshots
   //----------------------------------------------------------------
@@ -112,7 +112,7 @@ class SnapshotData : public DataContainer<json_t>,
   // Combine engines for accumulating data
   // Second engine should no longer be used after combining
   // as this function should use move semantics to minimize copying
-  SnapshotData &combine(SnapshotData &&eng); // Move semantics
+  SnapshotData &combine(SnapshotData &&eng);      // Move semantics
   SnapshotData &combine(const SnapshotData &eng); // Copy semantics
 
   // Operator overload for combine
@@ -128,17 +128,15 @@ class SnapshotData : public DataContainer<json_t>,
   // Access Templated DataContainers
   //----------------------------------------------------------------
 
-  template <typename T>
-  stringmap_t<PershotSnapshot<T>>& pershot_snapshots();
+  template <typename T> stringmap_t<PershotSnapshot<T>> &pershot_snapshots();
 
   template <typename T>
-  const stringmap_t<PershotSnapshot<T>>& pershot_snapshots() const;
+  const stringmap_t<PershotSnapshot<T>> &pershot_snapshots() const;
 
-  template <typename T>
-  stringmap_t<AverageSnapshot<T>>& average_snapshots();
+  template <typename T> stringmap_t<AverageSnapshot<T>> &average_snapshots();
 
   template <typename T>
-  const stringmap_t<AverageSnapshot<T>>& average_snapshots() const;
+  const stringmap_t<AverageSnapshot<T>> &average_snapshots() const;
 
   //----------------------------------------------------------------
   // Config
@@ -174,7 +172,7 @@ void SnapshotData::set_config(const json_t &config) {
 // Generic
 template <typename T>
 void SnapshotData::add_pershot_snapshot(const std::string &type,
-                                          const std::string &label, T &&datum) {
+                                        const std::string &label, T &&datum) {
   if (return_snapshots_) {
     // use implicit to_json conversion function for T
     json_t tmp = datum;
@@ -188,12 +186,13 @@ void SnapshotData::add_pershot_snapshot(const std::string &type,
 
 template <typename T>
 void SnapshotData::add_average_snapshot(const std::string &type,
-                                          const std::string &label,
-                                          const std::string &memory, T &&datum,
-                                          bool variance) {
+                                        const std::string &label,
+                                        const std::string &memory, T &&datum,
+                                        bool variance) {
   if (return_snapshots_) {
-    json_t tmp = datum;  // use implicit to_json conversion function for T
-    DataContainer<json_t>::add_average_snapshot(type, label, memory, std::move(tmp), variance);
+    json_t tmp = datum; // use implicit to_json conversion function for T
+    DataContainer<json_t>::add_average_snapshot(type, label, memory,
+                                                std::move(tmp), variance);
   }
 }
 
@@ -202,22 +201,22 @@ void SnapshotData::add_average_snapshot(const std::string &type,
 //------------------------------------------------------------------
 
 template <typename T>
-stringmap_t<PershotSnapshot<T>>& SnapshotData::pershot_snapshots() {
+stringmap_t<PershotSnapshot<T>> &SnapshotData::pershot_snapshots() {
   return DataContainer<T>::pershot_snapshots_;
 }
 
 template <typename T>
-const stringmap_t<PershotSnapshot<T>>& SnapshotData::pershot_snapshots() const {
+const stringmap_t<PershotSnapshot<T>> &SnapshotData::pershot_snapshots() const {
   return DataContainer<T>::pershot_snapshots_;
 }
 
 template <typename T>
-stringmap_t<AverageSnapshot<T>>& SnapshotData::average_snapshots() {
+stringmap_t<AverageSnapshot<T>> &SnapshotData::average_snapshots() {
   return DataContainer<T>::average_snapshots_;
 }
 
 template <typename T>
-const stringmap_t<AverageSnapshot<T>>& SnapshotData::average_snapshots() const {
+const stringmap_t<AverageSnapshot<T>> &SnapshotData::average_snapshots() const {
   return DataContainer<T>::average_snapshots_;
 }
 
@@ -237,7 +236,6 @@ void SnapshotData::clear() {
   DataContainer<matrix<std::complex<double>>>::clear();
   DataContainer<std::map<std::string, complex_t>>::clear();
   DataContainer<std::map<std::string, double>>::clear();
-
 }
 
 SnapshotData &SnapshotData::combine(const SnapshotData &other) {
@@ -299,6 +297,6 @@ json_t SnapshotData::to_json() {
 }
 
 //------------------------------------------------------------------------------
-}  // end namespace AER
+} // end namespace AER
 //------------------------------------------------------------------------------
 #endif
diff --git a/src/framework/results/pybind_result.hpp b/src/framework/results/pybind_result.hpp
old mode 100755
new mode 100644
index b97d6812fd..ad460c69e1
--- a/src/framework/results/pybind_result.hpp
+++ b/src/framework/results/pybind_result.hpp
@@ -32,39 +32,39 @@ template <> py::object to_python(AER::ExperimentResult &&result);
 // Move a Result object to a Python dict
 template <> py::object to_python(AER::Result &&result);
 
-} //end namespace AerToPy
-
+} // end namespace AerToPy
 
 //============================================================================
 // Implementations
 //============================================================================
 
-template <>
-py::object AerToPy::to_python(AER::ExperimentResult &&result) {
+template <> py::object AerToPy::to_python(AER::ExperimentResult &&result) {
   py::dict pyexperiment;
 
   pyexperiment["shots"] = result.shots;
   pyexperiment["seed_simulator"] = result.seed;
 
-  pyexperiment["data"] =  AerToPy::to_python(std::move(result.data));
+  pyexperiment["data"] = AerToPy::to_python(std::move(result.data));
   // Add legacy snapshot data
-  py::dict legacy_snapshots = AerToPy::from_snapshot(std::move(result.legacy_data));
+  py::dict legacy_snapshots =
+      AerToPy::from_snapshot(std::move(result.legacy_data));
   if (!legacy_snapshots.empty()) {
     pyexperiment["data"]["snapshots"] = std::move(legacy_snapshots);
   }
 
   pyexperiment["metadata"] = AerToPy::to_python(std::move(result.metadata));
 
-  pyexperiment["success"] = (result.status == AER::ExperimentResult::Status::completed);
+  pyexperiment["success"] =
+      (result.status == AER::ExperimentResult::Status::completed);
   switch (result.status) {
-    case AER::ExperimentResult::Status::completed:
-      pyexperiment["status"] = "DONE";
-      break;
-    case AER::ExperimentResult::Status::error:
-      pyexperiment["status"] = std::string("ERROR: ") + result.message;
-      break;
-    case AER::ExperimentResult::Status::empty:
-      pyexperiment["status"] = "EMPTY";
+  case AER::ExperimentResult::Status::completed:
+    pyexperiment["status"] = "DONE";
+    break;
+  case AER::ExperimentResult::Status::error:
+    pyexperiment["status"] = std::string("ERROR: ") + result.message;
+    break;
+  case AER::ExperimentResult::Status::empty:
+    pyexperiment["status"] = "EMPTY";
   }
   pyexperiment["time_taken"] = result.time_taken;
 
@@ -76,9 +76,7 @@ py::object AerToPy::to_python(AER::ExperimentResult &&result) {
   return std::move(pyexperiment);
 }
 
-
-template <>
-py::object AerToPy::to_python(AER::Result &&result) {
+template <> py::object AerToPy::to_python(AER::Result &&result) {
   py::dict pyresult;
   pyresult["qobj_id"] = result.qobj_id;
 
@@ -88,7 +86,7 @@ py::object AerToPy::to_python(AER::Result &&result) {
   pyresult["job_id"] = result.job_id;
 
   py::list exp_results;
-  for(AER::ExperimentResult& exp : result.results)
+  for (AER::ExperimentResult &exp : result.results)
     exp_results.append(AerToPy::to_python(std::move(exp)));
   pyresult["results"] = std::move(exp_results);
   pyresult["metadata"] = AerToPy::to_python(std::move(result.metadata));
@@ -101,17 +99,17 @@ py::object AerToPy::to_python(AER::Result &&result) {
   }
   pyresult["success"] = (result.status == AER::Result::Status::completed);
   switch (result.status) {
-    case AER::Result::Status::completed:
-      pyresult["status"] = "COMPLETED";
-      break;
-    case AER::Result::Status::partial_completed:
-      pyresult["status"] = "PARTIAL COMPLETED";
-      break;
-    case AER::Result::Status::error:
-      pyresult["status"] = std::string("ERROR: ") + result.message;
-      break;
-    case AER::Result::Status::empty:
-      pyresult["status"] = "EMPTY";
+  case AER::Result::Status::completed:
+    pyresult["status"] = "COMPLETED";
+    break;
+  case AER::Result::Status::partial_completed:
+    pyresult["status"] = "PARTIAL COMPLETED";
+    break;
+  case AER::Result::Status::error:
+    pyresult["status"] = std::string("ERROR: ") + result.message;
+    break;
+  case AER::Result::Status::empty:
+    pyresult["status"] = "EMPTY";
   }
   return std::move(pyresult);
 }
diff --git a/src/framework/results/result.hpp b/src/framework/results/result.hpp
old mode 100755
new mode 100644
index 03e3b18407..681186e783
--- a/src/framework/results/result.hpp
+++ b/src/framework/results/result.hpp
@@ -26,14 +26,13 @@ namespace AER {
 
 struct Result {
 public:
-
   // Result status:
   // completed: all experiments were executed successfully
   // partial: only some experiments were executed succesfully
-  enum class Status {empty, completed, partial_completed, error};
+  enum class Status { empty, completed, partial_completed, error };
 
   // Constructor
-  Result(size_t num_exp = 0) {results.resize(num_exp);}
+  Result(size_t num_exp = 0) { results.resize(num_exp); }
 
   // Experiment results
   std::vector<ExperimentResult> results;
@@ -44,18 +43,18 @@ struct Result {
   std::string qobj_id;
   std::string job_id;
   std::string date;
-  
+
   // Success and status
   Status status = Status::empty; // Result status
-  std::string message; // error message
+  std::string message;           // error message
 
   // Metadata
   json_t header;
   Metadata metadata;
 
   // Size and resize
-  auto size() {return results.size();}
-  void resize(size_t size) {results.resize(size);}
+  auto size() { return results.size(); }
+  void resize(size_t size) { results.resize(size); }
 
   // Serialize engine data to JSON
   json_t to_json();
@@ -68,7 +67,7 @@ json_t Result::to_json() {
   // Initialize output as additional data JSON
   json_t js;
   js["qobj_id"] = qobj_id;
-  
+
   js["backend_name"] = backend_name;
   js["backend_version"] = backend_version;
   js["date"] = date;
@@ -76,26 +75,26 @@ json_t Result::to_json() {
   if (results.empty()) {
     js["results"] = json_t::array({});
   } else {
-      for (auto& res : results) {
-        js["results"].push_back(res.to_json());
-      }
+    for (auto &res : results) {
+      js["results"].push_back(res.to_json());
+    }
   }
   if (header.empty() == false)
     js["header"] = header;
   js["metadata"] = metadata.to_json();
   js["success"] = (status == Status::completed);
   switch (status) {
-    case Status::completed:
-      js["status"] = std::string("COMPLETED");
-      break;
-    case Status:: partial_completed:
-      js["status"] = std::string("PARTIAL COMPLETED");
-      break;
-    case Status::error:
-      js["status"] = std::string("ERROR: ") + message;
-      break;
-    case Status::empty:
-      js["status"] = std::string("EMPTY");
+  case Status::completed:
+    js["status"] = std::string("COMPLETED");
+    break;
+  case Status::partial_completed:
+    js["status"] = std::string("PARTIAL COMPLETED");
+    break;
+  case Status::error:
+    js["status"] = std::string("ERROR: ") + message;
+    break;
+  case Status::empty:
+    js["status"] = std::string("EMPTY");
   }
   return js;
 }
diff --git a/src/framework/rng.hpp b/src/framework/rng.hpp
old mode 100755
new mode 100644
index 37d77ec7cb..ec306514f7
--- a/src/framework/rng.hpp
+++ b/src/framework/rng.hpp
@@ -31,7 +31,6 @@ namespace AER {
 
 class RngEngine {
 public:
-
   //-----------------------------------------------------------------------
   // Constructors
   //-----------------------------------------------------------------------
@@ -47,22 +46,18 @@ class RngEngine {
   //-----------------------------------------------------------------------
 
   // Set random seed for the RNG engine
-  void set_random_seed() { 
+  void set_random_seed() {
     std::random_device rd;
     set_seed(rd());
   }
 
   // Set a fixed seed for the RNG engine
-  void set_seed(size_t seed)
-  {
-    rng.seed(seed); 
+  void set_seed(size_t seed) {
+    rng.seed(seed);
     initial_seed_ = seed;
   }
 
-  size_t initial_seed(void)
-  {
-    return initial_seed_;
-  }
+  size_t initial_seed(void) { return initial_seed_; }
 
   //-----------------------------------------------------------------------
   // Sampling methods
@@ -76,13 +71,11 @@ class RngEngine {
 
   // Generate a uniformly distributed pseudo random real in the half-open
   // interval [0,b)
-  double rand(double b) {
-    return rand(double(0), b);
-  };
+  double rand(double b) { return rand(double(0), b); };
 
   // Generate a uniformly distributed pseudo random real in the half-open
   // interval [0,1)
-  double rand() {return rand(0, 1); };
+  double rand() { return rand(0, 1); };
 
   // Generate a uniformly distributed pseudo random integer in the closed
   // interval [a,b]
@@ -103,8 +96,8 @@ class RngEngine {
   }
 
 private:
-  std::mt19937_64 rng; // Mersenne twister rng engine
-  size_t initial_seed_; //save seed used to initialize rng engine 
+  std::mt19937_64 rng;  // Mersenne twister rng engine
+  size_t initial_seed_; // save seed used to initialize rng engine
 };
 
 //------------------------------------------------------------------------------
diff --git a/src/framework/stl_ostream.hpp b/src/framework/stl_ostream.hpp
old mode 100755
new mode 100644
index 786dd07ec6..36e0b1ed13
--- a/src/framework/stl_ostream.hpp
+++ b/src/framework/stl_ostream.hpp
@@ -32,8 +32,10 @@
 // * std::array           a => "[a[0], ..., a[N-1]]"
 // * std::set             s => "{s[0], ..., s[N-1]}"
 // * std::unordered_set   s => "{s[0], ..., s[N-1]}"
-// * std::map             m => "{m[0].first: m[0].second, ..., m[N-1].first: m[N-1].second}"
-// * std::unordered_map   m => "{m[0].first: m[0].second, ..., m[N-1].first: m[N-1].second}"
+// * std::map             m => "{m[0].first: m[0].second, ..., m[N-1].first:
+// m[N-1].second}"
+// * std::unordered_map   m => "{m[0].first: m[0].second, ..., m[N-1].first:
+// m[N-1].second}"
 // * std::pair            p => "p.first:p.second"
 //=============================================================================
 
@@ -44,51 +46,58 @@ template <class T, size_t N>
 std::ostream &operator<<(std::ostream &out, const std::array<T, N> &a);
 
 template <class Key, class Compare, class Allocator>
-std::ostream &operator<<(std::ostream &out, const std::set<Key, Compare, Allocator> &s);
+std::ostream &operator<<(std::ostream &out,
+                         const std::set<Key, Compare, Allocator> &s);
 
 template <class Key, class Hash, class KeyEqual, class Allocator>
-std::ostream &operator<<(std::ostream &out, const std::unordered_set<Key, Hash, KeyEqual, Allocator> &s);
+std::ostream &
+operator<<(std::ostream &out,
+           const std::unordered_set<Key, Hash, KeyEqual, Allocator> &s);
 
 template <class Key, class T, class Compare, class Allocator>
-std::ostream &operator<<(std::ostream &out, const std::map<Key, T, Compare, Allocator> &m);
+std::ostream &operator<<(std::ostream &out,
+                         const std::map<Key, T, Compare, Allocator> &m);
 
 template <class Key, class T, class Hash, class KeyEqual, class Allocator>
-std::ostream &operator<<(std::ostream &out, const std::unordered_map<Key, T, Hash, KeyEqual, Allocator> &m);
+std::ostream &
+operator<<(std::ostream &out,
+           const std::unordered_map<Key, T, Hash, KeyEqual, Allocator> &m);
 
 //=============================================================================
 // Implementations
 //=============================================================================
 namespace { // private namespace
 
-  // Private overload for std::pair used by map and unordered_map
-  template <class T1, class T2>
-  std::ostream &operator<<(std::ostream &out, const std::pair<T1, T2> &p) {
-    out << p.first << ":" << p.second;
-    return out;
-  }
+// Private overload for std::pair used by map and unordered_map
+template <class T1, class T2>
+std::ostream &operator<<(std::ostream &out, const std::pair<T1, T2> &p) {
+  out << p.first << ":" << p.second;
+  return out;
+}
 
-  // Helper function for printing containers
-  template <typename container_t>
-  std::ostream& container_to_stream(std::ostream& out,
-                                    const container_t& container,
-                                    const std::string &delim_left,
-                                    const std::string &delim_right,
-                                    const std::string &seperator = ", "){
-      out << delim_left;
-      size_t pos = 0, last = container.size() - 1;
-      for (auto const &p : container) {
-          out << p;
-          if (pos != last)
-              out << seperator;
-          pos++;
-      }
-      out << delim_right;
-      return out;
+// Helper function for printing containers
+template <typename container_t>
+std::ostream &container_to_stream(std::ostream &out,
+                                  const container_t &container,
+                                  const std::string &delim_left,
+                                  const std::string &delim_right,
+                                  const std::string &seperator = ", ") {
+  out << delim_left;
+  size_t pos = 0, last = container.size() - 1;
+  for (auto const &p : container) {
+    out << p;
+    if (pos != last)
+      out << seperator;
+    pos++;
   }
+  out << delim_right;
+  return out;
 }
+} // namespace
 
 template <class T, class Allocator>
-std::ostream &operator<<(std::ostream &out, const std::vector<T, Allocator> &v) {
+std::ostream &operator<<(std::ostream &out,
+                         const std::vector<T, Allocator> &v) {
   return container_to_stream(out, v, "[", "]");
 }
 
@@ -98,22 +107,28 @@ std::ostream &operator<<(std::ostream &out, const std::array<T, N> &a) {
 }
 
 template <class Key, class Compare, class Allocator>
-std::ostream &operator<<(std::ostream &out, const std::set<Key, Compare, Allocator> &s) {
+std::ostream &operator<<(std::ostream &out,
+                         const std::set<Key, Compare, Allocator> &s) {
   return container_to_stream(out, s, "{", "}");
 }
 
 template <class Key, class Hash, class KeyEqual, class Allocator>
-std::ostream &operator<<(std::ostream &out, const std::unordered_set<Key, Hash, KeyEqual, Allocator> &s) {
+std::ostream &
+operator<<(std::ostream &out,
+           const std::unordered_set<Key, Hash, KeyEqual, Allocator> &s) {
   return container_to_stream(out, s, "{", "}");
 }
 
 template <class Key, class T, class Compare, class Allocator>
-std::ostream &operator<<(std::ostream &out, const std::map<Key, T, Compare, Allocator> &m) {
+std::ostream &operator<<(std::ostream &out,
+                         const std::map<Key, T, Compare, Allocator> &m) {
   return container_to_stream(out, m, "{", "}");
 }
 
 template <class Key, class T, class Hash, class KeyEqual, class Allocator>
-std::ostream &operator<<(std::ostream &out, const std::unordered_map<Key, T, Hash, KeyEqual, Allocator> &m) {
+std::ostream &
+operator<<(std::ostream &out,
+           const std::unordered_map<Key, T, Hash, KeyEqual, Allocator> &m) {
   return container_to_stream(out, m, "{", "}");
 }
 
diff --git a/src/framework/types.hpp b/src/framework/types.hpp
old mode 100755
new mode 100644
index 619d294312..9f4cb02cd7
--- a/src/framework/types.hpp
+++ b/src/framework/types.hpp
@@ -15,8 +15,8 @@
 #ifndef _aer_framework_types_hpp_
 #define _aer_framework_types_hpp_
 
-#include <cstdint>
 #include <complex>
+#include <cstdint>
 #include <iostream>
 #include <map>
 #include <set>
@@ -25,10 +25,9 @@
 #include <unordered_set>
 #include <vector>
 
-#include "framework/matrix.hpp" // matrix class
 #include "framework/linalg/vector.hpp" // AER::Vector class
-#include "framework/stl_ostream.hpp" 
-
+#include "framework/matrix.hpp"        // matrix class
+#include "framework/stl_ostream.hpp"
 
 //=============================================================================
 // Numeric Types for backends
@@ -36,25 +35,23 @@
 
 namespace AER {
 
-  // Numeric Types
-  using int_t = int_fast64_t;
-  using uint_t = uint_fast64_t; 
-  using complex_t = std::complex<double>;
-  using complexf_t = std::complex<float>;
-  using cvector_t = std::vector<complex_t>;
-  using cvectorf_t = std::vector<complexf_t>;
-  using cmatrix_t = matrix<complex_t>;
-  using cmatrixf_t = matrix<complexf_t>;
-  using rvector_t = std::vector<double>;
-  using rmatrix_t = matrix<double>;
-  using reg_t = std::vector<uint_t>;
-  using stringset_t = std::unordered_set<std::string>;
-  template <typename T>
-  using stringmap_t = std::unordered_map<std::string, T>;
-  using mps_container_t = std::pair<std::vector<std::pair<cmatrix_t, cmatrix_t>>, 
-			                              std::vector<rvector_t>>;
-}
-
+// Numeric Types
+using int_t = int_fast64_t;
+using uint_t = uint_fast64_t;
+using complex_t = std::complex<double>;
+using complexf_t = std::complex<float>;
+using cvector_t = std::vector<complex_t>;
+using cvectorf_t = std::vector<complexf_t>;
+using cmatrix_t = matrix<complex_t>;
+using cmatrixf_t = matrix<complexf_t>;
+using rvector_t = std::vector<double>;
+using rmatrix_t = matrix<double>;
+using reg_t = std::vector<uint_t>;
+using stringset_t = std::unordered_set<std::string>;
+template <typename T> using stringmap_t = std::unordered_map<std::string, T>;
+using mps_container_t = std::pair<std::vector<std::pair<cmatrix_t, cmatrix_t>>,
+                                  std::vector<rvector_t>>;
+} // namespace AER
 
 //-----------------------------------------------------------------------------
 #endif
diff --git a/src/framework/utils.hpp b/src/framework/utils.hpp
old mode 100755
new mode 100644
index 171492c5ce..0765fbd16b
--- a/src/framework/utils.hpp
+++ b/src/framework/utils.hpp
@@ -16,9 +16,9 @@
 #define _aer_framework_utils_hpp_
 
 #include <algorithm>
-#include <sstream>
 #include <cmath>
 #include <limits>
+#include <sstream>
 #include <string>
 
 #include "framework/avx2_detect.hpp"
@@ -37,7 +37,6 @@
 #include <windows.h>
 #endif
 
-
 namespace AER {
 namespace Utils {
 
@@ -46,13 +45,14 @@ namespace Utils {
 //------------------------------------------------------------------------------
 
 // Construct a matrix from a vector of matrix-row vectors
-template<class T> matrix<T> make_matrix(const std::vector<std::vector<T>> &mat);
+template <class T>
+matrix<T> make_matrix(const std::vector<std::vector<T>> &mat);
 
 // Reshape a length column-major vectorized matrix into a square matrix
-template<class T> matrix<T> devectorize_matrix(const std::vector<T> &vec);
+template <class T> matrix<T> devectorize_matrix(const std::vector<T> &vec);
 
 // Vectorize a matrix by stacking matrix columns (column-major vectorization)
-template<class T> std::vector<T> vectorize_matrix(const matrix<T> &mat);
+template <class T> std::vector<T> vectorize_matrix(const matrix<T> &mat);
 
 // Return the transpose a matrix
 template <class T> matrix<T> transpose(const matrix<T> &A);
@@ -66,20 +66,19 @@ template <class T>
 matrix<std::complex<T>> conjugate(const matrix<std::complex<T>> &A);
 
 // Given a list of matrices for a multiplexer stacks and packs them 0/1/2/...
-// into a single 2^control x (2^target x 2^target) cmatrix_t) 
+// into a single 2^control x (2^target x 2^target) cmatrix_t)
 // Equivalent to a 2^qubits x 2^target "flat" matrix
-template<class T>
-matrix<T> stacked_matrix(const std::vector<matrix<T>> &mmat);
+template <class T> matrix<T> stacked_matrix(const std::vector<matrix<T>> &mmat);
 
 // Return a vector containing the diagonal of a matrix
-template<class T> std::vector<T> matrix_diagonal(const matrix<T>& mat);
+template <class T> std::vector<T> matrix_diagonal(const matrix<T> &mat);
 
 // Inplace transformations
-template <class T> matrix<T>& transpose_inplace(matrix<T> &A);
+template <class T> matrix<T> &transpose_inplace(matrix<T> &A);
 template <class T>
-matrix<std::complex<T>>& dagger_inplace(matrix<std::complex<T>> &A);
+matrix<std::complex<T>> &dagger_inplace(matrix<std::complex<T>> &A);
 template <class T>
-matrix<std::complex<T>>& conjugate_inplace(matrix<std::complex<T>> &A);
+matrix<std::complex<T>> &conjugate_inplace(matrix<std::complex<T>> &A);
 
 // Tracing
 template <class T> T trace(const matrix<T> &A);
@@ -87,7 +86,8 @@ template <class T> matrix<T> partial_trace_a(const matrix<T> &rho, size_t dimA);
 template <class T> matrix<T> partial_trace_b(const matrix<T> &rho, size_t dimB);
 
 // Tensor product
-template <class T> matrix<T> tensor_product(const matrix<T> &A, const matrix<T> &B);
+template <class T>
+matrix<T> tensor_product(const matrix<T> &A, const matrix<T> &B);
 template <class T> matrix<T> unitary_superop(const matrix<T> &mat);
 template <class T> matrix<T> kraus_superop(const std::vector<matrix<T>> &kmats);
 
@@ -96,50 +96,47 @@ template <class T> matrix<T> kraus_superop(const std::vector<matrix<T>> &kmats);
 // The matrices must have the same dimensions
 // If axis == 0, place rows of B after rows of A (vertical extension)
 // If axis == 1, place columns of B after columns of A (horizontal extension)
-template <class T> matrix<T> concatenate (const matrix<T> &A, const matrix<T> &B, uint_t axis);
+template <class T>
+matrix<T> concatenate(const matrix<T> &A, const matrix<T> &B, uint_t axis);
 
 // split
 // Splits A into 2 matrices B and C equal in dimensions
 // If axis == 0, split A by rows. A must have an even number of rows.
 // If axis == 1, split A by columns. A must have an even number of columns.
-template <class T> void split (const matrix<T> &A, matrix<T> &B, matrix<T> &C, uint_t axis);
+template <class T>
+void split(const matrix<T> &A, matrix<T> &B, matrix<T> &C, uint_t axis);
 
-//Elementwise matrix multiplication
-template <class T> matrix<T> elementwise_multiplication(const matrix<T> &A, const matrix<T> &B);
+// Elementwise matrix multiplication
+template <class T>
+matrix<T> elementwise_multiplication(const matrix<T> &A, const matrix<T> &B);
 
-//Matrix sum of elements
+// Matrix sum of elements
 template <class T> T sum(const matrix<T> &A);
 
 // Matrix comparison
-template <class T>
-bool is_square(const matrix<T> &mat);
+template <class T> bool is_square(const matrix<T> &mat);
 
-template <class T>
-bool is_diagonal(const matrix<T> &mat);
+template <class T> bool is_diagonal(const matrix<T> &mat);
 
 template <class T>
 bool is_equal(const matrix<T> &mat1, const matrix<T> &mat2, double threshold);
 
-template <class T>
-bool is_diagonal(const matrix<T> &mat, double threshold);
+template <class T> bool is_diagonal(const matrix<T> &mat, double threshold);
 
-template <class T> 
-std::pair<bool, double> is_identity_phase(const matrix<T> &mat, double threshold);
+template <class T>
+std::pair<bool, double> is_identity_phase(const matrix<T> &mat,
+                                          double threshold);
 
-template <class T> 
-bool is_identity(const matrix<T> &mat, double threshold);
+template <class T> bool is_identity(const matrix<T> &mat, double threshold);
 
 template <class T>
 bool is_diagonal_identity(const matrix<T> &mat, double threshold);
 
-template <class T>
-bool is_unitary(const matrix<T> &mat, double threshold);
+template <class T> bool is_unitary(const matrix<T> &mat, double threshold);
 
-template <class T>
-bool is_hermitian(const matrix<T> &mat, double threshold);
+template <class T> bool is_hermitian(const matrix<T> &mat, double threshold);
 
-template <class T>
-bool is_symmetrix(const matrix<T> &mat, double threshold);
+template <class T> bool is_symmetrix(const matrix<T> &mat, double threshold);
 
 template <class T>
 bool is_cptp_kraus(const std::vector<matrix<T>> &kraus, double threshold);
@@ -149,8 +146,7 @@ bool is_cptp_kraus(const std::vector<matrix<T>> &kraus, double threshold);
 //------------------------------------------------------------------------------
 
 // Return true of the vector has norm-1.
-template <typename T>
-double is_unit_vector(const std::vector<T> &vec);
+template <typename T> double is_unit_vector(const std::vector<T> &vec);
 
 // Conjugate a vector
 template <typename T>
@@ -159,15 +155,15 @@ template <class T>
 Vector<std::complex<T>> conjugate(const Vector<std::complex<T>> &v);
 
 // Compute the Euclidean 2-norm of a vector
-template <typename T>
-double norm(const std::vector<T> &vec);
+template <typename T> double norm(const std::vector<T> &vec);
 
 // Return the matrix formed by taking the outproduct of two vector |ket><bra|
 template <typename T>
 matrix<T> outer_product(const std::vector<T> &ket, const std::vector<T> &bra);
 
-template <typename T>
-inline matrix<T> projector(const std::vector<T> &ket) {return outer_product(ket, ket);}
+template <typename T> inline matrix<T> projector(const std::vector<T> &ket) {
+  return outer_product(ket, ket);
+}
 
 // Tensor product vector
 template <typename T>
@@ -180,10 +176,10 @@ Vector<T> tensor_product(const Vector<T> &v, const Vector<T> &w);
 template <typename T1, typename T2>
 std::vector<T1> scalar_multiply(const std::vector<T1> &vec, T2 val);
 
-// Inplace multiply each entry in a vector by a scalar and returns a reference to
-// the input vector argument. The product of types T1 * T2 must be valid.
+// Inplace multiply each entry in a vector by a scalar and returns a reference
+// to the input vector argument. The product of types T1 * T2 must be valid.
 template <typename T1, typename T2>
-std::vector<T1>& scalar_multiply_inplace(std::vector<T1> &vec, T2 scalar);
+std::vector<T1> &scalar_multiply_inplace(std::vector<T1> &vec, T2 scalar);
 
 // Truncate the first argument its absolute value is less than epsilon
 // this function returns a refernce to the chopped first argument
@@ -194,8 +190,7 @@ double chop(double val, double epsilon);
 float chop(float val, double epsilon);
 
 // As above for complex first arguments
-template <typename T>
-std::complex<T> chop(std::complex<T> val, double epsilon);
+template <typename T> std::complex<T> chop(std::complex<T> val, double epsilon);
 // Truncate each element in a vector if its absolute value is less than epsilon
 // This function returns a reference to the chopped input vector
 template <typename T>
@@ -206,19 +201,19 @@ std::vector<T> chop(const std::vector<T> &vec, double epsilon);
 
 // Add rhs vector to lhs using move semantics.
 // rhs should not be used after this operation.
-template <class T>
-void combine(std::vector<T> &lhs, const std::vector<T> &rhs);
-
+template <class T> void combine(std::vector<T> &lhs, const std::vector<T> &rhs);
 
 // Convert a dense vector into sparse ket form.
 // epsilon determins the threshold for which small values will be removed from
 // the output. The base of the ket (2-10 for qudits, or 16 for hexadecimal)
 // specifies the subsystem dimension and the base of the dit-string labels.
 template <typename T>
-std::map<std::string, T> vec2ket(const std::vector<T> &vec, double epsilon, uint_t base = 2);
+std::map<std::string, T> vec2ket(const std::vector<T> &vec, double epsilon,
+                                 uint_t base = 2);
 
 template <typename T>
-std::map<std::string, T> vec2ket(const T* const vec, uint_t dim, double epsilon, uint_t base = 2);
+std::map<std::string, T> vec2ket(const T *const vec, uint_t dim, double epsilon,
+                                 uint_t base = 2);
 
 //------------------------------------------------------------------------------
 // Bit Conversions
@@ -228,11 +223,11 @@ std::map<std::string, T> vec2ket(const T* const vec, uint_t dim, double epsilon,
 // and leading zeros are removed
 // Example: 0010A -> 0x10a
 std::string format_hex(const std::string &hex);
-std::string& format_hex_inplace(std::string &hex);
+std::string &format_hex_inplace(std::string &hex);
 
 // Pad string with a char if it is less
 std::string padleft(const std::string &s, char c, size_t min_length);
-std::string& padleft_inplace(std::string &s, char c, size_t min_length);
+std::string &padleft_inplace(std::string &s, char c, size_t min_length);
 
 // Convert integers and hexadecimals to register vectors
 reg_t int2reg(uint_t n, uint_t base = 2);
@@ -252,11 +247,13 @@ std::string int2string(uint_t n, uint_t base = 2);
 std::string int2string(uint_t n, uint_t base, uint_t length);
 
 // Convert integers to bit-strings
-inline std::string int2bin(uint_t n) {return int2string(n, 2);}
-inline std::string int2bin(uint_t n, uint_t length) {return int2string(n, 2, length);}
+inline std::string int2bin(uint_t n) { return int2string(n, 2); }
+inline std::string int2bin(uint_t n, uint_t length) {
+  return int2string(n, 2, length);
+}
 
 // Convert integers to hex-strings
-inline std::string int2hex(uint_t n) {return bin2hex(int2bin(n));}
+inline std::string int2hex(uint_t n) { return bin2hex(int2bin(n)); }
 
 // Convert reg to int
 uint_t reg2int(const reg_t &reg, uint_t base);
@@ -265,37 +262,34 @@ uint_t reg2int(const reg_t &reg, uint_t base);
 const uint_t zer = 0U;
 const uint_t one = 1U;
 
-
 //==============================================================================
 // Implementations: Matrix functions
 //==============================================================================
 
-template<class T>
-matrix<T> devectorize_matrix(const std::vector<T>& vec) {
+template <class T> matrix<T> devectorize_matrix(const std::vector<T> &vec) {
   size_t dim = std::sqrt(vec.size());
   matrix<T> mat(dim, dim);
-  for (size_t col=0; col < dim; col++)
-    for (size_t row=0; row < dim; row++) {
+  for (size_t col = 0; col < dim; col++)
+    for (size_t row = 0; row < dim; row++) {
       mat(row, col) = vec[dim * col + row];
     }
   return mat;
 }
 
-template<class T>
-std::vector<T> vectorize_matrix(const matrix<T>& mat) {
+template <class T> std::vector<T> vectorize_matrix(const matrix<T> &mat) {
   std::vector<T> vec;
   vec.resize(mat.size(), 0.);
   size_t nrows = mat.GetRows();
   size_t ncols = mat.GetColumns();
-  for (size_t col=0; col < ncols; col++)
-    for (size_t row=0; row < nrows; row++) {
+  for (size_t col = 0; col < ncols; col++)
+    for (size_t row = 0; row < nrows; row++) {
       vec[nrows * col + row] = mat(row, col);
     }
   return vec;
 }
 
 template <class T>
-matrix<T> make_matrix(const std::vector<std::vector<T>> & mat) {
+matrix<T> make_matrix(const std::vector<std::vector<T>> &mat) {
   size_t nrows = mat.size();
   size_t ncols = mat[0].size();
   matrix<T> ret(nrows, ncols);
@@ -306,9 +300,7 @@ matrix<T> make_matrix(const std::vector<std::vector<T>> & mat) {
   return ret;
 }
 
-
-template <class T>
-matrix<T> transpose(const matrix<T> &A) {
+template <class T> matrix<T> transpose(const matrix<T> &A) {
   // Transposes a Matrix
   const size_t rows = A.GetRows(), cols = A.GetColumns();
   matrix<T> temp(cols, rows);
@@ -320,7 +312,6 @@ matrix<T> transpose(const matrix<T> &A) {
   return temp;
 }
 
-
 template <class T>
 matrix<std::complex<T>> dagger(const matrix<std::complex<T>> &A) {
   // Take the Hermitian conjugate of a complex matrix
@@ -334,7 +325,6 @@ matrix<std::complex<T>> dagger(const matrix<std::complex<T>> &A) {
   return temp;
 }
 
-
 template <class T>
 matrix<std::complex<T>> conjugate(const matrix<std::complex<T>> &A) {
   // Take the complex conjugate of a complex matrix
@@ -349,46 +339,47 @@ matrix<std::complex<T>> conjugate(const matrix<std::complex<T>> &A) {
 }
 
 template <class T>
-matrix<T> stacked_matrix(const std::vector<matrix<T>> &mmat){
-        size_t size_of_controls = mmat[0].GetRows(); // or GetColumns, as these matrices are (should be) square
-	size_t number_of_controls = mmat.size();
-
-	// Pack vector of matrices into single (stacked) matrix ... note: matrix dims: rows = (stacked_rows x size_of_controls) where:
-	//     stacked_rows is the number of control matrices * the size (#rows or #columns) of each control matrix
-	//     size_of_controls is the #rows (or #columns) of each control matrix
-	uint_t stacked_rows = number_of_controls*size_of_controls; // Used only for clarity in allocating the matrix
-
-	cmatrix_t stacked_matrix(stacked_rows, size_of_controls);
-	for(uint_t row = 0; row < stacked_rows; row++)
-		for(uint_t col = 0; col < size_of_controls; col++)
-			stacked_matrix(row, col) = {0.0, 0.0};
-
-	for(uint_t mmat_number = 0; mmat_number < mmat.size(); mmat_number++)
-	{
-		for(uint_t row = 0; row < size_of_controls; row++)
-		{
-			for(uint_t col = 0; col < size_of_controls; col++)
-			{
-				stacked_matrix(mmat_number * size_of_controls + row, col) = mmat[mmat_number](row, col);
-			}
-
-		}
-	}
-	return stacked_matrix;
-}
-
-template<class T>
-std::vector<T> matrix_diagonal(const matrix<T>& mat) {
+matrix<T> stacked_matrix(const std::vector<matrix<T>> &mmat) {
+  size_t size_of_controls =
+      mmat[0]
+          .GetRows(); // or GetColumns, as these matrices are (should be) square
+  size_t number_of_controls = mmat.size();
+
+  // Pack vector of matrices into single (stacked) matrix ... note: matrix dims:
+  // rows = (stacked_rows x size_of_controls) where:
+  //     stacked_rows is the number of control matrices * the size (#rows or
+  //     #columns) of each control matrix size_of_controls is the #rows (or
+  //     #columns) of each control matrix
+  uint_t stacked_rows =
+      number_of_controls *
+      size_of_controls; // Used only for clarity in allocating the matrix
+
+  cmatrix_t stacked_matrix(stacked_rows, size_of_controls);
+  for (uint_t row = 0; row < stacked_rows; row++)
+    for (uint_t col = 0; col < size_of_controls; col++)
+      stacked_matrix(row, col) = {0.0, 0.0};
+
+  for (uint_t mmat_number = 0; mmat_number < mmat.size(); mmat_number++) {
+    for (uint_t row = 0; row < size_of_controls; row++) {
+      for (uint_t col = 0; col < size_of_controls; col++) {
+        stacked_matrix(mmat_number * size_of_controls + row, col) =
+            mmat[mmat_number](row, col);
+      }
+    }
+  }
+  return stacked_matrix;
+}
+
+template <class T> std::vector<T> matrix_diagonal(const matrix<T> &mat) {
   std::vector<T> vec;
   size_t size = std::min(mat.GetRows(), mat.GetColumns());
   vec.resize(size, 0.);
-  for (size_t i=0; i < size; i++)
+  for (size_t i = 0; i < size; i++)
     vec[i] = mat(i, i);
   return vec;
 }
 
-template <class T> 
-matrix<T>& transpose_inplace(matrix<T> &A) {
+template <class T> matrix<T> &transpose_inplace(matrix<T> &A) {
   // Transposes a Matrix
   const size_t rows = A.GetRows(), cols = A.GetColumns();
   for (size_t i = 0; i < rows; i++) {
@@ -401,9 +392,8 @@ matrix<T>& transpose_inplace(matrix<T> &A) {
   return A;
 }
 
-
 template <class T>
-matrix<std::complex<T>>& dagger_inplace(matrix<std::complex<T>> &A) {
+matrix<std::complex<T>> &dagger_inplace(matrix<std::complex<T>> &A) {
   // Take the Hermitian conjugate of a complex matrix
   const size_t cols = A.GetColumns(), rows = A.GetRows();
   matrix<std::complex<T>> temp(cols, rows);
@@ -418,9 +408,8 @@ matrix<std::complex<T>>& dagger_inplace(matrix<std::complex<T>> &A) {
   return A;
 }
 
-
 template <class T>
-matrix<std::complex<T>>& conj_inplace(matrix<std::complex<T>> &A) {
+matrix<std::complex<T>> &conj_inplace(matrix<std::complex<T>> &A) {
   // Take the complex conjugate of a complex matrix
   const size_t rows = A.GetRows(), cols = A.GetColumns();
   for (size_t i = 0; i < rows; i++) {
@@ -431,9 +420,7 @@ matrix<std::complex<T>>& conj_inplace(matrix<std::complex<T>> &A) {
   return A;
 }
 
-
-template <class T>
-T trace(const matrix<T> &A) {
+template <class T> T trace(const matrix<T> &A) {
   // Finds the trace of a matrix
   size_t rows = A.GetRows(), cols = A.GetColumns();
   if (rows != cols) {
@@ -454,7 +441,8 @@ matrix<T> partial_trace_a(const matrix<T> &rho, size_t dimA) {
     throw std::invalid_argument("MU::partial_trace_a: matrix is not square");
   }
   if (rows % dimA != 0) {
-    throw std::invalid_argument("MU::partial_trace_a: dim(rho)/dim(system b) is not an integer");
+    throw std::invalid_argument(
+        "MU::partial_trace_a: dim(rho)/dim(system b) is not an integer");
   }
   size_t dimB = rows / dimA;
   matrix<T> rhoB(dimB, dimB);
@@ -471,7 +459,6 @@ matrix<T> partial_trace_a(const matrix<T> &rho, size_t dimA) {
   return rhoB;
 }
 
-
 template <class T>
 matrix<T> partial_trace_b(const matrix<T> &rho, size_t dimB) {
   // Traces out second system (dimension dimB) of composite Hilbert space
@@ -480,7 +467,8 @@ matrix<T> partial_trace_b(const matrix<T> &rho, size_t dimB) {
     throw std::invalid_argument("MU::partial_trace_b: matrix is not square");
   }
   if (rows % dimB != 0) {
-    throw std::invalid_argument("MU::partial_trace_b: dim(rho)/dim(system a) is not an integer");
+    throw std::invalid_argument(
+        "MU::partial_trace_b: dim(rho)/dim(system a) is not an integer");
   }
   size_t dimA = rows / dimB;
   matrix<T> rhoA(dimA, dimA);
@@ -499,7 +487,6 @@ matrix<T> partial_trace_b(const matrix<T> &rho, size_t dimB) {
   return rhoA;
 }
 
-
 template <class T>
 matrix<T> tensor_product(const matrix<T> &A, const matrix<T> &B) {
   // Works out the TensorProduct of two matricies A tensor B
@@ -536,7 +523,8 @@ template <class T> matrix<T> unitary_superop(const matrix<T> &mat) {
   return tensor_product(conjugate(mat), mat);
 }
 
-template <class T> matrix<T> kraus_superop(const std::vector<matrix<T>> &kmats) {
+template <class T>
+matrix<T> kraus_superop(const std::vector<matrix<T>> &kmats) {
   if (kmats.empty())
     return matrix<T>();
   matrix<T> mat = unitary_superop(kmats[0]);
@@ -547,63 +535,64 @@ template <class T> matrix<T> kraus_superop(const std::vector<matrix<T>> &kmats)
 }
 
 template <class T>
-matrix<T> concatenate (const matrix<T> &A, const matrix<T> &B, uint_t axis) {
-  if (axis != 0 && axis!= 1) {
+matrix<T> concatenate(const matrix<T> &A, const matrix<T> &B, uint_t axis) {
+  if (axis != 0 && axis != 1) {
     throw std::invalid_argument("Utils::concatenate: axis must be 0 or 1");
   }
-  size_t rows1 = A.GetRows(), rows2 = B.GetRows(), cols1 = A.GetColumns(), cols2 = B.GetColumns();
+  size_t rows1 = A.GetRows(), rows2 = B.GetRows(), cols1 = A.GetColumns(),
+         cols2 = B.GetColumns();
   matrix<T> temp = A;
-  if(axis == 0) {
-     if(cols1 != cols2) {
-	throw std::invalid_argument("Utils::concatenate: axis must be 0 or 1");
-     }
-  temp.resize(rows1 + rows2, cols1);
-  for (size_t i = 0; i < rows2; i++)
-	for (size_t j = 0; j < cols1; j++)
-      temp(rows1 + i,j) = B(i,j);
-  }
-  else if(axis == 1) {
-    if(rows1 != rows2) {
-      throw std::invalid_argument("Utils::concatenate: the 2 matrices have a different number of rows");
-	}
-	temp.resize(rows1, cols1 + cols2);
-	for (size_t i = 0; i < rows1; i++)
-	  for (size_t j = 0; j < cols2; j++)
-		temp(i,cols1 + j) = B(i,j);
+  if (axis == 0) {
+    if (cols1 != cols2) {
+      throw std::invalid_argument("Utils::concatenate: axis must be 0 or 1");
+    }
+    temp.resize(rows1 + rows2, cols1);
+    for (size_t i = 0; i < rows2; i++)
+      for (size_t j = 0; j < cols1; j++)
+        temp(rows1 + i, j) = B(i, j);
+  } else if (axis == 1) {
+    if (rows1 != rows2) {
+      throw std::invalid_argument(
+          "Utils::concatenate: the 2 matrices have a different number of rows");
+    }
+    temp.resize(rows1, cols1 + cols2);
+    for (size_t i = 0; i < rows1; i++)
+      for (size_t j = 0; j < cols2; j++)
+        temp(i, cols1 + j) = B(i, j);
   }
   return temp;
 }
 
 template <class T>
-void split (const matrix<T> &A, matrix<T> &B, matrix<T> &C, uint_t axis) {
+void split(const matrix<T> &A, matrix<T> &B, matrix<T> &C, uint_t axis) {
   if (axis != 0 && axis != 1) {
     throw std::invalid_argument("Utils::split: axis must be 0 or 1");
   }
   size_t rows = A.GetRows(), cols = A.GetColumns();
   matrix<T> temp = A;
-  if(axis == 0) {
+  if (axis == 0) {
     if (rows % 2 != 0) {
       throw std::invalid_argument("Utils::split: can't split matrix A by rows");
     }
-    B.resize(rows/2 , cols);
-    C.resize(rows/2 , cols);
-    for (size_t i = 0; i < rows/2; i++) {
+    B.resize(rows / 2, cols);
+    C.resize(rows / 2, cols);
+    for (size_t i = 0; i < rows / 2; i++) {
       for (size_t j = 0; j < cols; j++) {
-	B(i,j) = A(i,j);
-	C(i,j) = A(i+rows/2,j);
+        B(i, j) = A(i, j);
+        C(i, j) = A(i + rows / 2, j);
       }
     }
-  }
-  else if(axis == 1) {
+  } else if (axis == 1) {
     if (cols % 2 != 0) {
-      throw std::invalid_argument("Utils::split: can't split matrix A by columns"); 
+      throw std::invalid_argument(
+          "Utils::split: can't split matrix A by columns");
     }
-    B.resize(rows, cols/2);
-    C.resize(rows, cols/2);
-    for (size_t i = 0; i < rows; i++){
-      for (size_t j = 0; j < cols/2; j++) {
-	B(i,j) = A(i,j);
-	C(i,j) = A(i,j+cols/2);
+    B.resize(rows, cols / 2);
+    C.resize(rows, cols / 2);
+    for (size_t i = 0; i < rows; i++) {
+      for (size_t j = 0; j < cols / 2; j++) {
+        B(i, j) = A(i, j);
+        C(i, j) = A(i, j + cols / 2);
       }
     }
   }
@@ -615,8 +604,9 @@ matrix<T> elementwise_multiplication(const matrix<T> &A, const matrix<T> &B) {
   // If A or B is empty it will return the other matrix
   size_t rows1 = A.GetRows(), rows2 = B.GetRows(), cols1 = A.GetColumns(),
          cols2 = B.GetColumns();
-  if(rows1 != rows2 || cols1 != cols2) {
-    throw std::invalid_argument("Utils::elementwise_multiplication: matrices have different sizes");
+  if (rows1 != rows2 || cols1 != cols2) {
+    throw std::invalid_argument(
+        "Utils::elementwise_multiplication: matrices have different sizes");
   }
   matrix<T> temp(rows1, cols1);
   for (size_t i = 0; i < rows1; i++)
@@ -625,24 +615,20 @@ matrix<T> elementwise_multiplication(const matrix<T> &A, const matrix<T> &B) {
   return temp;
 }
 
-template <class T>
-T sum(const matrix<T> &A){
+template <class T> T sum(const matrix<T> &A) {
   T temp = 0;
-  for(uint_t i = 0; i < A.size(); i++)
+  for (uint_t i = 0; i < A.size(); i++)
     temp += A[i];
   return temp;
 }
 
-
-template <class T>
-bool is_square(const matrix<T> &mat) {
+template <class T> bool is_square(const matrix<T> &mat) {
   if (mat.GetRows() != mat.GetColumns())
     return false;
   return true;
 }
 
-template <class T>
-bool is_diagonal(const matrix<T> &mat) {
+template <class T> bool is_diagonal(const matrix<T> &mat) {
   // Check if row-matrix for diagonal
   if (mat.GetRows() == 1 && mat.GetColumns() > 0)
     return true;
@@ -660,42 +646,41 @@ bool is_equal(const matrix<T> &mat1, const matrix<T> &mat2, double threshold) {
 
   // Check matrices are equal on an entry by entry basis
   double delta = 0;
-  for (size_t i=0; i < nrows; i++) {
-    for (size_t j=0; j < ncols; j++) {
+  for (size_t i = 0; i < nrows; i++) {
+    for (size_t j = 0; j < ncols; j++) {
       delta += std::real(std::abs(mat1(i, j) - mat2(i, j)));
     }
   }
   return (delta < threshold);
 }
 
-template <class T>
-bool is_diagonal(const matrix<T> &mat, double threshold) {
+template <class T> bool is_diagonal(const matrix<T> &mat, double threshold) {
   // Check U matrix is identity
   const auto nrows = mat.GetRows();
   const auto ncols = mat.GetColumns();
   if (nrows != ncols)
     return false;
-  for (size_t i=0; i < nrows; i++)
-    for (size_t j=0; j < ncols; j++)
+  for (size_t i = 0; i < nrows; i++)
+    for (size_t j = 0; j < ncols; j++)
       if (i != j && std::real(std::abs(mat(i, j))) > threshold)
         return false;
   return true;
 }
 
+template <class T>
+std::pair<bool, double> is_identity_phase(const matrix<T> &mat,
+                                          double threshold) {
 
-template <class T> 
-std::pair<bool, double> is_identity_phase(const matrix<T> &mat, double threshold) {
-  
   // To check if identity we first check we check that:
   // 1. U(0,0) = exp(i * theta)
   // 2. U(i, i) = U(0, 0)
-  // 3. U(i, j) = 0 for j != i 
+  // 3. U(i, j) = 0 for j != i
   auto failed = std::make_pair(false, 0.0);
 
   // Check condition 1.
   const auto u00 = mat(0, 0);
-  //if (std::norm(std::abs(u00) - 1.0) > threshold)
-  //  return failed;
+  // if (std::norm(std::abs(u00) - 1.0) > threshold)
+  //   return failed;
   if (std::norm(std::abs(u00) - 1.0) > threshold) {
     return failed;
   }
@@ -707,10 +692,9 @@ std::pair<bool, double> is_identity_phase(const matrix<T> &mat, double threshold
   const auto ncols = mat.GetColumns();
   if (nrows != ncols)
     return failed;
-  for (size_t i=0; i < nrows; i++) {
-    for (size_t j=0; j < ncols; j++) {
-      auto val = (i==j) ? std::norm(mat(i, j) - u00)
-                        : std::norm(mat(i, j));
+  for (size_t i = 0; i < nrows; i++) {
+    for (size_t j = 0; j < ncols; j++) {
+      auto val = (i == j) ? std::norm(mat(i, j) - u00) : std::norm(mat(i, j));
       if (val > threshold) {
         return failed; // fail fast if single entry differs
       } else
@@ -725,8 +709,7 @@ std::pair<bool, double> is_identity_phase(const matrix<T> &mat, double threshold
   return std::make_pair(true, theta);
 }
 
-template <class T> 
-bool is_identity(const matrix<T> &mat, double threshold) {
+template <class T> bool is_identity(const matrix<T> &mat, double threshold) {
   // Check mat(0, 0) == 1
   if (std::norm(mat(0, 0) - T(1)) > threshold)
     return false;
@@ -742,19 +725,18 @@ bool is_diagonal_identity(const matrix<T> &mat, double threshold) {
     return false;
   double delta = 0.;
   const auto ncols = mat.GetColumns();
-  for (size_t j=0; j < ncols; j++) {
+  for (size_t j = 0; j < ncols; j++) {
     delta += std::real(std::abs(mat(0, j) - 1.0));
   }
   return (delta < threshold);
 }
 
-template <class T> 
-bool is_unitary(const matrix<T> &mat, double threshold) {
+template <class T> bool is_unitary(const matrix<T> &mat, double threshold) {
   size_t nrows = mat.GetRows();
   size_t ncols = mat.GetColumns();
   // Check if diagonal row-matrix
   if (nrows == 1) {
-    for (size_t j=0; j < ncols; j++) {
+    for (size_t j = 0; j < ncols; j++) {
       double delta = std::abs(1.0 - std::real(std::abs(mat(0, j))));
       if (delta > threshold)
         return false;
@@ -769,14 +751,12 @@ bool is_unitary(const matrix<T> &mat, double threshold) {
   return is_identity(check, threshold);
 }
 
-
 template <class T>
 bool is_hermitian_matrix(const matrix<T> &mat, double threshold) {
   return is_equal(mat, dagger(mat), threshold);
 }
 
-template <class T>
-bool is_symmetrix(const matrix<T> &mat, double threshold) {
+template <class T> bool is_symmetrix(const matrix<T> &mat, double threshold) {
   return is_equal(mat, transpose(mat), threshold);
 }
 
@@ -802,21 +782,22 @@ bool is_unit_vector(const std::vector<T> &vec, double threshold) {
 template <typename T>
 std::vector<std::complex<T>> conjugate(const std::vector<std::complex<T>> &v) {
   std::vector<std::complex<T>> ret;
-  std::transform(v.cbegin(), v.cend(), std::back_inserter(ret),
-                [] (const std::complex<T> &c) -> std::complex<T> { return std::conj(c); });
+  std::transform(
+      v.cbegin(), v.cend(), std::back_inserter(ret),
+      [](const std::complex<T> &c) -> std::complex<T> { return std::conj(c); });
   return ret;
 }
 
 template <typename T>
 Vector<std::complex<T>> conjugate(const Vector<std::complex<T>> &v) {
   Vector<std::complex<T>> ret(v.size(), false);
-  std::transform(v.data(), v.data() + v.size(), ret.data(),
-                [] (const std::complex<T> &c) -> std::complex<T> { return std::conj(c); });
+  std::transform(
+      v.data(), v.data() + v.size(), ret.data(),
+      [](const std::complex<T> &c) -> std::complex<T> { return std::conj(c); });
   return ret;
 }
 
-template <typename T>
-double norm(const std::vector<T> &vec) {
+template <typename T> double norm(const std::vector<T> &vec) {
   double val = 0.0;
   for (const auto &v : vec) {
     val += std::real(v * std::conj(v));
@@ -843,8 +824,8 @@ std::vector<T> tensor_product(const std::vector<T> &vec1,
   ret.reserve(vec1.size() * vec2.size());
   for (const auto &a : vec1)
     for (const auto &b : vec2) {
-        ret.push_back(a * b);
-  }
+      ret.push_back(a * b);
+    }
   return ret;
 }
 
@@ -855,8 +836,8 @@ Vector<T> tensor_product(const Vector<T> &vec1, const Vector<T> &vec2) {
   Vector<T> ret(SZ1 * SZ2, false);
   for (size_t i = 0; i < SZ1; ++i)
     for (size_t j = 0; j < SZ2; ++j) {
-        ret[SZ2 * i + j] = vec1[i] * vec2[j];
-  }
+      ret[SZ2 * i + j] = vec1[i] * vec2[j];
+    }
   return ret;
 }
 
@@ -870,30 +851,26 @@ std::vector<T1> scalar_multiply(const std::vector<T1> &vec, T2 val) {
   return ret;
 }
 
-
 template <typename T1, typename T2>
-std::vector<T1>& scalar_multiply_inplace(std::vector<T1> &vec, T2 val) {
+std::vector<T1> &scalar_multiply_inplace(std::vector<T1> &vec, T2 val) {
   for (auto &elt : vec) {
     elt = val * elt; // use * incase T1 doesn't have *= method
   }
   return vec;
 }
 
-
 double &chop_inplace(double &val, double epsilon) {
   if (std::abs(val) < epsilon)
     val = 0.;
   return val;
 }
 
-
 std::complex<double> &chop_inplace(std::complex<double> &val, double epsilon) {
   val.real(chop(val.real(), epsilon));
   val.imag(chop(val.imag(), epsilon));
   return val;
 }
 
-
 template <typename T>
 std::vector<T> &chop_inplace(std::vector<T> &vec, double epsilon) {
   if (epsilon > 0.)
@@ -902,7 +879,6 @@ std::vector<T> &chop_inplace(std::vector<T> &vec, double epsilon) {
   return vec;
 }
 
-
 double chop(double val, double epsilon) {
   return (std::abs(val) < epsilon) ? 0. : val;
 }
@@ -916,7 +892,6 @@ std::complex<T> chop(std::complex<T> val, double epsilon) {
   return {chop(val.real(), epsilon), chop(val.imag(), epsilon)};
 }
 
-
 template <typename T>
 std::vector<T> chop(const std::vector<T> &vec, double epsilon) {
   std::vector<T> tmp;
@@ -926,7 +901,6 @@ std::vector<T> chop(const std::vector<T> &vec, double epsilon) {
   return tmp;
 }
 
-
 template <class T>
 void combine(std::vector<T> &lhs, const std::vector<T> &rhs) {
   // if lhs is empty, set it to be rhs vector
@@ -936,16 +910,17 @@ void combine(std::vector<T> &lhs, const std::vector<T> &rhs) {
   }
   // if lhs is not empty rhs must be same size
   if (lhs.size() != rhs.size()) {
-    throw std::invalid_argument("Utils::combine (vectors are not same length.)");
+    throw std::invalid_argument(
+        "Utils::combine (vectors are not same length.)");
   }
-  for (size_t j=0; j < lhs.size(); ++j) {
+  for (size_t j = 0; j < lhs.size(); ++j) {
     lhs[j] += rhs[j];
   }
 }
 
-
 template <typename T>
-std::map<std::string, T> vec2ket(const std::vector<T> &vec, double epsilon, uint_t base) {
+std::map<std::string, T> vec2ket(const std::vector<T> &vec, double epsilon,
+                                 uint_t base) {
 
   bool hex_output = false;
   if (base == 16) {
@@ -958,15 +933,16 @@ std::map<std::string, T> vec2ket(const std::vector<T> &vec, double epsilon, uint
   uint_t nint = std::trunc(n);
   if (std::abs(nint - n) > 1e-5) {
     std::stringstream ss;
-    ss << "vec2ket (vector dimension " << dim << " is not of size " << base << "^n)";
+    ss << "vec2ket (vector dimension " << dim << " is not of size " << base
+       << "^n)";
     throw std::invalid_argument(ss.str());
   }
   std::map<std::string, T> ketmap;
   for (size_t k = 0; k < dim; ++k) {
     T val = chop(vec[k], epsilon);
     if (std::abs(val) > epsilon) {
-      std::string key = (hex_output) ? Utils::int2hex(k)
-                                     : Utils::int2string(k, base, nint);
+      std::string key =
+          (hex_output) ? Utils::int2hex(k) : Utils::int2string(k, base, nint);
       ketmap.insert({key, val});
     }
   }
@@ -974,7 +950,8 @@ std::map<std::string, T> vec2ket(const std::vector<T> &vec, double epsilon, uint
 }
 
 template <typename T>
-std::map<std::string, T> vec2ket(const T* const vec, uint_t dim, double epsilon, uint_t base){
+std::map<std::string, T> vec2ket(const T *const vec, uint_t dim, double epsilon,
+                                 uint_t base) {
   bool hex_output = false;
   if (base == 16) {
     hex_output = true;
@@ -985,7 +962,8 @@ std::map<std::string, T> vec2ket(const T* const vec, uint_t dim, double epsilon,
   uint_t nint = std::trunc(n);
   if (std::abs(nint - n) > 1e-5) {
     std::stringstream ss;
-    ss << "vec2ket (vector dimension " << dim << " is not of size " << base << "^n)";
+    ss << "vec2ket (vector dimension " << dim << " is not of size " << base
+       << "^n)";
     throw std::invalid_argument(ss.str());
   }
 
@@ -993,8 +971,8 @@ std::map<std::string, T> vec2ket(const T* const vec, uint_t dim, double epsilon,
   for (size_t k = 0; k < dim; ++k) {
     T val = chop(vec[k], epsilon);
     if (std::abs(val) > epsilon) {
-      std::string key = (hex_output) ? Utils::int2hex(k)
-                                     : Utils::int2string(k, base, nint);
+      std::string key =
+          (hex_output) ? Utils::int2hex(k) : Utils::int2string(k, base, nint);
       ketmap.insert({key, val});
     }
   }
@@ -1005,7 +983,7 @@ std::map<std::string, T> vec2ket(const T* const vec, uint_t dim, double epsilon,
 // Implementations: Bit conversions
 //==============================================================================
 
-std::string& format_hex_inplace(std::string &hex) {
+std::string &format_hex_inplace(std::string &hex) {
   // make abcdef and x lower case
   std::transform(hex.begin(), hex.end(), hex.begin(), ::tolower);
   // check if 0x prefix is present, add if it isn't
@@ -1017,28 +995,24 @@ std::string& format_hex_inplace(std::string &hex) {
   return hex;
 }
 
-
 std::string format_hex(const std::string &hex) {
   std::string tmp = hex;
   format_hex_inplace(tmp);
   return tmp;
 }
 
-
-std::string& padleft_inplace(std::string &s, char c, size_t min_length) {
+std::string &padleft_inplace(std::string &s, char c, size_t min_length) {
   auto l = s.size();
   if (l < min_length)
     s = std::string(min_length - l, c) + s;
   return s;
 }
 
-
 std::string padleft(const std::string &s, char c, size_t min_length) {
   std::string tmp = s;
   return padleft_inplace(tmp, c, min_length);
 }
 
-
 reg_t int2reg(uint_t n, uint_t base) {
   reg_t ret;
   while (n >= base) {
@@ -1049,7 +1023,6 @@ reg_t int2reg(uint_t n, uint_t base) {
   return ret;
 }
 
-
 reg_t int2reg(uint_t n, uint_t base, uint_t minlen) {
   reg_t ret = int2reg(n, base);
   if (ret.size() < minlen) // pad vector with zeros
@@ -1057,12 +1030,11 @@ reg_t int2reg(uint_t n, uint_t base, uint_t minlen) {
   return ret;
 }
 
-
 reg_t hex2reg(std::string str) {
   reg_t reg;
   std::string prefix = str.substr(0, 2);
   if (prefix == "0x" || prefix == "0X") { // Hexadecimal
-    str.erase(0, 2); // remove '0x';
+    str.erase(0, 2);                      // remove '0x';
     size_t length = (str.size() % 8) + 32 * (str.size() / 8);
     reg.reserve(length);
     while (str.size() > 8) {
@@ -1081,7 +1053,6 @@ reg_t hex2reg(std::string str) {
   }
 }
 
-
 std::string hex2bin(std::string str, bool prefix) {
   // empty case
   if (str.empty())
@@ -1104,16 +1075,16 @@ std::string hex2bin(std::string str, bool prefix) {
 
   // Start with remain
   if (remain != 0)
-      bin += int2string(std::stoull(str.substr(0, remain), nullptr, 16), 2);
+    bin += int2string(std::stoull(str.substr(0, remain), nullptr, 16), 2);
 
-  for (size_t j=0; j < chunks; ++j) {
-    std::string part = int2string(std::stoull(str.substr(remain + j * block, block), nullptr, 16), 2, 64);
+  for (size_t j = 0; j < chunks; ++j) {
+    std::string part = int2string(
+        std::stoull(str.substr(remain + j * block, block), nullptr, 16), 2, 64);
     bin += part;
   }
   return bin;
 }
 
-
 std::string bin2hex(std::string str, bool prefix) {
   // empty case
   if (str.empty())
@@ -1157,9 +1128,11 @@ std::string bin2hex(std::string str, bool prefix) {
       hex += part;
     }
     // Add any additional chunks
-    for (size_t j=1; j < chunks; ++j) {
+    for (size_t j = 1; j < chunks; ++j) {
       std::stringstream ss; // clear string stream
-      ss << std::hex << std::stoull(str.substr(remain + j * bin_block, bin_block), nullptr, 2);
+      ss << std::hex
+         << std::stoull(str.substr(remain + j * bin_block, bin_block), nullptr,
+                        2);
       part = ss.str();
       part.insert(0, hex_block - part.size(), '0');
       hex += part;
@@ -1168,27 +1141,26 @@ std::string bin2hex(std::string str, bool prefix) {
   return hex;
 }
 
-
 uint_t reg2int(const reg_t &reg, uint_t base) {
   uint_t ret = 0;
   if (base == 2) {
     // For base-2 use bit-shifting
-    for (size_t j=0; j < reg.size(); j++)
+    for (size_t j = 0; j < reg.size(); j++)
       if (reg[j])
         ret += (1ULL << j);
   } else {
     // For other bases use exponentiation
-    for (size_t j=0; j < reg.size(); j++)
+    for (size_t j = 0; j < reg.size(); j++)
       if (reg[j] > 0)
         ret += reg[j] * static_cast<uint_t>(pow(base, j));
   }
   return ret;
 }
 
-
 std::string int2string(uint_t n, uint_t base) {
   if (base < 2 || base > 10) {
-    throw std::invalid_argument("Utils::int2string base must be between 2 and 10.");
+    throw std::invalid_argument(
+        "Utils::int2string base must be between 2 and 10.");
   }
   if (n < base)
     return std::to_string(n);
@@ -1196,85 +1168,68 @@ std::string int2string(uint_t n, uint_t base) {
     return int2string(n / base, base) + std::to_string(n % base);
 }
 
-
 std::string int2string(uint_t n, uint_t base, uint_t minlen) {
   std::string tmp = int2string(n, base);
   return padleft_inplace(tmp, '0', minlen);
 }
 
 #ifdef _MSC_VER
-  #ifdef _WIN64
-    #define POPCNT __popcnt64
-  #else
-    #define POPCNT __popcnt
-  #endif
-  #define INTRINSIC_PARITY 1
-  inline bool _intrinsic_parity(uint_t x)
-  {
-    return (POPCNT(x) & one);
-  }
-  inline uint_t _instrinsic_weight(uint_t x)
-  {
-    return (POPCNT(x));
-  }
+#ifdef _WIN64
+#define POPCNT __popcnt64
+#else
+#define POPCNT __popcnt
+#endif
+#define INTRINSIC_PARITY 1
+inline bool _intrinsic_parity(uint_t x) { return (POPCNT(x) & one); }
+inline uint_t _instrinsic_weight(uint_t x) { return (POPCNT(x)); }
 #endif
 #ifdef __GNUC__
-  #define INTRINSIC_PARITY 1
-  inline bool _intrinsic_parity(uint_t x)
-  {
-    return (__builtin_popcountll(x) & one);
-  }
-  inline uint_t _instrinsic_weight(uint_t x)
-  {
-    return (__builtin_popcountll(x));
-  }
+#define INTRINSIC_PARITY 1
+inline bool _intrinsic_parity(uint_t x) {
+  return (__builtin_popcountll(x) & one);
+}
+inline uint_t _instrinsic_weight(uint_t x) { return (__builtin_popcountll(x)); }
 #endif
 #ifdef _CLANG_
-  #if __has__builtin(__builtin_popcount)
-  #define INTRINSIC_PARITY 1
-    inline bool _intrinsic_parity(uint_t x)
-    {
-      return (__builtin_popcountll(x) & one);
-    }
-    inline uint_t _instrinsic_weight(uint_t x)
-    {
-      return (__builtin_popcountll(x));
-    }
-  #endif
+#if __has__builtin(__builtin_popcount)
+#define INTRINSIC_PARITY 1
+inline bool _intrinsic_parity(uint_t x) {
+  return (__builtin_popcountll(x) & one);
+}
+inline uint_t _instrinsic_weight(uint_t x) { return (__builtin_popcountll(x)); }
 #endif
-  // Implementation from http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan
-  static bool _naive_parity(uint_t x)
-  {
-    uint_t c; // c accumulates the total bits set in x
-    for (c = 0; x; c++)
-    {
-      x &= (x - 1); // clear the least significant bit set
-    }
-    return (c&one);
-  }
-  static uint_t _naive_weight(uint_t x)
-  {
-    auto count = x;
-    count = (count & 0x5555555555555555) + ((count >> 1) & 0x5555555555555555);
-    count = (count & 0x3333333333333333) + ((count >> 2) & 0x3333333333333333);
-    count = (count & 0x0f0f0f0f0f0f0f0f) + ((count >> 4) & 0x0f0f0f0f0f0f0f0f);
-    count = (count & 0x00ff00ff00ff00ff) + ((count >> 8) & 0x00ff00ff00ff00ff);
-    count = (count & 0x0000ffff0000ffff) + ((count >> 16) & 0x0000ffff0000ffff);
-    count = (count & 0x00000000ffffffff) + ((count >> 32) & 0x00000000ffffffff);
-    return count;
+#endif
+// Implementation from
+// http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan
+static bool _naive_parity(uint_t x) {
+  uint_t c; // c accumulates the total bits set in x
+  for (c = 0; x; c++) {
+    x &= (x - 1); // clear the least significant bit set
   }
+  return (c & one);
+}
+static uint_t _naive_weight(uint_t x) {
+  auto count = x;
+  count = (count & 0x5555555555555555) + ((count >> 1) & 0x5555555555555555);
+  count = (count & 0x3333333333333333) + ((count >> 2) & 0x3333333333333333);
+  count = (count & 0x0f0f0f0f0f0f0f0f) + ((count >> 4) & 0x0f0f0f0f0f0f0f0f);
+  count = (count & 0x00ff00ff00ff00ff) + ((count >> 8) & 0x00ff00ff00ff00ff);
+  count = (count & 0x0000ffff0000ffff) + ((count >> 16) & 0x0000ffff0000ffff);
+  count = (count & 0x00000000ffffffff) + ((count >> 32) & 0x00000000ffffffff);
+  return count;
+}
 
 #ifdef INTRINSIC_PARITY
-  bool (*hamming_parity)(uint_t) = is_avx2_supported() ? &_intrinsic_parity : &_naive_parity;
-  uint_t (*popcount)(uint_t) = is_avx2_supported() ? &_instrinsic_weight : &_naive_weight;
+bool (*hamming_parity)(uint_t) = is_avx2_supported() ? &_intrinsic_parity
+                                                     : &_naive_parity;
+uint_t (*popcount)(uint_t) = is_avx2_supported() ? &_instrinsic_weight
+                                                 : &_naive_weight;
 #else
-  bool (*hamming_parity)(uint_t) = &_naive_parity;
-  uint_t (*popcount)(uint_t) = &_naive_weight;
+bool (*hamming_parity)(uint_t) = &_naive_parity;
+uint_t (*popcount)(uint_t) = &_naive_weight;
 #endif
 
-
-size_t get_system_memory_mb() 
-{
+size_t get_system_memory_mb() {
   size_t total_physical_memory = 0;
 #if defined(__linux__) || defined(__APPLE__)
   size_t pages = (size_t)sysconf(_SC_PHYS_PAGES);
@@ -1289,53 +1244,50 @@ size_t get_system_memory_mb()
   return total_physical_memory >> 20;
 }
 
-//apply OpenMP parallel loop to lambda function if enabled
-template<typename Lambda>
-void apply_omp_parallel_for(bool enabled, int_t i_begin, int_t i_end, Lambda& func, int nthreads = 0)
-{
-  if(enabled){
-    if(nthreads > 0){
+// apply OpenMP parallel loop to lambda function if enabled
+template <typename Lambda>
+void apply_omp_parallel_for(bool enabled, int_t i_begin, int_t i_end,
+                            Lambda &func, int nthreads = 0) {
+  if (enabled) {
+    if (nthreads > 0) {
 #pragma omp parallel for num_threads(nthreads)
-      for(int_t i=i_begin;i<i_end;i++)
+      for (int_t i = i_begin; i < i_end; i++)
         func(i);
-    }
-    else{
+    } else {
 #pragma omp parallel for
-      for(int_t i=i_begin;i<i_end;i++)
+      for (int_t i = i_begin; i < i_end; i++)
         func(i);
     }
-  }
-  else{
-    for(int_t i=i_begin;i<i_end;i++)
+  } else {
+    for (int_t i = i_begin; i < i_end; i++)
       func(i);
   }
 }
 
-//apply OpenMP parallel loop to lambda function and return reduced double if enabled
-template<typename Lambda>
-double apply_omp_parallel_for_reduction(bool enabled, int_t i_begin, int_t i_end, Lambda& func, int nthreads = 0)
-{
+// apply OpenMP parallel loop to lambda function and return reduced double if
+// enabled
+template <typename Lambda>
+double apply_omp_parallel_for_reduction(bool enabled, int_t i_begin,
+                                        int_t i_end, Lambda &func,
+                                        int nthreads = 0) {
   double val = 0.0;
-  if(enabled){
-    if(nthreads > 0){
-#pragma omp parallel for reduction(+:val) num_threads(nthreads)
-      for(int_t i=i_begin;i<i_end;i++)
+  if (enabled) {
+    if (nthreads > 0) {
+#pragma omp parallel for reduction(+ : val) num_threads(nthreads)
+      for (int_t i = i_begin; i < i_end; i++)
         val += func(i);
-    }
-    else{
-#pragma omp parallel for reduction(+:val)
-      for(int_t i=i_begin;i<i_end;i++)
+    } else {
+#pragma omp parallel for reduction(+ : val)
+      for (int_t i = i_begin; i < i_end; i++)
         val += func(i);
     }
-  }
-  else{
-    for(int_t i=i_begin;i<i_end;i++)
+  } else {
+    for (int_t i = i_begin; i < i_end; i++)
       val += func(i);
   }
   return val;
 }
 
-
 //------------------------------------------------------------------------------
 } // end namespace Utils
 //------------------------------------------------------------------------------
diff --git a/src/misc/clang_omp_symbols.hpp b/src/misc/clang_omp_symbols.hpp
index 4817c7aa78..8301974ba5 100644
--- a/src/misc/clang_omp_symbols.hpp
+++ b/src/misc/clang_omp_symbols.hpp
@@ -16,10 +16,10 @@
 #define _aer_misc_hacks_clang_symbols_
 
 /*
- * This is some sort of "black magic" to solve a problem we have with OpenMP libraries on Mac.
- * The problem is actually in the library itself, but it's out of our control, so we had to
- * fix it this way.
- * Symbol signatures are taken from: https://github.com/llvm/llvm-project/blob/main/openmp/runtime/src/kmp.h
+ * This is some sort of "black magic" to solve a problem we have with OpenMP
+ * libraries on Mac. The problem is actually in the library itself, but it's out
+ * of our control, so we had to fix it this way. Symbol signatures are taken
+ * from: https://github.com/llvm/llvm-project/blob/main/openmp/runtime/src/kmp.h
  */
 
 #include <dlfcn.h>
@@ -28,313 +28,350 @@
 // Define undefined symbols
 extern "C" {
 
-    typedef struct {
-        int reserved_1;
-        int flags;
-        int reserved_2;
-        int reserved_3;
-        char *psource;
-    }id;
-
-    typedef int kmp_int32;
-    typedef struct ident {
-        kmp_int32 reserved_1; /**<  might be used in Fortran; see above  */
-        kmp_int32 flags; /**<  also f.flags; KMP_IDENT_xxx flags; KMP_IDENT_KMPC
-                            identifies this union member  */
-        kmp_int32 reserved_2; /**<  not really used in Fortran any more; see above */
-        kmp_int32 reserved_3; /**<  source[4] in Fortran, do not use for C++  */
-        char const *psource; /**<  String describing the source location.
-                            The string is composed of semi-colon separated fields
-                            which describe the source file, the function and a pair
-                            of line numbers that delimit the construct. */
-    } ident_t;
-    typedef ident_t kmp_Ident;
-
-    using __kmpc_barrier_t = void(*)(id*, int);
-    __kmpc_barrier_t _hook__kmpc_barrier;
-    void __kmpc_barrier(id* pId, int gtid){
-        _hook__kmpc_barrier(pId, gtid);
-    }
-
-    using __kmpc_for_static_fini_t =  void(*)(kmp_Ident *, int32_t);
-    __kmpc_for_static_fini_t _hook__kmpc_for_static_fini;
-    void __kmpc_for_static_fini(kmp_Ident *loc, int32_t global_tid){
-        _hook__kmpc_for_static_fini(loc, global_tid);
-    }
-
-    using __kmpc_for_static_init_4_t = void(*)(kmp_Ident *, int32_t, int32_t, int32_t *,
-                                     int32_t *, int32_t *, int32_t *, int32_t, int32_t);
-    __kmpc_for_static_init_4_t _hook__kmpc_for_static_init_4;
-    void __kmpc_for_static_init_4(kmp_Ident *loc, int32_t global_tid,
-                                     int32_t sched, int32_t *plastiter,
-                                     int32_t *plower, int32_t *pupper,
-                                     int32_t *pstride, int32_t incr,
-                                     int32_t chunk){
-        _hook__kmpc_for_static_init_4(loc, global_tid, sched, plastiter, plower, pupper, pstride,
-                                       incr, chunk);
-    }
-
-    using __kmpc_for_static_init_8_t = void(*)(kmp_Ident *, int32_t, int32_t, int32_t *,
-                                     int64_t *, int64_t *, int64_t *, int64_t, int64_t);
-    __kmpc_for_static_init_8_t _hook__kmpc_for_static_init_8;
-    void __kmpc_for_static_init_8(kmp_Ident *loc, int32_t global_tid,
-                                     int32_t sched, int32_t *plastiter,
-                                     int64_t *plower, int64_t *pupper,
-                                     int64_t *pstride, int64_t incr,
-                                     int64_t chunk){
-        _hook__kmpc_for_static_init_8(loc, global_tid, sched, plastiter, plower, pupper, pstride,
-                                       incr, chunk);
-    }
+typedef struct {
+  int reserved_1;
+  int flags;
+  int reserved_2;
+  int reserved_3;
+  char *psource;
+} id;
+
+typedef int kmp_int32;
+typedef struct ident {
+  kmp_int32 reserved_1; /**<  might be used in Fortran; see above  */
+  kmp_int32 flags;      /**<  also f.flags; KMP_IDENT_xxx flags; KMP_IDENT_KMPC
+                           identifies this union member  */
+  kmp_int32 reserved_2; /**<  not really used in Fortran any more; see above */
+  kmp_int32 reserved_3; /**<  source[4] in Fortran, do not use for C++  */
+  char const *psource;  /**<  String describing the source location.
+                       The string is composed of semi-colon separated fields
+                       which describe the source file, the function and a pair
+                       of line numbers that delimit the construct. */
+} ident_t;
+typedef ident_t kmp_Ident;
+
+using __kmpc_barrier_t = void (*)(id *, int);
+__kmpc_barrier_t _hook__kmpc_barrier;
+void __kmpc_barrier(id *pId, int gtid) { _hook__kmpc_barrier(pId, gtid); }
+
+using __kmpc_for_static_fini_t = void (*)(kmp_Ident *, int32_t);
+__kmpc_for_static_fini_t _hook__kmpc_for_static_fini;
+void __kmpc_for_static_fini(kmp_Ident *loc, int32_t global_tid) {
+  _hook__kmpc_for_static_fini(loc, global_tid);
+}
 
-    using __kmpc_for_static_init_8u_t = void(*)(kmp_Ident *, int32_t, int32_t, int32_t *, uint64_t *, uint64_t *,
-                                      int64_t *, int64_t, int64_t);
-    __kmpc_for_static_init_8u_t _hook__kmpc_for_static_init_8u;
-    void __kmpc_for_static_init_8u(kmp_Ident *loc, int32_t global_tid,
-                                      int32_t sched, int32_t *plastiter1,
-                                      uint64_t *plower, uint64_t *pupper,
-                                      int64_t *pstride, int64_t incr,
-                                      int64_t chunk){
-        _hook__kmpc_for_static_init_8u(loc, global_tid, sched, plastiter1, plower, pupper, pstride,
-                                       incr, chunk);
-    }
+using __kmpc_for_static_init_4_t = void (*)(kmp_Ident *, int32_t, int32_t,
+                                            int32_t *, int32_t *, int32_t *,
+                                            int32_t *, int32_t, int32_t);
+__kmpc_for_static_init_4_t _hook__kmpc_for_static_init_4;
+void __kmpc_for_static_init_4(kmp_Ident *loc, int32_t global_tid, int32_t sched,
+                              int32_t *plastiter, int32_t *plower,
+                              int32_t *pupper, int32_t *pstride, int32_t incr,
+                              int32_t chunk) {
+  _hook__kmpc_for_static_init_4(loc, global_tid, sched, plastiter, plower,
+                                pupper, pstride, incr, chunk);
+}
 
-    using kpm_int32 = int;
-    typedef void (*kmp_ParFctPtr)(kpm_int32 *global_tid, kpm_int32 *bound_tid, ...);
-    using __kmpc_fork_call_t = void(*)(kmp_Ident *, kpm_int32, kmp_ParFctPtr, ...);
-    __kmpc_fork_call_t _hook__kmpc_fork_call;
-    #include <stdarg.h>
-    void __kmpc_fork_call(kmp_Ident *loc, kpm_int32 argc, kmp_ParFctPtr microtask, ...){
-        va_list argptr;
-        va_start(argptr, microtask);
-        // The types are always pointer to void (from llvm kmp_runtime.cpp)
-        void * arg1 = va_arg(argptr, void *);
-        void * arg2 = va_arg(argptr, void *);
-        void * arg3 = va_arg(argptr, void *);
-        void * arg4 = va_arg(argptr, void *);
-        void * arg5 = va_arg(argptr, void *);
-        void * arg6 = va_arg(argptr, void *);
-        void * arg7 = va_arg(argptr, void *);
-        void * arg8 = va_arg(argptr, void *);
-        void * arg9 = va_arg(argptr, void *);
-        _hook__kmpc_fork_call(loc, argc, microtask, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
-        va_end(argptr);
-    }
+using __kmpc_for_static_init_8_t = void (*)(kmp_Ident *, int32_t, int32_t,
+                                            int32_t *, int64_t *, int64_t *,
+                                            int64_t *, int64_t, int64_t);
+__kmpc_for_static_init_8_t _hook__kmpc_for_static_init_8;
+void __kmpc_for_static_init_8(kmp_Ident *loc, int32_t global_tid, int32_t sched,
+                              int32_t *plastiter, int64_t *plower,
+                              int64_t *pupper, int64_t *pstride, int64_t incr,
+                              int64_t chunk) {
+  _hook__kmpc_for_static_init_8(loc, global_tid, sched, plastiter, plower,
+                                pupper, pstride, incr, chunk);
+}
 
-    using __kmpc_push_num_threads_t = void(*)(kmp_Ident *, int32_t, int32_t);
-    __kmpc_push_num_threads_t _hook__kmpc_push_num_threads;
-    void __kmpc_push_num_threads(kmp_Ident *loc, int32_t global_tid, int32_t num_threads){
-        _hook__kmpc_push_num_threads(loc, global_tid, num_threads);
-    }
+using __kmpc_for_static_init_8u_t = void (*)(kmp_Ident *, int32_t, int32_t,
+                                             int32_t *, uint64_t *, uint64_t *,
+                                             int64_t *, int64_t, int64_t);
+__kmpc_for_static_init_8u_t _hook__kmpc_for_static_init_8u;
+void __kmpc_for_static_init_8u(kmp_Ident *loc, int32_t global_tid,
+                               int32_t sched, int32_t *plastiter1,
+                               uint64_t *plower, uint64_t *pupper,
+                               int64_t *pstride, int64_t incr, int64_t chunk) {
+  _hook__kmpc_for_static_init_8u(loc, global_tid, sched, plastiter1, plower,
+                                 pupper, pstride, incr, chunk);
+}
 
-    typedef kmp_int32 kmp_critical_name[8];
-    using __kmpc_reduce_nowait_t = kmp_int32(*)(ident_t *, kmp_int32, kmp_int32, size_t,
-                                void *, void (*)(void *lhs_data, void *rhs_data),kmp_critical_name *);
-    __kmpc_reduce_nowait_t _hook__kmpc_reduce_nowait;
-    kmp_int32 __kmpc_reduce_nowait(
-                                ident_t *loc, kmp_int32 global_tid, kmp_int32 num_vars, size_t reduce_size,
-                                void *reduce_data, void (*reduce_func)(void *lhs_data, void *rhs_data),
-                                kmp_critical_name *lck){
-        return _hook__kmpc_reduce_nowait(loc, global_tid, num_vars, reduce_size, reduce_data, reduce_func, lck);
-    }
+using kpm_int32 = int;
+typedef void (*kmp_ParFctPtr)(kpm_int32 *global_tid, kpm_int32 *bound_tid, ...);
+using __kmpc_fork_call_t = void (*)(kmp_Ident *, kpm_int32, kmp_ParFctPtr, ...);
+__kmpc_fork_call_t _hook__kmpc_fork_call;
+#include <stdarg.h>
+void __kmpc_fork_call(kmp_Ident *loc, kpm_int32 argc, kmp_ParFctPtr microtask,
+                      ...) {
+  va_list argptr;
+  va_start(argptr, microtask);
+  // The types are always pointer to void (from llvm kmp_runtime.cpp)
+  void *arg1 = va_arg(argptr, void *);
+  void *arg2 = va_arg(argptr, void *);
+  void *arg3 = va_arg(argptr, void *);
+  void *arg4 = va_arg(argptr, void *);
+  void *arg5 = va_arg(argptr, void *);
+  void *arg6 = va_arg(argptr, void *);
+  void *arg7 = va_arg(argptr, void *);
+  void *arg8 = va_arg(argptr, void *);
+  void *arg9 = va_arg(argptr, void *);
+  _hook__kmpc_fork_call(loc, argc, microtask, arg1, arg2, arg3, arg4, arg5,
+                        arg6, arg7, arg8, arg9);
+  va_end(argptr);
+}
 
+using __kmpc_push_num_threads_t = void (*)(kmp_Ident *, int32_t, int32_t);
+__kmpc_push_num_threads_t _hook__kmpc_push_num_threads;
+void __kmpc_push_num_threads(kmp_Ident *loc, int32_t global_tid,
+                             int32_t num_threads) {
+  _hook__kmpc_push_num_threads(loc, global_tid, num_threads);
+}
 
-    using __kmpc_for_static_init_4u_t = void(*)(kmp_Ident *, int32_t, int32_t, int32_t *, uint32_t *, uint32_t *,
-                                                int32_t *, int32_t, int32_t);
-    __kmpc_for_static_init_4u_t _hook__kmpc_for_static_init_4u;
-    void __kmpc_for_static_init_4u(kmp_Ident *loc, int32_t global_tid,
-                                      int32_t sched, int32_t *plastiter,
-                                      uint32_t *plower, uint32_t *pupper,
-                                      int32_t *pstride, int32_t incr,
-                                      int32_t chunk){
-        _hook__kmpc_for_static_init_4u(loc, global_tid, sched, plastiter, plower, pupper, pstride, incr, chunk);
-    }
+typedef kmp_int32 kmp_critical_name[8];
+using __kmpc_reduce_nowait_t = kmp_int32 (*)(
+    ident_t *, kmp_int32, kmp_int32, size_t, void *,
+    void (*)(void *lhs_data, void *rhs_data), kmp_critical_name *);
+__kmpc_reduce_nowait_t _hook__kmpc_reduce_nowait;
+kmp_int32
+__kmpc_reduce_nowait(ident_t *loc, kmp_int32 global_tid, kmp_int32 num_vars,
+                     size_t reduce_size, void *reduce_data,
+                     void (*reduce_func)(void *lhs_data, void *rhs_data),
+                     kmp_critical_name *lck) {
+  return _hook__kmpc_reduce_nowait(loc, global_tid, num_vars, reduce_size,
+                                   reduce_data, reduce_func, lck);
+}
 
-    using __kmpc_end_reduce_nowait_t = void(*)(ident_t *, kmp_int32,   kmp_critical_name *);
-    __kmpc_end_reduce_nowait_t _hook__kmpc_end_reduce_nowait;
-    void __kmpc_end_reduce_nowait(ident_t *loc, kmp_int32 global_tid, kmp_critical_name *lck){
-        _hook__kmpc_end_reduce_nowait(loc, global_tid, lck);
-    }
+using __kmpc_for_static_init_4u_t = void (*)(kmp_Ident *, int32_t, int32_t,
+                                             int32_t *, uint32_t *, uint32_t *,
+                                             int32_t *, int32_t, int32_t);
+__kmpc_for_static_init_4u_t _hook__kmpc_for_static_init_4u;
+void __kmpc_for_static_init_4u(kmp_Ident *loc, int32_t global_tid,
+                               int32_t sched, int32_t *plastiter,
+                               uint32_t *plower, uint32_t *pupper,
+                               int32_t *pstride, int32_t incr, int32_t chunk) {
+  _hook__kmpc_for_static_init_4u(loc, global_tid, sched, plastiter, plower,
+                                 pupper, pstride, incr, chunk);
+}
 
-    using __kmpc_serialized_parallel_t = void(*)(kmp_Ident *loc, uint32_t global_tid);
-    __kmpc_serialized_parallel_t _hook__kmpc_serialized_parallel;
-    void __kmpc_serialized_parallel(kmp_Ident *loc, uint32_t global_tid){
-        _hook__kmpc_serialized_parallel(loc, global_tid);
-    }
+using __kmpc_end_reduce_nowait_t = void (*)(ident_t *, kmp_int32,
+                                            kmp_critical_name *);
+__kmpc_end_reduce_nowait_t _hook__kmpc_end_reduce_nowait;
+void __kmpc_end_reduce_nowait(ident_t *loc, kmp_int32 global_tid,
+                              kmp_critical_name *lck) {
+  _hook__kmpc_end_reduce_nowait(loc, global_tid, lck);
+}
 
-    using __kmpc_end_serialized_parallel_t = void(*)(ident_t *loc, kmp_int32 global_tid);
-    __kmpc_end_serialized_parallel_t _hook__kmpc_end_serialized_parallel;
-    void __kmpc_end_serialized_parallel(ident_t *loc, kmp_int32 global_tid){
-        _hook__kmpc_end_serialized_parallel(loc, global_tid);
-    }
+using __kmpc_serialized_parallel_t = void (*)(kmp_Ident *loc,
+                                              uint32_t global_tid);
+__kmpc_serialized_parallel_t _hook__kmpc_serialized_parallel;
+void __kmpc_serialized_parallel(kmp_Ident *loc, uint32_t global_tid) {
+  _hook__kmpc_serialized_parallel(loc, global_tid);
+}
 
-    using __kmpc_global_thread_num_t = int(*)(id*);
-    __kmpc_global_thread_num_t _hook__kmpc_global_thread_num;
-    int __kmpc_global_thread_num(id* pId){
-        return _hook__kmpc_global_thread_num(pId);
-    }
+using __kmpc_end_serialized_parallel_t = void (*)(ident_t *loc,
+                                                  kmp_int32 global_tid);
+__kmpc_end_serialized_parallel_t _hook__kmpc_end_serialized_parallel;
+void __kmpc_end_serialized_parallel(ident_t *loc, kmp_int32 global_tid) {
+  _hook__kmpc_end_serialized_parallel(loc, global_tid);
+}
 
-    using __kmpc_critical_t = void(*)(ident_t *, kmp_int32, kmp_critical_name *);
-    __kmpc_critical_t _hook__kmpc_critical;
-    void __kmpc_critical(ident_t *id, kmp_int32 global_tid, kmp_critical_name *lck){
-        return _hook__kmpc_critical(id, global_tid, lck);
-    }
+using __kmpc_global_thread_num_t = int (*)(id *);
+__kmpc_global_thread_num_t _hook__kmpc_global_thread_num;
+int __kmpc_global_thread_num(id *pId) {
+  return _hook__kmpc_global_thread_num(pId);
+}
 
-    using __kmpc_end_critical_t = void(*)(ident_t *, kmp_int32, kmp_critical_name *);
-    __kmpc_end_critical_t _hook__kmpc_end_critical;
-    void __kmpc_end_critical(ident_t *id, kmp_int32 global_tid, kmp_critical_name *lck){
-        return _hook__kmpc_end_critical(id, global_tid, lck);
-    }
+using __kmpc_critical_t = void (*)(ident_t *, kmp_int32, kmp_critical_name *);
+__kmpc_critical_t _hook__kmpc_critical;
+void __kmpc_critical(ident_t *id, kmp_int32 global_tid,
+                     kmp_critical_name *lck) {
+  return _hook__kmpc_critical(id, global_tid, lck);
+}
 
-    using __kmpc_master_t = kmp_int32(*)(ident_t *, kmp_int32);
-    __kmpc_master_t _hook__kmpc_master;
-    kmp_int32 __kmpc_master(ident_t *id, kmp_int32 global_tid){
-        return _hook__kmpc_master(id, global_tid);
-    }
+using __kmpc_end_critical_t = void (*)(ident_t *, kmp_int32,
+                                       kmp_critical_name *);
+__kmpc_end_critical_t _hook__kmpc_end_critical;
+void __kmpc_end_critical(ident_t *id, kmp_int32 global_tid,
+                         kmp_critical_name *lck) {
+  return _hook__kmpc_end_critical(id, global_tid, lck);
+}
 
-    using __kmpc_end_master_t = void(*)(ident_t *, kmp_int32);
-    __kmpc_end_master_t _hook__kmpc_end_master;
-    void __kmpc_end_master(ident_t *id, kmp_int32 global_tid){
-        return _hook__kmpc_end_master(id, global_tid);
-    }
+using __kmpc_master_t = kmp_int32 (*)(ident_t *, kmp_int32);
+__kmpc_master_t _hook__kmpc_master;
+kmp_int32 __kmpc_master(ident_t *id, kmp_int32 global_tid) {
+  return _hook__kmpc_master(id, global_tid);
+}
 
-    #define __KAI_KMPC_CONVENTION
-    using omp_get_max_threads_t = int(*)(void);
-    omp_get_max_threads_t _hook_omp_get_max_threads;
-    int __KAI_KMPC_CONVENTION omp_get_max_threads(void) {
-        return _hook_omp_get_max_threads();
-    }
-    using omp_get_num_threads_t = int(*)(void);
-    omp_get_num_threads_t _hook_omp_get_num_threads;
-    int __KAI_KMPC_CONVENTION omp_get_num_threads(void) {
-        return _hook_omp_get_num_threads();
-    }
-    using omp_get_thread_num_t = int(*)(void);
-    omp_get_thread_num_t _hook_omp_get_thread_num;
-    int __KAI_KMPC_CONVENTION omp_get_thread_num(void) {
-        return _hook_omp_get_thread_num();
-    }
-    using omp_set_nested_t = void(*)(int);
-    omp_set_nested_t _hook_omp_set_nested;
-    void __KAI_KMPC_CONVENTION omp_set_nested(int foo){
-        _hook_omp_set_nested(foo);
-    }
-    using omp_set_max_active_levels_t = void(*)(int);
-    omp_set_max_active_levels_t _hook_omp_set_max_active_levels;
-    void __KAI_KMPC_CONVENTION omp_set_max_active_levels(int foo){
-        _hook_omp_set_max_active_levels(foo);
-    }
-    using omp_get_num_procs_t = int(*)(void);
-    omp_get_num_procs_t _hook_omp_get_num_procs;
-    int __KAI_KMPC_CONVENTION omp_get_num_procs(void) {
-        return _hook_omp_get_num_procs();
-    }
+using __kmpc_end_master_t = void (*)(ident_t *, kmp_int32);
+__kmpc_end_master_t _hook__kmpc_end_master;
+void __kmpc_end_master(ident_t *id, kmp_int32 global_tid) {
+  return _hook__kmpc_end_master(id, global_tid);
+}
 
+#define __KAI_KMPC_CONVENTION
+using omp_get_max_threads_t = int (*)(void);
+omp_get_max_threads_t _hook_omp_get_max_threads;
+int __KAI_KMPC_CONVENTION omp_get_max_threads(void) {
+  return _hook_omp_get_max_threads();
+}
+using omp_get_num_threads_t = int (*)(void);
+omp_get_num_threads_t _hook_omp_get_num_threads;
+int __KAI_KMPC_CONVENTION omp_get_num_threads(void) {
+  return _hook_omp_get_num_threads();
+}
+using omp_get_thread_num_t = int (*)(void);
+omp_get_thread_num_t _hook_omp_get_thread_num;
+int __KAI_KMPC_CONVENTION omp_get_thread_num(void) {
+  return _hook_omp_get_thread_num();
+}
+using omp_set_nested_t = void (*)(int);
+omp_set_nested_t _hook_omp_set_nested;
+void __KAI_KMPC_CONVENTION omp_set_nested(int foo) {
+  _hook_omp_set_nested(foo);
+}
+using omp_set_max_active_levels_t = void (*)(int);
+omp_set_max_active_levels_t _hook_omp_set_max_active_levels;
+void __KAI_KMPC_CONVENTION omp_set_max_active_levels(int foo) {
+  _hook_omp_set_max_active_levels(foo);
+}
+using omp_get_num_procs_t = int (*)(void);
+omp_get_num_procs_t _hook_omp_get_num_procs;
+int __KAI_KMPC_CONVENTION omp_get_num_procs(void) {
+  return _hook_omp_get_num_procs();
+}
 
-    // Symbols above this line would be needed in a future, if clang changes
-    // the OpenMP implementation. So I'll keep them here just in case I need
-    // them in the future
-    void __kmpc_dispatch_init_4(kmp_Ident *loc, int32_t global_tid,
-                                   int32_t sched, int32_t lower, int32_t upper,
-                                   int32_t incr, int32_t chunk); //{}
-    void __kmpc_dispatch_init_4u(kmp_Ident *loc, int32_t global_tid,
-                                    int32_t sched, uint32_t lower,
-                                    uint32_t upper, int32_t incr,
-                                    int32_t chunk); //{}
-    void __kmpc_dispatch_init_8(kmp_Ident *loc, int32_t global_tid,
-                                   int32_t sched, int64_t lower, int64_t upper,
-                                   int64_t incr, int64_t chunk); //{}
-    void __kmpc_dispatch_init_8u(kmp_Ident *loc, int32_t global_tid,
-                                    int32_t sched, uint64_t lower,
-                                    uint64_t upper, int64_t incr,
-                                    int64_t chunk); //{}
-    int __kmpc_dispatch_next_4(kmp_Ident *loc, int32_t global_tid,
-                                  int32_t *plastiter, int32_t *plower,
-                                  int32_t *pupper, int32_t *pstride); //{}
-    int __kmpc_dispatch_next_4u(kmp_Ident *loc, int32_t global_tid,
-                                   int32_t *plastiter, uint32_t *plower,
-                                   uint32_t *pupper, int32_t *pstride); //{}
-    int __kmpc_dispatch_next_8(kmp_Ident *loc, int32_t global_tid,
-                                  int32_t *plastiter, int64_t *plower,
-                                  int64_t *pupper, int64_t *pstride); //{}
-    int __kmpc_dispatch_next_8u(kmp_Ident *loc, int32_t global_tid,
-                                   int32_t *plastiter, uint64_t *plower,
-                                   uint64_t *pupper, int64_t *pstride); //{}
-    void __kmpc_dispatch_fini_4(kmp_Ident *loc, int32_t global_tid); //{}
-    void __kmpc_dispatch_fini_4u(kmp_Ident *loc, int32_t global_tid); //{}
-    void __kmpc_dispatch_fini_8(kmp_Ident *loc, int32_t global_tid); //{}
-    void __kmpc_dispatch_fini_8u(kmp_Ident *loc, int32_t global_tid); //{}
-    void __kmpc_for_static_init_4_simple_spmd(kmp_Ident *loc, int32_t global_tid,
+// Symbols above this line would be needed in a future, if clang changes
+// the OpenMP implementation. So I'll keep them here just in case I need
+// them in the future
+void __kmpc_dispatch_init_4(kmp_Ident *loc, int32_t global_tid, int32_t sched,
+                            int32_t lower, int32_t upper, int32_t incr,
+                            int32_t chunk); //{}
+void __kmpc_dispatch_init_4u(kmp_Ident *loc, int32_t global_tid, int32_t sched,
+                             uint32_t lower, uint32_t upper, int32_t incr,
+                             int32_t chunk); //{}
+void __kmpc_dispatch_init_8(kmp_Ident *loc, int32_t global_tid, int32_t sched,
+                            int64_t lower, int64_t upper, int64_t incr,
+                            int64_t chunk); //{}
+void __kmpc_dispatch_init_8u(kmp_Ident *loc, int32_t global_tid, int32_t sched,
+                             uint64_t lower, uint64_t upper, int64_t incr,
+                             int64_t chunk); //{}
+int __kmpc_dispatch_next_4(kmp_Ident *loc, int32_t global_tid,
+                           int32_t *plastiter, int32_t *plower, int32_t *pupper,
+                           int32_t *pstride); //{}
+int __kmpc_dispatch_next_4u(kmp_Ident *loc, int32_t global_tid,
+                            int32_t *plastiter, uint32_t *plower,
+                            uint32_t *pupper, int32_t *pstride); //{}
+int __kmpc_dispatch_next_8(kmp_Ident *loc, int32_t global_tid,
+                           int32_t *plastiter, int64_t *plower, int64_t *pupper,
+                           int64_t *pstride); //{}
+int __kmpc_dispatch_next_8u(kmp_Ident *loc, int32_t global_tid,
+                            int32_t *plastiter, uint64_t *plower,
+                            uint64_t *pupper, int64_t *pstride);  //{}
+void __kmpc_dispatch_fini_4(kmp_Ident *loc, int32_t global_tid);  //{}
+void __kmpc_dispatch_fini_4u(kmp_Ident *loc, int32_t global_tid); //{}
+void __kmpc_dispatch_fini_8(kmp_Ident *loc, int32_t global_tid);  //{}
+void __kmpc_dispatch_fini_8u(kmp_Ident *loc, int32_t global_tid); //{}
+void __kmpc_for_static_init_4_simple_spmd(kmp_Ident *loc, int32_t global_tid,
                                           int32_t sched, int32_t *plastiter,
                                           int32_t *plower, int32_t *pupper,
                                           int32_t *pstride, int32_t incr,
                                           int32_t chunk); //{}
-    void __kmpc_for_static_init_4u_simple_spmd(kmp_Ident *loc, int32_t global_tid,
+void __kmpc_for_static_init_4u_simple_spmd(kmp_Ident *loc, int32_t global_tid,
                                            int32_t sched, int32_t *plastiter,
                                            uint32_t *plower, uint32_t *pupper,
                                            int32_t *pstride, int32_t incr,
                                            int32_t chunk); //{}
-    void __kmpc_for_static_init_8_simple_spmd(kmp_Ident *loc, int32_t global_tid,
+void __kmpc_for_static_init_8_simple_spmd(kmp_Ident *loc, int32_t global_tid,
                                           int32_t sched, int32_t *plastiter,
                                           int64_t *plower, int64_t *pupper,
                                           int64_t *pstride, int64_t incr,
                                           int64_t chunk); //{}
-    void __kmpc_for_static_init_8u_simple_spmd(kmp_Ident *loc, int32_t global_tid,
+void __kmpc_for_static_init_8u_simple_spmd(kmp_Ident *loc, int32_t global_tid,
                                            int32_t sched, int32_t *plastiter1,
                                            uint64_t *plower, uint64_t *pupper,
                                            int64_t *pstride, int64_t incr,
                                            int64_t chunk); //{}
-    void __kmpc_for_static_init_4_simple_generic(kmp_Ident *loc,
-                                             int32_t global_tid, int32_t sched,
-                                             int32_t *plastiter,
+void __kmpc_for_static_init_4_simple_generic(kmp_Ident *loc, int32_t global_tid,
+                                             int32_t sched, int32_t *plastiter,
                                              int32_t *plower, int32_t *pupper,
                                              int32_t *pstride, int32_t incr,
                                              int32_t chunk); //{}
-    void __kmpc_for_static_init_4u_simple_generic(
-                                            kmp_Ident *loc, int32_t global_tid, int32_t sched, int32_t *plastiter,
-                                            uint32_t *plower, uint32_t *pupper, int32_t *pstride, int32_t incr,
-                                            int32_t chunk); //{}
-    void __kmpc_for_static_init_8_simple_generic(kmp_Ident *loc,
-                                             int32_t global_tid, int32_t sched,
-                                             int32_t *plastiter,
+void __kmpc_for_static_init_4u_simple_generic(
+    kmp_Ident *loc, int32_t global_tid, int32_t sched, int32_t *plastiter,
+    uint32_t *plower, uint32_t *pupper, int32_t *pstride, int32_t incr,
+    int32_t chunk); //{}
+void __kmpc_for_static_init_8_simple_generic(kmp_Ident *loc, int32_t global_tid,
+                                             int32_t sched, int32_t *plastiter,
                                              int64_t *plower, int64_t *pupper,
                                              int64_t *pstride, int64_t incr,
                                              int64_t chunk); //{}
-    void __kmpc_for_static_init_8u_simple_generic(
-                                            kmp_Ident *loc, int32_t global_tid, int32_t sched, int32_t *plastiter1,
-                                            uint64_t *plower, uint64_t *pupper, int64_t *pstride, int64_t incr,
-                                            int64_t chunk); //{}
+void __kmpc_for_static_init_8u_simple_generic(
+    kmp_Ident *loc, int32_t global_tid, int32_t sched, int32_t *plastiter1,
+    uint64_t *plower, uint64_t *pupper, int64_t *pstride, int64_t incr,
+    int64_t chunk); //{}
 }
 
-
 namespace AER {
 namespace Hacks {
 
-void populate_hooks(void * handle){
-    _hook__kmpc_barrier = reinterpret_cast<decltype(&__kmpc_barrier)>(dlsym(handle, "__kmpc_barrier"));
-    _hook__kmpc_for_static_fini = reinterpret_cast<decltype(&__kmpc_for_static_fini)>(dlsym(handle, "__kmpc_for_static_fini"));
-    _hook__kmpc_end_reduce_nowait = reinterpret_cast<decltype(&__kmpc_end_reduce_nowait)>(dlsym(handle, "__kmpc_end_reduce_nowait"));
-    _hook__kmpc_reduce_nowait = reinterpret_cast<decltype(&__kmpc_reduce_nowait)>(dlsym(handle, "__kmpc_reduce_nowait"));
-    _hook__kmpc_for_static_init_4 = reinterpret_cast<decltype(&__kmpc_for_static_init_4)>(dlsym(handle, "__kmpc_for_static_init_4"));
-    _hook__kmpc_for_static_init_8 = reinterpret_cast<decltype(&__kmpc_for_static_init_8)>(dlsym(handle, "__kmpc_for_static_init_8"));
-    _hook__kmpc_for_static_init_8u = reinterpret_cast<decltype(&__kmpc_for_static_init_8u)>(dlsym(handle, "__kmpc_for_static_init_8u"));
-    _hook__kmpc_fork_call = reinterpret_cast<decltype(&__kmpc_fork_call)>(dlsym(handle, "__kmpc_fork_call"));
-    _hook__kmpc_push_num_threads = reinterpret_cast<decltype(&__kmpc_push_num_threads)>(dlsym(handle, "__kmpc_push_num_threads"));
-    _hook__kmpc_serialized_parallel = reinterpret_cast<decltype(&__kmpc_serialized_parallel)>(dlsym(handle, "__kmpc_serialized_parallel"));
-    _hook__kmpc_end_serialized_parallel = reinterpret_cast<decltype(&__kmpc_end_serialized_parallel)>(dlsym(handle, "__kmpc_end_serialized_parallel"));
-    _hook__kmpc_global_thread_num = reinterpret_cast<decltype(&__kmpc_global_thread_num)>(dlsym(handle, "__kmpc_global_thread_num"));
-    _hook__kmpc_critical = reinterpret_cast<decltype(&__kmpc_critical)>(dlsym(handle, "__kmpc_critical"));
-    _hook__kmpc_end_critical = reinterpret_cast<decltype(&__kmpc_end_critical)>(dlsym(handle, "__kmpc_end_critical"));
-    _hook__kmpc_master = reinterpret_cast<decltype(&__kmpc_master)>(dlsym(handle, "__kmpc_master"));
-    _hook__kmpc_end_master = reinterpret_cast<decltype(&__kmpc_end_master)>(dlsym(handle, "__kmpc_end_master"));
-    _hook_omp_get_max_threads = reinterpret_cast<decltype(&omp_get_max_threads)>(dlsym(handle, "omp_get_max_threads"));
-    _hook_omp_get_num_threads = reinterpret_cast<decltype(&omp_get_num_threads)>(dlsym(handle, "omp_get_num_threads"));
-    _hook_omp_get_thread_num = reinterpret_cast<decltype(&omp_get_thread_num)>(dlsym(handle, "omp_get_thread_num"));
-    _hook_omp_set_nested = reinterpret_cast<decltype(&omp_set_nested)>(dlsym(handle, "omp_set_nested"));
-    _hook_omp_set_max_active_levels = reinterpret_cast<decltype(&omp_set_max_active_levels)>(dlsym(handle, "omp_set_max_active_levels"));
-    _hook_omp_get_num_procs = reinterpret_cast<decltype(&omp_get_num_procs)>(dlsym(handle, "omp_get_num_procs"));
+void populate_hooks(void *handle) {
+  _hook__kmpc_barrier = reinterpret_cast<decltype(&__kmpc_barrier)>(
+      dlsym(handle, "__kmpc_barrier"));
+  _hook__kmpc_for_static_fini =
+      reinterpret_cast<decltype(&__kmpc_for_static_fini)>(
+          dlsym(handle, "__kmpc_for_static_fini"));
+  _hook__kmpc_end_reduce_nowait =
+      reinterpret_cast<decltype(&__kmpc_end_reduce_nowait)>(
+          dlsym(handle, "__kmpc_end_reduce_nowait"));
+  _hook__kmpc_reduce_nowait = reinterpret_cast<decltype(&__kmpc_reduce_nowait)>(
+      dlsym(handle, "__kmpc_reduce_nowait"));
+  _hook__kmpc_for_static_init_4 =
+      reinterpret_cast<decltype(&__kmpc_for_static_init_4)>(
+          dlsym(handle, "__kmpc_for_static_init_4"));
+  _hook__kmpc_for_static_init_8 =
+      reinterpret_cast<decltype(&__kmpc_for_static_init_8)>(
+          dlsym(handle, "__kmpc_for_static_init_8"));
+  _hook__kmpc_for_static_init_8u =
+      reinterpret_cast<decltype(&__kmpc_for_static_init_8u)>(
+          dlsym(handle, "__kmpc_for_static_init_8u"));
+  _hook__kmpc_fork_call = reinterpret_cast<decltype(&__kmpc_fork_call)>(
+      dlsym(handle, "__kmpc_fork_call"));
+  _hook__kmpc_push_num_threads =
+      reinterpret_cast<decltype(&__kmpc_push_num_threads)>(
+          dlsym(handle, "__kmpc_push_num_threads"));
+  _hook__kmpc_serialized_parallel =
+      reinterpret_cast<decltype(&__kmpc_serialized_parallel)>(
+          dlsym(handle, "__kmpc_serialized_parallel"));
+  _hook__kmpc_end_serialized_parallel =
+      reinterpret_cast<decltype(&__kmpc_end_serialized_parallel)>(
+          dlsym(handle, "__kmpc_end_serialized_parallel"));
+  _hook__kmpc_global_thread_num =
+      reinterpret_cast<decltype(&__kmpc_global_thread_num)>(
+          dlsym(handle, "__kmpc_global_thread_num"));
+  _hook__kmpc_critical = reinterpret_cast<decltype(&__kmpc_critical)>(
+      dlsym(handle, "__kmpc_critical"));
+  _hook__kmpc_end_critical = reinterpret_cast<decltype(&__kmpc_end_critical)>(
+      dlsym(handle, "__kmpc_end_critical"));
+  _hook__kmpc_master = reinterpret_cast<decltype(&__kmpc_master)>(
+      dlsym(handle, "__kmpc_master"));
+  _hook__kmpc_end_master = reinterpret_cast<decltype(&__kmpc_end_master)>(
+      dlsym(handle, "__kmpc_end_master"));
+  _hook_omp_get_max_threads = reinterpret_cast<decltype(&omp_get_max_threads)>(
+      dlsym(handle, "omp_get_max_threads"));
+  _hook_omp_get_num_threads = reinterpret_cast<decltype(&omp_get_num_threads)>(
+      dlsym(handle, "omp_get_num_threads"));
+  _hook_omp_get_thread_num = reinterpret_cast<decltype(&omp_get_thread_num)>(
+      dlsym(handle, "omp_get_thread_num"));
+  _hook_omp_set_nested = reinterpret_cast<decltype(&omp_set_nested)>(
+      dlsym(handle, "omp_set_nested"));
+  _hook_omp_set_max_active_levels =
+      reinterpret_cast<decltype(&omp_set_max_active_levels)>(
+          dlsym(handle, "omp_set_max_active_levels"));
+  _hook_omp_get_num_procs = reinterpret_cast<decltype(&omp_get_num_procs)>(
+      dlsym(handle, "omp_get_num_procs"));
 }
 
-}
-}
+} // namespace Hacks
+} // namespace AER
 
 #endif
diff --git a/src/misc/common_macros.hpp b/src/misc/common_macros.hpp
index 5088c68098..a9070cdfb1 100644
--- a/src/misc/common_macros.hpp
+++ b/src/misc/common_macros.hpp
@@ -16,7 +16,7 @@
 #define QASM_SIMULATOR_COMMON_MACROS_HPP
 
 #if defined(__GNUC__) && defined(__x86_64__) && defined(__AVX2__)
- #define GNUC_AVX2
+#define GNUC_AVX2
 #endif
 
-#endif //QASM_SIMULATOR_COMMON_MACROS_HPP
+#endif // QASM_SIMULATOR_COMMON_MACROS_HPP
diff --git a/src/misc/gcc_omp_symbols.hpp b/src/misc/gcc_omp_symbols.hpp
index 3ff2b0f162..72dc31391c 100644
--- a/src/misc/gcc_omp_symbols.hpp
+++ b/src/misc/gcc_omp_symbols.hpp
@@ -15,102 +15,107 @@
 #ifndef _aer_misc_hacks_gcc_symbols_
 #define _aer_misc_hacks_gcc_symbols_
 
-#include <iostream>
 #include <dlfcn.h>
+#include <iostream>
 #include <sys/types.h>
 
-// These symboles were taken from: https://github.com/gcc-mirror/gcc/blob/gcc-8_2_0-release/libgomp/libgomp_g.h
+// These symboles were taken from:
+// https://github.com/gcc-mirror/gcc/blob/gcc-8_2_0-release/libgomp/libgomp_g.h
 
 // Define undefined symbols
 extern "C" {
 
-    using GOMP_atomic_start_t = void(*)();
-    GOMP_atomic_start_t _hook_GOMP_atomic_start;
-    void GOMP_atomic_start (void){
-        _hook_GOMP_atomic_start();
-    }
+using GOMP_atomic_start_t = void (*)();
+GOMP_atomic_start_t _hook_GOMP_atomic_start;
+void GOMP_atomic_start(void) { _hook_GOMP_atomic_start(); }
 
-    using GOMP_atomic_end_t = void(*)();
-    GOMP_atomic_end_t _hook_GOMP_atomic_end;
-    void GOMP_atomic_end (void){
-        _hook_GOMP_atomic_end();
-    }
+using GOMP_atomic_end_t = void (*)();
+GOMP_atomic_end_t _hook_GOMP_atomic_end;
+void GOMP_atomic_end(void) { _hook_GOMP_atomic_end(); }
 
-    using GOMP_barrier_t = void(*)();
-    GOMP_barrier_t _hook_GOMP_barrier;
-    void GOMP_barrier(void){
-        _hook_GOMP_barrier();
-    }
+using GOMP_barrier_t = void (*)();
+GOMP_barrier_t _hook_GOMP_barrier;
+void GOMP_barrier(void) { _hook_GOMP_barrier(); }
 
-    using GOMP_parallel_t = void(*)(void (*)(void *), void *, unsigned, unsigned);
-    GOMP_parallel_t _hook_GOMP_parallel;
-    void GOMP_parallel(void (*fn) (void *), void *data, unsigned num_threads, unsigned flags){
-        _hook_GOMP_parallel(fn, data, num_threads, flags);
-    }
+using GOMP_parallel_t = void (*)(void (*)(void *), void *, unsigned, unsigned);
+GOMP_parallel_t _hook_GOMP_parallel;
+void GOMP_parallel(void (*fn)(void *), void *data, unsigned num_threads,
+                   unsigned flags) {
+  _hook_GOMP_parallel(fn, data, num_threads, flags);
+}
 
-    using GOMP_critical_start_t = void(*)();
-    GOMP_critical_start_t _hook_GOMP_critical_start;
-    void GOMP_critical_start(void){
-        _hook_GOMP_critical_start();
-    }
+using GOMP_critical_start_t = void (*)();
+GOMP_critical_start_t _hook_GOMP_critical_start;
+void GOMP_critical_start(void) { _hook_GOMP_critical_start(); }
 
-    using GOMP_critical_end_t = void(*)();
-    GOMP_critical_end_t _hook_GOMP_critical_end;
-    void GOMP_critical_end(void){
-        _hook_GOMP_critical_end();
-    }
+using GOMP_critical_end_t = void (*)();
+GOMP_critical_end_t _hook_GOMP_critical_end;
+void GOMP_critical_end(void) { _hook_GOMP_critical_end(); }
 
-    #define __KAI_KMPC_CONVENTION
-    using omp_get_max_threads_t = int(*)(void);
-    omp_get_max_threads_t _hook_omp_get_max_threads;
-    int __KAI_KMPC_CONVENTION omp_get_max_threads(void) {
-        return _hook_omp_get_max_threads();
-    }
-    using omp_set_nested_t = void(*)(int);
-    omp_set_nested_t _hook_omp_set_nested;
-    void __KAI_KMPC_CONVENTION omp_set_nested(int foo){
-        _hook_omp_set_nested(foo);
-    }
-    using omp_set_max_active_levels_t = void(*)(int);
-    omp_set_max_active_levels_t _hook_omp_set_max_active_levels;
-    void __KAI_KMPC_CONVENTION omp_set_max_active_levels(int foo){
-        _hook_omp_set_max_active_levels(foo);
-    }
-    using omp_get_num_threads_t = int(*)(void);
-    omp_get_num_threads_t _hook_omp_get_num_threads;
-    int __KAI_KMPC_CONVENTION omp_get_num_threads(void) {
-        return _hook_omp_get_num_threads();
-    }
-    using omp_get_thread_num_t = int(*)(void);
-    omp_get_thread_num_t _hook_omp_get_thread_num;
-    int __KAI_KMPC_CONVENTION omp_get_thread_num(void) {
-        return _hook_omp_get_thread_num();
-    }
-    using omp_get_num_procs_t = int(*)(void);
-    omp_get_num_procs_t _hook_omp_get_num_procs;
-    int __KAI_KMPC_CONVENTION omp_get_num_procs(void) {
-        return _hook_omp_get_num_procs();
-    }
+#define __KAI_KMPC_CONVENTION
+using omp_get_max_threads_t = int (*)(void);
+omp_get_max_threads_t _hook_omp_get_max_threads;
+int __KAI_KMPC_CONVENTION omp_get_max_threads(void) {
+  return _hook_omp_get_max_threads();
+}
+using omp_set_nested_t = void (*)(int);
+omp_set_nested_t _hook_omp_set_nested;
+void __KAI_KMPC_CONVENTION omp_set_nested(int foo) {
+  _hook_omp_set_nested(foo);
+}
+using omp_set_max_active_levels_t = void (*)(int);
+omp_set_max_active_levels_t _hook_omp_set_max_active_levels;
+void __KAI_KMPC_CONVENTION omp_set_max_active_levels(int foo) {
+  _hook_omp_set_max_active_levels(foo);
+}
+using omp_get_num_threads_t = int (*)(void);
+omp_get_num_threads_t _hook_omp_get_num_threads;
+int __KAI_KMPC_CONVENTION omp_get_num_threads(void) {
+  return _hook_omp_get_num_threads();
+}
+using omp_get_thread_num_t = int (*)(void);
+omp_get_thread_num_t _hook_omp_get_thread_num;
+int __KAI_KMPC_CONVENTION omp_get_thread_num(void) {
+  return _hook_omp_get_thread_num();
+}
+using omp_get_num_procs_t = int (*)(void);
+omp_get_num_procs_t _hook_omp_get_num_procs;
+int __KAI_KMPC_CONVENTION omp_get_num_procs(void) {
+  return _hook_omp_get_num_procs();
+}
 }
 
 namespace AER {
 namespace Hacks {
 
-    void populate_hooks(void * handle){
-        _hook_GOMP_atomic_end = reinterpret_cast<decltype(&GOMP_atomic_end)>(dlsym(handle, "GOMP_atomic_end"));
-        _hook_GOMP_atomic_start = reinterpret_cast<decltype(&GOMP_atomic_start)>(dlsym(handle, "GOMP_atomic_start"));
-        _hook_GOMP_barrier = reinterpret_cast<decltype(&GOMP_barrier)>(dlsym(handle, "GOMP_barrier"));
-        _hook_GOMP_parallel = reinterpret_cast<decltype(&GOMP_parallel)>(dlsym(handle, "GOMP_parallel"));
-        _hook_GOMP_critical_end = reinterpret_cast<decltype(&GOMP_critical_end)>(dlsym(handle, "GOMP_critical_end"));
-        _hook_GOMP_critical_start = reinterpret_cast<decltype(&GOMP_critical_start)>(dlsym(handle, "GOMP_critical_start"));
-        _hook_omp_get_num_threads = reinterpret_cast<decltype(&omp_get_num_threads)>(dlsym(handle, "omp_get_num_threads"));
-        _hook_omp_get_max_threads = reinterpret_cast<decltype(&omp_get_max_threads)>(dlsym(handle, "omp_get_max_threads"));
-        _hook_omp_set_nested = reinterpret_cast<decltype(&omp_set_nested)>(dlsym(handle, "omp_set_nested"));
-        _hook_omp_set_max_active_levels = reinterpret_cast<decltype(&omp_set_max_active_levels)>(dlsym(handle, "omp_set_max_active_levels"));
-        _hook_omp_get_thread_num = reinterpret_cast<decltype(&omp_get_thread_num)>(dlsym(handle, "omp_get_thread_num"));
-        _hook_omp_get_num_procs = reinterpret_cast<decltype(&omp_get_num_procs)>(dlsym(handle, "omp_get_num_procs"));
-    }
-}
+void populate_hooks(void *handle) {
+  _hook_GOMP_atomic_end = reinterpret_cast<decltype(&GOMP_atomic_end)>(
+      dlsym(handle, "GOMP_atomic_end"));
+  _hook_GOMP_atomic_start = reinterpret_cast<decltype(&GOMP_atomic_start)>(
+      dlsym(handle, "GOMP_atomic_start"));
+  _hook_GOMP_barrier =
+      reinterpret_cast<decltype(&GOMP_barrier)>(dlsym(handle, "GOMP_barrier"));
+  _hook_GOMP_parallel = reinterpret_cast<decltype(&GOMP_parallel)>(
+      dlsym(handle, "GOMP_parallel"));
+  _hook_GOMP_critical_end = reinterpret_cast<decltype(&GOMP_critical_end)>(
+      dlsym(handle, "GOMP_critical_end"));
+  _hook_GOMP_critical_start = reinterpret_cast<decltype(&GOMP_critical_start)>(
+      dlsym(handle, "GOMP_critical_start"));
+  _hook_omp_get_num_threads = reinterpret_cast<decltype(&omp_get_num_threads)>(
+      dlsym(handle, "omp_get_num_threads"));
+  _hook_omp_get_max_threads = reinterpret_cast<decltype(&omp_get_max_threads)>(
+      dlsym(handle, "omp_get_max_threads"));
+  _hook_omp_set_nested = reinterpret_cast<decltype(&omp_set_nested)>(
+      dlsym(handle, "omp_set_nested"));
+  _hook_omp_set_max_active_levels =
+      reinterpret_cast<decltype(&omp_set_max_active_levels)>(
+          dlsym(handle, "omp_set_max_active_levels"));
+  _hook_omp_get_thread_num = reinterpret_cast<decltype(&omp_get_thread_num)>(
+      dlsym(handle, "omp_get_thread_num"));
+  _hook_omp_get_num_procs = reinterpret_cast<decltype(&omp_get_num_procs)>(
+      dlsym(handle, "omp_get_num_procs"));
 }
+} // namespace Hacks
+} // namespace AER
 
 #endif
\ No newline at end of file
diff --git a/src/misc/hacks.hpp b/src/misc/hacks.hpp
index beaf628af5..d4992567cf 100644
--- a/src/misc/hacks.hpp
+++ b/src/misc/hacks.hpp
@@ -18,18 +18,18 @@
 // We only need this hack for MacOS builds,
 // on Linux and Windows everything works fine
 #ifdef __APPLE__
+#include <dlfcn.h>
+#include <functional>
+#include <iostream>
 #include <mach-o/dyld.h>
 #include <mach-o/nlist.h>
 #include <sys/types.h>
-#include <dlfcn.h>
-#include <iostream>
 #include <vector>
-#include <functional>
 
 #if defined(__clang__)
-    #include "clang_omp_symbols.hpp"
+#include "clang_omp_symbols.hpp"
 #elif defined(__GNUC__) || defined(__GNUG__)
-    #include "gcc_omp_symbols.hpp"
+#include "gcc_omp_symbols.hpp"
 #endif
 
 namespace {
@@ -38,48 +38,53 @@ namespace {
  *  library loaded, then load our default one.
  */
 
-auto _apple_get_loaded_openmp_library = [](const std::string& default_path) -> std::string {
-    // Iterate through all images currently in memory
-    for (int32_t i = _dyld_image_count(); i >= 0 ; i--) {
-        const char *image_name = _dyld_get_image_name(i);
-        if(image_name) {
-            // These are the only libraries we know that implement OpenMP on Mac
-            // and that clash each other
-            if(strstr(image_name, "libomp.dylib") ||
-                strstr(image_name, "libiomp5.dylib") ||
-                strstr(image_name, "libgomp.dylib")) {
-                    return std::string(image_name);
-                }
-        }
+auto _apple_get_loaded_openmp_library =
+    [](const std::string &default_path) -> std::string {
+  // Iterate through all images currently in memory
+  for (int32_t i = _dyld_image_count(); i >= 0; i--) {
+    const char *image_name = _dyld_get_image_name(i);
+    if (image_name) {
+      // These are the only libraries we know that implement OpenMP on Mac
+      // and that clash each other
+      if (strstr(image_name, "libomp.dylib") ||
+          strstr(image_name, "libiomp5.dylib") ||
+          strstr(image_name, "libgomp.dylib")) {
+        return std::string(image_name);
+      }
     }
-    return default_path + "/libomp.dylib";
+  }
+  return default_path + "/libomp.dylib";
 };
 
 /*
  * I hope this is a temporary hack, for fixing Issue:
  * https://github.com/Qiskit/qiskit-aer/issues/1
  */
-auto _apple_maybe_load_openmp = [](const std::string& library_path) -> void {
-    // dlopen() will return a handle to the library if this is already loaded
-    void * handle = dlopen(_apple_get_loaded_openmp_library(library_path).c_str(), RTLD_LAZY);
-    if(handle == nullptr){
-        fprintf(stderr, "WARNING: Couldn't load libomp.dylib but we needed to. Error: %s\n", dlerror());
-        fprintf(stderr, "Make sure you have libomp.dylib or libiomp5.dylib accesible to the program\n");
-    }
-    AER::Hacks::populate_hooks(handle);
+auto _apple_maybe_load_openmp = [](const std::string &library_path) -> void {
+  // dlopen() will return a handle to the library if this is already loaded
+  void *handle =
+      dlopen(_apple_get_loaded_openmp_library(library_path).c_str(), RTLD_LAZY);
+  if (handle == nullptr) {
+    fprintf(stderr,
+            "WARNING: Couldn't load libomp.dylib but we needed to. Error: %s\n",
+            dlerror());
+    fprintf(stderr, "Make sure you have libomp.dylib or libiomp5.dylib "
+                    "accesible to the program\n");
+  }
+  AER::Hacks::populate_hooks(handle);
 };
-}
+} // namespace
 
 #endif // endif __APPLE__
 
 namespace AER {
 namespace Hacks {
-    #ifdef __APPLE__
-        const auto maybe_load_openmp = ::_apple_maybe_load_openmp;
-    #else
-        const auto maybe_load_openmp = [](const std::string& dummy) -> void {};
-    #endif
-}
-}
+#ifdef __APPLE__
+const auto maybe_load_openmp = ::_apple_maybe_load_openmp;
+#else
+const auto maybe_load_openmp = [](const std::string &dummy) -> void {};
+#endif
+} // namespace Hacks
+} // namespace AER
 
 #endif
diff --git a/src/misc/warnings.hpp b/src/misc/warnings.hpp
index eb1cec8775..ed3ce38155 100644
--- a/src/misc/warnings.hpp
+++ b/src/misc/warnings.hpp
@@ -30,11 +30,11 @@
   DISABLE_WARNING(-Wall)                                                       \
   DISABLE_WARNING(-Wextra)                                                     \
   DISABLE_WARNING(-Wshadow)                                                    \
-  DISABLE_WARNING(-Wfloat-equal)                                               \
+  DISABLE_WARNING(-Wfloat - equal)                                             \
   DISABLE_WARNING(-Wundef)                                                     \
   DISABLE_WARNING(-Wpedantic)                                                  \
-  DISABLE_WARNING(-Wredundant-decls)                                           \
-  DISABLE_WARNING(-Wsign-compare)
+  DISABLE_WARNING(-Wredundant - decls)                                         \
+  DISABLE_WARNING(-Wsign - compare)
 
 #define DISABLE_WARNING_POP DO_PRAGMA(GCC diagnostic pop)
 
diff --git a/src/misc/wrap_thrust.hpp b/src/misc/wrap_thrust.hpp
index 17d6e4d99c..1737c918fa 100644
--- a/src/misc/wrap_thrust.hpp
+++ b/src/misc/wrap_thrust.hpp
@@ -21,22 +21,22 @@
 
 #include "misc/warnings.hpp"
 DISABLE_WARNING_PUSH
-#include <thrust/for_each.h>
+#include <thrust/binary_search.h>
 #include <thrust/complex.h>
+#include <thrust/detail/vector_base.h>
+#include <thrust/execution_policy.h>
+#include <thrust/for_each.h>
+#include <thrust/functional.h>
 #include <thrust/inner_product.h>
+#include <thrust/iterator/constant_iterator.h>
 #include <thrust/transform.h>
 #include <thrust/transform_scan.h>
-#include <thrust/binary_search.h>
-#include <thrust/execution_policy.h>
-#include <thrust/functional.h>
 #include <thrust/tuple.h>
-#include <thrust/iterator/constant_iterator.h>
-#include <thrust/detail/vector_base.h>
 
+#include <thrust/fill.h>
 #include <thrust/iterator/counting_iterator.h>
-#include <thrust/iterator/transform_iterator.h>
 #include <thrust/iterator/permutation_iterator.h>
-#include <thrust/fill.h>
+#include <thrust/iterator/transform_iterator.h>
 
 #ifdef AER_THRUST_CUDA
 #include <thrust/device_vector.h>
diff --git a/src/noise/noise_model.hpp b/src/noise/noise_model.hpp
index 8f0f43684e..8761984c0b 100644
--- a/src/noise/noise_model.hpp
+++ b/src/noise/noise_model.hpp
@@ -18,17 +18,18 @@
 #define _USE_MATH_DEFINES
 #include <math.h>
 
-#include "framework/operations.hpp"
-#include "framework/types.hpp"
-#include "framework/rng.hpp"
 #include "framework/circuit.hpp"
 #include "framework/linalg/matrix_utils.hpp"
+#include "framework/operations.hpp"
+#include "framework/rng.hpp"
+#include "framework/types.hpp"
 
 namespace AER {
 namespace Noise {
-//predifine NoiseModel here for passing noise model to State::apply_ops
+// predifine NoiseModel here for passing noise model to State::apply_ops
 class NoiseModel;
-}}
+} // namespace Noise
+} // namespace AER
 
 #include "noise/quantum_error.hpp"
 #include "noise/readout_error.hpp"
@@ -48,45 +49,42 @@ namespace Noise {
 
 class NoiseModel {
 public:
-
   using Method = QuantumError::Method;
   using NoiseOps = std::vector<Operations::Op>;
 
   NoiseModel() = default;
-  NoiseModel(const json_t &js) {load_from_json(js);}
+  NoiseModel(const json_t &js) { load_from_json(js); }
 
   // Sample a noisy implementation of a full circuit
   // An RngEngine is passed in as a reference so that sampling
   // can be done in a thread-safe manner.
   // Sample methods are:
   // standard: each noisy op will be returned along with additional noise ops
-  // superop: each noisy gate or reset will be returned as a single superop 
-  Circuit sample_noise(const Circuit &circ,
-                       RngEngine &rng,
-                       const Method method = Method::circuit,bool sample_at_runtime = false) const;
+  // superop: each noisy gate or reset will be returned as a single superop
+  Circuit sample_noise(const Circuit &circ, RngEngine &rng,
+                       const Method method = Method::circuit,
+                       bool sample_at_runtime = false) const;
 
-  NoiseOps sample_noise_loc(const Operations::Op &op,RngEngine &rng) const;
+  NoiseOps sample_noise_loc(const Operations::Op &op, RngEngine &rng) const;
 
   // Enable superop sampling method
   // This will cause all QuantumErrors stored in the noise model
   // to calculate their superoperator representations and raise
   // an exception if they cannot be converted.
-  void enable_superop_method(int num_threads=1);
+  void enable_superop_method(int num_threads = 1);
 
   // Enable kraus sampling method
   // This will cause all QuantumErrors stored in the noise model
   // to calculate their canonical Kraus representations and raise
   // an exception if they cannot be converted.
-  void enable_kraus_method(int num_threads=1);
+  void enable_kraus_method(int num_threads = 1);
 
   //-----------------------------------------------------------------------
   // Checking if errors types are in noise model
   //-----------------------------------------------------------------------
 
   // Return True if noise model contains readout errors
-  inline bool has_readout_errors() const {
-    return !readout_errors_.empty();
-  }
+  inline bool has_readout_errors() const { return !readout_errors_.empty(); }
 
   // Return True if noise model contains quantum errors
   inline bool has_quantum_errors() const {
@@ -99,9 +97,7 @@ class NoiseModel {
   }
 
   // Return True if noise model contains local quantum errors
-  inline bool has_local_quantum_errors() const {
-    return local_quantum_errors_;
-  }
+  inline bool has_local_quantum_errors() const { return local_quantum_errors_; }
 
   // Return true if the noise model is ideal
   inline bool is_ideal() const {
@@ -120,7 +116,7 @@ class NoiseModel {
                          const stringset_t &op_labels,
                          const std::vector<reg_t> &op_qubits = {},
                          const std::vector<reg_t> &noise_qubits = {});
-  
+
   // Add a ReadoutError to the noise model
   void add_readout_error(const ReadoutError &error,
                          const std::vector<reg_t> &op_qubits = {});
@@ -129,51 +125,45 @@ class NoiseModel {
   // Utils
   //-----------------------------------------------------------------------
 
-  // Return vector of noise qubits for non local error on specified label and qubits
-  // If no nonlocal error exists an empty set is returned.
-  std::set<uint_t> nonlocal_noise_qubits(const std::string label, const reg_t &qubits) const;
+  // Return vector of noise qubits for non local error on specified label and
+  // qubits If no nonlocal error exists an empty set is returned.
+  std::set<uint_t> nonlocal_noise_qubits(const std::string label,
+                                         const reg_t &qubits) const;
 
   // Return the opset for the noise model
-  inline const Operations::OpSet& opset() const {return opset_;}
+  inline const Operations::OpSet &opset() const { return opset_; }
 
 private:
-
-  Circuit sample_noise_circuit(const Circuit &circ,
-                               RngEngine &rng,
-                               const Method method,bool sample_at_runtime) const;
+  Circuit sample_noise_circuit(const Circuit &circ, RngEngine &rng,
+                               const Method method,
+                               bool sample_at_runtime) const;
 
   // Sample noise for the current operation.
 
-  NoiseOps sample_noise_op(const Operations::Op &op,
-                           RngEngine &rng,
-                           const Method method,
-                           const reg_t &mapping,bool sample_at_runtime) const;
+  NoiseOps sample_noise_op(const Operations::Op &op, RngEngine &rng,
+                           const Method method, const reg_t &mapping,
+                           bool sample_at_runtime) const;
 
   // Sample noise for the current operation
-  void sample_readout_noise(const Operations::Op &op,
-                            NoiseOps &noise_after,
-                            RngEngine &rng,
-                            const reg_t &mapping)  const;
+  void sample_readout_noise(const Operations::Op &op, NoiseOps &noise_after,
+                            RngEngine &rng, const reg_t &mapping) const;
 
   void sample_local_quantum_noise(const Operations::Op &op,
-                                  NoiseOps &noise_before,
-                                  NoiseOps &noise_after,
-                                  RngEngine &rng,
-                                  const Method method,
-                                  const reg_t &mapping,bool sample_at_runtime)  const;
+                                  NoiseOps &noise_before, NoiseOps &noise_after,
+                                  RngEngine &rng, const Method method,
+                                  const reg_t &mapping,
+                                  bool sample_at_runtime) const;
 
   void sample_nonlocal_quantum_noise(const Operations::Op &op,
-                                     NoiseOps &noise_ops,
-                                     NoiseOps &noise_after,
-                                     RngEngine &rng,
-                                     const Method method,
-                                     const reg_t &mapping,bool sample_at_runtime) const;
+                                     NoiseOps &noise_ops, NoiseOps &noise_after,
+                                     RngEngine &rng, const Method method,
+                                     const reg_t &mapping,
+                                     bool sample_at_runtime) const;
 
   // Sample noise for the current operation
-  NoiseOps sample_noise_helper(const Operations::Op &op,
-                               RngEngine &rng,
-                               const Method method,
-                               const reg_t &mapping,bool sample_at_runtime) const;
+  NoiseOps sample_noise_helper(const Operations::Op &op, RngEngine &rng,
+                               const Method method, const reg_t &mapping,
+                               bool sample_at_runtime) const;
 
   // Add a local quantum error to the noise model for specific qubits
   void add_local_quantum_error(const QuantumError &error,
@@ -186,7 +176,7 @@ class NoiseModel {
                                   const std::vector<reg_t> &op_qubits,
                                   const std::vector<reg_t> &noise_qubits);
 
-  //create loc noise
+  // create loc noise
   NoiseOps create_noise_loc(const Operations::Op &op) const;
 
   // Flags which say whether the local or nonlocal error tables are used
@@ -231,16 +221,31 @@ class NoiseModel {
   cmatrix_t op2unitary(const Operations::Op &op) const;
 
   // Parameterized Gates
-  enum class ParamGate {u1, u2, u3, r, rx, ry, rz, rxx, ryy, rzz, rzx, cp, cu};
+  enum class ParamGate {
+    u1,
+    u2,
+    u3,
+    r,
+    rx,
+    ry,
+    rz,
+    rxx,
+    ryy,
+    rzz,
+    rzx,
+    cp,
+    cu
+  };
   const static stringmap_t<ParamGate> param_gate_table_;
 
   // Joint OpSet of all errors
   Operations::OpSet opset_;
 
   // Allowed sampling methods
-  std::unordered_set<Method> enabled_methods_ = std::unordered_set<Method>({Method::circuit});
+  std::unordered_set<Method> enabled_methods_ =
+      std::unordered_set<Method>({Method::circuit});
 
-  //saved qubit mapping for runtime loc
+  // saved qubit mapping for runtime loc
   mutable reg_t circ_mapping_;
 };
 
@@ -248,34 +253,22 @@ class NoiseModel {
 // Parameterized Gates
 //=========================================================================
 
-const stringmap_t<NoiseModel::ParamGate>
-NoiseModel::param_gate_table_ = {
-  {"u", ParamGate::u3},
-  {"u3", ParamGate::u3},
-  {"u2", ParamGate::u2},
-  {"u1", ParamGate::u1},
-  {"r", ParamGate::r},
-  {"rx", ParamGate::rx},
-  {"ry", ParamGate::ry},
-  {"rz", ParamGate::rz},
-  {"rxx", ParamGate::rxx},
-  {"ryy", ParamGate::ryy},
-  {"rzz", ParamGate::rzz},
-  {"rzx", ParamGate::rzx},
-  {"p", ParamGate::u1},
-  {"cp", ParamGate::cp},
-  {"cu1", ParamGate::cp},
-  {"cu", ParamGate::cu},
+const stringmap_t<NoiseModel::ParamGate> NoiseModel::param_gate_table_ = {
+    {"u", ParamGate::u3},    {"u3", ParamGate::u3},   {"u2", ParamGate::u2},
+    {"u1", ParamGate::u1},   {"r", ParamGate::r},     {"rx", ParamGate::rx},
+    {"ry", ParamGate::ry},   {"rz", ParamGate::rz},   {"rxx", ParamGate::rxx},
+    {"ryy", ParamGate::ryy}, {"rzz", ParamGate::rzz}, {"rzx", ParamGate::rzx},
+    {"p", ParamGate::u1},    {"cp", ParamGate::cp},   {"cu1", ParamGate::cp},
+    {"cu", ParamGate::cu},
 };
 
-
 //=========================================================================
 // Noise sampling
 //=========================================================================
 
-Circuit NoiseModel::sample_noise(const Circuit &circ,
-                                 RngEngine &rng,
-                                 const Method method,bool sample_at_runtime) const {
+Circuit NoiseModel::sample_noise(const Circuit &circ, RngEngine &rng,
+                                 const Method method,
+                                 bool sample_at_runtime) const {
   // Check edge case of empty circuit
   if (circ.ops.empty()) {
     return circ;
@@ -283,18 +276,20 @@ Circuit NoiseModel::sample_noise(const Circuit &circ,
   // Check if sampling method is enabled
   if (enabled_methods_.find(method) == enabled_methods_.end()) {
     throw std::runtime_error(
-      "Kraus or superoperator noise sampling method has not been enabled.");
+        "Kraus or superoperator noise sampling method has not been enabled.");
   }
-  return sample_noise_circuit(circ, rng, method,sample_at_runtime);
+  return sample_noise_circuit(circ, rng, method, sample_at_runtime);
 }
 
-NoiseModel::NoiseOps NoiseModel::sample_noise_loc(const Operations::Op &op,RngEngine &rng) const
-{
-  auto noise_ops = sample_noise_op(op, rng, Method::circuit,circ_mapping_,false);
+NoiseModel::NoiseOps NoiseModel::sample_noise_loc(const Operations::Op &op,
+                                                  RngEngine &rng) const {
+  auto noise_ops =
+      sample_noise_op(op, rng, Method::circuit, circ_mapping_, false);
 
-  // If original op is conditional, make all the noise operations also conditional
+  // If original op is conditional, make all the noise operations also
+  // conditional
   if (op.conditional) {
-    for (auto& noise_op : noise_ops) {
+    for (auto &noise_op : noise_ops) {
       noise_op.conditional = op.conditional;
       noise_op.conditional_reg = op.conditional_reg;
       noise_op.bfunc = op.bfunc;
@@ -303,78 +298,81 @@ NoiseModel::NoiseOps NoiseModel::sample_noise_loc(const Operations::Op &op,RngEn
   return noise_ops;
 }
 
-Circuit NoiseModel::sample_noise_circuit(const Circuit &circ,
-                                         RngEngine &rng,
-                                         const Method method,bool sample_at_runtime) const 
-{
-    bool noise_active = true; // set noise active to on-state
-    Circuit noisy_circ;
-    // Copy metadata
-    noisy_circ.seed = circ.seed;
-    noisy_circ.shots = circ.shots;
-    noisy_circ.header = circ.header;
-
-    // Reserve double length of ops just to be safe
-    noisy_circ.ops.reserve(2 * circ.ops.size());
-
-    // Qubit mapping
-    reg_t mapping;
-    if (circ.remapped_qubits)
-      mapping = reg_t(circ.qubits().cbegin(), circ.qubits().cend());
-
-    // Sample a noisy realization of the circuit
-    for (const auto &op: circ.ops) {
-      switch (op.type) {
-        // Operations that cannot have noise
-        case Operations::OpType::barrier:
-          noisy_circ.ops.push_back(op);
-          break;
-        case Operations::OpType::snapshot:
-          noisy_circ.ops.push_back(op);
-          break;
-        case Operations::OpType::kraus:
-          noisy_circ.ops.push_back(op);
-          break;
-        case Operations::OpType::superop:
-          noisy_circ.ops.push_back(op);
-          break;
-        case Operations::OpType::roerror:
-          noisy_circ.ops.push_back(op);
-          break;
-        case Operations::OpType::bfunc:
-          noisy_circ.ops.push_back(op);
-          break;
-        // Switch noise on or off during current circuit sample
-        case Operations::OpType::noise_switch:
-          noise_active = static_cast<int>(std::real(op.params[0]));
-          break;
-        default:
-          if (noise_active) {
-            NoiseOps noisy_op = sample_noise_op(op, rng, method, mapping, sample_at_runtime);
-            noisy_circ.ops.insert(noisy_circ.ops.end(), noisy_op.begin(), noisy_op.end());
-          }
-          break;
+Circuit NoiseModel::sample_noise_circuit(const Circuit &circ, RngEngine &rng,
+                                         const Method method,
+                                         bool sample_at_runtime) const {
+  bool noise_active = true; // set noise active to on-state
+  Circuit noisy_circ;
+  // Copy metadata
+  noisy_circ.seed = circ.seed;
+  noisy_circ.shots = circ.shots;
+  noisy_circ.header = circ.header;
+
+  // Reserve double length of ops just to be safe
+  noisy_circ.ops.reserve(2 * circ.ops.size());
+
+  // Qubit mapping
+  reg_t mapping;
+  if (circ.remapped_qubits)
+    mapping = reg_t(circ.qubits().cbegin(), circ.qubits().cend());
+
+  // Sample a noisy realization of the circuit
+  for (const auto &op : circ.ops) {
+    switch (op.type) {
+    // Operations that cannot have noise
+    case Operations::OpType::barrier:
+      noisy_circ.ops.push_back(op);
+      break;
+    case Operations::OpType::snapshot:
+      noisy_circ.ops.push_back(op);
+      break;
+    case Operations::OpType::kraus:
+      noisy_circ.ops.push_back(op);
+      break;
+    case Operations::OpType::superop:
+      noisy_circ.ops.push_back(op);
+      break;
+    case Operations::OpType::roerror:
+      noisy_circ.ops.push_back(op);
+      break;
+    case Operations::OpType::bfunc:
+      noisy_circ.ops.push_back(op);
+      break;
+    // Switch noise on or off during current circuit sample
+    case Operations::OpType::noise_switch:
+      noise_active = static_cast<int>(std::real(op.params[0]));
+      break;
+    default:
+      if (noise_active) {
+        NoiseOps noisy_op =
+            sample_noise_op(op, rng, method, mapping, sample_at_runtime);
+        noisy_circ.ops.insert(noisy_circ.ops.end(), noisy_op.begin(),
+                              noisy_op.end());
       }
+      break;
     }
-    // Update circuit parameters
-    noisy_circ.set_params();
-    if(sample_at_runtime){
-      noisy_circ.can_sample = false;
-      circ_mapping_ = mapping;
-    }
-    return noisy_circ;
+  }
+  // Update circuit parameters
+  noisy_circ.set_params();
+  if (sample_at_runtime) {
+    noisy_circ.can_sample = false;
+    circ_mapping_ = mapping;
+  }
+  return noisy_circ;
 }
 
 NoiseModel::NoiseOps NoiseModel::sample_noise_op(const Operations::Op &op,
                                                  RngEngine &rng,
                                                  const Method method,
-                                                 const reg_t &mapping,bool sample_at_runtime) const 
-{
-  auto noise_ops = sample_noise_helper(op, rng, method, mapping, sample_at_runtime);
+                                                 const reg_t &mapping,
+                                                 bool sample_at_runtime) const {
+  auto noise_ops =
+      sample_noise_helper(op, rng, method, mapping, sample_at_runtime);
 
-  // If original op is conditional, make all the noise operations also conditional
+  // If original op is conditional, make all the noise operations also
+  // conditional
   if (op.conditional) {
-    for (auto& noise_op : noise_ops) {
+    for (auto &noise_op : noise_ops) {
       noise_op.conditional = op.conditional;
       noise_op.conditional_reg = op.conditional_reg;
       noise_op.bfunc = op.bfunc;
@@ -383,29 +381,28 @@ NoiseModel::NoiseOps NoiseModel::sample_noise_op(const Operations::Op &op,
   return noise_ops;
 }
 
-
 void NoiseModel::enable_superop_method(int num_threads) {
   if (enabled_methods_.find(Method::superop) == enabled_methods_.end()) {
-    #pragma omp parallel for if (num_threads > 1 && quantum_errors_.size() > 10) num_threads(num_threads)
-    for (int i=0; i < quantum_errors_.size(); i++)  {
+#pragma omp parallel for if (num_threads > 1 && quantum_errors_.size() > 10)   \
+    num_threads(num_threads)
+    for (int i = 0; i < quantum_errors_.size(); i++) {
       quantum_errors_[i].compute_superoperator();
     }
     enabled_methods_.insert(Method::superop);
   }
 }
 
-
 void NoiseModel::enable_kraus_method(int num_threads) {
   if (enabled_methods_.find(Method::kraus) == enabled_methods_.end()) {
-    #pragma omp parallel for if (num_threads > 1 && quantum_errors_.size() > 10) num_threads(num_threads)
-    for (int i=0; i < quantum_errors_.size(); i++)  {
+#pragma omp parallel for if (num_threads > 1 && quantum_errors_.size() > 10)   \
+    num_threads(num_threads)
+    for (int i = 0; i < quantum_errors_.size(); i++) {
       quantum_errors_[i].compute_kraus();
     }
     enabled_methods_.insert(Method::kraus);
   }
 }
 
-
 void NoiseModel::add_readout_error(const ReadoutError &error,
                                    const std::vector<reg_t> &op_qubits) {
   // Add roerror to noise model ops
@@ -427,7 +424,6 @@ void NoiseModel::add_readout_error(const ReadoutError &error,
   }
 }
 
-
 void NoiseModel::add_quantum_error(const QuantumError &error,
                                    const stringset_t &op_labels,
                                    const std::vector<reg_t> &op_qubits,
@@ -448,7 +444,6 @@ void NoiseModel::add_quantum_error(const QuantumError &error,
   }
 }
 
-
 void NoiseModel::add_local_quantum_error(const QuantumError &error,
                                          const stringset_t &op_labels,
                                          const std::vector<reg_t> &op_qubits) {
@@ -461,7 +456,7 @@ void NoiseModel::add_local_quantum_error(const QuantumError &error,
   // Get position of error in error vector
   const auto error_pos = quantum_errors_.size() - 1;
   // Add error index to the error table
-  for (const auto &gate: op_labels)
+  for (const auto &gate : op_labels)
     for (const auto &qubits : op_qubits) {
       local_quantum_error_table_[gate][reg2string(qubits)].push_back(error_pos);
       for (const auto &qubit : qubits)
@@ -469,11 +464,10 @@ void NoiseModel::add_local_quantum_error(const QuantumError &error,
     }
 }
 
-
-void NoiseModel::add_nonlocal_quantum_error(const QuantumError &error,
-                                            const stringset_t &op_labels,
-                                            const std::vector<reg_t> &op_qubits,
-                                            const std::vector<reg_t> &noise_qubits) {
+void NoiseModel::add_nonlocal_quantum_error(
+    const QuantumError &error, const stringset_t &op_labels,
+    const std::vector<reg_t> &op_qubits,
+    const std::vector<reg_t> &noise_qubits) {
 
   // Turn on nonlocal error flag
   if (!op_labels.empty() && !op_qubits.empty() && !noise_qubits.empty()) {
@@ -484,31 +478,33 @@ void NoiseModel::add_nonlocal_quantum_error(const QuantumError &error,
   // Get position of error in error vector
   const auto error_pos = quantum_errors_.size() - 1;
   // Add error index to the error table
-  for (const auto &gate: op_labels)
+  for (const auto &gate : op_labels)
     for (const auto &qubits_gate : op_qubits) {
       for (const auto &qubit : qubits_gate)
         noise_qubits_.insert(qubit);
       for (const auto &qubits_noise : noise_qubits) {
-        nonlocal_quantum_error_table_[gate][reg2string(qubits_gate)][reg2string(qubits_noise)].push_back(error_pos);
+        nonlocal_quantum_error_table_[gate][reg2string(qubits_gate)]
+                                     [reg2string(qubits_noise)]
+                                         .push_back(error_pos);
         for (const auto &qubit : qubits_noise)
           noise_qubits_.insert(qubit);
       }
     }
 }
 
-
-NoiseModel::NoiseOps NoiseModel::sample_noise_helper(const Operations::Op &op,
-                                                     RngEngine &rng,
-                                                     const Method method,
-                                                     const reg_t &mapping,bool sample_at_runtime) const 
-{
+NoiseModel::NoiseOps
+NoiseModel::sample_noise_helper(const Operations::Op &op, RngEngine &rng,
+                                const Method method, const reg_t &mapping,
+                                bool sample_at_runtime) const {
   // Return operator set
   NoiseOps noise_before;
   NoiseOps noise_after;
   // Apply local errors first
-  sample_local_quantum_noise(op, noise_before, noise_after, rng, method, mapping, sample_at_runtime);
+  sample_local_quantum_noise(op, noise_before, noise_after, rng, method,
+                             mapping, sample_at_runtime);
   // Apply nonlocal errors second
-  sample_nonlocal_quantum_noise(op, noise_before, noise_after, rng, method, mapping, sample_at_runtime);
+  sample_nonlocal_quantum_noise(op, noise_before, noise_after, rng, method,
+                                mapping, sample_at_runtime);
   // Apply readout error to measure ops
   if (op.type == Operations::OpType::measure) {
     sample_readout_noise(op, noise_after, rng, mapping);
@@ -524,39 +520,38 @@ NoiseModel::NoiseOps NoiseModel::sample_noise_helper(const Operations::Op &op,
                    std::make_move_iterator(noise_after.begin()),
                    std::make_move_iterator(noise_after.end()));
 
-  if (op.type != Operations::OpType::measure &&
-      noise_ops.size() == 2 &&
+  if (op.type != Operations::OpType::measure && noise_ops.size() == 2 &&
       noise_ops[0].qubits == noise_ops[1].qubits) {
     // Try and fuse operations
     // If either are superoperators combine superoperators
     // else if either are unitaries combine unitaries
     // otherwise return the full list
-    auto& first_op = noise_ops[0];
-    auto& second_op = noise_ops[1];
+    auto &first_op = noise_ops[0];
+    auto &second_op = noise_ops[1];
 
     if (second_op.type == Operations::OpType::superop) {
-      auto& current = second_op;
+      auto &current = second_op;
       const auto mat = op2superop(first_op);
       if (!mat.empty()) {
         current.mats[0] = current.mats[0] * mat;
         return NoiseOps({current});
       }
     } else if (first_op.type == Operations::OpType::superop) {
-      auto& current = first_op;
+      auto &current = first_op;
       const auto mat = op2superop(second_op);
       if (!mat.empty()) {
         current.mats[0] = mat * current.mats[0];
         return NoiseOps({current});
       }
-    } else if (second_op.type == Operations::OpType::matrix) { 
-      auto& current = noise_before[1];
+    } else if (second_op.type == Operations::OpType::matrix) {
+      auto &current = noise_before[1];
       const auto mat = op2unitary(first_op);
       if (!mat.empty()) {
         current.mats[0] = current.mats[0] * mat;
         return NoiseOps({current});
       }
     } else if (first_op.type == Operations::OpType::matrix) {
-      auto& current = first_op;
+      auto &current = first_op;
       const auto mat = op2unitary(second_op);
       if (!mat.empty()) {
         current.mats[0] = mat * current.mats[0];
@@ -568,10 +563,8 @@ NoiseModel::NoiseOps NoiseModel::sample_noise_helper(const Operations::Op &op,
   return noise_before;
 }
 
-
 void NoiseModel::sample_readout_noise(const Operations::Op &op,
-                                      NoiseOps &noise_after,
-                                      RngEngine &rng,
+                                      NoiseOps &noise_after, RngEngine &rng,
                                       const reg_t &mapping) const {
   // If no readout errors are defined pass
   if (readout_errors_.empty()) {
@@ -580,7 +573,7 @@ void NoiseModel::sample_readout_noise(const Operations::Op &op,
   // Check if measure op writes only to memory, or also to registers
   // We will use the same error model for both memory and registers
   bool has_registers = !op.registers.empty();
-  
+
   // Optional remap circuit qubits to noise model qubits
   const auto op_qubits = remap_reg(op.qubits, mapping);
 
@@ -617,36 +610,36 @@ void NoiseModel::sample_readout_noise(const Operations::Op &op,
       registers_sets.push_back(op.registers);
   }
   // Iterate over qubits
-  for (size_t qs=0; qs < qubit_keys.size(); ++qs) {
+  for (size_t qs = 0; qs < qubit_keys.size(); ++qs) {
     auto iter_qubits = readout_error_table_.find(qubit_keys[qs]);
     if (iter_qubits != readout_error_table_.end() ||
         iter_default != readout_error_table_.end()) {
       auto &error_positions = (iter_qubits != readout_error_table_.end())
-        ? iter_qubits->second
-        : iter_default->second;
+                                  ? iter_qubits->second
+                                  : iter_default->second;
       for (auto &pos : error_positions) {
         // Sample Readout error
-        auto noise_ops = readout_errors_[pos].sample_noise(memory_sets[qs], rng);
+        auto noise_ops =
+            readout_errors_[pos].sample_noise(memory_sets[qs], rng);
         if (has_registers) {
-          for (auto& noise_op: noise_ops) {
+          for (auto &noise_op : noise_ops) {
             noise_op.registers = registers_sets[qs];
           }
         }
-        // Add noise after the error 
-        noise_after.insert(noise_after.end(), noise_ops.begin(), noise_ops.end());
+        // Add noise after the error
+        noise_after.insert(noise_after.end(), noise_ops.begin(),
+                           noise_ops.end());
       }
     }
   }
 }
 
-
 void NoiseModel::sample_local_quantum_noise(const Operations::Op &op,
                                             NoiseOps &noise_before,
                                             NoiseOps &noise_after,
-                                            RngEngine &rng,
-                                            const Method method,
-                                            const reg_t &mapping,bool sample_at_runtime) const 
-{
+                                            RngEngine &rng, const Method method,
+                                            const reg_t &mapping,
+                                            bool sample_at_runtime) const {
   // If no errors are defined pass
   if (local_quantum_errors_ == false)
     return;
@@ -654,8 +647,8 @@ void NoiseModel::sample_local_quantum_noise(const Operations::Op &op,
   // Get op name, or label if it is a gate or unitary matrix
   std::string name = (op.type == Operations::OpType::matrix ||
                       op.type == Operations::OpType::gate)
-    ? op.string_params[0]
-    : op.name;
+                         ? op.string_params[0]
+                         : op.name;
 
   // Check if op is a measure or reset
   bool is_measure_or_reset = (op.type == Operations::OpType::measure ||
@@ -678,13 +671,15 @@ void NoiseModel::sample_local_quantum_noise(const Operations::Op &op,
     // Format qubit sets
     std::vector<std::string> qubit_keys;
     std::vector<reg_t> original_qubits;
-    if (is_measure_or_reset && qubit_map.find(op_qubits_key) == qubit_map.end()) {
+    if (is_measure_or_reset &&
+        qubit_map.find(op_qubits_key) == qubit_map.end()) {
       // Since measure and reset ops can be defined on multiple qubits
       // but error model may be specified only on single qubits we add
       // each one separately. If a multi-qubit model is found for specified
       // qubits however, that will be used instead.
-      for (size_t i=0; i < remapped_op_qubits.size(); ++i) {
-        qubit_keys.push_back(std::to_string(remapped_op_qubits[i]) + std::string(","));
+      for (size_t i = 0; i < remapped_op_qubits.size(); ++i) {
+        qubit_keys.push_back(std::to_string(remapped_op_qubits[i]) +
+                             std::string(","));
         original_qubits.push_back(reg_t({op.qubits[i]}));
       }
     } else {
@@ -692,52 +687,51 @@ void NoiseModel::sample_local_quantum_noise(const Operations::Op &op,
       qubit_keys.push_back(op_qubits_key);
       original_qubits.push_back(op.qubits);
     }
-    for(size_t i=0; i < qubit_keys.size(); ++i){
-      const auto& op_qubits = original_qubits[i];
-      const auto& qubit_key = qubit_keys[i];
+    for (size_t i = 0; i < qubit_keys.size(); ++i) {
+      const auto &op_qubits = original_qubits[i];
+      const auto &qubit_key = qubit_keys[i];
       auto iter_qubits = qubit_map.find(qubit_key);
-      if (iter_qubits != qubit_map.end() ||
-          iter_default != qubit_map.end()) {
+      if (iter_qubits != qubit_map.end() || iter_default != qubit_map.end()) {
         auto &error_positions = (iter_qubits != qubit_map.end())
-          ? iter_qubits->second
-          : iter_default->second;
+                                    ? iter_qubits->second
+                                    : iter_default->second;
         for (auto &pos : error_positions) {
           NoiseOps noise_ops;
-          if(sample_at_runtime)
+          if (sample_at_runtime)
             noise_ops = create_noise_loc(op);
           else
-            noise_ops = quantum_errors_[pos].sample_noise(op_qubits, rng, method);
+            noise_ops =
+                quantum_errors_[pos].sample_noise(op_qubits, rng, method);
           // Duplicate same sampled error operations
           if (quantum_errors_[pos].errors_after())
-            noise_after.insert(noise_after.end(), noise_ops.begin(), noise_ops.end());
+            noise_after.insert(noise_after.end(), noise_ops.begin(),
+                               noise_ops.end());
           else
-            noise_before.insert(noise_before.end(), noise_ops.begin(), noise_ops.end());
+            noise_before.insert(noise_before.end(), noise_ops.begin(),
+                                noise_ops.end());
         }
       }
     }
   }
 }
 
-
-void NoiseModel::sample_nonlocal_quantum_noise(const Operations::Op &op,
-                                               NoiseOps &noise_before,
-                                               NoiseOps &noise_after,
-                                               RngEngine &rng,
-                                               const Method method,
-                                               const reg_t &mapping,bool sample_at_runtime) const 
-{
+void NoiseModel::sample_nonlocal_quantum_noise(
+    const Operations::Op &op, NoiseOps &noise_before, NoiseOps &noise_after,
+    RngEngine &rng, const Method method, const reg_t &mapping,
+    bool sample_at_runtime) const {
   // If no errors are defined pass
   if (nonlocal_quantum_errors_ == false)
     return;
-  
+
   // Get op name, or label if it is a gate or unitary matrix
   std::string name = (op.type == Operations::OpType::matrix ||
                       op.type == Operations::OpType::gate)
-    ? op.string_params[0]
-    : op.name;
+                         ? op.string_params[0]
+                         : op.name;
 
   if (!mapping.empty()) {
-    throw std::invalid_argument("Non-local noise model cannot be used with a qubit mapping.");
+    throw std::invalid_argument(
+        "Non-local noise model cannot be used with a qubit mapping.");
   }
 
   // Convert qubits to string for table lookup
@@ -749,8 +743,9 @@ void NoiseModel::sample_nonlocal_quantum_noise(const Operations::Op &op,
     // Format qubit sets
     std::vector<std::string> qubit_keys;
 
-    if ((op.type == Operations::OpType::measure || op.type == Operations::OpType::reset)
-        && qubit_map.find(qubits_str) == qubit_map.end()) {
+    if ((op.type == Operations::OpType::measure ||
+         op.type == Operations::OpType::reset) &&
+        qubit_map.find(qubits_str) == qubit_map.end()) {
       // Since measure and reset ops can be defined on multiple qubits
       // but error model may be specified only on single qubits we add
       // each one separately. If a multi-qubit model is found for specified
@@ -762,7 +757,7 @@ void NoiseModel::sample_nonlocal_quantum_noise(const Operations::Op &op,
       // for gate operations we use the qubits as specified
       qubit_keys.push_back(reg2string(op.qubits));
     }
-    for (const auto &qubits: qubit_keys) {
+    for (const auto &qubits : qubit_keys) {
       // Check if the qubits are listed in the inner model
       auto iter_qubits = qubit_map.find(qubits);
       if (iter_qubits != qubit_map.end()) {
@@ -771,11 +766,11 @@ void NoiseModel::sample_nonlocal_quantum_noise(const Operations::Op &op,
           auto &error_positions = target_pair.second;
           for (auto &pos : error_positions) {
             NoiseOps ops;
-            if(sample_at_runtime)
+            if (sample_at_runtime)
               ops = create_noise_loc(op);
-            else{
-              ops = quantum_errors_[pos].sample_noise(string2reg(target_qubits), rng,
-                                                         method);
+            else {
+              ops = quantum_errors_[pos].sample_noise(string2reg(target_qubits),
+                                                      rng, method);
             }
             if (quantum_errors_[pos].errors_after())
               noise_after.insert(noise_after.end(), ops.begin(), ops.end());
@@ -788,8 +783,8 @@ void NoiseModel::sample_nonlocal_quantum_noise(const Operations::Op &op,
   }
 }
 
-NoiseModel::NoiseOps NoiseModel::create_noise_loc(const Operations::Op &op) const
-{
+NoiseModel::NoiseOps
+NoiseModel::create_noise_loc(const Operations::Op &op) const {
   NoiseOps ops(1);
   ops[0] = op;
   ops[0].type = Operations::OpType::qerror_loc;
@@ -798,56 +793,57 @@ NoiseModel::NoiseOps NoiseModel::create_noise_loc(const Operations::Op &op) cons
 
 cmatrix_t NoiseModel::op2superop(const Operations::Op &op) const {
   switch (op.type) {
-    case Operations::OpType::superop:
-      return op.mats[0];
-    case Operations::OpType::kraus: {
-      return Utils::kraus_superop(op.mats);
-    }
-    case Operations::OpType::reset:
-      return Linalg::SMatrix::reset(1ULL << op.qubits.size());
-    case  Operations::OpType::matrix:
-      return Utils::unitary_superop(op.mats[0]);
-    case Operations::OpType::gate:  {
-      auto it = param_gate_table_.find(op.name);
-      if (it != param_gate_table_.end()) {
-        // Get parameterized gate superop
-        switch (it -> second) {
-          case ParamGate::u1:
-            return Linalg::SMatrix::u1(op.params[0]);
-          case ParamGate::u2:
-            return Linalg::SMatrix::u2(op.params[0], op.params[1]);
-          case ParamGate::u3:
-            return Linalg::SMatrix::u3(op.params[0], op.params[1], op.params[2]);
-          case ParamGate::r:
-            return Linalg::SMatrix::r(op.params[0], op.params[1]);
-          case ParamGate::rx:
-            return Linalg::SMatrix::rx(op.params[0]);
-          case ParamGate::ry:
-            return Linalg::SMatrix::ry(op.params[0]);
-          case ParamGate::rz:
-            return Linalg::SMatrix::rz(op.params[0]);
-          case ParamGate::rxx:
-            return Linalg::SMatrix::rxx(op.params[0]);
-          case ParamGate::ryy:
-            return Linalg::SMatrix::ryy(op.params[0]);
-          case ParamGate::rzz:
-            return Linalg::SMatrix::rzz(op.params[0]);
-          case ParamGate::rzx:
-            return Linalg::SMatrix::rzx(op.params[0]);
-          case ParamGate::cp:
-            return Linalg::SMatrix::cphase(op.params[0]);
-          case ParamGate::cu:
-            return Linalg::SMatrix::cu(op.params[0], op.params[1], op.params[2], op.params[3]);
-        }
-      } else {
-        // Check if we can convert this gate to a standard superoperator matrix
-        if (Linalg::SMatrix::allowed_name(op.name)) {
-          return Linalg::SMatrix::from_name(op.name);
-        }
+  case Operations::OpType::superop:
+    return op.mats[0];
+  case Operations::OpType::kraus: {
+    return Utils::kraus_superop(op.mats);
+  }
+  case Operations::OpType::reset:
+    return Linalg::SMatrix::reset(1ULL << op.qubits.size());
+  case Operations::OpType::matrix:
+    return Utils::unitary_superop(op.mats[0]);
+  case Operations::OpType::gate: {
+    auto it = param_gate_table_.find(op.name);
+    if (it != param_gate_table_.end()) {
+      // Get parameterized gate superop
+      switch (it->second) {
+      case ParamGate::u1:
+        return Linalg::SMatrix::u1(op.params[0]);
+      case ParamGate::u2:
+        return Linalg::SMatrix::u2(op.params[0], op.params[1]);
+      case ParamGate::u3:
+        return Linalg::SMatrix::u3(op.params[0], op.params[1], op.params[2]);
+      case ParamGate::r:
+        return Linalg::SMatrix::r(op.params[0], op.params[1]);
+      case ParamGate::rx:
+        return Linalg::SMatrix::rx(op.params[0]);
+      case ParamGate::ry:
+        return Linalg::SMatrix::ry(op.params[0]);
+      case ParamGate::rz:
+        return Linalg::SMatrix::rz(op.params[0]);
+      case ParamGate::rxx:
+        return Linalg::SMatrix::rxx(op.params[0]);
+      case ParamGate::ryy:
+        return Linalg::SMatrix::ryy(op.params[0]);
+      case ParamGate::rzz:
+        return Linalg::SMatrix::rzz(op.params[0]);
+      case ParamGate::rzx:
+        return Linalg::SMatrix::rzx(op.params[0]);
+      case ParamGate::cp:
+        return Linalg::SMatrix::cphase(op.params[0]);
+      case ParamGate::cu:
+        return Linalg::SMatrix::cu(op.params[0], op.params[1], op.params[2],
+                                   op.params[3]);
+      }
+    } else {
+      // Check if we can convert this gate to a standard superoperator matrix
+      if (Linalg::SMatrix::allowed_name(op.name)) {
+        return Linalg::SMatrix::from_name(op.name);
       }
     }
-    default:
-      return cmatrix_t();
+  }
+  default:
+    return cmatrix_t();
   }
 }
 
@@ -855,35 +851,35 @@ cmatrix_t NoiseModel::op2unitary(const Operations::Op &op) const {
   switch (op.type) {
   case Operations::OpType::matrix:
     return op.mats[0];
-  case Operations::OpType::gate:  {
+  case Operations::OpType::gate: {
     auto it = param_gate_table_.find(op.name);
     if (it != param_gate_table_.end()) {
       // Get parameterized gate superop
-      switch (it -> second) {
-        case ParamGate::u1:
-          return Linalg::Matrix::u1(op.params[0]);
-        case ParamGate::u2:
-          return Linalg::Matrix::u2(op.params[0], op.params[1]);
-        case ParamGate::u3:
-          return Linalg::Matrix::u3(op.params[0], op.params[1], op.params[2]);
-        case ParamGate::r:
-          return Linalg::Matrix::r(op.params[0], op.params[1]);
-        case ParamGate::rx:
-          return Linalg::Matrix::rx(op.params[0]);
-        case ParamGate::ry:
-          return Linalg::Matrix::ry(op.params[0]);
-        case ParamGate::rz:
-          return Linalg::Matrix::rz(op.params[0]);
-        case ParamGate::rxx:
-          return Linalg::Matrix::rxx(op.params[0]);
-        case ParamGate::ryy:
-          return Linalg::Matrix::ryy(op.params[0]);
-        case ParamGate::rzz:
-          return Linalg::Matrix::rzz(op.params[0]);
-        case ParamGate::rzx:
-          return Linalg::Matrix::rzx(op.params[0]);
-        case ParamGate::cp:
-          return Linalg::Matrix::cphase(op.params[0]);
+      switch (it->second) {
+      case ParamGate::u1:
+        return Linalg::Matrix::u1(op.params[0]);
+      case ParamGate::u2:
+        return Linalg::Matrix::u2(op.params[0], op.params[1]);
+      case ParamGate::u3:
+        return Linalg::Matrix::u3(op.params[0], op.params[1], op.params[2]);
+      case ParamGate::r:
+        return Linalg::Matrix::r(op.params[0], op.params[1]);
+      case ParamGate::rx:
+        return Linalg::Matrix::rx(op.params[0]);
+      case ParamGate::ry:
+        return Linalg::Matrix::ry(op.params[0]);
+      case ParamGate::rz:
+        return Linalg::Matrix::rz(op.params[0]);
+      case ParamGate::rxx:
+        return Linalg::Matrix::rxx(op.params[0]);
+      case ParamGate::ryy:
+        return Linalg::Matrix::ryy(op.params[0]);
+      case ParamGate::rzz:
+        return Linalg::Matrix::rzz(op.params[0]);
+      case ParamGate::rzx:
+        return Linalg::Matrix::rzx(op.params[0]);
+      case ParamGate::cp:
+        return Linalg::Matrix::cphase(op.params[0]);
       }
     } else {
       // Check if we can convert this gate to a standard superoperator matrix
@@ -897,14 +893,13 @@ cmatrix_t NoiseModel::op2unitary(const Operations::Op &op) const {
   }
 }
 
-
 std::string NoiseModel::reg2string(const reg_t &reg) const {
   std::stringstream result;
-  std::copy(reg.begin(), reg.end(), std::ostream_iterator<reg_t::value_type>(result, ","));
+  std::copy(reg.begin(), reg.end(),
+            std::ostream_iterator<reg_t::value_type>(result, ","));
   return result.str();
 }
 
-
 reg_t NoiseModel::string2reg(std::string s) const {
   reg_t result;
   size_t pos = 0;
@@ -915,13 +910,12 @@ reg_t NoiseModel::string2reg(std::string s) const {
   return result;
 }
 
-
 //=========================================================================
 // Qubit Remapping
 //=========================================================================
 
 std::set<uint_t> NoiseModel::nonlocal_noise_qubits(const std::string label,
-                                                   const reg_t& qubits) const {
+                                                   const reg_t &qubits) const {
   std::set<uint_t> all_noise_qubits;
   // Check if label has noise
   const auto outer_it = nonlocal_quantum_error_table_.find(label);
@@ -971,8 +965,9 @@ reg_t NoiseModel::remap_reg(const reg_t &reg, const reg_t &mapping) const {
   {
     "type": "qerror",
     "operations": ["x", "y", ...],  // ops to apply error to
-    "gate_qubits": [[0], [1]]      // error only apples when op is on these qubits (blank for all)
-    "noise_qubits": [[2], ...]     // error term will be applied to these qubits (blank for input qubits)
+    "gate_qubits": [[0], [1]]      // error only apples when op is on these
+  qubits (blank for all) "noise_qubits": [[2], ...]     // error term will be
+  applied to these qubits (blank for input qubits)
                                    // if false noise will be applied before op
     "probabilities": [p0, p1, ..],
     "instructions": [qobj_circuit_instrs0, qobj_circuit_instrs1, ...]
@@ -983,7 +978,8 @@ reg_t NoiseModel::remap_reg(const reg_t &reg, const reg_t &mapping) const {
     "type": "roerror",
     "operations": ["measure"],
     "probabilities": [[P(0|0), P(0|1)], [P(1|0), P(1|1)]]
-    "gate_qubits": [[0]]  // error only apples when op is on these qubits (blank for all)
+    "gate_qubits": [[0]]  // error only apples when op is on these qubits (blank
+  for all)
   }
 */
 
@@ -1000,24 +996,27 @@ void NoiseModel::load_from_json(const json_t &js) {
 
   if (JSON::check_key("errors", js)) {
     if (!js["errors"].is_array()) {
-      throw std::invalid_argument("Invalid noise_params JSON: \"error\" field is not a list");
+      throw std::invalid_argument(
+          "Invalid noise_params JSON: \"error\" field is not a list");
     }
     for (const auto &gate_js : JSON::get_value("errors", js)) {
       std::string type;
       JSON::get_value(type, "type", gate_js);
-      stringset_t ops; // want set so ops are unique, and we can pull out measure
+      stringset_t
+          ops; // want set so ops are unique, and we can pull out measure
       JSON::get_value(ops, "operations", gate_js);
       std::vector<reg_t> gate_qubits;
       JSON::get_value(gate_qubits, "gate_qubits", gate_js);
       std::vector<reg_t> noise_qubits;
       JSON::get_value(noise_qubits, "noise_qubits", gate_js);
 
-      // We treat measure as a separate error op so that it can be applied before
-      // the measure operation, rather than after like the other gates
+      // We treat measure as a separate error op so that it can be applied
+      // before the measure operation, rather than after like the other gates
       if (ops.find("measure") != ops.end() && type != "roerror") {
         ops.erase("measure"); // remove measure from set of ops
         if (type != "qerror")
-          throw std::invalid_argument("NoiseModel: Invalid noise type (" + type + ")");
+          throw std::invalid_argument("NoiseModel: Invalid noise type (" +
+                                      type + ")");
         QuantumError error;
         error.load_from_json(gate_js);
         error.set_errors_before(); // set errors before the op
@@ -1036,8 +1035,9 @@ void NoiseModel::load_from_json(const json_t &js) {
         ReadoutError error; // readout error goes after
         error.load_from_json(gate_js);
         add_readout_error(error, gate_qubits);
-      }else {
-        throw std::invalid_argument("NoiseModel: Invalid noise type (" + type + ")");
+      } else {
+        throw std::invalid_argument("NoiseModel: Invalid noise type (" + type +
+                                    ")");
       }
     }
   }
@@ -1047,7 +1047,6 @@ inline void from_json(const json_t &js, NoiseModel &model) {
   model = NoiseModel(js);
 }
 
-
 //-------------------------------------------------------------------------
 } // end namespace Noise
 //-------------------------------------------------------------------------
diff --git a/src/noise/quantum_error.hpp b/src/noise/quantum_error.hpp
index aa6738f663..b791f5bfe5 100644
--- a/src/noise/quantum_error.hpp
+++ b/src/noise/quantum_error.hpp
@@ -15,9 +15,9 @@
 #ifndef _aer_noise_quantum_error_hpp_
 #define _aer_noise_quantum_error_hpp_
 
+#include "framework/noise_utils.hpp"
 #include "framework/opset.hpp"
 #include "simulators/superoperator/superoperator_state.hpp"
-#include "framework/noise_utils.hpp"
 
 namespace AER {
 namespace Noise {
@@ -31,9 +31,8 @@ namespace Noise {
 
 class QuantumError {
 public:
-
   // Methods for sampling
-  enum class Method {circuit, superop, kraus};
+  enum class Method { circuit, superop, kraus };
 
   // Alias for return type
   using NoiseOps = std::vector<Operations::Op>;
@@ -43,22 +42,21 @@ class QuantumError {
   //-----------------------------------------------------------------------
 
   // Sample a noisy implementation of op
-  NoiseOps sample_noise(const reg_t &qubits,
-                        RngEngine &rng,
+  NoiseOps sample_noise(const reg_t &qubits, RngEngine &rng,
                         Method method = Method::circuit) const;
 
   // Return the opset for the quantum error
-  const Operations::OpSet& opset() const {return opset_;}
+  const Operations::OpSet &opset() const { return opset_; }
 
   // Return the superoperator matrix representation of the error.
   // If the error cannot be converted to a superoperator an error
   // will be raised.
-  const cmatrix_t& superoperator() const;
+  const cmatrix_t &superoperator() const;
 
   // Return the canonical Kraus representation of the error.
   // If the error cannot be converted to a Kraus an error
   // will be raised.
-  const std::vector<cmatrix_t>& kraus() const;
+  const std::vector<cmatrix_t> &kraus() const;
 
   //-----------------------------------------------------------------------
   // Initialization
@@ -79,7 +77,7 @@ class QuantumError {
 
   // Compute the superoperator representation of the quantum error
   void compute_superoperator();
-  
+
   // Compute canonical Kraus representation of the quantum error
   void compute_kraus();
 
@@ -88,19 +86,19 @@ class QuantumError {
   //-----------------------------------------------------------------------
 
   // Set number of qubits or memory bits for error
-  inline void set_num_qubits(uint_t num_qubits) {num_qubits_ = num_qubits;}
+  inline void set_num_qubits(uint_t num_qubits) { num_qubits_ = num_qubits; }
 
   // Get number of qubits or memory bits for error
-  inline uint_t get_num_qubits() const {return num_qubits_;}
+  inline uint_t get_num_qubits() const { return num_qubits_; }
 
   // Set the sampled errors to be applied after the original operation
-  inline void set_errors_after() {errors_after_op_ = true;}
+  inline void set_errors_after() { errors_after_op_ = true; }
 
   // Set the sampled errors to be applied before the original operation
-  inline void set_errors_before() {errors_after_op_ = false;}
+  inline void set_errors_before() { errors_after_op_ = false; }
 
   // Returns true if the errors are to be applied after the operation
-  inline bool errors_after() const {return errors_after_op_;}
+  inline bool errors_after() const { return errors_after_op_; }
 
   // Set threshold for checking probabilities and matrices
   void set_threshold(double);
@@ -134,7 +132,6 @@ class QuantumError {
 // Implementation: Mixed unitary error subclass
 //-------------------------------------------------------------------------
 
-
 QuantumError::NoiseOps QuantumError::sample_noise(const reg_t &qubits,
                                                   RngEngine &rng,
                                                   Method method) const {
@@ -145,39 +142,40 @@ QuantumError::NoiseOps QuantumError::sample_noise(const reg_t &qubits,
     throw std::invalid_argument(msg.str());
   }
   switch (method) {
-    case Method::superop: {
-      // Truncate qubits to size of the actual error
-      reg_t op_qubits = qubits;
-      op_qubits.resize(get_num_qubits());
-      auto op = Operations::make_superop(op_qubits, superoperator());
-      return NoiseOps({op});
-    }
-    case Method::kraus: {
-      // Truncate qubits to size of the actual error
-      reg_t op_qubits = qubits;
-      op_qubits.resize(get_num_qubits());
-      auto op = Operations::make_kraus(op_qubits, kraus());
-      return NoiseOps({op});
+  case Method::superop: {
+    // Truncate qubits to size of the actual error
+    reg_t op_qubits = qubits;
+    op_qubits.resize(get_num_qubits());
+    auto op = Operations::make_superop(op_qubits, superoperator());
+    return NoiseOps({op});
+  }
+  case Method::kraus: {
+    // Truncate qubits to size of the actual error
+    reg_t op_qubits = qubits;
+    op_qubits.resize(get_num_qubits());
+    auto op = Operations::make_kraus(op_qubits, kraus());
+    return NoiseOps({op});
+  }
+  default: {
+    auto r = rng.rand_int(probabilities_);
+    // Check for invalid arguments
+    if (r + 1 > circuits_.size()) {
+      throw std::invalid_argument("QuantumError: probability outcome (" +
+                                  std::to_string(r) +
+                                  ")"
+                                  " is greater than number of circuits (" +
+                                  std::to_string(circuits_.size()) + ").");
     }
-    default: {
-      auto r = rng.rand_int(probabilities_);
-      // Check for invalid arguments
-      if (r + 1 > circuits_.size()) {
-        throw std::invalid_argument(
-          "QuantumError: probability outcome (" + std::to_string(r) + ")"
-          " is greater than number of circuits (" + std::to_string(circuits_.size()) + ")."
-        );
+    NoiseOps noise_ops = circuits_[r];
+    // Add qubits to noise op commands;
+    for (auto &op : noise_ops) {
+      // Update qubits based on position in qubits list
+      for (auto &qubit : op.qubits) {
+        qubit = qubits[qubit];
       }
-      NoiseOps noise_ops = circuits_[r];
-      // Add qubits to noise op commands;
-      for (auto &op : noise_ops) {
-        // Update qubits based on position in qubits list
-        for (auto &qubit: op.qubits) {
-          qubit = qubits[qubit];
-        }
-      }
-      return noise_ops;
     }
+    return noise_ops;
+  }
   }
 }
 
@@ -189,10 +187,9 @@ void QuantumError::set_circuits(const std::vector<NoiseOps> &circuits,
                                 const rvector_t &probs) {
   if (probs.size() != circuits.size()) {
     throw std::invalid_argument(
-      "QuantumError: invalid input, number of circuits (" +
-      std::to_string(circuits.size()) + ") and number of probabilities (" +
-      std::to_string(probs.size()) + ") are not equal."
-    );
+        "QuantumError: invalid input, number of circuits (" +
+        std::to_string(circuits.size()) + ") and number of probabilities (" +
+        std::to_string(probs.size()) + ") are not equal.");
   }
   // Check probability vector
   double total = 0.;
@@ -203,17 +200,18 @@ void QuantumError::set_circuits(const std::vector<NoiseOps> &circuits,
     total += p;
   }
   if (!probs_valid || std::abs(total - 1.0) > threshold_) {
-    throw std::invalid_argument("QuantumError: invalid probability vector total (" +
-                                std::to_string(total) + "!= 1)");
+    throw std::invalid_argument(
+        "QuantumError: invalid probability vector total (" +
+        std::to_string(total) + "!= 1)");
   }
   // Reset OpSet
   opset_ = Operations::OpSet();
   // Add elements with non-zero probability
-  for (size_t j=0; j < probs.size(); j++ ) {
+  for (size_t j = 0; j < probs.size(); j++) {
     if (probs[j] > threshold_) {
       probabilities_.push_back(probs[j]);
       circuits_.push_back(circuits[j]);
-      for (const auto &op: circuits[j]) {
+      for (const auto &op : circuits[j]) {
         // Check max qubit size
         for (const auto &qubit : op.qubits) {
           num_qubits = std::max(num_qubits, qubit + 1);
@@ -226,7 +224,6 @@ void QuantumError::set_circuits(const std::vector<NoiseOps> &circuits,
   set_num_qubits(num_qubits);
 }
 
-
 void QuantumError::set_from_kraus(const std::vector<cmatrix_t> &mats) {
   // Check input isn't empty
   if (mats.empty())
@@ -234,14 +231,16 @@ void QuantumError::set_from_kraus(const std::vector<cmatrix_t> &mats) {
 
   // Check input is a CPTP map
   if (Utils::is_cptp_kraus(mats, threshold_) == false)
-    throw std::invalid_argument("QuantumError: Kraus channel input is not a CPTP map.");
+    throw std::invalid_argument(
+        "QuantumError: Kraus channel input is not a CPTP map.");
 
   // Get number of qubits from first Kraus operator
   size_t mat_dim = mats[0].GetRows();
   auto num_qubits = static_cast<unsigned>(std::log2(mat_dim));
   set_num_qubits(num_qubits);
   if (mat_dim != 1ULL << num_qubits)
-    throw std::invalid_argument("QuantumError: Kraus channel input is a multi-qubit channel.");
+    throw std::invalid_argument(
+        "QuantumError: Kraus channel input is a multi-qubit channel.");
 
   // Check if each matrix is a:
   // - scaled identity matrix
@@ -254,17 +253,18 @@ void QuantumError::set_from_kraus(const std::vector<cmatrix_t> &mats) {
 
   // Matrices
   std::vector<cmatrix_t> unitaries; // non-identity unitaries
-  std::vector<cmatrix_t> kraus; // non-unitary Kraus matrices
+  std::vector<cmatrix_t> kraus;     // non-unitary Kraus matrices
 
   for (const auto &mat : mats) {
     if (!Utils::is_square(mat) && !Utils::is_diagonal(mat)) {
       throw std::invalid_argument("Error matrix is not square or diagonal.");
     }
-    // Get the value of the first non-zero diagonal element of mat * dagger(mat) for rescaling
+    // Get the value of the first non-zero diagonal element of mat * dagger(mat)
+    // for rescaling
     double p = 0.;
-    for (size_t i=0; i < mat.GetColumns(); i ++) {
-      for (size_t j=0; j < mat.GetRows(); j ++) {
-        p += std::real(std::abs(mat(j, i) * std::conj(mat(j, i)) ));
+    for (size_t i = 0; i < mat.GetColumns(); i++) {
+      for (size_t j = 0; j < mat.GetRows(); j++) {
+        p += std::real(std::abs(mat(j, i) * std::conj(mat(j, i))));
       }
       if (p > threshold_)
         break;
@@ -273,7 +273,8 @@ void QuantumError::set_from_kraus(const std::vector<cmatrix_t> &mats) {
       // Rescale mat by probability
       cmatrix_t tmp = (1 / std::sqrt(p)) * mat;
       // Check if rescaled matrix is an identity
-      if (Utils::is_identity(tmp, threshold_) || Utils::is_diagonal_identity(tmp, threshold_)) {
+      if (Utils::is_identity(tmp, threshold_) ||
+          Utils::is_diagonal_identity(tmp, threshold_)) {
         // Add to identity probability
         probs[0] += p;
         p_unitary += p;
@@ -292,7 +293,7 @@ void QuantumError::set_from_kraus(const std::vector<cmatrix_t> &mats) {
 
   // Create noise circuits:
   std::vector<NoiseOps> circuits;
-  
+
   // Add identity
   Operations::Op iden;
   iden.name = "id";
@@ -304,7 +305,7 @@ void QuantumError::set_from_kraus(const std::vector<cmatrix_t> &mats) {
   // for indexing remaining errors operators
   reg_t error_qubits(num_qubits);
   std::iota(error_qubits.begin(), error_qubits.end(), 0);
-  for (size_t j=1; j < probs.size(); j++) {
+  for (size_t j = 1; j < probs.size(); j++) {
     auto op = Operations::make_unitary(error_qubits, unitaries[j - 1]);
     circuits.push_back({op});
   }
@@ -314,10 +315,12 @@ void QuantumError::set_from_kraus(const std::vector<cmatrix_t> &mats) {
   double p_kraus = 1.0 - p_unitary;
   if (std::abs(p_kraus) > threshold_) {
     // Rescale Kraus operators by probability
-    Utils::scalar_multiply_inplace(kraus, complex_t(1. / std::sqrt(p_kraus), 0.0));
+    Utils::scalar_multiply_inplace(kraus,
+                                   complex_t(1. / std::sqrt(p_kraus), 0.0));
     // Check rescaled Kraus map is still CPTP
     if (Utils::is_cptp_kraus(kraus, threshold_) == false) {
-      throw std::invalid_argument("QuantumError: Rescaled non-unitary Kraus channel is not a CPTP map.");
+      throw std::invalid_argument("QuantumError: Rescaled non-unitary Kraus "
+                                  "channel is not a CPTP map.");
     }
     // Add Kraus error subcircuit
     auto op = Operations::make_kraus(error_qubits, kraus);
@@ -330,8 +333,7 @@ void QuantumError::set_from_kraus(const std::vector<cmatrix_t> &mats) {
   set_circuits(circuits, probs);
 }
 
-
-const cmatrix_t& QuantumError::superoperator() const {
+const cmatrix_t &QuantumError::superoperator() const {
   // Check the superoperator is actually computed
   // If not raise an exception
   if (superoperator_.empty()) {
@@ -340,8 +342,7 @@ const cmatrix_t& QuantumError::superoperator() const {
   return superoperator_;
 }
 
-
-const std::vector<cmatrix_t>& QuantumError::kraus() const {
+const std::vector<cmatrix_t> &QuantumError::kraus() const {
   // Check the canonical Kraus method is actually computed
   // If not raise an exception
   if (canonical_kraus_.empty()) {
@@ -350,14 +351,13 @@ const std::vector<cmatrix_t>& QuantumError::kraus() const {
   return canonical_kraus_;
 }
 
-
 void QuantumError::compute_superoperator() {
   // Initialize superoperator matrix to correct size
   size_t dim = 1ULL << (2 * get_num_qubits());
   superoperator_.initialize(dim, dim);
   // We use the superoperator simulator state to do this
   QubitSuperoperator::State<> superop;
-  for (size_t j=0; j<circuits_.size(); j++ ){
+  for (size_t j = 0; j < circuits_.size(); j++) {
     // Initialize identity superoperator
     superop.initialize_qreg(get_num_qubits());
     // Apply each gate in the circuit
@@ -387,8 +387,6 @@ void QuantumError::load_from_json(const json_t &js) {
   set_circuits(circuits, probs);
 }
 
-
-
 //-------------------------------------------------------------------------
 } // end namespace Noise
 //-------------------------------------------------------------------------
diff --git a/src/noise/readout_error.hpp b/src/noise/readout_error.hpp
index 6d609bb9f2..42da7029c7 100644
--- a/src/noise/readout_error.hpp
+++ b/src/noise/readout_error.hpp
@@ -22,11 +22,8 @@ namespace Noise {
 // Readout Error class
 //=========================================================================
 
-
-
 class ReadoutError {
 public:
-
   // Alias for return type
   using NoiseOps = std::vector<Operations::Op>;
 
@@ -35,8 +32,7 @@ class ReadoutError {
   //-----------------------------------------------------------------------
 
   // Sample a noisy implementation of op
-  NoiseOps sample_noise(const reg_t &memory,
-                        RngEngine &rng) const;
+  NoiseOps sample_noise(const reg_t &memory, RngEngine &rng) const;
 
   //-----------------------------------------------------------------------
   // Initialization
@@ -56,18 +52,17 @@ class ReadoutError {
   //-----------------------------------------------------------------------
 
   // Set number of qubits or memory bits for error
-  inline void set_num_qubits(uint_t num_qubits) {num_qubits_ = num_qubits;}
+  inline void set_num_qubits(uint_t num_qubits) { num_qubits_ = num_qubits; }
 
   // Get number of qubits or memory bits for error
-  inline uint_t get_num_qubits() const {return num_qubits_;}
+  inline uint_t get_num_qubits() const { return num_qubits_; }
 
 protected:
-
   // Number of qubits/memory bits the error applies to
   uint_t num_qubits_ = 0;
 
   // Vector of assignment probability vectors
-  std::vector<rvector_t> assignment_probabilities_; 
+  std::vector<rvector_t> assignment_probabilities_;
 
   // threshold for checking probabilities
   double threshold_ = 1e-10;
@@ -82,12 +77,12 @@ ReadoutError::NoiseOps ReadoutError::sample_noise(const reg_t &memory,
   (void)rng; // RNG is unused for readout error since it is handled by engine
   // Check assignment fidelity matrix is correct size
   if (memory.size() > get_num_qubits())
-    throw std::invalid_argument("ReadoutError: number of qubits don't match assignment probability matrix.");
+    throw std::invalid_argument("ReadoutError: number of qubits don't match "
+                                "assignment probability matrix.");
   // Initialize return ops,
   return {Operations::make_roerror(memory, assignment_probabilities_)};
 }
 
-
 void ReadoutError::set_probabilities(const std::vector<rvector_t> &probs) {
   assignment_probabilities_ = probs;
   set_num_qubits(assignment_probabilities_.size());
@@ -95,16 +90,18 @@ void ReadoutError::set_probabilities(const std::vector<rvector_t> &probs) {
     double total = 0.0;
     for (const auto &p : ps) {
       if (p < 0 || p > 1) {
-        throw std::invalid_argument("ReadoutError probability is not valid (p=" + std::to_string(p) +").");
+        throw std::invalid_argument(
+            "ReadoutError probability is not valid (p=" + std::to_string(p) +
+            ").");
       }
       total += p;
     }
     if (std::abs(total - 1) > threshold_)
-      throw std::invalid_argument("ReadoutError probability vector is not normalized.");
+      throw std::invalid_argument(
+          "ReadoutError probability vector is not normalized.");
   }
 }
 
-
 void ReadoutError::load_from_json(const json_t &js) {
   std::vector<rvector_t> probs;
   JSON::get_value(probs, "probabilities", js);
diff --git a/src/open_pulse/eval_hamiltonian.hpp b/src/open_pulse/eval_hamiltonian.hpp
index 925d84e3ab..4328316201 100644
--- a/src/open_pulse/eval_hamiltonian.hpp
+++ b/src/open_pulse/eval_hamiltonian.hpp
@@ -15,94 +15,102 @@
 #ifndef _EVAL_HAMILTONIAN_HPP
 #define _EVAL_HAMILTONIAN_HPP
 
-#include <unordered_map>
-#include <vector>
+#include "framework/types.hpp"
+#include "iterators.hpp"
+#include "misc/warnings.hpp"
 #include <complex>
 #include <string>
-#include "misc/warnings.hpp"
+#include <unordered_map>
+#include <vector>
 DISABLE_WARNING_PUSH
 #include <muparserx/mpParser.h>
 DISABLE_WARNING_POP
 
 struct ParserValues {
-    ParserValues(std::unique_ptr<mup::ParserX> parser, const std::string& expr):
-        parser(std::move(parser)), expr(expr) {
-    }
-    std::unique_ptr<mup::ParserX> parser;
-    std::string expr;
-    std::unordered_map<std::string, std::unique_ptr<mup::Value>> var_values;
+  ParserValues(std::unique_ptr<mup::ParserX> parser, const std::string &expr)
+      : parser(std::move(parser)), expr(expr) {}
+  std::unique_ptr<mup::ParserX> parser;
+  std::string expr;
+  std::unordered_map<std::string, std::unique_ptr<mup::Value>> var_values;
 };
 
 namespace std {
-  template <>
-  struct hash<ParserValues>{
-    std::size_t operator()(const ParserValues& p) const {
-      return std::hash<std::string>()(p.expr);
-    }
-  };
-}
+template <> struct hash<ParserValues> {
+  std::size_t operator()(const ParserValues &p) const {
+    return std::hash<std::string>()(p.expr);
+  }
+};
+} // namespace std
 
 // TODO: Document
-complex_t evaluate_hamiltonian_expression(const std::string& expr_string,
-                                  const std::vector<double>& vars,
-                                  const std::vector<std::string>& vars_names,
-                                  const std::unordered_map<std::string, complex_t>& chan_values){
-
-
-    static std::unordered_map<std::string, std::unique_ptr<ParserValues>> parser_expr;
-    auto parser_iter = parser_expr.find(expr_string);
-    if(parser_iter == parser_expr.end()){
-        auto parserx = std::make_unique<mup::ParserX>();
-        //Value pi(M_PI);
-        //parser->DefineVar("npi", Variable(&pi));
-        const auto replace = [](const std::string& from, const std::string& to, std::string where) -> std::string {
-            size_t start_pos = 0;
-            while((start_pos = where.find(from, start_pos)) != std::string::npos) {
-                where.replace(start_pos, from.length(), to);
-                start_pos += to.length();
-            }
-            return where;
-        };
-        parserx->SetExpr(replace("np.pi", "pi", expr_string));
-        auto parser = std::make_unique<ParserValues>(std::move(parserx), expr_string);
-        //std::cout << "Creating parser: " << std::hex << parser.get() << " for expr: " << expr_string << "\n";
-        parser_expr.emplace(expr_string, std::move(parser));
-    }
-    auto * parser = parser_expr[expr_string].get();
-
-    //std::cout << "Getting parser " << std::hex << parser << "\n";
+AER::complex_t evaluate_hamiltonian_expression(
+    const std::string &expr_string, const std::vector<double> &vars,
+    const std::vector<std::string> &vars_names,
+    const std::unordered_map<std::string, AER::complex_t> &chan_values) {
 
-    auto maybe_update_value = [parser](const std::string& var_name, const complex_t& var_value){
-        if(parser->var_values.find(var_name) == parser->var_values.end()){
-            parser->var_values.emplace(var_name, std::make_unique<mup::Value>(var_value));
-            parser->parser->DefineVar(var_name, mup::Variable(parser->var_values[var_name].get()));
-        }else{ // There's already a variable defined for this expresion
-            //std::cout << var_name << " is now: " << std::to_string(var_value.real()) << "," << std::to_string(var_value.imag()) << "\n";
-            auto * ref = parser->var_values[var_name].get();
-            // Update the value from the container
-            *ref = var_value;
-        }
+  static std::unordered_map<std::string, std::unique_ptr<ParserValues>>
+      parser_expr;
+  auto parser_iter = parser_expr.find(expr_string);
+  if (parser_iter == parser_expr.end()) {
+    auto parserx = std::make_unique<mup::ParserX>();
+    // Value pi(M_PI);
+    // parser->DefineVar("npi", Variable(&pi));
+    const auto replace = [](const std::string &from, const std::string &to,
+                            std::string where) -> std::string {
+      size_t start_pos = 0;
+      while ((start_pos = where.find(from, start_pos)) != std::string::npos) {
+        where.replace(start_pos, from.length(), to);
+        start_pos += to.length();
+      }
+      return where;
     };
+    parserx->SetExpr(replace("np.pi", "pi", expr_string));
+    auto parser =
+        std::make_unique<ParserValues>(std::move(parserx), expr_string);
+    // std::cout << "Creating parser: " << std::hex << parser.get() << " for
+    // expr: " << expr_string << "\n";
+    parser_expr.emplace(expr_string, std::move(parser));
+  }
+  auto *parser = parser_expr[expr_string].get();
 
-    for(const auto &idx_var : enumerate(vars)){
-        size_t index = idx_var.first;
-        auto var_value = static_cast<complex_t>(idx_var.second);
-        maybe_update_value(vars_names[index], var_value);
-    }
+  // std::cout << "Getting parser " << std::hex << parser << "\n";
 
-    for(const auto &idx_channel : chan_values){
-        auto channel = idx_channel.first; // The string of the channel
-        auto var_value = idx_channel.second; // The complex_t of the map
-        maybe_update_value(channel, var_value);
+  auto maybe_update_value = [parser](const std::string &var_name,
+                                     const AER::complex_t &var_value) {
+    if (parser->var_values.find(var_name) == parser->var_values.end()) {
+      parser->var_values.emplace(var_name,
+                                 std::make_unique<mup::Value>(var_value));
+      parser->parser->DefineVar(
+          var_name, mup::Variable(parser->var_values[var_name].get()));
+    } else { // There's already a variable defined for this expresion
+      // std::cout << var_name << " is now: " <<
+      // std::to_string(var_value.real()) << "," <<
+      // std::to_string(var_value.imag()) << "\n";
+      auto *ref = parser->var_values[var_name].get();
+      // Update the value from the container
+      *ref = var_value;
     }
+  };
 
-    try{
-        mup::Value result = parser->parser->Eval();
-        return result.GetComplex();
-    }catch(std::exception ex){
-        std::cout << ex.what();
-    }
-    return 0.;
+  for (const auto &idx_var : enumerate(vars)) {
+    size_t index = idx_var.first;
+    auto var_value = static_cast<AER::complex_t>(idx_var.second);
+    maybe_update_value(vars_names[index], var_value);
+  }
+
+  for (const auto &idx_channel : chan_values) {
+    auto channel = idx_channel.first;    // The string of the channel
+    auto var_value = idx_channel.second; // The AER::complex_t of the map
+    maybe_update_value(channel, var_value);
+  }
+
+  try {
+    mup::Value result = parser->parser->Eval();
+    return result.GetComplex();
+  } catch (std::exception ex) {
+    std::cout << ex.what();
+  }
+  return 0.;
 }
 
 #endif //_EVAL_HAMILTONIAN_HPP
diff --git a/src/open_pulse/iterators.hpp b/src/open_pulse/iterators.hpp
index 64e7919412..226ac0f049 100644
--- a/src/open_pulse/iterators.hpp
+++ b/src/open_pulse/iterators.hpp
@@ -15,11 +15,13 @@
 #ifndef _ITERATORS_HPP
 #define _ITERATORS_HPP
 
-template <typename T>
-struct iterator_extractor { using type = typename T::iterator; };
+template <typename T> struct iterator_extractor {
+  using type = typename T::iterator;
+};
 
-template <typename T>
-struct iterator_extractor<T const> { using type = typename T::const_iterator; };
+template <typename T> struct iterator_extractor<T const> {
+  using type = typename T::const_iterator;
+};
 
 /**
  * Python-like `enumerate()` for C++14 ranged-for
@@ -33,59 +35,49 @@ struct iterator_extractor<T const> { using type = typename T::const_iterator; };
  * }
  * ```
  **/
-template <typename T>
-class Indexer {
+template <typename T> class Indexer {
 public:
-    class _Iterator {
-        using inner_iterator =  typename iterator_extractor<T>::type;
-        using inner_reference = typename std::iterator_traits<inner_iterator>::reference;
-    public:
-        using reference = std::pair<size_t, inner_reference>;
-
-        _Iterator(inner_iterator it): _pos(0), _it(it) {}
-
-        reference operator*() const {
-            return reference(_pos, *_it);
-        }
-
-        _Iterator& operator++() {
-            ++_pos;
-            ++_it;
-            return *this;
-        }
-
-        _Iterator operator++(int) {
-            _Iterator tmp(*this);
-            ++*this;
-            return tmp;
-        }
-
-        bool operator==(_Iterator const& it) const {
-            return _it == it._it;
-        }
-        bool operator!=(_Iterator const& it) const {
-            return !(*this == it);
-        }
-
-    private:
-        size_t _pos;
-        inner_iterator _it;
-    };
-
-    Indexer(T& t): _container(t) {}
-
-    _Iterator begin() const {
-        return _Iterator(_container.begin());
+  class _Iterator {
+    using inner_iterator = typename iterator_extractor<T>::type;
+    using inner_reference =
+        typename std::iterator_traits<inner_iterator>::reference;
+
+  public:
+    using reference = std::pair<size_t, inner_reference>;
+
+    _Iterator(inner_iterator it) : _pos(0), _it(it) {}
+
+    reference operator*() const { return reference(_pos, *_it); }
+
+    _Iterator &operator++() {
+      ++_pos;
+      ++_it;
+      return *this;
     }
-    _Iterator end() const {
-        return _Iterator(_container.end());
+
+    _Iterator operator++(int) {
+      _Iterator tmp(*this);
+      ++*this;
+      return tmp;
     }
 
+    bool operator==(_Iterator const &it) const { return _it == it._it; }
+    bool operator!=(_Iterator const &it) const { return !(*this == it); }
+
+  private:
+    size_t _pos;
+    inner_iterator _it;
+  };
+
+  Indexer(T &t) : _container(t) {}
+
+  _Iterator begin() const { return _Iterator(_container.begin()); }
+  _Iterator end() const { return _Iterator(_container.end()); }
+
 private:
-    T& _container;
+  T &_container;
 }; // class Indexer
 
-template <typename T>
-Indexer<T> enumerate(T& t) { return Indexer<T>(t); }
+template <typename T> Indexer<T> enumerate(T &t) { return Indexer<T>(t); }
 
 #endif
\ No newline at end of file
diff --git a/src/open_pulse/log.hpp b/src/open_pulse/log.hpp
index 457536fcf8..ec79d435fe 100644
--- a/src/open_pulse/log.hpp
+++ b/src/open_pulse/log.hpp
@@ -15,86 +15,90 @@
 #ifndef _LOG_HPP
 #define _LOG_HPP
 
-#include <unordered_map>
-#include <vector>
+#include "nparray.hpp"
+#include "python_to_cpp.hpp"
+#include "types.hpp"
 #include <complex>
-#include <spdlog/spdlog.h>
 #include <spdlog/sinks/basic_file_sink.h>
-#include "types.hpp"
-#include "python_to_cpp.hpp"
-#include "nparray.hpp"
+#include <spdlog/spdlog.h>
+#include <unordered_map>
+#include <vector>
 
-template<typename T>
-void jlog(const std::string& msg, const T& value){
-    spdlog::debug("{}: {}", msg, value);
+template <typename T> void jlog(const std::string &msg, const T &value) {
+  spdlog::debug("{}: {}", msg, value);
 }
 
-template<>
-void jlog(const std::string& msg, const complex_t& values){
-    spdlog::debug("{}: [{},{}i]", msg, values.real(), values.imag());
+template <> void jlog(const std::string &msg, const complex_t &values) {
+  spdlog::debug("{}: [{},{}i]", msg, values.real(), values.imag());
 }
 
-template<typename T>
-void jlog(const std::string& msg, const NpArray<T>& values){
-    spdlog::debug("{}", msg);
-    spdlog::debug(".shape: ");
-    for(const auto &shape : values.shape)
-        spdlog::debug("{} ", shape);
+template <typename T>
+void jlog(const std::string &msg, const NpArray<T> &values) {
+  spdlog::debug("{}", msg);
+  spdlog::debug(".shape: ");
+  for (const auto &shape : values.shape)
+    spdlog::debug("{} ", shape);
 
-    spdlog::debug("\n.data: ");
-    for(const auto &val : values.data){
-        jlog("", val);
-    }
+  spdlog::debug("\n.data: ");
+  for (const auto &val : values.data) {
+    jlog("", val);
+  }
 }
 
-template<typename T>
-void jlog(const std::string& msg, const std::vector<T>& values){
-    spdlog::debug("{}", msg);
-    for(const auto &val : values){
-        jlog("", val);
-    }
+template <typename T>
+void jlog(const std::string &msg, const std::vector<T> &values) {
+  spdlog::debug("{}", msg);
+  for (const auto &val : values) {
+    jlog("", val);
+  }
 }
 
-template<>
-void jlog(const std::string& msg, const std::unordered_map<std::string, std::vector<std::vector<double>>>& values){
-    spdlog::debug("{}", msg);
-    for(const auto &val : values){
-        for(const auto &inner: val.second){
-            for(const auto &inner2: inner){
-                spdlog::debug("{}:{} ", val.first, inner2);
-            }
-        }
+template <>
+void jlog(const std::string &msg,
+          const std::unordered_map<std::string,
+                                   std::vector<std::vector<double>>> &values) {
+  spdlog::debug("{}", msg);
+  for (const auto &val : values) {
+    for (const auto &inner : val.second) {
+      for (const auto &inner2 : inner) {
+        spdlog::debug("{}:{} ", val.first, inner2);
+      }
     }
+  }
 }
 
-template<>
-void jlog(const std::string& msg, const std::unordered_map<std::string, double>& values){
-    spdlog::debug("{}", msg);
-    for(const auto &val : values){
-        spdlog::debug("{}:{} ", val.first, val.second);
-    }
+template <>
+void jlog(const std::string &msg,
+          const std::unordered_map<std::string, double> &values) {
+  spdlog::debug("{}", msg);
+  for (const auto &val : values) {
+    spdlog::debug("{}:{} ", val.first, val.second);
+  }
 }
 
-template<>
-void jlog(const std::string& msg, const std::unordered_map<std::string, std::vector<NpArray<double>>>& values){
-    spdlog::debug("{}", msg);
-    for(const auto &val : values){
-        for(const auto &inner: val.second){
-            jlog(val.first, inner);
-        }
+template <>
+void jlog(const std::string &msg,
+          const std::unordered_map<std::string, std::vector<NpArray<double>>>
+              &values) {
+  spdlog::debug("{}", msg);
+  for (const auto &val : values) {
+    for (const auto &inner : val.second) {
+      jlog(val.first, inner);
     }
+  }
 }
 
-template<>
-void jlog(const std::string& msg, const ordered_map<std::string, std::vector<NpArray<double>>>& values){
-    spdlog::debug("{}", msg);
-    using order_map_t = ordered_map<std::string, std::vector<NpArray<double>>>;
-    for(const auto &val : const_cast<order_map_t&>(values)){
-        for(const auto &inner: val.second){
-            jlog(val.first, inner);
-        }
+template <>
+void jlog(
+    const std::string &msg,
+    const ordered_map<std::string, std::vector<NpArray<double>>> &values) {
+  spdlog::debug("{}", msg);
+  using order_map_t = ordered_map<std::string, std::vector<NpArray<double>>>;
+  for (const auto &val : const_cast<order_map_t &>(values)) {
+    for (const auto &inner : val.second) {
+      jlog(val.first, inner);
     }
+  }
 }
 
-
 #endif //_LOG_HPP
\ No newline at end of file
diff --git a/src/open_pulse/numeric_integrator.cpp b/src/open_pulse/numeric_integrator.cpp
index 8e9d88584b..0d3957492e 100644
--- a/src/open_pulse/numeric_integrator.cpp
+++ b/src/open_pulse/numeric_integrator.cpp
@@ -1,8 +1,8 @@
-#include <csignal>
-#include <vector>
 #include <complex>
+#include <csignal>
 #include <iostream>
 #include <memory>
+#include <vector>
 #define _USE_MATH_DEFINES
 #include <math.h>
 
@@ -14,9 +14,9 @@ DISABLE_WARNING_POP
 #ifdef DEBUG
 #include "misc/warnings.hpp"
 DISABLE_WARNING_PUSH
-#include <spdlog/spdlog.h>
-#include <spdlog/sinks/basic_file_sink.h>
 #include <callgrind/callgrind.h>
+#include <spdlog/sinks/basic_file_sink.h>
+#include <spdlog/spdlog.h>
 DISABLE_WARNING_POP
 #endif
 #include "numeric_integrator.hpp"
@@ -24,10 +24,8 @@ DISABLE_WARNING_POP
 
 #ifdef DEBUG
 class Unregister {
-  public:
-    ~Unregister(){
-        spdlog::drop_all();
-    }
+public:
+  ~Unregister() { spdlog::drop_all(); }
 };
 #endif
 
@@ -35,124 +33,127 @@ class Unregister {
  * Python // operator-like division
  */
 int32_t floor_div(int32_t a, int32_t b) {
-    int32_t q = a / b;
-    int32_t r = a - q*b;
-    q -= ((r != 0) & ((r ^ b) < 0));
-    return q;
+  int32_t q = a / b;
+  int32_t r = a - q * b;
+  q -= ((r != 0) & ((r ^ b) < 0));
+  return q;
 }
 
-complex_t chan_value(
-    double t,
-    unsigned int chan_num,
-    const double freq_ch,
-    const NpArray<double>& chan_pulse_times,
-    const NpArray<complex_t>& pulse_array,
-    const NpArray<int>& pulse_indexes,
-    const NpArray<double>& fc_array,
-    const NpArray<uint8_t>& reg){
-
-    static const auto get_arr_idx = [](double t, double start, double stop, size_t len_array) -> int {
-        return static_cast<int>(std::floor((t - start) / (stop - start) * len_array));
-    };
-
-    complex_t out = {0., 0.};
-    auto num_times = floor_div(static_cast<int>(chan_pulse_times.shape[0]), 4);
-
-    for(auto i=0; i < num_times; ++i){
-        auto start_time = chan_pulse_times[4 * i];
-        auto stop_time = chan_pulse_times[4 * i + 1];
-        if(start_time <= t && t < stop_time){
-            auto cond = static_cast<int>(chan_pulse_times[4 * i + 3]);
-            if(cond < 0 || reg[cond]) {
-                auto temp_idx = static_cast<int>(chan_pulse_times[4 * i + 2]);
-                auto start_idx = pulse_indexes[temp_idx];
-                auto stop_idx = pulse_indexes[temp_idx+1];
-                auto offset_idx = get_arr_idx(t, start_time, stop_time, stop_idx - start_idx);
-                out = pulse_array[start_idx + offset_idx];
-            }
-        }
+complex_t chan_value(double t, unsigned int chan_num, const double freq_ch,
+                     const NpArray<double> &chan_pulse_times,
+                     const NpArray<complex_t> &pulse_array,
+                     const NpArray<int> &pulse_indexes,
+                     const NpArray<double> &fc_array,
+                     const NpArray<uint8_t> &reg) {
+
+  static const auto get_arr_idx = [](double t, double start, double stop,
+                                     size_t len_array) -> int {
+    return static_cast<int>(
+        std::floor((t - start) / (stop - start) * len_array));
+  };
+
+  complex_t out = {0., 0.};
+  auto num_times = floor_div(static_cast<int>(chan_pulse_times.shape[0]), 4);
+
+  for (auto i = 0; i < num_times; ++i) {
+    auto start_time = chan_pulse_times[4 * i];
+    auto stop_time = chan_pulse_times[4 * i + 1];
+    if (start_time <= t && t < stop_time) {
+      auto cond = static_cast<int>(chan_pulse_times[4 * i + 3]);
+      if (cond < 0 || reg[cond]) {
+        auto temp_idx = static_cast<int>(chan_pulse_times[4 * i + 2]);
+        auto start_idx = pulse_indexes[temp_idx];
+        auto stop_idx = pulse_indexes[temp_idx + 1];
+        auto offset_idx =
+            get_arr_idx(t, start_time, stop_time, stop_idx - start_idx);
+        out = pulse_array[start_idx + offset_idx];
+      }
     }
+  }
 
-    // TODO floating point comparsion with complex<double> ?!
-    // Seems like this is equivalent to: out != complex_t(0., 0.)
-    if(out != 0.){
-        num_times = floor_div(fc_array.shape[0], 3);
-
-        // get the index of the phase change
-        // this loop will result in finding the index of the phase to use +1
-        auto phase_idx = 0;
-        while(phase_idx < num_times){
-            if(t < fc_array[3 * phase_idx]) break;
-            phase_idx++;
-        }
+  // TODO floating point comparsion with complex<double> ?!
+  // Seems like this is equivalent to: out != complex_t(0., 0.)
+  if (out != 0.) {
+    num_times = floor_div(fc_array.shape[0], 3);
+
+    // get the index of the phase change
+    // this loop will result in finding the index of the phase to use +1
+    auto phase_idx = 0;
+    while (phase_idx < num_times) {
+      if (t < fc_array[3 * phase_idx])
+        break;
+      phase_idx++;
+    }
 
-        double phase = 0.;
-        if(phase_idx > 0){
-            phase = fc_array[3 * (phase_idx - 1) + 1];
-        }
+    double phase = 0.;
+    if (phase_idx > 0) {
+      phase = fc_array[3 * (phase_idx - 1) + 1];
+    }
 
-        if(phase != 0.){
-            out *= std::exp(complex_t(0., 1.) * phase);
-        }
-        out *= std::exp(complex_t(0., 1.) * 2. * M_PI * freq_ch * t);
+    if (phase != 0.) {
+      out *= std::exp(complex_t(0., 1.) * phase);
     }
-    return out.real();
+    out *= std::exp(complex_t(0., 1.) * 2. * M_PI * freq_ch * t);
+  }
+  return out.real();
 }
 
 struct RhsData {
-  RhsData(py::object the_global_data,
-          py::object the_exp,
-          py::object the_system,
-          py::object the_channels,
-          py::object the_reg) {
-
-      PyObject *py_global_data = the_global_data.ptr();
-      PyObject *py_exp = the_exp.ptr();
-      PyObject *py_system = the_system.ptr();
-      PyObject *py_register = the_reg.ptr();
-
-      if (py_global_data == nullptr ||
-          py_exp == nullptr ||
-          py_system == nullptr ||
-          py_register == nullptr) {
-          std::string msg = "These arguments cannot be null: ";
-          msg += (py_global_data == nullptr ? "py_global_data " : "");
-          msg += (py_exp == nullptr ? "py_exp " : "");
-          msg += (py_system == nullptr ? "py_system " : "");
-          msg += (py_register == nullptr ? "py_register " : "");
-          throw std::invalid_argument(msg);
-      }
+  RhsData(py::object the_global_data, py::object the_exp, py::object the_system,
+          py::object the_channels, py::object the_reg) {
+
+    PyObject *py_global_data = the_global_data.ptr();
+    PyObject *py_exp = the_exp.ptr();
+    PyObject *py_system = the_system.ptr();
+    PyObject *py_register = the_reg.ptr();
+
+    if (py_global_data == nullptr || py_exp == nullptr ||
+        py_system == nullptr || py_register == nullptr) {
+      std::string msg = "These arguments cannot be null: ";
+      msg += (py_global_data == nullptr ? "py_global_data " : "");
+      msg += (py_exp == nullptr ? "py_exp " : "");
+      msg += (py_system == nullptr ? "py_system " : "");
+      msg += (py_register == nullptr ? "py_register " : "");
+      throw std::invalid_argument(msg);
+    }
 
-      pulses = get_ordered_map_from_dict_item<std::string, std::vector<NpArray<double>>>(py_exp, "channels");
-      freqs = get_vec_from_dict_item<double>(py_global_data, "freqs");
-      pulse_array = get_value_from_dict_item<NpArray<complex_t>>(py_global_data, "pulse_array");
-      pulse_indices = get_value_from_dict_item<NpArray<int>>(py_global_data, "pulse_indices");
-      reg = get_value<NpArray<uint8_t>>(py_register);
-
-      systems = get_value<std::vector<TermExpression>>(py_system);
-      vars = get_vec_from_dict_item<double>(py_global_data, "vars");
-      vars_names = get_vec_from_dict_item<std::string>(py_global_data, "vars_names");
-      num_h_terms = get_value_from_dict_item<long>(py_global_data, "num_h_terms");
-      auto tmp_datas = get_vec_from_dict_item<NpArray<complex_t>>(py_global_data, "h_ops_data");
-      for (const auto& data: tmp_datas){
-          auto datas_back = datas.emplace(datas.end());
-          auto idxs_back = idxs.emplace(idxs.end());
-          auto ptrs_back = ptrs.emplace(ptrs.end());
-          ptrs_back->push_back(0);
-          auto first_j = 0;
-          auto last_j = 0;
-          for (auto i = 0; i < data.shape[0]; i++) {
-              for (auto j = 0; j < data.shape[1]; j++) {
-                  if (std::abs(data(i, j)) > 1e-15) {
-                      datas_back->push_back(data(i,j));
-                      idxs_back->push_back(j);
-                      last_j++;
-                  }
-              }
-              ptrs_back->push_back(last_j);
+    pulses = get_ordered_map_from_dict_item<std::string,
+                                            std::vector<NpArray<double>>>(
+        py_exp, "channels");
+    freqs = get_vec_from_dict_item<double>(py_global_data, "freqs");
+    pulse_array = get_value_from_dict_item<NpArray<complex_t>>(py_global_data,
+                                                               "pulse_array");
+    pulse_indices =
+        get_value_from_dict_item<NpArray<int>>(py_global_data, "pulse_indices");
+    reg = get_value<NpArray<uint8_t>>(py_register);
+
+    systems = get_value<std::vector<TermExpression>>(py_system);
+    vars = get_vec_from_dict_item<double>(py_global_data, "vars");
+    vars_names =
+        get_vec_from_dict_item<std::string>(py_global_data, "vars_names");
+    num_h_terms = get_value_from_dict_item<long>(py_global_data, "num_h_terms");
+    auto tmp_datas = get_vec_from_dict_item<NpArray<complex_t>>(py_global_data,
+                                                                "h_ops_data");
+    for (const auto &data : tmp_datas) {
+      auto datas_back = datas.emplace(datas.end());
+      auto idxs_back = idxs.emplace(idxs.end());
+      auto ptrs_back = ptrs.emplace(ptrs.end());
+      ptrs_back->push_back(0);
+      auto first_j = 0;
+      auto last_j = 0;
+      for (auto i = 0; i < data.shape[0]; i++) {
+        for (auto j = 0; j < data.shape[1]; j++) {
+          if (std::abs(data(i, j)) > 1e-15) {
+            datas_back->push_back(data(i, j));
+            idxs_back->push_back(j);
+            last_j++;
           }
+        }
+        ptrs_back->push_back(last_j);
       }
-      energy = get_value_from_dict_item<NpArray<double>>(py_global_data, "h_diag_elems");
+    }
+    energy = get_value_from_dict_item<NpArray<double>>(py_global_data,
+                                                       "h_diag_elems");
   }
 
   ordered_map<std::string, std::vector<NpArray<double>>> pulses;
@@ -173,100 +174,102 @@ struct RhsData {
   std::vector<complex_t> osc_terms_no_t;
 };
 
-py::array_t <complex_t> inner_ode_rhs(double t,
-                                      py::array_t <complex_t> the_vec,
-                                      const RhsData &rhs_data) {
-    if (the_vec.ptr() == nullptr) {
-        throw std::invalid_argument("py_vec cannot be null");
-    }
+py::array_t<complex_t> inner_ode_rhs(double t, py::array_t<complex_t> the_vec,
+                                     const RhsData &rhs_data) {
+  if (the_vec.ptr() == nullptr) {
+    throw std::invalid_argument("py_vec cannot be null");
+  }
 
-    auto vec = static_cast<complex_t *>(the_vec.request().ptr);
-    auto num_rows = the_vec.size();
-    py::array_t <complex_t> out_arr(num_rows);
-    auto out = static_cast<complex_t *>(out_arr.request().ptr);
-    memset(&out[0], 0, num_rows * sizeof(complex_t));
-
-    std::unordered_map<std::string, complex_t> chan_values;
-    chan_values.reserve(rhs_data.pulses.size());
-    for (const auto &elem : enumerate(rhs_data.pulses)) {
-        /**
-         * eleme is map of string as key type, and vector of vectors of doubles.
-         * elem["D0"] = [[0.,1.,2.][0.,1.,2.]]
-         **/
-        auto i = elem.first;
-        auto channel = elem.second.first;
-        auto pulse = elem.second.second;
-
-        auto val = chan_value(t, i, rhs_data.freqs[i], pulse[0], rhs_data.pulse_array,
-                              rhs_data.pulse_indices, pulse[1], rhs_data.reg);
-        chan_values.emplace(channel, val);
-    }
+  auto vec = static_cast<complex_t *>(the_vec.request().ptr);
+  auto num_rows = the_vec.size();
+  py::array_t<complex_t> out_arr(num_rows);
+  auto out = static_cast<complex_t *>(out_arr.request().ptr);
+  memset(&out[0], 0, num_rows * sizeof(complex_t));
+
+  std::unordered_map<std::string, complex_t> chan_values;
+  chan_values.reserve(rhs_data.pulses.size());
+  for (const auto &elem : enumerate(rhs_data.pulses)) {
+    /**
+     * eleme is map of string as key type, and vector of vectors of doubles.
+     * elem["D0"] = [[0.,1.,2.][0.,1.,2.]]
+     **/
+    auto i = elem.first;
+    auto channel = elem.second.first;
+    auto pulse = elem.second.second;
+
+    auto val =
+        chan_value(t, i, rhs_data.freqs[i], pulse[0], rhs_data.pulse_array,
+                   rhs_data.pulse_indices, pulse[1], rhs_data.reg);
+    chan_values.emplace(channel, val);
+  }
 
-    // 4. Eval the time-dependent terms and do SPMV.
-    for (int h_idx = 0; h_idx < rhs_data.num_h_terms; h_idx++) {
-        // TODO: Refactor
-        std::string term;
-        if (h_idx == rhs_data.systems.size() && rhs_data.num_h_terms > rhs_data.systems.size()) {
-            term = "1.0";
-        } else if (h_idx < rhs_data.systems.size()) {
-            term = rhs_data.systems[h_idx].term;
-        } else {
-            continue;
-        }
+  // 4. Eval the time-dependent terms and do SPMV.
+  for (int h_idx = 0; h_idx < rhs_data.num_h_terms; h_idx++) {
+    // TODO: Refactor
+    std::string term;
+    if (h_idx == rhs_data.systems.size() &&
+        rhs_data.num_h_terms > rhs_data.systems.size()) {
+      term = "1.0";
+    } else if (h_idx < rhs_data.systems.size()) {
+      term = rhs_data.systems[h_idx].term;
+    } else {
+      continue;
+    }
 
-        auto td = evaluate_hamiltonian_expression(term, rhs_data.vars, rhs_data.vars_names, chan_values);
-        if (std::abs(td) > 1e-15) {
-            for (auto i = 0; i < num_rows; i++) {
-                complex_t dot = {0., 0.};
-                auto row_start = rhs_data.ptrs[h_idx][i];
-                auto row_end = rhs_data.ptrs[h_idx][i + 1];
-                for (auto j = row_start; j < row_end; ++j) {
-                    auto tmp_idx = rhs_data.idxs[h_idx][j];
-                    auto osc_term = std::exp(
-                            complex_t(0., 1.) * (rhs_data.energy[i] - rhs_data.energy[tmp_idx]) * t
-                        );
-                    complex_t coef = (i < tmp_idx ? std::conj(td) : td);
-                    dot += coef * osc_term * rhs_data.datas[h_idx][j] * vec[tmp_idx];
-                }
-                out[i] += dot;
-            }
+    auto td = evaluate_hamiltonian_expression(term, rhs_data.vars,
+                                              rhs_data.vars_names, chan_values);
+    if (std::abs(td) > 1e-15) {
+      for (auto i = 0; i < num_rows; i++) {
+        complex_t dot = {0., 0.};
+        auto row_start = rhs_data.ptrs[h_idx][i];
+        auto row_end = rhs_data.ptrs[h_idx][i + 1];
+        for (auto j = row_start; j < row_end; ++j) {
+          auto tmp_idx = rhs_data.idxs[h_idx][j];
+          auto osc_term =
+              std::exp(complex_t(0., 1.) *
+                       (rhs_data.energy[i] - rhs_data.energy[tmp_idx]) * t);
+          complex_t coef = (i < tmp_idx ? std::conj(td) : td);
+          dot += coef * osc_term * rhs_data.datas[h_idx][j] * vec[tmp_idx];
         }
-    } /* End of systems */
-    for (auto i = 0; i < num_rows; ++i) {
-        out[i] += complex_t(0., 1.) * rhs_data.energy[i] * vec[i];
+        out[i] += dot;
+      }
     }
+  } /* End of systems */
+  for (auto i = 0; i < num_rows; ++i) {
+    out[i] += complex_t(0., 1.) * rhs_data.energy[i] * vec[i];
+  }
 
-    return out_arr;
+  return out_arr;
 }
 
-RhsFunctor::RhsFunctor(py::object the_global_data, py::object the_exp, py::object the_system,
-                       py::object the_channels, py::object the_reg)
-    : rhs_data_(
-    std::make_shared<RhsData>(the_global_data, the_exp, the_system, the_channels, the_reg)) {}
+RhsFunctor::RhsFunctor(py::object the_global_data, py::object the_exp,
+                       py::object the_system, py::object the_channels,
+                       py::object the_reg)
+    : rhs_data_(std::make_shared<RhsData>(the_global_data, the_exp, the_system,
+                                          the_channels, the_reg)) {}
 
-py::array_t <complex_t> RhsFunctor::operator()(double t, py::array_t <complex_t> the_vec) {
-    return inner_ode_rhs(t, the_vec, *rhs_data_);
+py::array_t<complex_t> RhsFunctor::operator()(double t,
+                                              py::array_t<complex_t> the_vec) {
+  return inner_ode_rhs(t, the_vec, *rhs_data_);
 }
 
-py::array_t <complex_t> td_ode_rhs(double t,
-                                   py::array_t <complex_t> the_vec,
-                                   py::object the_global_data,
-                                   py::object the_exp,
-                                   py::object the_system,
-                                   py::object the_channels,
-                                   py::object the_reg) {
+py::array_t<complex_t> td_ode_rhs(double t, py::array_t<complex_t> the_vec,
+                                  py::object the_global_data,
+                                  py::object the_exp, py::object the_system,
+                                  py::object the_channels, py::object the_reg) {
 #ifdef DEBUG
-    CALLGRIND_START_INSTRUMENTATION;
+  CALLGRIND_START_INSTRUMENTATION;
 #endif
 
-    // I left this commented on porpose so we can use logging eventually
-    // This is just a RAII for the logger
-    // const Unregister unregister;
-    // auto file_logger = spdlog::basic_logger_mt("basic_logger", "logs/td_ode_rhs.txt");
-    // spdlog::set_default_logger(file_logger);
-    // spdlog::set_level(spdlog::level::debug); // Set global log level to debug
-    // spdlog::flush_on(spdlog::level::debug);
-
-    auto rhs_data = RhsData(the_global_data, the_exp, the_system, the_channels, the_reg);
-    return inner_ode_rhs(t, the_vec, rhs_data);
+  // I left this commented on porpose so we can use logging eventually
+  // This is just a RAII for the logger
+  // const Unregister unregister;
+  // auto file_logger = spdlog::basic_logger_mt("basic_logger",
+  // "logs/td_ode_rhs.txt"); spdlog::set_default_logger(file_logger);
+  // spdlog::set_level(spdlog::level::debug); // Set global log level to debug
+  // spdlog::flush_on(spdlog::level::debug);
+
+  auto rhs_data =
+      RhsData(the_global_data, the_exp, the_system, the_channels, the_reg);
+  return inner_ode_rhs(t, the_vec, rhs_data);
 }
diff --git a/src/open_pulse/numeric_integrator.hpp b/src/open_pulse/numeric_integrator.hpp
index 5cfb1df4a0..bdbeef2d5a 100644
--- a/src/open_pulse/numeric_integrator.hpp
+++ b/src/open_pulse/numeric_integrator.hpp
@@ -15,14 +15,14 @@
 #ifndef _NUMERIC_INTEGRATOR_HPP
 #define _NUMERIC_INTEGRATOR_HPP
 
+#include "misc/warnings.hpp"
 #include <cmath>
-#include <vector>
 #include <complex>
 #include <map>
-#include "misc/warnings.hpp"
+#include <vector>
 DISABLE_WARNING_PUSH
-#include <pybind11/pybind11.h>
 #include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
 DISABLE_WARNING_POP
 
 #include "types.hpp"
@@ -31,26 +31,21 @@ namespace py = pybind11;
 
 struct RhsData;
 
-py::array_t<complex_t> td_ode_rhs(double t,
-                                  py::array_t<complex_t> vec,
-                                  py::object global_data,
-                                  py::object exp,
-                                  py::object system,
-                                  py::object channels,
+py::array_t<complex_t> td_ode_rhs(double t, py::array_t<complex_t> vec,
+                                  py::object global_data, py::object exp,
+                                  py::object system, py::object channels,
                                   py::object reg);
 
 class RhsFunctor {
 public:
-    RhsFunctor(py::object the_global_data,
-               py::object the_exp,
-               py::object the_system,
-               py::object the_channels,
-               py::object the_reg);
+  RhsFunctor(py::object the_global_data, py::object the_exp,
+             py::object the_system, py::object the_channels,
+             py::object the_reg);
 
-    py::array_t <complex_t> operator()(double t, py::array_t <complex_t> the_vec);
+  py::array_t<complex_t> operator()(double t, py::array_t<complex_t> the_vec);
 
 private:
-    std::shared_ptr<RhsData> rhs_data_;
+  std::shared_ptr<RhsData> rhs_data_;
 };
 
 #endif // _NUMERIC_INTEGRATOR_HPP
\ No newline at end of file
diff --git a/src/open_pulse/ordered_map.hpp b/src/open_pulse/ordered_map.hpp
index 21d39ec872..65ff75d150 100644
--- a/src/open_pulse/ordered_map.hpp
+++ b/src/open_pulse/ordered_map.hpp
@@ -20,22 +20,26 @@
 #include <unordered_map>
 #include <utility>
 
-template <class Key, class T, class Hash = std::hash<Key>, class KeyEqual = std::equal_to<Key>,
+template <class Key, class T, class Hash = std::hash<Key>,
+          class KeyEqual = std::equal_to<Key>,
           class Allocator = std::allocator<std::pair<const Key, T>>>
 class ordered_map {
 public:
   using unordered_map_t = std::unordered_map<Key, T, Hash, KeyEqual, Allocator>;
   using vector_t = std::vector<Key>;
 
-  ordered_map(){}
-  ordered_map(const ordered_map& other) : internal_map(other.internal_map), order(other.order){
-    it.reset(new ordered_map_iterator_t<unordered_map_t, vector_t>(internal_map, order));
+  ordered_map() {}
+  ordered_map(const ordered_map &other)
+      : internal_map(other.internal_map), order(other.order) {
+    it.reset(new ordered_map_iterator_t<unordered_map_t, vector_t>(internal_map,
+                                                                   order));
   }
 
-  ordered_map& operator=(const ordered_map& other){
+  ordered_map &operator=(const ordered_map &other) {
     internal_map = other.internal_map;
     order = other.order;
-    it.reset(new ordered_map_iterator_t<unordered_map_t, vector_t>(internal_map, order));
+    it.reset(new ordered_map_iterator_t<unordered_map_t, vector_t>(internal_map,
+                                                                   order));
     return *this;
   }
 
@@ -44,7 +48,7 @@ class ordered_map {
     return internal_map.reserve(size);
   }
 
-  template <class... Args> decltype(auto) emplace(Args &&... args) {
+  template <class... Args> decltype(auto) emplace(Args &&...args) {
     const auto first = std::get<0>(std::forward_as_tuple(args...));
     order.emplace_back(first);
     return internal_map.emplace(std::forward<Args>(args)...);
@@ -52,9 +56,12 @@ class ordered_map {
 
   size_t size() const { return internal_map.size(); }
 
-  const T &operator[](const std::string &index) const { return internal_map[index]; }
+  const T &operator[](const std::string &index) const {
+    return internal_map[index];
+  }
 
-  // This is needed so we can use the container in an iterator context like ranged fors.
+  // This is needed so we can use the container in an iterator context like
+  // ranged fors.
   template <class _map_t, class _vec_t> class ordered_map_iterator_t {
     using unordered_map_iter_t = typename _map_t::iterator;
     using vec_iter_t = typename _vec_t::iterator;
@@ -93,9 +100,13 @@ class ordered_map {
       return *this;
     }
 
-    bool operator==(const ordered_map_iterator_t &rhs) const { return vec_iter == rhs.vec_iter; }
+    bool operator==(const ordered_map_iterator_t &rhs) const {
+      return vec_iter == rhs.vec_iter;
+    }
 
-    bool operator!=(const ordered_map_iterator_t &rhs) const { return vec_iter != rhs.vec_iter; }
+    bool operator!=(const ordered_map_iterator_t &rhs) const {
+      return vec_iter != rhs.vec_iter;
+    }
 
     const reference operator*() const { return *map_iter; }
   };
@@ -103,7 +114,8 @@ class ordered_map {
   using iterator = ordered_map_iterator_t<unordered_map_t, vector_t>;
   using const_iterator = ordered_map_iterator_t<unordered_map_t, vector_t>;
 
-  std::unique_ptr<iterator> it = std::make_unique<iterator>(internal_map, order);
+  std::unique_ptr<iterator> it =
+      std::make_unique<iterator>(internal_map, order);
 
   const_iterator begin() const { return it->begin(); }
 
diff --git a/src/open_pulse/pulse_utils.cpp b/src/open_pulse/pulse_utils.cpp
index d6d4b7cc7b..44bd54572b 100644
--- a/src/open_pulse/pulse_utils.cpp
+++ b/src/open_pulse/pulse_utils.cpp
@@ -1,172 +1,162 @@
 #include "pulse_utils.hpp"
 #include "zspmv.hpp"
 
-complex_t internal_expect_psi_csr(const py::array_t<complex_t>& data,
-                                  const py::array_t<int>& ind,
-                                  const py::array_t<int>& ptr,
-                                  const py::array_t<complex_t>& vec) {
-    auto data_raw = data.unchecked<1>();
-    auto vec_raw = vec.unchecked<1>();
-    auto ind_raw = ind.unchecked<1>();
-    auto ptr_raw = ptr.unchecked<1>();
-
-    auto nrows = vec.shape(0);
-    complex_t temp, expt = 0;
-
-    for (decltype(nrows) row = 0; row < nrows; row++) {
-        temp = 0;
-        auto vec_conj = std::conj(vec_raw[row]);
-        for (auto j = ptr_raw[row]; j < ptr_raw[row + 1]; j++) {
-            temp += data_raw[j] * vec_raw[ind_raw[j]];
-        }
-        expt += vec_conj * temp;
+complex_t internal_expect_psi_csr(const py::array_t<complex_t> &data,
+                                  const py::array_t<int> &ind,
+                                  const py::array_t<int> &ptr,
+                                  const py::array_t<complex_t> &vec) {
+  auto data_raw = data.unchecked<1>();
+  auto vec_raw = vec.unchecked<1>();
+  auto ind_raw = ind.unchecked<1>();
+  auto ptr_raw = ptr.unchecked<1>();
+
+  auto nrows = vec.shape(0);
+  complex_t temp, expt = 0;
+
+  for (decltype(nrows) row = 0; row < nrows; row++) {
+    temp = 0;
+    auto vec_conj = std::conj(vec_raw[row]);
+    for (auto j = ptr_raw[row]; j < ptr_raw[row + 1]; j++) {
+      temp += data_raw[j] * vec_raw[ind_raw[j]];
     }
-    return expt;
+    expt += vec_conj * temp;
+  }
+  return expt;
 }
 
-complex_t internal_expect_psi(const py::array_t<complex_t>& data,
-                              const py::array_t<complex_t>& vec) {
-    auto data_raw = data.unchecked<2>();
-    auto vec_raw = vec.unchecked<1>();
-    
-    auto nrows = data.shape(0);
-    auto ncols = data.shape(1);
-    complex_t temp, expt = 0;
-    
-    for (decltype(nrows) i = 0; i < nrows; i++) {
-        temp = 0;
-        auto vec_conj = std::conj(vec_raw[i]);
-        for (auto j = 0; j < ncols; j++) {
-            temp += data_raw(i, j) * vec_raw[j];
-        }
-        expt += vec_conj * temp;
-    }
-    return expt;
-}
+complex_t internal_expect_psi(const py::array_t<complex_t> &data,
+                              const py::array_t<complex_t> &vec) {
+  auto data_raw = data.unchecked<2>();
+  auto vec_raw = vec.unchecked<1>();
 
+  auto nrows = data.shape(0);
+  auto ncols = data.shape(1);
+  complex_t temp, expt = 0;
 
-py::object expect_psi_csr(py::array_t<complex_t> data,
-                          py::array_t<int> ind,
-                          py::array_t<int> ptr,
-                          py::array_t<complex_t> vec,
-                          bool isherm){
-    complex_t expt = internal_expect_psi_csr(data, ind, ptr, vec);
-    if(isherm){
-        return py::cast(std::real(expt));
+  for (decltype(nrows) i = 0; i < nrows; i++) {
+    temp = 0;
+    auto vec_conj = std::conj(vec_raw[i]);
+    for (auto j = 0; j < ncols; j++) {
+      temp += data_raw(i, j) * vec_raw[j];
     }
-    return py::cast(expt);
+    expt += vec_conj * temp;
+  }
+  return expt;
 }
 
+py::object expect_psi_csr(py::array_t<complex_t> data, py::array_t<int> ind,
+                          py::array_t<int> ptr, py::array_t<complex_t> vec,
+                          bool isherm) {
+  complex_t expt = internal_expect_psi_csr(data, ind, ptr, vec);
+  if (isherm) {
+    return py::cast(std::real(expt));
+  }
+  return py::cast(expt);
+}
 
-py::object expect_psi(py::array_t<complex_t> data,
-                      py::array_t<complex_t> vec,
-                      bool isherm){
-    complex_t expt = internal_expect_psi(data, vec);
-    if(isherm){
-        return py::cast(std::real(expt));
-    }
-    return py::cast(expt);
+py::object expect_psi(py::array_t<complex_t> data, py::array_t<complex_t> vec,
+                      bool isherm) {
+  complex_t expt = internal_expect_psi(data, vec);
+  if (isherm) {
+    return py::cast(std::real(expt));
+  }
+  return py::cast(expt);
 }
 
 py::array_t<double> occ_probabilities(py::array_t<int> qubits,
                                       py::array_t<complex_t> state,
-                                      py::list meas_ops){
-    auto meas_size = meas_ops.size();
-    py::array_t<double> probs(meas_size);
-    auto probs_raw = probs.mutable_unchecked<1>();
-    for(decltype(meas_size) i=0; i < meas_size; i++){
-        auto data = meas_ops[i].attr("data").attr("data").cast<py::array_t<complex_t>>();
-        probs_raw[i] = std::real(internal_expect_psi(data, state));
-    }
-    
-    return probs;
+                                      py::list meas_ops) {
+  auto meas_size = meas_ops.size();
+  py::array_t<double> probs(meas_size);
+  auto probs_raw = probs.mutable_unchecked<1>();
+  for (decltype(meas_size) i = 0; i < meas_size; i++) {
+    auto data =
+        meas_ops[i].attr("data").attr("data").cast<py::array_t<complex_t>>();
+    probs_raw[i] = std::real(internal_expect_psi(data, state));
+  }
+
+  return probs;
 }
 
 void write_shots_memory(py::array_t<unsigned char> mem,
                         py::array_t<unsigned int> mem_slots,
                         py::array_t<double> probs,
-                        py::array_t<double> rand_vals)
-{
-    auto nrows = mem.shape(0);
-    auto nprobs = probs.shape(0);
-
-    unsigned char temp;
-
-    auto mem_raw = mem.mutable_unchecked<2>();
-    auto mem_slots_raw = mem_slots.unchecked<1>();
-    auto probs_raw = probs.unchecked<1>();
-    auto rand_vals_raw = rand_vals.unchecked<1>();
-
-    for(decltype(nrows) i = 0; i < nrows; i++){
-        for(decltype(nprobs) j = 0; j < nprobs; j++) {
-            temp = static_cast<unsigned char>(probs_raw[j] > rand_vals_raw[nprobs*i+j]);
-            if(temp) {
-                mem_raw(i, mem_slots_raw[j]) = temp;
-            }
-        }
+                        py::array_t<double> rand_vals) {
+  auto nrows = mem.shape(0);
+  auto nprobs = probs.shape(0);
+
+  unsigned char temp;
+
+  auto mem_raw = mem.mutable_unchecked<2>();
+  auto mem_slots_raw = mem_slots.unchecked<1>();
+  auto probs_raw = probs.unchecked<1>();
+  auto rand_vals_raw = rand_vals.unchecked<1>();
+
+  for (decltype(nrows) i = 0; i < nrows; i++) {
+    for (decltype(nprobs) j = 0; j < nprobs; j++) {
+      temp = static_cast<unsigned char>(probs_raw[j] >
+                                        rand_vals_raw[nprobs * i + j]);
+      if (temp) {
+        mem_raw(i, mem_slots_raw[j]) = temp;
+      }
     }
+  }
 }
 
-void oplist_to_array(py::list A, py::array_t<complex_t> B, int start_idx)
-{
-    auto lenA = A.size();
-    if((start_idx+lenA) > B.shape(0)) {
-        throw std::runtime_error(std::string("Input list does not fit into array if start_idx is ") + std::to_string(start_idx) + ".");
-    }
-
-    auto B_raw = B.mutable_unchecked<1>();
-    for(decltype(lenA) kk=0; kk < lenA; kk++){
-        auto item = A[kk].cast<py::list>();
-        B_raw[start_idx+kk] = complex_t(item[0].cast<double>(), item[1].cast<double>());
-    }
+void oplist_to_array(py::list A, py::array_t<complex_t> B, int start_idx) {
+  auto lenA = A.size();
+  if ((start_idx + lenA) > B.shape(0)) {
+    throw std::runtime_error(
+        std::string("Input list does not fit into array if start_idx is ") +
+        std::to_string(start_idx) + ".");
+  }
+
+  auto B_raw = B.mutable_unchecked<1>();
+  for (decltype(lenA) kk = 0; kk < lenA; kk++) {
+    auto item = A[kk].cast<py::list>();
+    B_raw[start_idx + kk] =
+        complex_t(item[0].cast<double>(), item[1].cast<double>());
+  }
 }
 
-
-template <typename T>
-T * get_raw_data(py::array_t<T> array)
-{
-    return static_cast<T *>(array.request().ptr);
+template <typename T> T *get_raw_data(py::array_t<T> array) {
+  return static_cast<T *>(array.request().ptr);
 }
 
 py::array_t<complex_t> spmv_csr(py::array_t<complex_t> data,
-                                py::array_t<int> ind,
-                                py::array_t<int> ptr,
-                                py::array_t<complex_t> vec)
-{
-    auto data_raw = get_raw_data(data);
-    auto ind_raw = get_raw_data(ind);
-    auto ptr_raw = get_raw_data(ptr);
-    auto vec_raw = get_raw_data(vec);
-
-    auto num_rows = vec.shape(0);
-
-    py::array_t<complex_t> out(num_rows);
-    auto out_raw = get_raw_data(out);
-    memset(&out_raw[0], 0, num_rows * sizeof(complex_t));
-    zspmvpy(data_raw, ind_raw, ptr_raw, vec_raw, 1.0, out_raw, num_rows);
-
-    return out;
+                                py::array_t<int> ind, py::array_t<int> ptr,
+                                py::array_t<complex_t> vec) {
+  auto data_raw = get_raw_data(data);
+  auto ind_raw = get_raw_data(ind);
+  auto ptr_raw = get_raw_data(ptr);
+  auto vec_raw = get_raw_data(vec);
+
+  auto num_rows = vec.shape(0);
+
+  py::array_t<complex_t> out(num_rows);
+  auto out_raw = get_raw_data(out);
+  memset(&out_raw[0], 0, num_rows * sizeof(complex_t));
+  zspmvpy(data_raw, ind_raw, ptr_raw, vec_raw, 1.0, out_raw, num_rows);
+
+  return out;
 }
 
 py::array_t<complex_t> spmv(py::array_t<complex_t> data,
-                            py::array_t<complex_t> vec)
-{
-    auto data_raw = get_raw_data(data);
-    auto vec_raw = get_raw_data(vec);
-    
-    auto num_columns = data.shape(0);
-    auto num_rows = data.shape(1);
-    
-    py::array_t<complex_t> out(num_rows);
-    auto out_raw = get_raw_data(out);
-    memset(&out_raw[0], 0, num_rows * sizeof(complex_t));
-    for (auto row=0; row < num_rows; row++)
-    {
-        for (auto jj=0; jj <num_columns; jj++)
-        {
-            out_raw[row] += data_raw[row*num_columns + jj]*vec_raw[jj];
-        }
+                            py::array_t<complex_t> vec) {
+  auto data_raw = get_raw_data(data);
+  auto vec_raw = get_raw_data(vec);
+
+  auto num_columns = data.shape(0);
+  auto num_rows = data.shape(1);
+
+  py::array_t<complex_t> out(num_rows);
+  auto out_raw = get_raw_data(out);
+  memset(&out_raw[0], 0, num_rows * sizeof(complex_t));
+  for (auto row = 0; row < num_rows; row++) {
+    for (auto jj = 0; jj < num_columns; jj++) {
+      out_raw[row] += data_raw[row * num_columns + jj] * vec_raw[jj];
     }
-    
-    return out;
+  }
+
+  return out;
 }
\ No newline at end of file
diff --git a/src/open_pulse/pulse_utils.hpp b/src/open_pulse/pulse_utils.hpp
index 7a26ca11d0..adee3439c8 100644
--- a/src/open_pulse/pulse_utils.hpp
+++ b/src/open_pulse/pulse_utils.hpp
@@ -15,20 +15,17 @@
 #ifndef PULSE_UTILS_H
 #define PULSE_UTILS_H
 
-#include <pybind11/pybind11.h>
-#include <pybind11/numpy.h>
 #include "types.hpp"
+#include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
 
 namespace py = pybind11;
 
-py::object expect_psi_csr(py::array_t<complex_t> data,
-                          py::array_t<int> ind,
-                          py::array_t<int> ptr,
-                          py::array_t<complex_t> vec,
+py::object expect_psi_csr(py::array_t<complex_t> data, py::array_t<int> ind,
+                          py::array_t<int> ptr, py::array_t<complex_t> vec,
                           bool isherm);
 
-py::object expect_psi(py::array_t<complex_t> data,
-                      py::array_t<complex_t> vec,
+py::object expect_psi(py::array_t<complex_t> data, py::array_t<complex_t> vec,
                       bool isherm);
 
 //============================================================================
@@ -54,7 +51,6 @@ void write_shots_memory(py::array_t<unsigned char> mem,
                         py::array_t<double> probs,
                         py::array_t<double> rand_vals);
 
-
 //============================================================================
 // Takes a list of complex numbers represented by a list
 // of pairs of floats, and inserts them into a complex NumPy
@@ -67,7 +63,6 @@ void write_shots_memory(py::array_t<unsigned char> mem,
 //============================================================================
 void oplist_to_array(py::list A, py::array_t<complex_t> B, int start_idx);
 
-
 //============================================================================
 // Sparse matrix, dense vector multiplication.
 // Here the vector is assumed to have one-dimension.
@@ -90,11 +85,10 @@ void oplist_to_array(py::list A, py::array_t<complex_t> B, int start_idx);
 //         Returns dense array.
 //============================================================================
 py::array_t<complex_t> spmv_csr(py::array_t<complex_t> data,
-                                py::array_t<int> ind,
-                                py::array_t<int> ptr,
+                                py::array_t<int> ind, py::array_t<int> ptr,
                                 py::array_t<complex_t> vec);
 
 py::array_t<complex_t> spmv(py::array_t<complex_t> data,
                             py::array_t<complex_t> vec);
 
-#endif //PULSE_UTILS_H
+#endif // PULSE_UTILS_H
diff --git a/src/open_pulse/pulse_utils_bindings.cpp b/src/open_pulse/pulse_utils_bindings.cpp
index b417cd8727..19a8b1b16a 100644
--- a/src/open_pulse/pulse_utils_bindings.cpp
+++ b/src/open_pulse/pulse_utils_bindings.cpp
@@ -21,34 +21,45 @@ DISABLE_WARNING_PUSH
 DISABLE_WARNING_POP
 
 RhsFunctor get_ode_rhs_functor(py::object the_global_data, py::object the_exp,
-                               py::object the_system, py::object the_channels, py::object the_reg) {
-  return RhsFunctor(the_global_data, the_exp, the_system, the_channels, the_reg);
+                               py::object the_system, py::object the_channels,
+                               py::object the_reg) {
+  return RhsFunctor(the_global_data, the_exp, the_system, the_channels,
+                    the_reg);
 }
 
-
 class OccProbabilitiesFunctor {
 public:
-    OccProbabilitiesFunctor() = default;
-    py::array_t<double> operator()(py::array_t<int> qubits,
-                                   py::array_t<complex_t> state,
-                                   py::list meas_ops) { return occ_probabilities(qubits, state, meas_ops); }
+  OccProbabilitiesFunctor() = default;
+  py::array_t<double> operator()(py::array_t<int> qubits,
+                                 py::array_t<complex_t> state,
+                                 py::list meas_ops) {
+    return occ_probabilities(qubits, state, meas_ops);
+  }
 };
 
 PYBIND11_MODULE(pulse_utils, m) {
-    m.doc() = "Utility functions for pulse simulator"; // optional module docstring
-
-    m.def("td_ode_rhs_static", &td_ode_rhs, "Compute rhs for ODE");
-    m.def("cy_expect_psi_csr", &expect_psi_csr, "Expected value for a operator");
-    m.def("cy_expect_psi", &expect_psi, "Expected value for a operator");
-    m.def("occ_probabilities", &occ_probabilities, "Computes the occupation probabilities of the specifed qubits for the given state");
-    m.def("write_shots_memory", &write_shots_memory, "Converts probabilities back into shots");
-    m.def("oplist_to_array", &oplist_to_array, "Insert list of complex numbers into numpy complex array");
-    m.def("spmv_csr", &spmv_csr, "Sparse matrix, dense vector multiplication.");
-    m.def("spmv", &spmv, "Matrix vector multiplication.");
-
-    py::class_<RhsFunctor> ode_rhs_func(m, "OdeRhsFunctor");
-    ode_rhs_func.def("__call__", &RhsFunctor::operator());
-    ode_rhs_func.def("__reduce__", [ode_rhs_func](const RhsFunctor& self) { return py::make_tuple(ode_rhs_func, py::tuple());});
-
-    m.def("get_ode_rhs_functor", &get_ode_rhs_functor, "Get ode_rhs functor to allow caching of parameters");
+  m.doc() =
+      "Utility functions for pulse simulator"; // optional module docstring
+
+  m.def("td_ode_rhs_static", &td_ode_rhs, "Compute rhs for ODE");
+  m.def("cy_expect_psi_csr", &expect_psi_csr, "Expected value for a operator");
+  m.def("cy_expect_psi", &expect_psi, "Expected value for a operator");
+  m.def("occ_probabilities", &occ_probabilities,
+        "Computes the occupation probabilities of the specifed qubits for the "
+        "given state");
+  m.def("write_shots_memory", &write_shots_memory,
+        "Converts probabilities back into shots");
+  m.def("oplist_to_array", &oplist_to_array,
+        "Insert list of complex numbers into numpy complex array");
+  m.def("spmv_csr", &spmv_csr, "Sparse matrix, dense vector multiplication.");
+  m.def("spmv", &spmv, "Matrix vector multiplication.");
+
+  py::class_<RhsFunctor> ode_rhs_func(m, "OdeRhsFunctor");
+  ode_rhs_func.def("__call__", &RhsFunctor::operator());
+  ode_rhs_func.def("__reduce__", [ode_rhs_func](const RhsFunctor &self) {
+    return py::make_tuple(ode_rhs_func, py::tuple());
+  });
+
+  m.def("get_ode_rhs_functor", &get_ode_rhs_functor,
+        "Get ode_rhs functor to allow caching of parameters");
 }
diff --git a/src/open_pulse/python_to_cpp.hpp b/src/open_pulse/python_to_cpp.hpp
index d14f931343..c4a5a60865 100644
--- a/src/open_pulse/python_to_cpp.hpp
+++ b/src/open_pulse/python_to_cpp.hpp
@@ -15,390 +15,377 @@
 #ifndef _PYTHON_TO_CPP_HPP
 #define _PYTHON_TO_CPP_HPP
 
-#include <utility>
-#include <unordered_map>
-#include <map>
-#include <vector>
+#include <Python.h>
 #include <complex>
+#include <map>
 #include <type_traits>
-#include <Python.h>
+#include <unordered_map>
+#include <utility>
+#include <vector>
 #ifdef DEBUG
-#include <spdlog/spdlog.h>
 #include <spdlog/sinks/basic_file_sink.h>
+#include <spdlog/spdlog.h>
 #endif
 #include "misc/warnings.hpp"
 DISABLE_WARNING_PUSH
-#include <pybind11/pybind11.h>
 #include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
 DISABLE_WARNING_POP
+#include "eval_hamiltonian.hpp"
+#include "iterators.hpp"
 #include "ordered_map.hpp"
 #include "types.hpp"
-#include "iterators.hpp"
-#include "eval_hamiltonian.hpp"
 
-bool check_is_integer(PyObject * value){
-    if(value == nullptr)
-        throw std::invalid_argument("PyObject is null!");
+bool check_is_integer(PyObject *value) {
+  if (value == nullptr)
+    throw std::invalid_argument("PyObject is null!");
 
-    // Seems like this function checks every integer type
-    if(!PyLong_Check(value))
-        return false;
+  // Seems like this function checks every integer type
+  if (!PyLong_Check(value))
+    return false;
 
-    return true;
+  return true;
 }
 
-bool check_is_string(PyObject * value){
-    if(value == nullptr)
-        throw std::invalid_argument("PyObject is null!");
+bool check_is_string(PyObject *value) {
+  if (value == nullptr)
+    throw std::invalid_argument("PyObject is null!");
 
-    if(!PyUnicode_Check(value))
-        return false;
+  if (!PyUnicode_Check(value))
+    return false;
 
-    return true;
+  return true;
 }
 
-bool check_is_floating_point(PyObject * value){
-    if(value == nullptr)
-        throw std::invalid_argument("PyObject is null!");
+bool check_is_floating_point(PyObject *value) {
+  if (value == nullptr)
+    throw std::invalid_argument("PyObject is null!");
 
-    if(!PyFloat_Check(value))
-        return false;
+  if (!PyFloat_Check(value))
+    return false;
 
-    return true;
+  return true;
 }
 
-bool check_is_complex(PyObject * value){
-    if(value == nullptr)
-        throw std::invalid_argument("PyObject is null!");
+bool check_is_complex(PyObject *value) {
+  if (value == nullptr)
+    throw std::invalid_argument("PyObject is null!");
 
-    if(!PyComplex_Check(value))
-        return false;
+  if (!PyComplex_Check(value))
+    return false;
 
-    return true;
+  return true;
 }
 
-bool check_is_list(PyObject * value){
-    if(value == nullptr)
-        throw std::invalid_argument("Pyhton list is null!");
+bool check_is_list(PyObject *value) {
+  if (value == nullptr)
+    throw std::invalid_argument("Pyhton list is null!");
 
-    // Check that it's a list
-    if(!PyList_Check(value))
-        return false;
+  // Check that it's a list
+  if (!PyList_Check(value))
+    return false;
 
-    return true;
+  return true;
 }
 
-bool check_is_tuple(PyObject * value){
-    if(value == nullptr)
-        throw std::invalid_argument("Pyhton tuple is null!");
+bool check_is_tuple(PyObject *value) {
+  if (value == nullptr)
+    throw std::invalid_argument("Pyhton tuple is null!");
 
-    // Check that it's a tuple
-    if(!PyTuple_Check(value))
-        return false;
+  // Check that it's a tuple
+  if (!PyTuple_Check(value))
+    return false;
 
-    return true;
+  return true;
 }
 
-bool check_is_dict(PyObject * value){
-    if(value == nullptr)
-        throw std::invalid_argument("Pyhton dict is null!");
+bool check_is_dict(PyObject *value) {
+  if (value == nullptr)
+    throw std::invalid_argument("Pyhton dict is null!");
 
-    // Check that it's a dict
-    if(!PyDict_Check(value))
-        return false;
+  // Check that it's a dict
+  if (!PyDict_Check(value))
+    return false;
 
-    return true;
+  return true;
 }
 
-bool check_is_np_array(py::array value){
-    if(value.ptr() == nullptr)
-        throw std::invalid_argument("Numpy ndarray is null!");
-    // Check that it's a numpy ndarray
-    if(value.ndim() == 0)
-        return false;
+bool check_is_np_array(py::array value) {
+  if (value.ptr() == nullptr)
+    throw std::invalid_argument("Numpy ndarray is null!");
+  // Check that it's a numpy ndarray
+  if (value.ndim() == 0)
+    return false;
 
-    return true;
+  return true;
 }
 
-
 // Simon Brand technique to achive partial specialization on function templates
 // https://www.fluentcpp.com/2017/08/15/function-templates-partial-specialization-cpp/
 // This "type" struct will carry T, but wil be ignored by the compiler later.
-// It's like a help you give to the compiler so it can resolve the specialization
-template<typename T>
-struct type{};
+// It's like a help you give to the compiler so it can resolve the
+// specialization
+template <typename T> struct type {};
 
-template<typename T>
-T get_value(type<T> _, PyObject * value){
-    throw std::invalid_argument("Cannot get value for this type!");
+template <typename T> T get_value(type<T> _, PyObject *value) {
+  throw std::invalid_argument("Cannot get value for this type!");
 }
 
 // <JUAN> TODO: We might want to expose only these two functions
-template<typename T>
-T get_value(PyObject * value){
-    return get_value(type<T>{}, value);
+template <typename T> T get_value(PyObject *value) {
+  return get_value(type<T>{}, value);
 }
 
-template<typename T>
-const T get_value(py::array value){
-    return get_value(type<T>{}, value);
+template <typename T> const T get_value(py::array value) {
+  return get_value(type<T>{}, value);
 }
 // </JUAN>
 
-
-template<>
-uint8_t get_value(type<uint8_t> _, PyObject * value){
-    return get_value<long>(value);
+template <> uint8_t get_value(type<uint8_t> _, PyObject *value) {
+  return get_value<long>(value);
 }
 
-template<>
-long get_value(type<long> _, PyObject * value){
-    if(!check_is_integer(value))
-        throw std::invalid_argument("PyObject is not a long!");
+template <> long get_value(type<long> _, PyObject *value) {
+  if (!check_is_integer(value))
+    throw std::invalid_argument("PyObject is not a long!");
 
-    long c_value = PyLong_AsLong(value);
-    auto ex = PyErr_Occurred();
-    if(ex)
-        throw ex;
+  long c_value = PyLong_AsLong(value);
+  auto ex = PyErr_Occurred();
+  if (ex)
+    throw ex;
 
-    return c_value;
+  return c_value;
 }
 
-template<>
-double get_value(type<double> _, PyObject * value){
-    if(!check_is_floating_point(value)){
-        // it's not a floating point, but maybe an integer?
-        if(check_is_integer(value))
-            return static_cast<double>(get_value<long>(value));
+template <> double get_value(type<double> _, PyObject *value) {
+  if (!check_is_floating_point(value)) {
+    // it's not a floating point, but maybe an integer?
+    if (check_is_integer(value))
+      return static_cast<double>(get_value<long>(value));
 
-        throw std::invalid_argument("PyObject is not a double!");
-    }
+    throw std::invalid_argument("PyObject is not a double!");
+  }
 
-    double c_value = PyFloat_AsDouble(value);
-    auto ex = PyErr_Occurred();
-    if(ex)
-        throw ex;
+  double c_value = PyFloat_AsDouble(value);
+  auto ex = PyErr_Occurred();
+  if (ex)
+    throw ex;
 
-    return c_value;
+  return c_value;
 }
 
-template<>
-std::complex<double> get_value(type<std::complex<double>> _, PyObject * value){
-    if(!check_is_complex(value))
-        throw std::invalid_argument("PyObject is not a complex number!");
+template <>
+std::complex<double> get_value(type<std::complex<double>> _, PyObject *value) {
+  if (!check_is_complex(value))
+    throw std::invalid_argument("PyObject is not a complex number!");
 
-    Py_complex c_value = PyComplex_AsCComplex(value);
-    auto ex = PyErr_Occurred();
-    if(ex)
-        throw ex;
+  Py_complex c_value = PyComplex_AsCComplex(value);
+  auto ex = PyErr_Occurred();
+  if (ex)
+    throw ex;
 
-    return std::complex<double>(c_value.real, c_value.imag);
+  return std::complex<double>(c_value.real, c_value.imag);
 }
 
-template<>
-std::string get_value(type<std::string> _, PyObject * value){
-    if(!check_is_string(value))
-        throw std::invalid_argument("PyObject is not a string!");
+template <> std::string get_value(type<std::string> _, PyObject *value) {
+  if (!check_is_string(value))
+    throw std::invalid_argument("PyObject is not a string!");
 
-    auto bytes_str = PyUnicode_AsUTF8String(value);
-    auto c_str = PyBytes_AsString(bytes_str);
+  auto bytes_str = PyUnicode_AsUTF8String(value);
+  auto c_str = PyBytes_AsString(bytes_str);
 
-    if(c_str == nullptr)
-        throw std::invalid_argument("Conversion to utf-8 has failed!");
+  if (c_str == nullptr)
+    throw std::invalid_argument("Conversion to utf-8 has failed!");
 
-    return std::string(c_str);
+  return std::string(c_str);
 }
 
-template<typename T>
-std::vector<T> get_value(type<std::vector<T>> _, PyObject * value){
-    if(!check_is_list(value))
-        throw std::invalid_argument("PyObject is not a List!");
-
-    auto size = PyList_Size(value);
-    std::vector<T> vector;
-    vector.reserve(size);
-    for(auto i=0; i<size; ++i){
-        auto py_item = PyList_GetItem(value, i);
-        if(py_item == nullptr)
-            continue;
-        auto item = get_value<T>(py_item);
-        vector.emplace_back(item);
-    }
-    return vector;
+template <typename T>
+std::vector<T> get_value(type<std::vector<T>> _, PyObject *value) {
+  if (!check_is_list(value))
+    throw std::invalid_argument("PyObject is not a List!");
+
+  auto size = PyList_Size(value);
+  std::vector<T> vector;
+  vector.reserve(size);
+  for (auto i = 0; i < size; ++i) {
+    auto py_item = PyList_GetItem(value, i);
+    if (py_item == nullptr)
+      continue;
+    auto item = get_value<T>(py_item);
+    vector.emplace_back(item);
+  }
+  return vector;
 }
 
-template<typename T, typename U>
-std::pair<T, U> get_value(type<std::pair<T, U>> _, PyObject * value){
-    if(!check_is_tuple(value))
-        throw std::invalid_argument("PyObject is not a Tuple!");
+template <typename T, typename U>
+std::pair<T, U> get_value(type<std::pair<T, U>> _, PyObject *value) {
+  if (!check_is_tuple(value))
+    throw std::invalid_argument("PyObject is not a Tuple!");
 
-    if(PyTuple_Size(value) > 2)
-        throw std::invalid_argument("Tuples with more than 2 elements are not supported yet!!");
+  if (PyTuple_Size(value) > 2)
+    throw std::invalid_argument(
+        "Tuples with more than 2 elements are not supported yet!!");
 
-    auto first_py_item = PyTuple_GetItem(value, 0);
-    if(first_py_item == nullptr)
-        throw std::invalid_argument("The tuple must have a first element");
+  auto first_py_item = PyTuple_GetItem(value, 0);
+  if (first_py_item == nullptr)
+    throw std::invalid_argument("The tuple must have a first element");
 
-    auto second_py_item = PyTuple_GetItem(value, 1);
-    if(second_py_item == nullptr)
-        throw std::invalid_argument("The tuple must have a second element");
+  auto second_py_item = PyTuple_GetItem(value, 1);
+  if (second_py_item == nullptr)
+    throw std::invalid_argument("The tuple must have a second element");
 
-    auto first_item = get_value<T>(first_py_item);
-    auto second_item = get_value<U>(second_py_item);
+  auto first_item = get_value<T>(first_py_item);
+  auto second_item = get_value<U>(second_py_item);
 
-    return std::make_pair(first_item, second_item);
+  return std::make_pair(first_item, second_item);
 }
 
-template<typename ValueType>
-std::unordered_map<std::string, ValueType> get_value(type<std::unordered_map<std::string, ValueType>> _, PyObject * value){
-    if(!check_is_dict(value))
-        throw std::invalid_argument("PyObject is not a dictonary!!");
-
-    auto size = PyDict_Size(value);
-    std::unordered_map<std::string, ValueType> map;
-    map.reserve(size);
-
-    PyObject *key, *val;
-    Py_ssize_t pos = 0;
-    while (PyDict_Next(value, &pos, &key, &val)) {
-        auto inner_key = get_value<std::string>(key);
-        auto inner_value = get_value<ValueType>(val);
-        map.emplace(inner_key, inner_value);
-    }
-    return map;
+template <typename ValueType>
+std::unordered_map<std::string, ValueType>
+get_value(type<std::unordered_map<std::string, ValueType>> _, PyObject *value) {
+  if (!check_is_dict(value))
+    throw std::invalid_argument("PyObject is not a dictonary!!");
+
+  auto size = PyDict_Size(value);
+  std::unordered_map<std::string, ValueType> map;
+  map.reserve(size);
+
+  PyObject *key, *val;
+  Py_ssize_t pos = 0;
+  while (PyDict_Next(value, &pos, &key, &val)) {
+    auto inner_key = get_value<std::string>(key);
+    auto inner_value = get_value<ValueType>(val);
+    map.emplace(inner_key, inner_value);
+  }
+  return map;
 }
 
-template<typename ValueType>
-const ordered_map<std::string, ValueType> get_value(type<ordered_map<std::string, ValueType>> _, PyObject * value){
-    if(!check_is_dict(value))
-        throw std::invalid_argument("PyObject is not a dictonary!!");
-
-    auto size = PyDict_Size(value);
-    ordered_map<std::string, ValueType> map;
-    map.reserve(size);
-
-    PyObject *key, *val;
-    Py_ssize_t pos = 0;
-    while (PyDict_Next(value, &pos, &key, &val)) {
-        auto inner_key = get_value<std::string>(key);
-        auto inner_value = get_value<ValueType>(val);
-        map.emplace(inner_key, inner_value);
-    }
-    return map;
+template <typename ValueType>
+const ordered_map<std::string, ValueType>
+get_value(type<ordered_map<std::string, ValueType>> _, PyObject *value) {
+  if (!check_is_dict(value))
+    throw std::invalid_argument("PyObject is not a dictonary!!");
+
+  auto size = PyDict_Size(value);
+  ordered_map<std::string, ValueType> map;
+  map.reserve(size);
+
+  PyObject *key, *val;
+  Py_ssize_t pos = 0;
+  while (PyDict_Next(value, &pos, &key, &val)) {
+    auto inner_key = get_value<std::string>(key);
+    auto inner_value = get_value<ValueType>(val);
+    map.emplace(inner_key, inner_value);
+  }
+  return map;
 }
 
+template <> TermExpression get_value(type<TermExpression> _, PyObject *value) {
+  if (!check_is_tuple(value))
+    throw std::invalid_argument("PyObject is not a Tuple!");
 
-template<>
-TermExpression get_value(type<TermExpression>_, PyObject * value) {
-    if(!check_is_tuple(value))
-        throw std::invalid_argument("PyObject is not a Tuple!");
-
-    if(PyTuple_Size(value) > 2)
-        throw std::invalid_argument("Tuples with more than 2 elements are not supported yet!!");
+  if (PyTuple_Size(value) > 2)
+    throw std::invalid_argument(
+        "Tuples with more than 2 elements are not supported yet!!");
 
-    auto term = PyTuple_GetItem(value, 1); // 0 is first
-    if(term == nullptr)
-        throw std::invalid_argument("The tuple must have a second element");
+  auto term = PyTuple_GetItem(value, 1); // 0 is first
+  if (term == nullptr)
+    throw std::invalid_argument("The tuple must have a second element");
 
-    auto term_expr = get_value<std::string>(term);
-    return TermExpression(term_expr);
+  auto term_expr = get_value<std::string>(term);
+  return TermExpression(term_expr);
 }
 
+template <typename VecType> class NpArray {
+public:
+  NpArray() {}
+  NpArray(py::array array) {
+    if (array.ndim() > 2) {
+      throw std::runtime_error("NpArray can only wrap 1D or 2D arrays.");
+    }
+    _populate_data(array);
+    _populate_shape(array);
+    size = array.ndim() == 2 ? array.shape(0) * array.shape(1) : array.shape(0);
+  }
+
+  const VecType *data = nullptr;
+  size_t size = 0;
+
+  /**
+   * The shape of the array: like
+   * ```pyhton
+   * arr = np.array([0,1,2],[3,4,5])
+   * arr.shape
+   **/
+  std::vector<int> shape;
+
+  const VecType &operator[](size_t index) const { return data[index]; }
+
+  const VecType &operator()(size_t i, size_t j) const {
+    return data[i * shape[1] + j];
+  }
+
+  bool operator==(const NpArray<VecType> &other) const {
+    if (other.size != size || other.shape.size() != shape.size())
+      return false;
+
+    for (auto i = 0; i < other.size; ++i) {
+      if (data[i] != other[i])
+        return false;
+    }
 
-template<typename VecType>
-class NpArray {
-  public:
-	NpArray(){}
-	NpArray(py::array array){
-	    if(array.ndim() > 2){
-	        throw std::runtime_error("NpArray can only wrap 1D or 2D arrays.");
-	    }
-		_populate_data(array);
-		_populate_shape(array);
-        size = array.ndim() == 2 ? array.shape(0) * array.shape(1) : array.shape(0);
-	}
-
-    const VecType * data = nullptr;
-    size_t size = 0;
-
-    /**
-     * The shape of the array: like
-     * ```pyhton
-     * arr = np.array([0,1,2],[3,4,5])
-     * arr.shape
-     **/
-    std::vector<int> shape;
-
-    const VecType& operator[](size_t index) const {
-        return data[index];
+    for (auto i = 0; i < other.shape.size(); ++i) {
+      if (shape[i] != other.shape[i])
+        return false;
     }
-    
-    const VecType& operator()(size_t i, size_t j) const {
-        return data[i*shape[1] + j];
+
+    return true;
+  }
+
+private:
+  void _populate_shape(py::array array) {
+    if (!check_is_np_array(array))
+      throw std::invalid_argument("py::array is not a numpy array!");
+
+    auto num_dims = array.ndim();
+    shape.reserve(num_dims);
+    for (auto i = 0; i < num_dims; ++i) {
+      shape.emplace_back(array.shape(i));
     }
-    
-    bool operator==(const NpArray<VecType>& other) const {
-        if(other.size != size ||
-           other.shape.size() != shape.size())
-           return false;
-
-        for(auto i = 0; i < other.size; ++i){
-            if(data[i] != other[i])
-                return false;
-        }
-
-        for(auto i = 0; i < other.shape.size(); ++i){
-            if(shape[i] != other.shape[i])
-                return false;
-        }
-
-        return true;
+    if (shape.size() == 1) {
+      shape.emplace_back(0);
     }
-  private:
-
-	void _populate_shape(py::array array){
-        if(!check_is_np_array(array))
-            throw std::invalid_argument("py::array is not a numpy array!");
-        
-		auto num_dims = array.ndim();
-		shape.reserve(num_dims);
-		for(auto i = 0; i < num_dims; ++i){
-			shape.emplace_back(array.shape(i));
-		}
-		if(shape.size() == 1){
-		    shape.emplace_back(0);
-		}
-	}
-
-    void _populate_data(py::array array){
-        data = reinterpret_cast<VecType *>(array.request().ptr);
-	}
+  }
+
+  void _populate_data(py::array array) {
+    data = reinterpret_cast<VecType *>(array.request().ptr);
+  }
 };
 
-template<typename T>
-const NpArray<T> get_value(type<NpArray<T>> _, py::array value){
-    if(!check_is_np_array(value))
-        throw std::invalid_argument("py::array is not a numpy array!");
-    
-    return NpArray<T>(value);
-}
+template <typename T>
+const NpArray<T> get_value(type<NpArray<T>> _, py::array value) {
+  if (!check_is_np_array(value))
+    throw std::invalid_argument("py::array is not a numpy array!");
 
-template<typename T>
-const NpArray<T> get_value(type<NpArray<T>> _, PyObject * value) {
-    py::array array = py::cast<py::array>(value);
-    return get_value<NpArray<T>>(array);
+  return NpArray<T>(value);
 }
 
-
-PyObject * _get_py_value_from_py_dict(PyObject * dict, const std::string& key){
-    if(!check_is_dict(dict))
-        throw std::invalid_argument("Python dictionary is null!");
-    return PyDict_GetItemString(dict, key.c_str());
+template <typename T>
+const NpArray<T> get_value(type<NpArray<T>> _, PyObject *value) {
+  py::array array = py::cast<py::array>(value);
+  return get_value<NpArray<T>>(array);
 }
 
+PyObject *_get_py_value_from_py_dict(PyObject *dict, const std::string &key) {
+  if (!check_is_dict(dict))
+    throw std::invalid_argument("Python dictionary is null!");
+  return PyDict_GetItemString(dict, key.c_str());
+}
 
 /**
- * Returns a C++ vector from a Python list that is inside a Pyhton dictionary under a key.
+ * Returns a C++ vector from a Python list that is inside a Pyhton dictionary
+ *under a key.
  *
  * We assume that the item indexed by the key, it's a list:
  * ```python
@@ -417,15 +404,16 @@ PyObject * _get_py_value_from_py_dict(PyObject * dict, const std::string& key){
  * @param dict PyObject* A pointer to a PyObject type representing a dictionary
  * @return A vector of type VecType from the Pyhton's dictionary key.
  **/
-template<typename VecType>
-const std::vector<VecType> get_vec_from_dict_item(PyObject * dict, const std::string& item_key){
-    PyObject * py_value = _get_py_value_from_py_dict(dict, item_key);
-    return get_value<std::vector<VecType>>(py_value);
+template <typename VecType>
+const std::vector<VecType> get_vec_from_dict_item(PyObject *dict,
+                                                  const std::string &item_key) {
+  PyObject *py_value = _get_py_value_from_py_dict(dict, item_key);
+  return get_value<std::vector<VecType>>(py_value);
 }
 
 /**
- * Returns a C++ unordered_map from a Python dictionary that is inside another Pyhton
- * dictionary under a key.
+ * Returns a C++ unordered_map from a Python dictionary that is inside another
+ *Pyhton dictionary under a key.
  *
  * We assume that the item indexed by the key, it's a dictionary:
  * ```python
@@ -442,24 +430,26 @@ const std::vector<VecType> get_vec_from_dict_item(PyObject * dict, const std::st
  * ```
  *
  * @param dict PyObject* A pointer to a PyObject type representing a dictionary
- * @return An unordered map of type <KeyType,ValueType> from the Pyhton's dictionary key.
+ * @return An unordered map of type <KeyType,ValueType> from the Pyhton's
+ *dictionary key.
  **/
-template<typename KeyType, typename ValueType>
-const std::unordered_map<KeyType, ValueType> get_map_from_dict_item(PyObject * dict, const std::string& item_key){
-    PyObject * py_value = _get_py_value_from_py_dict(dict, item_key);
-    return get_value<std::unordered_map<KeyType, ValueType>>(py_value);
+template <typename KeyType, typename ValueType>
+const std::unordered_map<KeyType, ValueType>
+get_map_from_dict_item(PyObject *dict, const std::string &item_key) {
+  PyObject *py_value = _get_py_value_from_py_dict(dict, item_key);
+  return get_value<std::unordered_map<KeyType, ValueType>>(py_value);
 }
 
-
-template<typename KeyType, typename ValueType>
-const ordered_map<KeyType, ValueType> get_ordered_map_from_dict_item(PyObject * dict, const std::string& item_key){
-    PyObject * py_value = _get_py_value_from_py_dict(dict, item_key);
-    return get_value<ordered_map<KeyType, ValueType>>(py_value);
+template <typename KeyType, typename ValueType>
+const ordered_map<KeyType, ValueType>
+get_ordered_map_from_dict_item(PyObject *dict, const std::string &item_key) {
+  PyObject *py_value = _get_py_value_from_py_dict(dict, item_key);
+  return get_value<ordered_map<KeyType, ValueType>>(py_value);
 }
 
 /**
- * Returns a C++ value of type ValueTyep from a Python numeric that is inside a Pyhton
- * dictionary under a key.
+ * Returns a C++ value of type ValueTyep from a Python numeric that is inside a
+ *Pyhton dictionary under a key.
  *
  * We assume that the item indexed by the key, it's a numeric:
  * ```python
@@ -477,13 +467,14 @@ const ordered_map<KeyType, ValueType> get_ordered_map_from_dict_item(PyObject *
  * @param dict PyObject* A pointer to a PyObject type representing a dictionary
  * @return A long from the Pyhton's dictionary key.
  **/
-template<typename ValueType>
-ValueType get_value_from_dict_item(PyObject * dict, const std::string& item_key){
-    PyObject * py_value = _get_py_value_from_py_dict(dict, item_key);
-    if(py_value == Py_None)
-        return {};
-
-    return get_value<ValueType>(py_value);
+template <typename ValueType>
+ValueType get_value_from_dict_item(PyObject *dict,
+                                   const std::string &item_key) {
+  PyObject *py_value = _get_py_value_from_py_dict(dict, item_key);
+  if (py_value == Py_None)
+    return {};
+
+  return get_value<ValueType>(py_value);
 }
 
 #endif //_PYTHON_TO_CPP_HPP
diff --git a/src/open_pulse/test_python_to_cpp.cpp b/src/open_pulse/test_python_to_cpp.cpp
index 6839922018..a67434f607 100644
--- a/src/open_pulse/test_python_to_cpp.cpp
+++ b/src/open_pulse/test_python_to_cpp.cpp
@@ -1,77 +1,80 @@
 #include "test_python_to_cpp.hpp"
 
+#include "python_to_cpp.hpp"
+#include <Python.h>
+#include <complex>
 #include <csignal>
+#include <iostream>
 #include <unordered_map>
 #include <vector>
-#include <complex>
-#include <Python.h>
-#include <iostream>
-#include "python_to_cpp.hpp"
 
-bool cpp_test_py_list_to_cpp_vec(PyObject * val){
-    // val = [1., 2., 3.]
-    auto vec = get_value<std::vector<double>>(val);
-    auto expected = std::vector<double>{1., 2., 3.};
-    return vec == expected;
+bool cpp_test_py_list_to_cpp_vec(PyObject *val) {
+  // val = [1., 2., 3.]
+  auto vec = get_value<std::vector<double>>(val);
+  auto expected = std::vector<double>{1., 2., 3.};
+  return vec == expected;
 }
 
-bool cpp_test_py_list_of_lists_to_cpp_vector_of_vectors(PyObject * val){
-    // val = [[1., 2., 3.]]
-    auto vec = get_value<std::vector<std::vector<double>>>(val);
-    auto expected = std::vector<std::vector<double>>{{1., 2., 3.}};
-    return vec == expected;
+bool cpp_test_py_list_of_lists_to_cpp_vector_of_vectors(PyObject *val) {
+  // val = [[1., 2., 3.]]
+  auto vec = get_value<std::vector<std::vector<double>>>(val);
+  auto expected = std::vector<std::vector<double>>{{1., 2., 3.}};
+  return vec == expected;
 }
 
-bool cpp_test_py_dict_string_numeric_to_cpp_map_string_numeric(PyObject * val){
-    // val = {"key": 1}
-    auto map = get_value<std::unordered_map<std::string, long>>(val);
-    auto expected = std::unordered_map<std::string, long>{{"key", 1}};
-    return map == expected;
-
+bool cpp_test_py_dict_string_numeric_to_cpp_map_string_numeric(PyObject *val) {
+  // val = {"key": 1}
+  auto map = get_value<std::unordered_map<std::string, long>>(val);
+  auto expected = std::unordered_map<std::string, long>{{"key", 1}};
+  return map == expected;
 }
 
-bool cpp_test_py_dict_string_list_of_list_of_doubles_to_cpp_map_string_vec_of_vecs_of_doubles(PyObject * val){
-    // val = {"key": [[1., 2., 3.]]}
-    auto map = get_value<std::unordered_map<std::string, std::vector<std::vector<double>>>>(val);
-    auto expected = std::unordered_map<std::string, std::vector<std::vector<double>>>{{"key", {{1., 2., 3.}}}};
-    return map == expected;
+bool cpp_test_py_dict_string_list_of_list_of_doubles_to_cpp_map_string_vec_of_vecs_of_doubles(
+    PyObject *val) {
+  // val = {"key": [[1., 2., 3.]]}
+  auto map = get_value<
+      std::unordered_map<std::string, std::vector<std::vector<double>>>>(val);
+  auto expected =
+      std::unordered_map<std::string, std::vector<std::vector<double>>>{
+          {"key", {{1., 2., 3.}}}};
+  return map == expected;
 }
 
-bool cpp_test_np_array_of_doubles(py::array val){
-    // val = np.array([0., 1., 2., 3.])
-    auto vec = get_value<NpArray<double>>(val);
-    if(vec[0] != 0. || vec[1] != 1. || vec[2] != 2. || vec[3] != 3.)
-        return false;
+bool cpp_test_np_array_of_doubles(py::array val) {
+  // val = np.array([0., 1., 2., 3.])
+  auto vec = get_value<NpArray<double>>(val);
+  if (vec[0] != 0. || vec[1] != 1. || vec[2] != 2. || vec[3] != 3.)
+    return false;
 
-    return true;
+  return true;
 }
 
-bool cpp_test_np_2D_array_of_doubles(py::array val){
-    // val = np.array([[0., 1., 2., 3.],[10.,20.,30.,40]])
-    auto vec = get_value<NpArray<double>>(val);
-    if(vec(0, 0) != 0. || vec(0, 1) != 1. || vec(0, 2) != 2. || vec(0, 3) != 3. ||
-       vec(1, 0) != 10. || vec(1, 1) != 20. || vec(1, 2) != 30. || vec(1, 3) != 40. )
-        return false;
-    
-    return true;
-}
+bool cpp_test_np_2D_array_of_doubles(py::array val) {
+  // val = np.array([[0., 1., 2., 3.],[10.,20.,30.,40]])
+  auto vec = get_value<NpArray<double>>(val);
+  if (vec(0, 0) != 0. || vec(0, 1) != 1. || vec(0, 2) != 2. ||
+      vec(0, 3) != 3. || vec(1, 0) != 10. || vec(1, 1) != 20. ||
+      vec(1, 2) != 30. || vec(1, 3) != 40.)
+    return false;
 
+  return true;
+}
 
-bool cpp_test_evaluate_hamiltonians(PyObject * val){
-    // TODO: Add tests!
-    return false;
+bool cpp_test_evaluate_hamiltonians(PyObject *val) {
+  // TODO: Add tests!
+  return false;
 }
 
-bool cpp_test_py_ordered_map(PyObject * val){
-    // Ordered map should guarantee insertion order.
-    // val = {"D0": 1, "U0": 2, "D1": 3, "U1": 4}
-    std::vector<std::string> order = {"D0", "U0", "D1", "U1"};
-    auto ordered = get_value<ordered_map<std::string, long>>(val);
-    size_t i = 0;
-    for(const auto &elem: ordered) {
-        auto key = elem.first;
-        if(key != order[i++])
-            return false;
-    }
-    return true;
+bool cpp_test_py_ordered_map(PyObject *val) {
+  // Ordered map should guarantee insertion order.
+  // val = {"D0": 1, "U0": 2, "D1": 3, "U1": 4}
+  std::vector<std::string> order = {"D0", "U0", "D1", "U1"};
+  auto ordered = get_value<ordered_map<std::string, long>>(val);
+  size_t i = 0;
+  for (const auto &elem : ordered) {
+    auto key = elem.first;
+    if (key != order[i++])
+      return false;
+  }
+  return true;
 }
diff --git a/src/open_pulse/test_python_to_cpp.hpp b/src/open_pulse/test_python_to_cpp.hpp
index 35b5e3beb2..67777ec385 100644
--- a/src/open_pulse/test_python_to_cpp.hpp
+++ b/src/open_pulse/test_python_to_cpp.hpp
@@ -17,8 +17,8 @@
 
 #include "misc/warnings.hpp"
 DISABLE_WARNING_PUSH
-#include <pybind11/pybind11.h>
 #include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
 DISABLE_WARNING_POP
 
 namespace py = pybind11;
@@ -26,32 +26,63 @@ namespace py = pybind11;
 // TODO: Test QuantumObj
 // TODO: Test Hamiltonian
 
-bool cpp_test_py_list_to_cpp_vec(PyObject * val);
-bool cpp_test_py_list_of_lists_to_cpp_vector_of_vectors(PyObject * val);
-bool cpp_test_py_dict_string_numeric_to_cpp_map_string_numeric(PyObject * val);
-bool cpp_test_py_dict_string_list_of_list_of_doubles_to_cpp_map_string_vec_of_vecs_of_doubles(PyObject * val);
+bool cpp_test_py_list_to_cpp_vec(PyObject *val);
+bool cpp_test_py_list_of_lists_to_cpp_vector_of_vectors(PyObject *val);
+bool cpp_test_py_dict_string_numeric_to_cpp_map_string_numeric(PyObject *val);
+bool cpp_test_py_dict_string_list_of_list_of_doubles_to_cpp_map_string_vec_of_vecs_of_doubles(
+    PyObject *val);
 bool cpp_test_np_array_of_doubles(py::array val);
 bool cpp_test_np_2D_array_of_doubles(py::array val);
-bool cpp_test_evaluate_hamiltonians(PyObject * val);
-bool cpp_test_py_ordered_map(PyObject * val);
-
+bool cpp_test_evaluate_hamiltonians(PyObject *val);
+bool cpp_test_py_ordered_map(PyObject *val);
 
 PYBIND11_MODULE(test_python_to_cpp, m) {
-    m.doc() = "pybind11 test_python_to_cpp"; // optional module docstring
-
-    m.def("test_py_list_to_cpp_vec", [](py::list list) { return cpp_test_py_list_to_cpp_vec(list.ptr()); } , "");
-    m.def("test_py_list_of_lists_to_cpp_vector_of_vectors",
-            [](py::list list) { return cpp_test_py_list_of_lists_to_cpp_vector_of_vectors(list.ptr()); } , "");
-    m.def("test_py_dict_string_numeric_to_cpp_map_string_numeric",
-            [](py::dict dict) { return cpp_test_py_dict_string_numeric_to_cpp_map_string_numeric(dict.ptr()); } , "");
-    m.def("test_py_dict_string_list_of_list_of_doubles_to_cpp_map_string_vec_of_vecs_of_doubles",
-        [](py::dict dict) { return cpp_test_py_dict_string_list_of_list_of_doubles_to_cpp_map_string_vec_of_vecs_of_doubles(dict.ptr()); } , "");
-    m.def("test_np_array_of_doubles",
-            [](py::array_t<double> array_doubles) { return cpp_test_np_array_of_doubles(array_doubles); } , "");
-    m.def("test_np_2D_array_of_doubles",
-            [](py::array_t<double> array_doubles) { return cpp_test_np_2D_array_of_doubles(array_doubles); } , "");
-    m.def("test_evaluate_hamiltonians", [](py::list list) { return cpp_test_evaluate_hamiltonians(list.ptr()); } , "");
-    m.def("test_py_ordered_map", [](py::dict dict) { return cpp_test_py_ordered_map(dict.ptr()); } , "");
+  m.doc() = "pybind11 test_python_to_cpp"; // optional module docstring
+
+  m.def(
+      "test_py_list_to_cpp_vec",
+      [](py::list list) { return cpp_test_py_list_to_cpp_vec(list.ptr()); },
+      "");
+  m.def(
+      "test_py_list_of_lists_to_cpp_vector_of_vectors",
+      [](py::list list) {
+        return cpp_test_py_list_of_lists_to_cpp_vector_of_vectors(list.ptr());
+      },
+      "");
+  m.def(
+      "test_py_dict_string_numeric_to_cpp_map_string_numeric",
+      [](py::dict dict) {
+        return cpp_test_py_dict_string_numeric_to_cpp_map_string_numeric(
+            dict.ptr());
+      },
+      "");
+  m.def(
+      "test_py_dict_string_list_of_list_of_doubles_to_cpp_map_string_vec_of_"
+      "vecs_of_doubles",
+      [](py::dict dict) {
+        return cpp_test_py_dict_string_list_of_list_of_doubles_to_cpp_map_string_vec_of_vecs_of_doubles(
+            dict.ptr());
+      },
+      "");
+  m.def(
+      "test_np_array_of_doubles",
+      [](py::array_t<double> array_doubles) {
+        return cpp_test_np_array_of_doubles(array_doubles);
+      },
+      "");
+  m.def(
+      "test_np_2D_array_of_doubles",
+      [](py::array_t<double> array_doubles) {
+        return cpp_test_np_2D_array_of_doubles(array_doubles);
+      },
+      "");
+  m.def(
+      "test_evaluate_hamiltonians",
+      [](py::list list) { return cpp_test_evaluate_hamiltonians(list.ptr()); },
+      "");
+  m.def(
+      "test_py_ordered_map",
+      [](py::dict dict) { return cpp_test_py_ordered_map(dict.ptr()); }, "");
 }
 
 #endif // _TEST_HELPERS_HPP
\ No newline at end of file
diff --git a/src/open_pulse/types.hpp b/src/open_pulse/types.hpp
index f8dac3fd30..26a9470d53 100644
--- a/src/open_pulse/types.hpp
+++ b/src/open_pulse/types.hpp
@@ -20,8 +20,8 @@
 using complex_t = std::complex<double>;
 
 struct TermExpression {
-    TermExpression(const std::string& term) : term(term) {}
-    std::string term;
+  TermExpression(const std::string &term) : term(term) {}
+  std::string term;
 };
 
 #endif // _TEST_TYPES_HPP
\ No newline at end of file
diff --git a/src/open_pulse/zspmv.cpp b/src/open_pulse/zspmv.cpp
index bf84d7ed72..df91eab1da 100644
--- a/src/open_pulse/zspmv.cpp
+++ b/src/open_pulse/zspmv.cpp
@@ -3,11 +3,11 @@
 //    Copyright (c) 2011 and later, QuSTaR.
 //   All rights reserved.
 //
-//    Redistribution and use in source and binary forms, with or without 
-//    modification, are permitted provided that the following conditions are 
+//    Redistribution and use in source and binary forms, with or without
+//    modification, are permitted provided that the following conditions are
 //    met:
 //
-//   1. Redistributions of source code must retain the above copyright notice, 
+//   1. Redistributions of source code must retain the above copyright notice,
 //       this list of conditions and the following disclaimer.
 //
 //    2. Redistributions in binary form must reproduce the above copyright
@@ -18,155 +18,143 @@
 //       of its contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
-//    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+//    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 //    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-//    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
-//    PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
-//    HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
-//    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
-//    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-//    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
-//    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
-//    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+//    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+//    PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+//    HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+//    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+//    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+//    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+//    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+//    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 //    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //#############################################################################
 #include <complex>
 
 #if defined(__GNUC__) && defined(__SSE3__) // Using GCC or CLANG and SSE3
 #include <pmmintrin.h>
-void zspmvpy(const std::complex<double> * __restrict__ data, const int * __restrict__ ind,
-            const int * __restrict__ ptr,
-            const std::complex<double> * __restrict__ vec, const std::complex<double> a,
-            std::complex<double> * __restrict__ out, const unsigned int nrows)
-{
-    size_t row, jj;
-    unsigned int row_start, row_end;
-    __m128d num1, num2, num3, num4;
-    for (row=0; row < nrows; row++)
-    {
-        num4 = _mm_setzero_pd();
-        row_start = ptr[row];
-        row_end = ptr[row+1];
-        for (jj=row_start; jj <row_end; jj++)
-        {
-            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[0]);
-            num2 = _mm_set_pd(std::imag(vec[ind[jj]]),std::real(vec[ind[jj]]));
-            num3 = _mm_mul_pd(num2, num1);
-            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[1]);
-            num2 = _mm_shuffle_pd(num2, num2, 1);
-            num2 = _mm_mul_pd(num2, num1);
-            num3 = _mm_addsub_pd(num3, num2);
-            num4 = _mm_add_pd(num3, num4);
-        }
-        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[0]);
-        num3 = _mm_mul_pd(num4, num1);
-        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[1]);
-        num4 = _mm_shuffle_pd(num4, num4, 1);
-        num4 = _mm_mul_pd(num4, num1);
-        num3 = _mm_addsub_pd(num3, num4);
-        num2 = _mm_loadu_pd((double *)&out[row]);
-        num3 = _mm_add_pd(num2, num3);
-        _mm_storeu_pd((double *)&out[row], num3);
+void zspmvpy(const std::complex<double> *__restrict__ data,
+             const int *__restrict__ ind, const int *__restrict__ ptr,
+             const std::complex<double> *__restrict__ vec,
+             const std::complex<double> a,
+             std::complex<double> *__restrict__ out, const unsigned int nrows) {
+  size_t row, jj;
+  unsigned int row_start, row_end;
+  __m128d num1, num2, num3, num4;
+  for (row = 0; row < nrows; row++) {
+    num4 = _mm_setzero_pd();
+    row_start = ptr[row];
+    row_end = ptr[row + 1];
+    for (jj = row_start; jj < row_end; jj++) {
+      num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[0]);
+      num2 = _mm_set_pd(std::imag(vec[ind[jj]]), std::real(vec[ind[jj]]));
+      num3 = _mm_mul_pd(num2, num1);
+      num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[1]);
+      num2 = _mm_shuffle_pd(num2, num2, 1);
+      num2 = _mm_mul_pd(num2, num1);
+      num3 = _mm_addsub_pd(num3, num2);
+      num4 = _mm_add_pd(num3, num4);
     }
+    num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[0]);
+    num3 = _mm_mul_pd(num4, num1);
+    num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[1]);
+    num4 = _mm_shuffle_pd(num4, num4, 1);
+    num4 = _mm_mul_pd(num4, num1);
+    num3 = _mm_addsub_pd(num3, num4);
+    num2 = _mm_loadu_pd((double *)&out[row]);
+    num3 = _mm_add_pd(num2, num3);
+    _mm_storeu_pd((double *)&out[row], num3);
+  }
 }
-#elif defined(__GNUC__) // Using GCC or CLANG but no SSE3
-void zspmvpy(const std::complex<double> * __restrict__ data, const int * __restrict__ ind,
-            const int * __restrict__ ptr,
-            const std::complex<double> * __restrict__ vec, const std::complex<double> a,
-            std::complex<double> * __restrict__ out, const unsigned int nrows)
-{
-    size_t row, jj;
-    unsigned int row_start, row_end;
-    std::complex<double> dot;
-    for (row=0; row < nrows; row++)
-    {
-        dot = 0;
-        row_start = ptr[row];
-        row_end = ptr[row+1];
-        for (jj=row_start; jj <row_end; jj++)
-        {
-            dot += data[jj]*vec[ind[jj]];
-        }
-        out[row] += a*dot;
+#elif defined(__GNUC__)                     // Using GCC or CLANG but no SSE3
+void zspmvpy(const std::complex<double> *__restrict__ data,
+             const int *__restrict__ ind, const int *__restrict__ ptr,
+             const std::complex<double> *__restrict__ vec,
+             const std::complex<double> a,
+             std::complex<double> *__restrict__ out, const unsigned int nrows) {
+  size_t row, jj;
+  unsigned int row_start, row_end;
+  std::complex<double> dot;
+  for (row = 0; row < nrows; row++) {
+    dot = 0;
+    row_start = ptr[row];
+    row_end = ptr[row + 1];
+    for (jj = row_start; jj < row_end; jj++) {
+      dot += data[jj] * vec[ind[jj]];
     }
+    out[row] += a * dot;
+  }
 }
 #elif defined(_MSC_VER) && defined(__AVX__) // Visual Studio with AVX
 #include <pmmintrin.h>
-void zspmvpy(const std::complex<double> * __restrict data, const int * __restrict ind,
-            const int * __restrict ptr,
-            const std::complex<double> * __restrict vec, const std::complex<double> a,
-            std::complex<double> * __restrict out, const unsigned int nrows)
-{
-    size_t row, jj;
-    unsigned int row_start, row_end;
-    __m128d num1, num2, num3, num4;
-    for (row=0; row < nrows; row++)
-    {
-        num4 = _mm_setzero_pd();
-        row_start = ptr[row];
-        row_end = ptr[row+1];
-        for (jj=row_start; jj <row_end; jj++)
-        {
-            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[0]);
-            num2 = _mm_set_pd(std::imag(vec[ind[jj]]),std::real(vec[ind[jj]]));
-            num3 = _mm_mul_pd(num2, num1);
-            num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[1]);
-            num2 = _mm_shuffle_pd(num2, num2, 1);
-            num2 = _mm_mul_pd(num2, num1);
-            num3 = _mm_addsub_pd(num3, num2);
-            num4 = _mm_add_pd(num3, num4);
-        }
-        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[0]);
-        num3 = _mm_mul_pd(num4, num1);
-        num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[1]);
-        num4 = _mm_shuffle_pd(num4, num4, 1);
-        num4 = _mm_mul_pd(num4, num1);
-        num3 = _mm_addsub_pd(num3, num4);
-        num2 = _mm_loadu_pd((double *)&out[row]);
-        num3 = _mm_add_pd(num2, num3);
-        _mm_storeu_pd((double *)&out[row], num3);
+void zspmvpy(const std::complex<double> *__restrict data,
+             const int *__restrict ind, const int *__restrict ptr,
+             const std::complex<double> *__restrict vec,
+             const std::complex<double> a, std::complex<double> *__restrict out,
+             const unsigned int nrows) {
+  size_t row, jj;
+  unsigned int row_start, row_end;
+  __m128d num1, num2, num3, num4;
+  for (row = 0; row < nrows; row++) {
+    num4 = _mm_setzero_pd();
+    row_start = ptr[row];
+    row_end = ptr[row + 1];
+    for (jj = row_start; jj < row_end; jj++) {
+      num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[0]);
+      num2 = _mm_set_pd(std::imag(vec[ind[jj]]), std::real(vec[ind[jj]]));
+      num3 = _mm_mul_pd(num2, num1);
+      num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(data[jj])[1]);
+      num2 = _mm_shuffle_pd(num2, num2, 1);
+      num2 = _mm_mul_pd(num2, num1);
+      num3 = _mm_addsub_pd(num3, num2);
+      num4 = _mm_add_pd(num3, num4);
     }
+    num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[0]);
+    num3 = _mm_mul_pd(num4, num1);
+    num1 = _mm_loaddup_pd(&reinterpret_cast<const double(&)[2]>(a)[1]);
+    num4 = _mm_shuffle_pd(num4, num4, 1);
+    num4 = _mm_mul_pd(num4, num1);
+    num3 = _mm_addsub_pd(num3, num4);
+    num2 = _mm_loadu_pd((double *)&out[row]);
+    num3 = _mm_add_pd(num2, num3);
+    _mm_storeu_pd((double *)&out[row], num3);
+  }
 }
 #elif defined(_MSC_VER) // Visual Studio no AVX
-void zspmvpy(const std::complex<double> * __restrict data, const int * __restrict ind,
-            const int * __restrict ptr,
-            const std::complex<double> * __restrict vec, const std::complex<double> a,
-            std::complex<double> * __restrict out, const unsigned int nrows)
-{
-    size_t row, jj;
-    unsigned int row_start, row_end;
-    std::complex<double> dot;
-    for (row=0; row < nrows; row++)
-    {
-        dot = 0;
-        row_start = ptr[row];
-        row_end = ptr[row+1];
-        for (jj=row_start; jj <row_end; jj++)
-        {
-            dot += data[jj]*vec[ind[jj]];
-        }
-        out[row] += a*dot;
+void zspmvpy(const std::complex<double> *__restrict data,
+             const int *__restrict ind, const int *__restrict ptr,
+             const std::complex<double> *__restrict vec,
+             const std::complex<double> a, std::complex<double> *__restrict out,
+             const unsigned int nrows) {
+  size_t row, jj;
+  unsigned int row_start, row_end;
+  std::complex<double> dot;
+  for (row = 0; row < nrows; row++) {
+    dot = 0;
+    row_start = ptr[row];
+    row_end = ptr[row + 1];
+    for (jj = row_start; jj < row_end; jj++) {
+      dot += data[jj] * vec[ind[jj]];
     }
+    out[row] += a * dot;
+  }
 }
-#else // Everything else
-void zspmvpy(const std::complex<double> * data, const int * ind,
-            const int * ptr,
-            const std::complex<double> * vec, const std::complex<double> a,
-            std::complex<double> * out, const unsigned int nrows)
-{
-    size_t row, jj;
-    unsigned int row_start, row_end;
-    std::complex<double> dot;
-    for (row=0; row < nrows; row++)
-    {
-        dot = 0;
-        row_start = ptr[row];
-        row_end = ptr[row+1];
-        for (jj=row_start; jj <row_end; jj++)
-        {
-            dot += data[jj]*vec[ind[jj]];
-        }
-        out[row] += a*dot;
+#else                   // Everything else
+void zspmvpy(const std::complex<double> *data, const int *ind, const int *ptr,
+             const std::complex<double> *vec, const std::complex<double> a,
+             std::complex<double> *out, const unsigned int nrows) {
+  size_t row, jj;
+  unsigned int row_start, row_end;
+  std::complex<double> dot;
+  for (row = 0; row < nrows; row++) {
+    dot = 0;
+    row_start = ptr[row];
+    row_end = ptr[row + 1];
+    for (jj = row_start; jj < row_end; jj++) {
+      dot += data[jj] * vec[ind[jj]];
     }
+    out[row] += a * dot;
+  }
 }
 #endif
diff --git a/src/open_pulse/zspmv.hpp b/src/open_pulse/zspmv.hpp
index ef9e45808b..5dfcf81d62 100644
--- a/src/open_pulse/zspmv.hpp
+++ b/src/open_pulse/zspmv.hpp
@@ -3,11 +3,11 @@
 //    Copyright (c) 2011 and later, QuSTaR.
 //   All rights reserved.
 //
-//    Redistribution and use in source and binary forms, with or without 
-//    modification, are permitted provided that the following conditions are 
+//    Redistribution and use in source and binary forms, with or without
+//    modification, are permitted provided that the following conditions are
 //    met:
 //
-//   1. Redistributions of source code must retain the above copyright notice, 
+//   1. Redistributions of source code must retain the above copyright notice,
 //       this list of conditions and the following disclaimer.
 //
 //    2. Redistributions in binary form must reproduce the above copyright
@@ -18,36 +18,34 @@
 //       of its contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
-//    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+//    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 //    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-//    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
-//    PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
-//    HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
-//    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
-//    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
-//    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
-//    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
-//    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+//    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+//    PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+//    HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+//    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+//    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+//    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+//    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+//    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 //    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //#############################################################################
 #include <complex>
 
 #ifdef __GNUC__
-void zspmvpy(const std::complex<double> * __restrict__ data, const int * __restrict__ ind, 
-            const int *__restrict__ ptr,
-            const std::complex<double> * __restrict__ vec, const std::complex<double> a, 
-            std::complex<double> * __restrict__ out,
-            const unsigned int nrows);
+void zspmvpy(const std::complex<double> *__restrict__ data,
+             const int *__restrict__ ind, const int *__restrict__ ptr,
+             const std::complex<double> *__restrict__ vec,
+             const std::complex<double> a,
+             std::complex<double> *__restrict__ out, const unsigned int nrows);
 #elif defined(_MSC_VER)
-void zspmvpy(const std::complex<double> * __restrict data, const int * __restrict ind, 
-            const int *__restrict ptr,
-            const std::complex<double> * __restrict vec, const std::complex<double> a, 
-            std::complex<double> * __restrict out,
-            const unsigned int nrows);
+void zspmvpy(const std::complex<double> *__restrict data,
+             const int *__restrict ind, const int *__restrict ptr,
+             const std::complex<double> *__restrict vec,
+             const std::complex<double> a, std::complex<double> *__restrict out,
+             const unsigned int nrows);
 #else
-void zspmvpy(const std::complex<double> * data, const int * ind, 
-            const int * ptr,
-            const std::complex<double> * vec, const std::complex<double> a, 
-            std::complex<double> * out,
-            const unsigned int nrows);           
+void zspmvpy(const std::complex<double> *data, const int *ind, const int *ptr,
+             const std::complex<double> *vec, const std::complex<double> a,
+             std::complex<double> *out, const unsigned int nrows);
 #endif
\ No newline at end of file
diff --git a/src/simulators/density_matrix/densitymatrix.hpp b/src/simulators/density_matrix/densitymatrix.hpp
old mode 100755
new mode 100644
index 424957eefa..14ac02c150
--- a/src/simulators/density_matrix/densitymatrix.hpp
+++ b/src/simulators/density_matrix/densitymatrix.hpp
@@ -15,7 +15,6 @@
 #ifndef _qv_density_matrix_hpp_
 #define _qv_density_matrix_hpp_
 
-
 #include "framework/utils.hpp"
 #include "simulators/unitary/unitarymatrix.hpp"
 
@@ -44,17 +43,17 @@ class DensityMatrix : public UnitaryMatrix<data_t> {
   // Constructors and Destructor
   //-----------------------------------------------------------------------
 
-  DensityMatrix() : DensityMatrix(0) {};
+  DensityMatrix() : DensityMatrix(0){};
   explicit DensityMatrix(size_t num_qubits);
-  DensityMatrix(const DensityMatrix& obj) {};
-  DensityMatrix &operator=(const DensityMatrix& obj) {};
+  DensityMatrix(const DensityMatrix &obj){};
+  DensityMatrix &operator=(const DensityMatrix &obj){};
 
   //-----------------------------------------------------------------------
   // Utility functions
   //-----------------------------------------------------------------------
 
   // Return the string name of the DensityMatrix class
-  static std::string name() {return "density_matrix";}
+  static std::string name() { return "density_matrix"; }
 
   // Initializes the current vector so that all qubits are in the |0> state.
   void initialize();
@@ -63,13 +62,11 @@ class DensityMatrix : public UnitaryMatrix<data_t> {
   // The vector can be either a statevector or a vectorized density matrix
   // If the length of the data vector does not match either case for the
   // number of qubits an exception is raised.
-  template <typename list_t>
-  void initialize_from_vector(const list_t &data);
-  template <typename list_t>
-  void initialize_from_vector(list_t &&data);
+  template <typename list_t> void initialize_from_vector(const list_t &data);
+  template <typename list_t> void initialize_from_vector(list_t &&data);
 
   // Returns the number of qubits for the superoperator
-  virtual uint_t num_qubits() const override {return BaseMatrix::num_qubits_;}
+  virtual uint_t num_qubits() const override { return BaseMatrix::num_qubits_; }
 
   // Convert qubit indicies to vectorized-density matrix qubitvector indices
   // For the QubitVector apply matrix function
@@ -80,20 +77,24 @@ class DensityMatrix : public UnitaryMatrix<data_t> {
   //-----------------------------------------------------------------------
 
   // Apply a N-qubit unitary matrix to the state vector.
-  // The matrix is input as vector of the column-major vectorized N-qubit matrix.
+  // The matrix is input as vector of the column-major vectorized N-qubit
+  // matrix.
   void apply_unitary_matrix(const reg_t &qubits, const cvector_t<double> &mat);
 
   // Apply a N-qubit superoperator matrix to the state vector.
-  // The matrix is input as vector of the column-major vectorized N-qubit superop.
+  // The matrix is input as vector of the column-major vectorized N-qubit
+  // superop.
   void apply_superop_matrix(const reg_t &qubits, const cvector_t<double> &mat);
 
   // Apply a N-qubit diagonal unitary matrix to the state vector.
   // The matrix is input as vector of the matrix diagonal.
-  void apply_diagonal_unitary_matrix(const reg_t &qubits, const cvector_t<double> &mat);
+  void apply_diagonal_unitary_matrix(const reg_t &qubits,
+                                     const cvector_t<double> &mat);
 
   // Apply a N-qubit diagonal superoperator matrix to the state vector.
   // The matrix is input as vector of the matrix diagonal.
-  void apply_diagonal_superop_matrix(const reg_t &qubits, const cvector_t<double> &mat);
+  void apply_diagonal_superop_matrix(const reg_t &qubits,
+                                     const cvector_t<double> &mat);
 
   //-----------------------------------------------------------------------
   // Apply Specialized Gates
@@ -102,7 +103,7 @@ class DensityMatrix : public UnitaryMatrix<data_t> {
   // Apply a 2-qubit Controlled-NOT gate to the state vector
   void apply_cnot(const uint_t qctrl, const uint_t qtrgt);
 
- // Apply a 2-qubit Controlled-Y gate to the state vector
+  // Apply a 2-qubit Controlled-Y gate to the state vector
   void apply_cy(const uint_t qctrl, const uint_t qtrgt);
 
   // Apply 2-qubit controlled-phase gate
@@ -121,7 +122,8 @@ class DensityMatrix : public UnitaryMatrix<data_t> {
   void apply_phase(const uint_t q, const complex_t &phase);
 
   // Apply a 3-qubit toffoli gate
-  void apply_toffoli(const uint_t qctrl0, const uint_t qctrl1, const uint_t qtrgt);
+  void apply_toffoli(const uint_t qctrl0, const uint_t qctrl1,
+                     const uint_t qtrgt);
 
   //-----------------------------------------------------------------------
   // Z-measurement outcome probabilities
@@ -131,25 +133,26 @@ class DensityMatrix : public UnitaryMatrix<data_t> {
   // outcome in [0, 2^num_qubits - 1]
   virtual double probability(const uint_t outcome) const override;
 
-
-  void apply_reset(const reg_t& qubits);
+  void apply_reset(const reg_t &qubits);
 
   //-----------------------------------------------------------------------
   // Expectation Values
   //-----------------------------------------------------------------------
 
   // Return Pauli expectation value
-  double expval_pauli(const reg_t &qubits, const std::string &pauli,const complex_t initial_phase=1.0) const;
-  double expval_pauli_non_diagonal_chunk(const reg_t &qubits, const std::string &pauli,const complex_t initial_phase=1.0) const;
+  double expval_pauli(const reg_t &qubits, const std::string &pauli,
+                      const complex_t initial_phase = 1.0) const;
+  double
+  expval_pauli_non_diagonal_chunk(const reg_t &qubits, const std::string &pauli,
+                                  const complex_t initial_phase = 1.0) const;
 
 protected:
-
   // Construct a vectorized superoperator from a vectorized matrix
   // This is equivalent to vec(tensor(conj(A), A))
   cvector_t<double> vmat2vsuperop(const cvector_t<double> &vmat) const;
 
-  // Qubit threshold for when apply unitary will apply as two matrix multiplications
-  // rather than as a 2n-qubit superoperator matrix.
+  // Qubit threshold for when apply unitary will apply as two matrix
+  // multiplications rather than as a 2n-qubit superoperator matrix.
   size_t apply_unitary_threshold_ = 4;
 };
 
@@ -159,21 +162,19 @@ class DensityMatrix : public UnitaryMatrix<data_t> {
  *
  ******************************************************************************/
 
-
 //------------------------------------------------------------------------------
 // Constructors & Destructor
 //------------------------------------------------------------------------------
 
 template <typename data_t>
 DensityMatrix<data_t>::DensityMatrix(size_t num_qubits)
-  : UnitaryMatrix<data_t>(num_qubits) {}
+    : UnitaryMatrix<data_t>(num_qubits) {}
 
 //------------------------------------------------------------------------------
 // Utility
 //------------------------------------------------------------------------------
 
-template <typename data_t>
-void DensityMatrix<data_t>::initialize() {
+template <typename data_t> void DensityMatrix<data_t>::initialize() {
   // Zero the underlying vector
   BaseVector::zero();
   // Set to be all |0> sate
@@ -189,11 +190,12 @@ void DensityMatrix<data_t>::initialize_from_vector(const list_t &vec) {
   } else if (BaseVector::data_size_ == vec.size() * vec.size()) {
     // Convert statevector into density matrix
     BaseVector::initialize_from_vector(
-      AER::Utils::tensor_product(AER::Utils::conjugate(vec), vec));
+        AER::Utils::tensor_product(AER::Utils::conjugate(vec), vec));
   } else {
-    throw std::runtime_error("DensityMatrix::initialize input vector is incorrect length. Expected: " +
-                             std::to_string(BaseVector::data_size_) + " Received: " +
-                             std::to_string(vec.size()));
+    throw std::runtime_error("DensityMatrix::initialize input vector is "
+                             "incorrect length. Expected: " +
+                             std::to_string(BaseVector::data_size_) +
+                             " Received: " + std::to_string(vec.size()));
   }
 }
 
@@ -206,11 +208,12 @@ void DensityMatrix<data_t>::initialize_from_vector(list_t &&vec) {
   } else if (BaseVector::data_size_ == vec.size() * vec.size()) {
     // Convert statevector into density matrix
     BaseVector::initialize_from_vector(
-      AER::Utils::tensor_product(AER::Utils::conjugate(vec), vec));
+        AER::Utils::tensor_product(AER::Utils::conjugate(vec), vec));
   } else {
-    throw std::runtime_error("DensityMatrix::initialize input vector is incorrect length. Expected: " +
-                             std::to_string(BaseVector::data_size_) + " Received: " +
-                             std::to_string(vec.size()));
+    throw std::runtime_error("DensityMatrix::initialize input vector is "
+                             "incorrect length. Expected: " +
+                             std::to_string(BaseVector::data_size_) +
+                             " Received: " + std::to_string(vec.size()));
   }
 }
 
@@ -223,22 +226,24 @@ reg_t DensityMatrix<data_t>::superop_qubits(const reg_t &qubits) const {
   reg_t superop_qubits = qubits;
   // Number of qubits
   const auto nq = num_qubits();
-  for (const auto &q: qubits) {
+  for (const auto &q : qubits) {
     superop_qubits.push_back(q + nq);
   }
   return superop_qubits;
 }
 
 template <typename data_t>
-cvector_t<double> DensityMatrix<data_t>::vmat2vsuperop(const cvector_t<double> &vmat) const {
+cvector_t<double>
+DensityMatrix<data_t>::vmat2vsuperop(const cvector_t<double> &vmat) const {
   // Get dimension of unvectorized matrix
   size_t dim = size_t(std::sqrt(vmat.size()));
   cvector_t<double> ret(dim * dim * dim * dim, 0.);
-  for (size_t i=0; i < dim; i++)
-    for (size_t j=0; j < dim; j++)
-      for (size_t k=0; k < dim; k++)
-        for (size_t l=0; l < dim; l++)
-          ret[dim*i+k+(dim*dim)*(dim*j+l)] = std::conj(vmat[i+dim*j])*vmat[k+dim*l];
+  for (size_t i = 0; i < dim; i++)
+    for (size_t j = 0; j < dim; j++)
+      for (size_t k = 0; k < dim; k++)
+        for (size_t l = 0; l < dim; l++)
+          ret[dim * i + k + (dim * dim) * (dim * j + l)] =
+              std::conj(vmat[i + dim * j]) * vmat[k + dim * l];
   return ret;
 }
 
@@ -249,20 +254,21 @@ void DensityMatrix<data_t>::apply_superop_matrix(const reg_t &qubits,
 }
 
 template <typename data_t>
-void DensityMatrix<data_t>::apply_diagonal_superop_matrix(const reg_t &qubits,
-                                                          const cvector_t<double> &diag) {
+void DensityMatrix<data_t>::apply_diagonal_superop_matrix(
+    const reg_t &qubits, const cvector_t<double> &diag) {
   BaseVector::apply_diagonal_matrix(superop_qubits(qubits), diag);
 }
 
 template <typename data_t>
 void DensityMatrix<data_t>::apply_unitary_matrix(const reg_t &qubits,
                                                  const cvector_t<double> &mat) {
-  // Check if we apply as two N-qubit matrix multiplications or a single 2N-qubit matrix mult.
+  // Check if we apply as two N-qubit matrix multiplications or a single
+  // 2N-qubit matrix mult.
   if (qubits.size() > apply_unitary_threshold_) {
     // Apply as two N-qubit matrix mults
     auto nq = num_qubits();
     reg_t conj_qubits;
-    for (const auto &q: qubits) {
+    for (const auto &q : qubits) {
       conj_qubits.push_back(q + nq);
     }
     // Apply id \otimes U
@@ -276,10 +282,11 @@ void DensityMatrix<data_t>::apply_unitary_matrix(const reg_t &qubits,
 }
 
 template <typename data_t>
-void DensityMatrix<data_t>::apply_diagonal_unitary_matrix(const reg_t &qubits,
-                                                          const cvector_t<double> &diag) {
+void DensityMatrix<data_t>::apply_diagonal_unitary_matrix(
+    const reg_t &qubits, const cvector_t<double> &diag) {
   // Apply as single 2N-qubit matrix mult.
-  apply_diagonal_superop_matrix(qubits, AER::Utils::tensor_product(AER::Utils::conjugate(diag), diag));
+  apply_diagonal_superop_matrix(
+      qubits, AER::Utils::tensor_product(AER::Utils::conjugate(diag), diag));
 }
 
 //-----------------------------------------------------------------------
@@ -289,25 +296,24 @@ void DensityMatrix<data_t>::apply_diagonal_unitary_matrix(const reg_t &qubits,
 template <typename data_t>
 void DensityMatrix<data_t>::apply_cnot(const uint_t qctrl, const uint_t qtrgt) {
   std::vector<std::pair<uint_t, uint_t>> pairs = {
-    {{1, 3}, {4, 12}, {5, 15}, {6, 14}, {7, 13}, {9, 11}}
-  };
+      {{1, 3}, {4, 12}, {5, 15}, {6, 14}, {7, 13}, {9, 11}}};
   const size_t nq = num_qubits();
   const reg_t qubits = {{qctrl, qtrgt, qctrl + nq, qtrgt + nq}};
   BaseVector::apply_permutation_matrix(qubits, pairs);
 }
 
 template <typename data_t>
-void DensityMatrix<data_t>::apply_cy(const uint_t qctrl, const uint_t qtrgt)
-{
+void DensityMatrix<data_t>::apply_cy(const uint_t qctrl, const uint_t qtrgt) {
   const reg_t qubits = {{qctrl, qtrgt}};
   apply_unitary_matrix(qubits, Linalg::VMatrix::CY);
 }
 
 template <typename data_t>
-void DensityMatrix<data_t>::apply_phase(const uint_t q, const complex_t &phase) {
+void DensityMatrix<data_t>::apply_phase(const uint_t q,
+                                        const complex_t &phase) {
   const complex_t iphase = std::conj(phase);
   // Lambda function for CZ gate
-  auto lambda = [&](const areg_t<1ULL << 2> &inds)->void {
+  auto lambda = [&](const areg_t<1ULL << 2> &inds) -> void {
     BaseVector::data_[inds[1]] *= phase;
     BaseVector::data_[inds[2]] *= iphase;
   };
@@ -321,7 +327,7 @@ void DensityMatrix<data_t>::apply_cphase(const uint_t q0, const uint_t q1,
                                          const complex_t &phase) {
   const complex_t iphase = std::conj(phase);
   // Lambda function for CZ gate
-  auto lambda = [&](const areg_t<1ULL << 4> &inds)->void {
+  auto lambda = [&](const areg_t<1ULL << 4> &inds) -> void {
     BaseVector::data_[inds[3]] *= phase;
     BaseVector::data_[inds[7]] *= phase;
     BaseVector::data_[inds[11]] *= phase;
@@ -337,8 +343,7 @@ void DensityMatrix<data_t>::apply_cphase(const uint_t q0, const uint_t q1,
 template <typename data_t>
 void DensityMatrix<data_t>::apply_swap(const uint_t q0, const uint_t q1) {
   std::vector<std::pair<uint_t, uint_t>> pairs = {
-   {{1, 2}, {4, 8}, {5, 10}, {6, 9}, {7, 11}, {13, 14}}
-  };
+      {{1, 2}, {4, 8}, {5, 10}, {6, 9}, {7, 11}, {13, 14}}};
   const size_t nq = num_qubits();
   const reg_t qubits = {{q0, q1, q0 + nq, q1 + nq}};
   BaseVector::apply_permutation_matrix(qubits, pairs);
@@ -347,23 +352,24 @@ void DensityMatrix<data_t>::apply_swap(const uint_t q0, const uint_t q1) {
 template <typename data_t>
 void DensityMatrix<data_t>::apply_x(const uint_t qubit) {
   // Lambda function for X gate superoperator
-  auto lambda = [&](const areg_t<1ULL << 2> &inds)->void {
+  auto lambda = [&](const areg_t<1ULL << 2> &inds) -> void {
     std::swap(BaseVector::data_[inds[0]], BaseVector::data_[inds[3]]);
     std::swap(BaseVector::data_[inds[1]], BaseVector::data_[inds[2]]);
   };
   // Use the lambda function
   const areg_t<2> qubits = {{qubit, qubit + num_qubits()}};
   BaseVector::apply_lambda(lambda, qubits);
-
 }
 
 template <typename data_t>
 void DensityMatrix<data_t>::apply_y(const uint_t qubit) {
   // Lambda function for Y gate superoperator
-  auto lambda = [&](const areg_t<1ULL << 2> &inds)->void {
+  auto lambda = [&](const areg_t<1ULL << 2> &inds) -> void {
     std::swap(BaseVector::data_[inds[0]], BaseVector::data_[inds[3]]);
-    const std::complex<data_t> cache = std::complex<data_t>(-1) * BaseVector::data_[inds[1]];
-    BaseVector::data_[inds[1]] = std::complex<data_t>(-1) * BaseVector::data_[inds[2]];
+    const std::complex<data_t> cache =
+        std::complex<data_t>(-1) * BaseVector::data_[inds[1]];
+    BaseVector::data_[inds[1]] =
+        std::complex<data_t>(-1) * BaseVector::data_[inds[2]];
     BaseVector::data_[inds[2]] = cache;
   };
   // Use the lambda function
@@ -375,35 +381,48 @@ template <typename data_t>
 void DensityMatrix<data_t>::apply_toffoli(const uint_t qctrl0,
                                           const uint_t qctrl1,
                                           const uint_t qtrgt) {
-  std::vector<std::pair<uint_t, uint_t>> pairs = {
-    {{3, 7}, {11, 15}, {19, 23}, {24, 56}, {25, 57}, {26, 58}, {27, 63},
-    {28, 60}, {29, 61}, {30, 62}, {31, 59}, {35, 39}, {43,47}, {51, 55}}
-  };
+  std::vector<std::pair<uint_t, uint_t>> pairs = {{{3, 7},
+                                                   {11, 15},
+                                                   {19, 23},
+                                                   {24, 56},
+                                                   {25, 57},
+                                                   {26, 58},
+                                                   {27, 63},
+                                                   {28, 60},
+                                                   {29, 61},
+                                                   {30, 62},
+                                                   {31, 59},
+                                                   {35, 39},
+                                                   {43, 47},
+                                                   {51, 55}}};
   const size_t nq = num_qubits();
-  const reg_t qubits = {{qctrl0, qctrl1, qtrgt,
-                         qctrl0 + nq, qctrl1 + nq, qtrgt + nq}};
+  const reg_t qubits = {
+      {qctrl0, qctrl1, qtrgt, qctrl0 + nq, qctrl1 + nq, qtrgt + nq}};
   BaseVector::apply_permutation_matrix(qubits, pairs);
 }
 
 template <typename data_t>
-double DensityMatrix<data_t>::expval_pauli(const reg_t &qubits,
-                                           const std::string &pauli,const complex_t initial_phase) const {
+double
+DensityMatrix<data_t>::expval_pauli(const reg_t &qubits,
+                                    const std::string &pauli,
+                                    const complex_t initial_phase) const {
 
   uint_t x_mask, z_mask, num_y, x_max;
-  std::tie(x_mask, z_mask, num_y, x_max) = QV::pauli_masks_and_phase(qubits, pauli);
+  std::tie(x_mask, z_mask, num_y, x_max) =
+      QV::pauli_masks_and_phase(qubits, pauli);
 
   // Special case for only I Paulis
   if (x_mask + z_mask == 0) {
     return std::real(BaseMatrix::trace());
   }
 
-  // Size of density matrix 
+  // Size of density matrix
   const size_t nrows = BaseMatrix::rows_;
   const size_t diag_stride = 1 + nrows;
 
   // specialize x_max == 0
   if (!x_mask) {
-    auto lambda = [&](const int_t i, double &val_re, double &val_im)->void {
+    auto lambda = [&](const int_t i, double &val_re, double &val_im) -> void {
       (void)val_im; // unused
       auto val = std::real(BaseVector::data_[i * diag_stride]);
       if (z_mask && (AER::Utils::popcount(i & z_mask) & 1)) {
@@ -411,7 +430,8 @@ double DensityMatrix<data_t>::expval_pauli(const reg_t &qubits,
       }
       val_re += val;
     };
-    return std::real(BaseVector::apply_reduction_lambda(std::move(lambda), size_t(0), nrows));
+    return std::real(BaseVector::apply_reduction_lambda(std::move(lambda),
+                                                        size_t(0), nrows));
   }
 
   auto phase = std::complex<data_t>(initial_phase);
@@ -419,45 +439,46 @@ double DensityMatrix<data_t>::expval_pauli(const reg_t &qubits,
 
   const uint_t mask_u = ~MASKS[x_max + 1];
   const uint_t mask_l = MASKS[x_max];
-  auto lambda = [&](const int_t i, double &val_re, double &val_im)->void {
+  auto lambda = [&](const int_t i, double &val_re, double &val_im) -> void {
     (void)val_im; // unused
     auto idx_vec = ((i << 1) & mask_u) | (i & mask_l);
     auto idx_mat = idx_vec ^ x_mask + nrows * idx_vec;
     // Since rho is hermitian rho[i, j] + rho[j, i] = 2 real(rho[i, j])
     auto val = 2 * std::real(phase * BaseVector::data_[idx_mat]);
     if (z_mask && (AER::Utils::popcount(idx_vec & z_mask) & 1)) {
-      val = - val;
+      val = -val;
     }
     val_re += val;
   };
-  return std::real(BaseVector::apply_reduction_lambda(
-    std::move(lambda), size_t(0), nrows >> 1));
+  return std::real(BaseVector::apply_reduction_lambda(std::move(lambda),
+                                                      size_t(0), nrows >> 1));
 }
 
 template <typename data_t>
-double DensityMatrix<data_t>::expval_pauli_non_diagonal_chunk(const reg_t &qubits,
-                                           const std::string &pauli,const complex_t initial_phase) const 
-{
+double DensityMatrix<data_t>::expval_pauli_non_diagonal_chunk(
+    const reg_t &qubits, const std::string &pauli,
+    const complex_t initial_phase) const {
   uint_t x_mask, z_mask, num_y, x_max;
-  std::tie(x_mask, z_mask, num_y, x_max) = QV::pauli_masks_and_phase(qubits, pauli);
+  std::tie(x_mask, z_mask, num_y, x_max) =
+      QV::pauli_masks_and_phase(qubits, pauli);
 
-  // Size of density matrix 
+  // Size of density matrix
   const size_t nrows = BaseMatrix::rows_;
 
   auto phase = std::complex<data_t>(initial_phase);
   QV::add_y_phase(num_y, phase);
 
-  auto lambda = [&](const int_t i, double &val_re, double &val_im)->void {
+  auto lambda = [&](const int_t i, double &val_re, double &val_im) -> void {
     (void)val_im; // unused
     auto idx_mat = i ^ x_mask + nrows * i;
     auto val = std::real(phase * BaseVector::data_[idx_mat]);
     if (z_mask && (AER::Utils::popcount(i & z_mask) & 1)) {
-      val = - val;
+      val = -val;
     }
     val_re += val;
   };
-  return std::real(BaseVector::apply_reduction_lambda(
-    std::move(lambda), size_t(0), nrows));
+  return std::real(
+      BaseVector::apply_reduction_lambda(std::move(lambda), size_t(0), nrows));
 }
 
 //-----------------------------------------------------------------------
@@ -470,10 +491,8 @@ double DensityMatrix<data_t>::probability(const uint_t outcome) const {
   return std::real(BaseVector::data_[outcome * shift]);
 }
 
-
 template <typename data_t>
-void DensityMatrix<data_t>::apply_reset(const reg_t& qubits)
-{
+void DensityMatrix<data_t>::apply_reset(const reg_t &qubits) {
   // TODO: This can be more efficient by adding reset
   // to base class rather than doing a matrix multiplication
   // where all but 1 row is zeros.
@@ -488,11 +507,11 @@ void DensityMatrix<data_t>::apply_reset(const reg_t& qubits)
 
 // ostream overload for templated qubitvector
 template <typename data_t>
-inline std::ostream &operator<<(std::ostream &out, const AER::QV::DensityMatrix<data_t>&m) {
+inline std::ostream &operator<<(std::ostream &out,
+                                const AER::QV::DensityMatrix<data_t> &m) {
   out << m.copy_to_matrix();
   return out;
 }
 
 //------------------------------------------------------------------------------
 #endif // end module
-
diff --git a/src/simulators/density_matrix/densitymatrix_state.hpp b/src/simulators/density_matrix/densitymatrix_state.hpp
index edac250e67..9f548a895a 100644
--- a/src/simulators/density_matrix/densitymatrix_state.hpp
+++ b/src/simulators/density_matrix/densitymatrix_state.hpp
@@ -37,22 +37,33 @@ using OpType = Operations::OpType;
 // OpSet of supported instructions
 const Operations::OpSet StateOpSet(
     // Op types
-    {OpType::gate, OpType::measure,
-     OpType::reset, OpType::snapshot,
-     OpType::barrier, OpType::bfunc, OpType::qerror_loc,
-     OpType::roerror, OpType::matrix,
-     OpType::diagonal_matrix, OpType::kraus,
-     OpType::superop, OpType::set_statevec,
-     OpType::set_densmat, OpType::save_expval,
-     OpType::save_expval_var, OpType::save_densmat,
-     OpType::save_probs, OpType::save_probs_ket,
-     OpType::save_amps_sq, OpType::save_state,
-     OpType::jump, OpType::mark
-    },
+    {OpType::gate,
+     OpType::measure,
+     OpType::reset,
+     OpType::snapshot,
+     OpType::barrier,
+     OpType::bfunc,
+     OpType::qerror_loc,
+     OpType::roerror,
+     OpType::matrix,
+     OpType::diagonal_matrix,
+     OpType::kraus,
+     OpType::superop,
+     OpType::set_statevec,
+     OpType::set_densmat,
+     OpType::save_expval,
+     OpType::save_expval_var,
+     OpType::save_densmat,
+     OpType::save_probs,
+     OpType::save_probs_ket,
+     OpType::save_amps_sq,
+     OpType::save_state,
+     OpType::jump,
+     OpType::mark},
     // Gates
-    {"U",    "CX",  "u1", "u2",  "u3", "u",   "cx",   "cy",  "cz",
-     "swap", "id",  "x",  "y",   "z",  "h",   "s",    "sdg", "t",
-     "tdg",  "ccx", "r",  "rx",  "ry", "rz",  "rxx",  "ryy", "rzz",
+    {"U",    "CX",  "u1", "u2",  "u3", "u",    "cx",  "cy",    "cz",
+     "swap", "id",  "x",  "y",   "z",  "h",    "s",   "sdg",   "t",
+     "tdg",  "ccx", "r",  "rx",  "ry", "rz",   "rxx", "ryy",   "rzz",
      "rzx",  "p",   "cp", "cu1", "sx", "sxdg", "x90", "delay", "pauli"},
     // Snapshots
     {"density_matrix", "memory", "register", "probabilities",
@@ -61,16 +72,46 @@ const Operations::OpSet StateOpSet(
 
 // Allowed gates enum class
 enum class Gates {
-  u1, u2, u3, r, rx,ry, rz, id, x, y, z, h, s, sdg, sx, sxdg, t, tdg,
-  cx, cy, cz, swap, rxx, ryy, rzz, rzx, ccx, cp, pauli
+  u1,
+  u2,
+  u3,
+  r,
+  rx,
+  ry,
+  rz,
+  id,
+  x,
+  y,
+  z,
+  h,
+  s,
+  sdg,
+  sx,
+  sxdg,
+  t,
+  tdg,
+  cx,
+  cy,
+  cz,
+  swap,
+  rxx,
+  ryy,
+  rzz,
+  rzx,
+  ccx,
+  cp,
+  pauli
 };
 
 // Allowed snapshots enum class
 enum class Snapshots {
-  cmemory, cregister,
+  cmemory,
+  cregister,
   densitymatrix,
-  probs, probs_var,
-  expval_pauli, expval_pauli_var
+  probs,
+  probs_var,
+  expval_pauli,
+  expval_pauli_var
   /* TODO: The following expectation value snapshots still need to be
      implemented */
   //,expval_matrix, expval_matrix_var
@@ -98,8 +139,7 @@ class State : public QuantumState::StateChunk<densmat_t> {
   // Apply an operation
   // If the op is not in allowed_ops an exeption will be raised.
   virtual void apply_op(const int_t iChunk, const Operations::Op &op,
-                        ExperimentResult &result,
-                        RngEngine &rng,
+                        ExperimentResult &result, RngEngine &rng,
                         bool final_op = false) override;
 
   // Initializes an n-qubit state to the all |0> state
@@ -134,25 +174,26 @@ class State : public QuantumState::StateChunk<densmat_t> {
   //-----------------------------------------------------------------------
   // Apply instructions
   //-----------------------------------------------------------------------
-  //apply op to multiple shots , return flase if op is not supported to execute in a batch
+  // apply op to multiple shots , return flase if op is not supported to execute
+  // in a batch
   bool apply_batched_op(const int_t iChunk, const Operations::Op &op,
-                                ExperimentResult &result,
-                                std::vector<RngEngine> &rng,
-                                bool final_op = false) override;
+                        ExperimentResult &result, std::vector<RngEngine> &rng,
+                        bool final_op = false) override;
 
   // Applies a sypported Gate operation to the state class.
   // If the input is not in allowed_gates an exeption will be raised.
   void apply_gate(const int_t iChunk, const Operations::Op &op);
 
-  //apply (multi) control gate by statevector
+  // apply (multi) control gate by statevector
   void apply_gate_statevector(const int_t iChunk, const Operations::Op &op);
 
   // Measure qubits and return a list of outcomes [q0, q1, ...]
   // If a state subclass supports this function it then "measure"
   // should be contained in the set returned by the 'allowed_ops'
   // method.
-  virtual void apply_measure(const int_t iChunk, const reg_t &qubits, const reg_t &cmemory,
-                             const reg_t &cregister, RngEngine &rng);
+  virtual void apply_measure(const int_t iChunk, const reg_t &qubits,
+                             const reg_t &cmemory, const reg_t &cregister,
+                             RngEngine &rng);
 
   // Reset the specified qubits to the |0> state by tracing out qubits
   void apply_reset(const int_t iChunk, const reg_t &qubits);
@@ -160,27 +201,33 @@ class State : public QuantumState::StateChunk<densmat_t> {
   // Apply a supported snapshot instruction
   // If the input is not in allowed_snapshots an exeption will be raised.
   virtual void apply_snapshot(const int_t iChunk, const Operations::Op &op,
-                              ExperimentResult &result,
-                              bool last_op = false);
+                              ExperimentResult &result, bool last_op = false);
 
   // Apply a matrix to given qubits (identity on all other qubits)
-  void apply_matrix(const int_t iChunk, const reg_t &qubits, const cmatrix_t &mat);
+  void apply_matrix(const int_t iChunk, const reg_t &qubits,
+                    const cmatrix_t &mat);
 
   // Apply a vectorized matrix to given qubits (identity on all other qubits)
-  void apply_matrix(const int_t iChunk, const reg_t &qubits, const cvector_t &vmat);
+  void apply_matrix(const int_t iChunk, const reg_t &qubits,
+                    const cvector_t &vmat);
 
-  //apply diagonal matrix
-  void apply_diagonal_unitary_matrix(const int_t iChunk, const reg_t &qubits, const cvector_t & diag);
+  // apply diagonal matrix
+  void apply_diagonal_unitary_matrix(const int_t iChunk, const reg_t &qubits,
+                                     const cvector_t &diag);
 
   // Apply a Kraus error operation
-  void apply_kraus(const int_t iChunk, const reg_t &qubits, const std::vector<cmatrix_t> &kraus);
+  void apply_kraus(const int_t iChunk, const reg_t &qubits,
+                   const std::vector<cmatrix_t> &kraus);
 
   // Apply an N-qubit Pauli gate
-  void apply_pauli(const int_t iChunk, const reg_t &qubits, const std::string &pauli);
+  void apply_pauli(const int_t iChunk, const reg_t &qubits,
+                   const std::string &pauli);
 
   // apply phase
-  void apply_phase(const int_t iChunk, const uint_t qubit, const complex_t phase);
-  void apply_phase(const int_t iChunk, const reg_t& qubits, const complex_t phase);
+  void apply_phase(const int_t iChunk, const uint_t qubit,
+                   const complex_t phase);
+  void apply_phase(const int_t iChunk, const reg_t &qubits,
+                   const complex_t phase);
 
   //-----------------------------------------------------------------------
   // Save data instructions
@@ -188,8 +235,7 @@ class State : public QuantumState::StateChunk<densmat_t> {
 
   // Save the current full density matrix
   void apply_save_state(const int_t iChunk, const Operations::Op &op,
-                        ExperimentResult &result,
-                        bool last_op = false);
+                        ExperimentResult &result, bool last_op = false);
 
   // Save the current density matrix or reduced density matrix
   void apply_save_density_matrix(const int_t iChunk, const Operations::Op &op,
@@ -206,11 +252,13 @@ class State : public QuantumState::StateChunk<densmat_t> {
 
   // Helper function for computing expectation value
   virtual double expval_pauli(const int_t iChunk, const reg_t &qubits,
-                              const std::string& pauli) override;
+                              const std::string &pauli) override;
 
   // Return the reduced density matrix for the simulator
-  cmatrix_t reduced_density_matrix(const int_t iChunk, const reg_t &qubits, bool last_op = false);
-  cmatrix_t reduced_density_matrix_helper(const int_t iChunk, const reg_t &qubits,
+  cmatrix_t reduced_density_matrix(const int_t iChunk, const reg_t &qubits,
+                                   bool last_op = false);
+  cmatrix_t reduced_density_matrix_helper(const int_t iChunk,
+                                          const reg_t &qubits,
                                           const reg_t &qubits_sorted);
 
   //-----------------------------------------------------------------------
@@ -232,10 +280,12 @@ class State : public QuantumState::StateChunk<densmat_t> {
   // 1 -> |q1 = 0, q0 = 1> state
   // 2 -> |q1 = 1, q0 = 0> state
   // 3 -> |q1 = 1, q0 = 1> state
-  std::pair<uint_t, double> sample_measure_with_prob(const int_t iChunk, const reg_t &qubits,
+  std::pair<uint_t, double> sample_measure_with_prob(const int_t iChunk,
+                                                     const reg_t &qubits,
                                                      RngEngine &rng);
 
-  void measure_reset_update(const int_t iChunk, const std::vector<uint_t> &qubits,
+  void measure_reset_update(const int_t iChunk,
+                            const std::vector<uint_t> &qubits,
                             const uint_t final_state, const uint_t meas_state,
                             const double meas_prob);
 
@@ -249,28 +299,27 @@ class State : public QuantumState::StateChunk<densmat_t> {
 
   // Snapshot reduced density matrix
   void snapshot_density_matrix(const int_t iChunk, const Operations::Op &op,
-                               ExperimentResult &result,
-                               bool last_op = false);
-                          
+                               ExperimentResult &result, bool last_op = false);
+
   // Snapshot current qubit probabilities for a measurement (average)
-  void snapshot_probabilities(const int_t iChunk, const Operations::Op &op, ExperimentResult &result,
-                              bool variance);
+  void snapshot_probabilities(const int_t iChunk, const Operations::Op &op,
+                              ExperimentResult &result, bool variance);
 
   // Snapshot the expectation value of a Pauli operator
-  void snapshot_pauli_expval(const int_t iChunk, const Operations::Op &op, ExperimentResult &result,
-                             bool variance);
+  void snapshot_pauli_expval(const int_t iChunk, const Operations::Op &op,
+                             ExperimentResult &result, bool variance);
 
   // Snapshot the expectation value of a matrix operator
-  void snapshot_matrix_expval(const int_t iChunk, const Operations::Op &op, ExperimentResult &result,
-                              bool variance);
+  void snapshot_matrix_expval(const int_t iChunk, const Operations::Op &op,
+                              ExperimentResult &result, bool variance);
 
   //-----------------------------------------------------------------------
   // Single-qubit gate helpers
   //-----------------------------------------------------------------------
 
   // Apply a waltz gate specified by parameters u3(theta, phi, lambda)
-  void apply_gate_u3(const int_t iChunk, const uint_t qubit, const double theta, const double phi,
-                     const double lambda);
+  void apply_gate_u3(const int_t iChunk, const uint_t qubit, const double theta,
+                     const double phi, const double lambda);
 
   //-----------------------------------------------------------------------
   // Config Settings
@@ -290,20 +339,18 @@ class State : public QuantumState::StateChunk<densmat_t> {
   // Table of allowed snapshot types to enum class members
   const static stringmap_t<Snapshots> snapshotset_;
 
-  //scale for density matrix = 2
-  //this function is used in the base class to scale chunk qubits for multi-chunk distribution
-  int qubit_scale(void) override
-  {
-    return 2;
-  }
+  // scale for density matrix = 2
+  // this function is used in the base class to scale chunk qubits for
+  // multi-chunk distribution
+  int qubit_scale(void) override { return 2; }
 
   //-----------------------------------------------------------------------
-  //Functions for multi-chunk distribution
+  // Functions for multi-chunk distribution
   //-----------------------------------------------------------------------
-  //swap between chunks
+  // swap between chunks
   void apply_chunk_swap(const reg_t &qubits) override;
 
-  //apply multiple swaps between chunks
+  // apply multiple swaps between chunks
   void apply_multi_chunk_swap(const reg_t &qubits) override;
 };
 
@@ -314,29 +361,29 @@ class State : public QuantumState::StateChunk<densmat_t> {
 template <class densmat_t>
 const stringmap_t<Gates> State<densmat_t>::gateset_({
     // Single qubit gates
-    {"delay", Gates::id},// Delay gate
-    {"id", Gates::id},   // Pauli-Identity gate
-    {"x", Gates::x},     // Pauli-X gate
-    {"y", Gates::y},     // Pauli-Y gate
-    {"z", Gates::z},     // Pauli-Z gate
-    {"s", Gates::s},     // Phase gate (aka sqrt(Z) gate)
-    {"sdg", Gates::sdg}, // Conjugate-transpose of Phase gate
-    {"h", Gates::h},     // Hadamard gate (X + Z / sqrt(2))
-    {"t", Gates::t},     // T-gate (sqrt(S))
-    {"tdg", Gates::tdg}, // Conjguate-transpose of T gate
-    {"x90", Gates::sx},  // Pi/2 X (equiv to Sqrt(X) gate)
-    {"sx", Gates::sx},   // Sqrt(X) gate
-    {"sxdg", Gates::sxdg},// Inverse Sqrt(X) gate
-    {"r", Gates::r},     // R rotation gate
-    {"rx", Gates::rx},   // Pauli-X rotation gate
-    {"ry", Gates::ry},   // Pauli-Y rotation gate
-    {"rz", Gates::rz},   // Pauli-Z rotation gate
+    {"delay", Gates::id},  // Delay gate
+    {"id", Gates::id},     // Pauli-Identity gate
+    {"x", Gates::x},       // Pauli-X gate
+    {"y", Gates::y},       // Pauli-Y gate
+    {"z", Gates::z},       // Pauli-Z gate
+    {"s", Gates::s},       // Phase gate (aka sqrt(Z) gate)
+    {"sdg", Gates::sdg},   // Conjugate-transpose of Phase gate
+    {"h", Gates::h},       // Hadamard gate (X + Z / sqrt(2))
+    {"t", Gates::t},       // T-gate (sqrt(S))
+    {"tdg", Gates::tdg},   // Conjguate-transpose of T gate
+    {"x90", Gates::sx},    // Pi/2 X (equiv to Sqrt(X) gate)
+    {"sx", Gates::sx},     // Sqrt(X) gate
+    {"sxdg", Gates::sxdg}, // Inverse Sqrt(X) gate
+    {"r", Gates::r},       // R rotation gate
+    {"rx", Gates::rx},     // Pauli-X rotation gate
+    {"ry", Gates::ry},     // Pauli-Y rotation gate
+    {"rz", Gates::rz},     // Pauli-Z rotation gate
     // Waltz Gates
     {"p", Gates::u1},  // Phase gate
     {"u1", Gates::u1}, // zero-X90 pulse waltz gate
     {"u2", Gates::u2}, // single-X90 pulse waltz gate
     {"u3", Gates::u3}, // two X90 pulse waltz gate
-    {"u", Gates::u3}, // two X90 pulse waltz gate
+    {"u", Gates::u3},  // two X90 pulse waltz gate
     {"U", Gates::u3},  // two X90 pulse waltz gate
     // Two-qubit gates
     {"CX", Gates::cx},     // Controlled-X gate (CNOT)
@@ -351,7 +398,7 @@ const stringmap_t<Gates> State<densmat_t>::gateset_({
     {"rzz", Gates::rzz},   // Pauli-ZZ rotation gate
     {"rzx", Gates::rzx},   // Pauli-ZX rotation gate
     // Three-qubit gates
-    {"ccx", Gates::ccx},   // Controlled-CX gate (Toffoli)
+    {"ccx", Gates::ccx}, // Controlled-CX gate (Toffoli)
     // Pauli gate
     {"pauli", Gates::pauli} // Multi-qubit Pauli gate
 });
@@ -374,129 +421,142 @@ const stringmap_t<Snapshots> State<densmat_t>::snapshotset_(
 // Initialization
 //-------------------------------------------------------------------------
 template <class densmat_t>
-void State<densmat_t>::initialize_qreg(uint_t num_qubits) 
-{
-  if(BaseState::qregs_.size() == 0)
-    BaseState::allocate(num_qubits,num_qubits,1);
+void State<densmat_t>::initialize_qreg(uint_t num_qubits) {
+  if (BaseState::qregs_.size() == 0)
+    BaseState::allocate(num_qubits, num_qubits, 1);
   initialize_omp();
 
-  for(int_t i=0;i<BaseState::qregs_.size();i++){
+  for (int_t i = 0; i < BaseState::qregs_.size(); i++) {
     BaseState::qregs_[i].set_num_qubits(BaseState::chunk_bits_);
   }
 
-  if(BaseState::multi_chunk_distribution_){
-    if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0){
-#pragma omp parallel for 
-      for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-        for(int_t iChunk = BaseState::top_chunk_of_group_[ig];iChunk < BaseState::top_chunk_of_group_[ig + 1];iChunk++){
-          if(BaseState::global_chunk_index_ + iChunk == 0){
+  if (BaseState::multi_chunk_distribution_) {
+    if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0) {
+#pragma omp parallel for
+      for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+        for (int_t iChunk = BaseState::top_chunk_of_group_[ig];
+             iChunk < BaseState::top_chunk_of_group_[ig + 1]; iChunk++) {
+          if (BaseState::global_chunk_index_ + iChunk == 0) {
             BaseState::qregs_[iChunk].initialize();
-          }
-          else{
+          } else {
             BaseState::qregs_[iChunk].zero();
           }
         }
       }
-    }
-    else{
-      for(int_t i=0;i<BaseState::qregs_.size();i++){
-        if(BaseState::global_chunk_index_ + i == 0){
+    } else {
+      for (int_t i = 0; i < BaseState::qregs_.size(); i++) {
+        if (BaseState::global_chunk_index_ + i == 0) {
           BaseState::qregs_[i].initialize();
-        }
-        else{
+        } else {
           BaseState::qregs_[i].zero();
         }
       }
     }
-  }
-  else{
-    for(int_t i=0;i<BaseState::qregs_.size();i++){
+  } else {
+    for (int_t i = 0; i < BaseState::qregs_.size(); i++) {
       BaseState::qregs_[i].initialize();
     }
   }
 }
 
-template <class densmat_t> void State<densmat_t>::initialize_omp() 
-{
+template <class densmat_t> void State<densmat_t>::initialize_omp() {
   uint_t i;
-  for(i=0;i<BaseState::qregs_.size();i++){
+  for (i = 0; i < BaseState::qregs_.size(); i++) {
     BaseState::qregs_[i].set_omp_threshold(omp_qubit_threshold_);
     if (BaseState::threads_ > 0)
-      BaseState::qregs_[i].set_omp_threads(BaseState::threads_); // set allowed OMP threads in qubitvector
+      BaseState::qregs_[i].set_omp_threads(
+          BaseState::threads_); // set allowed OMP threads in qubitvector
   }
 }
 
 template <class densmat_t>
 template <typename list_t>
-void State<densmat_t>::initialize_from_vector(const int_t iChunkIn, const list_t &vec)
-{
-  if((1ull << (BaseState::num_qubits_*2)) == vec.size()){
+void State<densmat_t>::initialize_from_vector(const int_t iChunkIn,
+                                              const list_t &vec) {
+  if ((1ull << (BaseState::num_qubits_ * 2)) == vec.size()) {
     BaseState::initialize_from_vector(iChunkIn, vec);
-  }
-  else if((1ull << (BaseState::num_qubits_*2)) == vec.size() * vec.size()) {
+  } else if ((1ull << (BaseState::num_qubits_ * 2)) ==
+             vec.size() * vec.size()) {
     int_t iChunk;
-    if(BaseState::multi_chunk_distribution_){
-      if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0){
-#pragma omp parallel for 
-        for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-          for(int_t iChunk = BaseState::top_chunk_of_group_[ig];iChunk < BaseState::top_chunk_of_group_[ig + 1];iChunk++){
-            uint_t irow_chunk = ((iChunk + BaseState::global_chunk_index_) >> ((BaseState::num_qubits_ - BaseState::chunk_bits_))) << (BaseState::chunk_bits_);
-            uint_t icol_chunk = ((iChunk + BaseState::global_chunk_index_) & ((1ull << ((BaseState::num_qubits_ - BaseState::chunk_bits_)))-1)) << (BaseState::chunk_bits_);
-
-            //copy part of state for this chunk
-            uint_t i,row,col;
+    if (BaseState::multi_chunk_distribution_) {
+      if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0) {
+#pragma omp parallel for
+        for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+          for (int_t iChunk = BaseState::top_chunk_of_group_[ig];
+               iChunk < BaseState::top_chunk_of_group_[ig + 1]; iChunk++) {
+            uint_t irow_chunk =
+                ((iChunk + BaseState::global_chunk_index_) >>
+                 ((BaseState::num_qubits_ - BaseState::chunk_bits_)))
+                << (BaseState::chunk_bits_);
+            uint_t icol_chunk = ((iChunk + BaseState::global_chunk_index_) &
+                                 ((1ull << ((BaseState::num_qubits_ -
+                                             BaseState::chunk_bits_))) -
+                                  1))
+                                << (BaseState::chunk_bits_);
+
+            // copy part of state for this chunk
+            uint_t i, row, col;
             list_t vec1(1ull << BaseState::chunk_bits_);
             list_t vec2(1ull << BaseState::chunk_bits_);
 
-            for(i=0;i<(1ull << BaseState::chunk_bits_);i++){
+            for (i = 0; i < (1ull << BaseState::chunk_bits_); i++) {
               vec1[i] = vec[(irow_chunk << BaseState::chunk_bits_) + i];
-              vec2[i] = std::conj(vec[(icol_chunk << BaseState::chunk_bits_) + i]);
+              vec2[i] =
+                  std::conj(vec[(icol_chunk << BaseState::chunk_bits_) + i]);
             }
-            BaseState::qregs_[iChunk].initialize_from_vector(AER::Utils::tensor_product(vec1, vec2));
+            BaseState::qregs_[iChunk].initialize_from_vector(
+                AER::Utils::tensor_product(vec1, vec2));
           }
         }
-      }
-      else{
-        for(iChunk=0;iChunk<BaseState::qregs_.size();iChunk++){
-          uint_t irow_chunk = ((iChunk + BaseState::global_chunk_index_) >> ((BaseState::num_qubits_ - BaseState::chunk_bits_))) << (BaseState::chunk_bits_);
-          uint_t icol_chunk = ((iChunk + BaseState::global_chunk_index_) & ((1ull << ((BaseState::num_qubits_ - BaseState::chunk_bits_)))-1)) << (BaseState::chunk_bits_);
-
-          //copy part of state for this chunk
-          uint_t i,row,col;
+      } else {
+        for (iChunk = 0; iChunk < BaseState::qregs_.size(); iChunk++) {
+          uint_t irow_chunk =
+              ((iChunk + BaseState::global_chunk_index_) >>
+               ((BaseState::num_qubits_ - BaseState::chunk_bits_)))
+              << (BaseState::chunk_bits_);
+          uint_t icol_chunk =
+              ((iChunk + BaseState::global_chunk_index_) &
+               ((1ull << ((BaseState::num_qubits_ - BaseState::chunk_bits_))) -
+                1))
+              << (BaseState::chunk_bits_);
+
+          // copy part of state for this chunk
+          uint_t i, row, col;
           list_t vec1(1ull << BaseState::chunk_bits_);
           list_t vec2(1ull << BaseState::chunk_bits_);
 
-          for(i=0;i<(1ull << BaseState::chunk_bits_);i++){
+          for (i = 0; i < (1ull << BaseState::chunk_bits_); i++) {
             vec1[i] = vec[(irow_chunk << BaseState::chunk_bits_) + i];
-            vec2[i] = std::conj(vec[(icol_chunk << BaseState::chunk_bits_) + i]);
+            vec2[i] =
+                std::conj(vec[(icol_chunk << BaseState::chunk_bits_) + i]);
           }
-          BaseState::qregs_[iChunk].initialize_from_vector(AER::Utils::tensor_product(vec1, vec2));
+          BaseState::qregs_[iChunk].initialize_from_vector(
+              AER::Utils::tensor_product(vec1, vec2));
         }
       }
+    } else {
+      BaseState::qregs_[iChunkIn].initialize_from_vector(
+          AER::Utils::tensor_product(AER::Utils::conjugate(vec), vec));
     }
-    else{
-      BaseState::qregs_[iChunkIn].initialize_from_vector(AER::Utils::tensor_product(AER::Utils::conjugate(vec), vec));
-    }
-  }
-  else {
-    throw std::runtime_error("DensityMatrixChunk::initialize input vector is incorrect length. Expected: " +
-                             std::to_string((1ull << (BaseState::num_qubits_*2))) + " Received: " +
-                             std::to_string(vec.size()));
+  } else {
+    throw std::runtime_error(
+        "DensityMatrixChunk::initialize input vector is incorrect length. "
+        "Expected: " +
+        std::to_string((1ull << (BaseState::num_qubits_ * 2))) +
+        " Received: " + std::to_string(vec.size()));
   }
 }
 
 template <class densmat_t>
-auto State<densmat_t>::move_to_matrix(const int_t iChunk)
-{
-  if(!BaseState::multi_chunk_distribution_)
+auto State<densmat_t>::move_to_matrix(const int_t iChunk) {
+  if (!BaseState::multi_chunk_distribution_)
     return BaseState::qregs_[iChunk].move_to_matrix();
   return BaseState::apply_to_matrix(false);
 }
 
 template <class densmat_t>
-auto State<densmat_t>::copy_to_matrix(const int_t iChunk)
-{
-  if(!BaseState::multi_chunk_distribution_)
+auto State<densmat_t>::copy_to_matrix(const int_t iChunk) {
+  if (!BaseState::multi_chunk_distribution_)
     return BaseState::qregs_[iChunk].copy_to_matrix();
   return BaseState::apply_to_matrix(true);
 }
@@ -507,23 +567,21 @@ auto State<densmat_t>::copy_to_matrix(const int_t iChunk)
 
 template <class densmat_t>
 size_t State<densmat_t>::required_memory_mb(
-    uint_t num_qubits, const std::vector<Operations::Op> &ops) const 
-{
+    uint_t num_qubits, const std::vector<Operations::Op> &ops) const {
   (void)ops; // avoid unused variable compiler warning
   (void)ops; // avoid unused variable compiler warning
   densmat_t tmp;
-  return tmp.required_memory_mb(2*num_qubits);
+  return tmp.required_memory_mb(2 * num_qubits);
 }
 
 template <class densmat_t>
-void State<densmat_t>::set_config(const json_t &config) 
-{
+void State<densmat_t>::set_config(const json_t &config) {
   BaseState::set_config(config);
 
   // Set threshold for truncating snapshots
   JSON::get_value(json_chop_threshold_, "chop_threshold", config);
   uint_t i;
-  for(i=0;i<BaseState::qregs_.size();i++){
+  for (i = 0; i < BaseState::qregs_.size(); i++) {
     BaseState::qregs_[i].set_json_chop_threshold(json_chop_threshold_);
   }
 
@@ -532,126 +590,127 @@ void State<densmat_t>::set_config(const json_t &config)
                   config);
 }
 
-
 //=========================================================================
 // Implementation: apply operations
 //=========================================================================
 
 template <class densmat_t>
 void State<densmat_t>::apply_op(const int_t iChunk, const Operations::Op &op,
-                                 ExperimentResult &result,
-                                 RngEngine &rng,
-                                 bool final_ops) 
-{
-  if(BaseState::check_conditional(iChunk, op)) {
+                                ExperimentResult &result, RngEngine &rng,
+                                bool final_ops) {
+  if (BaseState::check_conditional(iChunk, op)) {
     switch (op.type) {
-      case OpType::barrier:
-      case OpType::qerror_loc:
-        break;
-      case OpType::reset:
-        apply_reset(iChunk, op.qubits);
-        break;
-      case OpType::measure:
-        apply_measure(iChunk, op.qubits, op.memory, op.registers, rng);
-        break;
-      case OpType::bfunc:
-        BaseState::cregs_[0].apply_bfunc(op);
-        break;
-      case OpType::roerror:
-        BaseState::cregs_[0].apply_roerror(op, rng);
-        break;
-      case OpType::gate:
-        apply_gate(iChunk, op);
-        break;
-      case OpType::snapshot:
-        apply_snapshot(iChunk, op, result, final_ops);
-        break;
-      case OpType::matrix:
-        apply_matrix(iChunk, op.qubits, op.mats[0]);
-        break;
-      case OpType::diagonal_matrix:
-        apply_diagonal_unitary_matrix(iChunk, op.qubits, op.params);
-        break;
-      case OpType::superop:
-        BaseState::qregs_[iChunk].apply_superop_matrix(op.qubits, Utils::vectorize_matrix(op.mats[0]));
-        break;
-      case OpType::kraus:
-        apply_kraus(iChunk, op.qubits, op.mats);
-        break;
-      case OpType::set_statevec:
-        initialize_from_vector(iChunk, op.params);
-        break;
-      case OpType::set_densmat:
-        BaseState::initialize_from_matrix(iChunk, op.mats[0]);
-        break;
-      case OpType::save_expval:
-      case OpType::save_expval_var:
-        BaseState::apply_save_expval(iChunk, op, result);
-        break;
-      case OpType::save_state:
-        apply_save_state(iChunk, op, result, final_ops);
-        break;
-      case OpType::save_densmat:
-        apply_save_density_matrix(iChunk, op, result, final_ops);
-        break;
-      case OpType::save_probs:
-      case OpType::save_probs_ket:
-        apply_save_probs(iChunk, op, result);
-        break;
-      case OpType::save_amps_sq:
-        apply_save_amplitudes_sq(iChunk, op, result);
-        break;
-      default:
-        throw std::invalid_argument("DensityMatrix::State::invalid instruction \'" +
-                                    op.name + "\'.");
-    }
-  }
-}
-
-template <class densmat_t>
-bool State<densmat_t>::apply_batched_op(const int_t iChunk, const Operations::Op &op,
-                                  ExperimentResult &result,
-                                  std::vector<RngEngine> &rng,
-                                  bool final_ops) 
-{
-  if(op.conditional)
-    BaseState::qregs_[iChunk].set_conditional(op.conditional_reg);
-
-  switch (op.type) {
     case OpType::barrier:
-    case OpType::nop:
     case OpType::qerror_loc:
       break;
     case OpType::reset:
-      BaseState::qregs_[iChunk].apply_reset(op.qubits);
+      apply_reset(iChunk, op.qubits);
       break;
     case OpType::measure:
-      BaseState::qregs_[iChunk].apply_batched_measure(op.qubits,rng,op.memory,op.registers);
+      apply_measure(iChunk, op.qubits, op.memory, op.registers, rng);
       break;
     case OpType::bfunc:
-      BaseState::qregs_[iChunk].apply_bfunc(op);
+      BaseState::cregs_[0].apply_bfunc(op);
       break;
     case OpType::roerror:
-      BaseState::qregs_[iChunk].apply_roerror(op, rng);
+      BaseState::cregs_[0].apply_roerror(op, rng);
       break;
     case OpType::gate:
       apply_gate(iChunk, op);
       break;
+    case OpType::snapshot:
+      apply_snapshot(iChunk, op, result, final_ops);
+      break;
     case OpType::matrix:
       apply_matrix(iChunk, op.qubits, op.mats[0]);
       break;
     case OpType::diagonal_matrix:
-      BaseState::qregs_[iChunk].apply_diagonal_unitary_matrix(op.qubits, op.params);
+      apply_diagonal_unitary_matrix(iChunk, op.qubits, op.params);
       break;
     case OpType::superop:
-      BaseState::qregs_[iChunk].apply_superop_matrix(op.qubits, Utils::vectorize_matrix(op.mats[0]));
+      BaseState::qregs_[iChunk].apply_superop_matrix(
+          op.qubits, Utils::vectorize_matrix(op.mats[0]));
       break;
     case OpType::kraus:
       apply_kraus(iChunk, op.qubits, op.mats);
       break;
+    case OpType::set_statevec:
+      initialize_from_vector(iChunk, op.params);
+      break;
+    case OpType::set_densmat:
+      BaseState::initialize_from_matrix(iChunk, op.mats[0]);
+      break;
+    case OpType::save_expval:
+    case OpType::save_expval_var:
+      BaseState::apply_save_expval(iChunk, op, result);
+      break;
+    case OpType::save_state:
+      apply_save_state(iChunk, op, result, final_ops);
+      break;
+    case OpType::save_densmat:
+      apply_save_density_matrix(iChunk, op, result, final_ops);
+      break;
+    case OpType::save_probs:
+    case OpType::save_probs_ket:
+      apply_save_probs(iChunk, op, result);
+      break;
+    case OpType::save_amps_sq:
+      apply_save_amplitudes_sq(iChunk, op, result);
+      break;
     default:
-      //other operations should be called to indivisual chunks by apply_op
-      return false;
+      throw std::invalid_argument(
+          "DensityMatrix::State::invalid instruction \'" + op.name + "\'.");
+    }
+  }
+}
+
+template <class densmat_t>
+bool State<densmat_t>::apply_batched_op(const int_t iChunk,
+                                        const Operations::Op &op,
+                                        ExperimentResult &result,
+                                        std::vector<RngEngine> &rng,
+                                        bool final_ops) {
+  if (op.conditional)
+    BaseState::qregs_[iChunk].set_conditional(op.conditional_reg);
+
+  switch (op.type) {
+  case OpType::barrier:
+  case OpType::nop:
+  case OpType::qerror_loc:
+    break;
+  case OpType::reset:
+    BaseState::qregs_[iChunk].apply_reset(op.qubits);
+    break;
+  case OpType::measure:
+    BaseState::qregs_[iChunk].apply_batched_measure(op.qubits, rng, op.memory,
+                                                    op.registers);
+    break;
+  case OpType::bfunc:
+    BaseState::qregs_[iChunk].apply_bfunc(op);
+    break;
+  case OpType::roerror:
+    BaseState::qregs_[iChunk].apply_roerror(op, rng);
+    break;
+  case OpType::gate:
+    apply_gate(iChunk, op);
+    break;
+  case OpType::matrix:
+    apply_matrix(iChunk, op.qubits, op.mats[0]);
+    break;
+  case OpType::diagonal_matrix:
+    BaseState::qregs_[iChunk].apply_diagonal_unitary_matrix(op.qubits,
+                                                            op.params);
+    break;
+  case OpType::superop:
+    BaseState::qregs_[iChunk].apply_superop_matrix(
+        op.qubits, Utils::vectorize_matrix(op.mats[0]));
+    break;
+  case OpType::kraus:
+    apply_kraus(iChunk, op.qubits, op.mats);
+    break;
+  default:
+    // other operations should be called to indivisual chunks by apply_op
+    return false;
   }
   return true;
 }
@@ -661,9 +720,9 @@ bool State<densmat_t>::apply_batched_op(const int_t iChunk, const Operations::Op
 //=========================================================================
 
 template <class densmat_t>
-void State<densmat_t>::apply_save_probs(const int_t iChunk, const Operations::Op &op,
-                                            ExperimentResult &result) 
-{
+void State<densmat_t>::apply_save_probs(const int_t iChunk,
+                                        const Operations::Op &op,
+                                        ExperimentResult &result) {
   auto probs = measure_probs(iChunk, op.qubits);
   auto cr = this->creg(BaseState::get_global_shot_index(iChunk));
   if (op.type == OpType::save_probs_ket) {
@@ -671,132 +730,151 @@ void State<densmat_t>::apply_save_probs(const int_t iChunk, const Operations::Op
                              Utils::vec2ket(probs, json_chop_threshold_, 16),
                              op.type, op.save_type);
   } else {
-    result.save_data_average(cr, op.string_params[0],
-                             std::move(probs), op.type, op.save_type);
+    result.save_data_average(cr, op.string_params[0], std::move(probs), op.type,
+                             op.save_type);
   }
 }
 
 template <class densmat_t>
-void State<densmat_t>::apply_save_amplitudes_sq(const int_t iChunkIn, const Operations::Op &op,
+void State<densmat_t>::apply_save_amplitudes_sq(const int_t iChunkIn,
+                                                const Operations::Op &op,
                                                 ExperimentResult &result) {
   if (op.int_params.empty()) {
-    throw std::invalid_argument("Invalid save_amplitudes_sq instructions (empty params).");
+    throw std::invalid_argument(
+        "Invalid save_amplitudes_sq instructions (empty params).");
   }
   const int_t size = op.int_params.size();
   rvector_t amps_sq(size);
 
-  if(BaseState::multi_chunk_distribution_){
+  if (BaseState::multi_chunk_distribution_) {
     int_t iChunk;
-#pragma omp parallel for if(BaseState::chunk_omp_parallel_) private(iChunk) 
-    for(iChunk=0;iChunk<BaseState::qregs_.size();iChunk++){
-      uint_t irow,icol;
-      irow = (BaseState::global_chunk_index_ + iChunk) >> ((BaseState::num_qubits_ - BaseState::chunk_bits_));
-      icol = (BaseState::global_chunk_index_ + iChunk) - (irow << ((BaseState::num_qubits_ - BaseState::chunk_bits_)));
-      if(irow != icol)
+#pragma omp parallel for if (BaseState::chunk_omp_parallel_) private(iChunk)
+    for (iChunk = 0; iChunk < BaseState::qregs_.size(); iChunk++) {
+      uint_t irow, icol;
+      irow = (BaseState::global_chunk_index_ + iChunk) >>
+             ((BaseState::num_qubits_ - BaseState::chunk_bits_));
+      icol = (BaseState::global_chunk_index_ + iChunk) -
+             (irow << ((BaseState::num_qubits_ - BaseState::chunk_bits_)));
+      if (irow != icol)
         continue;
 
-#pragma omp parallel for if (size > pow(2, omp_qubit_threshold_) &&        \
-                                 BaseState::threads_ > 1 && !BaseState::chunk_omp_parallel_)  \
-                          num_threads(BaseState::threads_)
+#pragma omp parallel for if (size > pow(2, omp_qubit_threshold_) &&            \
+                             BaseState::threads_ > 1 &&                        \
+                             !BaseState::chunk_omp_parallel_)                  \
+    num_threads(BaseState::threads_)
       for (int_t i = 0; i < size; ++i) {
         uint_t idx = BaseState::mapped_index(op.int_params[i]);
-        if(idx >= (irow << BaseState::chunk_bits_) && idx < ((irow+1) << BaseState::chunk_bits_))
-          amps_sq[i] = BaseState::qregs_[iChunk].probability(idx - (irow << BaseState::chunk_bits_));
+        if (idx >= (irow << BaseState::chunk_bits_) &&
+            idx < ((irow + 1) << BaseState::chunk_bits_))
+          amps_sq[i] = BaseState::qregs_[iChunk].probability(
+              idx - (irow << BaseState::chunk_bits_));
       }
     }
 #ifdef AER_MPI
-  BaseState::reduce_sum(amps_sq);
-#endif  
-  }
-  else{
-#pragma omp parallel for if (size > pow(2, omp_qubit_threshold_) &&        \
-                                 BaseState::threads_ > 1)                       \
-                          num_threads(BaseState::threads_)
+    BaseState::reduce_sum(amps_sq);
+#endif
+  } else {
+#pragma omp parallel for if (size > pow(2, omp_qubit_threshold_) &&            \
+                             BaseState::threads_ > 1)                          \
+    num_threads(BaseState::threads_)
     for (int_t i = 0; i < size; ++i) {
       amps_sq[i] = BaseState::qregs_[iChunkIn].probability(op.int_params[i]);
     }
   }
   auto cr = this->creg(BaseState::get_global_shot_index(iChunkIn));
-  result.save_data_average(cr, op.string_params[0],
-                           std::move(amps_sq), op.type, op.save_type);
+  result.save_data_average(cr, op.string_params[0], std::move(amps_sq), op.type,
+                           op.save_type);
 }
 
 template <class densmat_t>
 double State<densmat_t>::expval_pauli(const int_t iChunk, const reg_t &qubits,
-                                      const std::string& pauli)  {
-  if(!BaseState::multi_chunk_distribution_)
+                                      const std::string &pauli) {
+  if (!BaseState::multi_chunk_distribution_)
     return BaseState::qregs_[iChunk].expval_pauli(qubits, pauli);
 
   reg_t qubits_in_chunk;
   reg_t qubits_out_chunk;
   std::string pauli_in_chunk;
   std::string pauli_out_chunk;
-  int_t i,n;
+  int_t i, n;
   double expval(0.);
 
-  //get inner/outer chunk pauli string
+  // get inner/outer chunk pauli string
   n = pauli.size();
-  for(i=0;i<n;i++){
-    if(qubits[i] < BaseState::chunk_bits_){
+  for (i = 0; i < n; i++) {
+    if (qubits[i] < BaseState::chunk_bits_) {
       qubits_in_chunk.push_back(qubits[i]);
-      pauli_in_chunk.push_back(pauli[n-i-1]);
-    }
-    else{
+      pauli_in_chunk.push_back(pauli[n - i - 1]);
+    } else {
       qubits_out_chunk.push_back(qubits[i]);
-      pauli_out_chunk.push_back(pauli[n-i-1]);
+      pauli_out_chunk.push_back(pauli[n - i - 1]);
     }
   }
 
   int_t nrows = 1ull << ((BaseState::num_qubits_ - BaseState::chunk_bits_));
 
-  if(qubits_out_chunk.size() > 0){  //there are bits out of chunk
+  if (qubits_out_chunk.size() > 0) { // there are bits out of chunk
     std::complex<double> phase = 1.0;
 
-    std::reverse(pauli_out_chunk.begin(),pauli_out_chunk.end());
-    std::reverse(pauli_in_chunk.begin(),pauli_in_chunk.end());
+    std::reverse(pauli_out_chunk.begin(), pauli_out_chunk.end());
+    std::reverse(pauli_in_chunk.begin(), pauli_in_chunk.end());
 
     uint_t x_mask, z_mask, num_y, x_max;
-    std::tie(x_mask, z_mask, num_y, x_max) = AER::QV::pauli_masks_and_phase(qubits_out_chunk, pauli_out_chunk);
+    std::tie(x_mask, z_mask, num_y, x_max) =
+        AER::QV::pauli_masks_and_phase(qubits_out_chunk, pauli_out_chunk);
 
     z_mask >>= (BaseState::chunk_bits_);
-    if(x_mask != 0){
+    if (x_mask != 0) {
       x_mask >>= (BaseState::chunk_bits_);
       x_max -= (BaseState::chunk_bits_);
 
-      AER::QV::add_y_phase(num_y,phase);
+      AER::QV::add_y_phase(num_y, phase);
 
       const uint_t mask_u = ~((1ull << (x_max + 1)) - 1);
       const uint_t mask_l = (1ull << x_max) - 1;
 
-      for(i=0;i<nrows/2;i++){
+      for (i = 0; i < nrows / 2; i++) {
         uint_t irow = ((i << 1) & mask_u) | (i & mask_l);
         uint_t iChunk = (irow ^ x_mask) + irow * nrows;
 
-        if(BaseState::chunk_index_begin_[BaseState::distributed_rank_] <= iChunk && BaseState::chunk_index_end_[BaseState::distributed_rank_] > iChunk){  //on this process
+        if (BaseState::chunk_index_begin_[BaseState::distributed_rank_] <=
+                iChunk &&
+            BaseState::chunk_index_end_[BaseState::distributed_rank_] >
+                iChunk) { // on this process
           double sign = 2.0;
           if (z_mask && (AER::Utils::popcount(irow & z_mask) & 1))
             sign = -2.0;
-          expval += sign * BaseState::qregs_[iChunk-BaseState::global_chunk_index_].expval_pauli_non_diagonal_chunk(qubits_in_chunk, pauli_in_chunk,phase);
+          expval += sign *
+                    BaseState::qregs_[iChunk - BaseState::global_chunk_index_]
+                        .expval_pauli_non_diagonal_chunk(qubits_in_chunk,
+                                                         pauli_in_chunk, phase);
         }
       }
-    }
-    else{
-      for(i=0;i<nrows;i++){
-        uint_t iChunk = i * (nrows+1);
-        if(BaseState::chunk_index_begin_[BaseState::distributed_rank_] <= iChunk && BaseState::chunk_index_end_[BaseState::distributed_rank_] > iChunk){  //on this process
+    } else {
+      for (i = 0; i < nrows; i++) {
+        uint_t iChunk = i * (nrows + 1);
+        if (BaseState::chunk_index_begin_[BaseState::distributed_rank_] <=
+                iChunk &&
+            BaseState::chunk_index_end_[BaseState::distributed_rank_] >
+                iChunk) { // on this process
           double sign = 1.0;
           if (z_mask && (AER::Utils::popcount(i & z_mask) & 1))
             sign = -1.0;
-          expval += sign * BaseState::qregs_[iChunk-BaseState::global_chunk_index_].expval_pauli(qubits_in_chunk, pauli_in_chunk,1.0);
+          expval +=
+              sign * BaseState::qregs_[iChunk - BaseState::global_chunk_index_]
+                         .expval_pauli(qubits_in_chunk, pauli_in_chunk, 1.0);
         }
       }
     }
-  }
-  else{ //all bits are inside chunk
-    for(i=0;i<nrows;i++){
-      uint_t iChunk = i * (nrows+1);
-      if(BaseState::chunk_index_begin_[BaseState::distributed_rank_] <= iChunk && BaseState::chunk_index_end_[BaseState::distributed_rank_] > iChunk){  //on this process
-        expval += BaseState::qregs_[iChunk-BaseState::global_chunk_index_].expval_pauli(qubits, pauli,1.0);
+  } else { // all bits are inside chunk
+    for (i = 0; i < nrows; i++) {
+      uint_t iChunk = i * (nrows + 1);
+      if (BaseState::chunk_index_begin_[BaseState::distributed_rank_] <=
+              iChunk &&
+          BaseState::chunk_index_end_[BaseState::distributed_rank_] >
+              iChunk) { // on this process
+        expval += BaseState::qregs_[iChunk - BaseState::global_chunk_index_]
+                      .expval_pauli(qubits, pauli, 1.0);
       }
     }
   }
@@ -808,7 +886,8 @@ double State<densmat_t>::expval_pauli(const int_t iChunk, const reg_t &qubits,
 }
 
 template <class densmat_t>
-void State<densmat_t>::apply_save_density_matrix(const int_t iChunk, const Operations::Op &op,
+void State<densmat_t>::apply_save_density_matrix(const int_t iChunk,
+                                                 const Operations::Op &op,
                                                  ExperimentResult &result,
                                                  bool last_op) {
   auto cr = this->creg(BaseState::get_global_shot_index(iChunk));
@@ -818,32 +897,30 @@ void State<densmat_t>::apply_save_density_matrix(const int_t iChunk, const Opera
 }
 
 template <class densmat_t>
-void State<densmat_t>::apply_save_state(const int_t iChunk, const Operations::Op &op,
+void State<densmat_t>::apply_save_state(const int_t iChunk,
+                                        const Operations::Op &op,
                                         ExperimentResult &result,
-                                        bool last_op) 
-{
+                                        bool last_op) {
   if (op.qubits.size() != BaseState::num_qubits_) {
-    throw std::invalid_argument(
-        op.name + " was not applied to all qubits."
-        " Only the full state can be saved.");
+    throw std::invalid_argument(op.name + " was not applied to all qubits."
+                                          " Only the full state can be saved.");
   }
   // Renamp single data type to average
   Operations::DataSubType save_type;
   switch (op.save_type) {
-    case Operations::DataSubType::single:
-      save_type = Operations::DataSubType::average;
-      break;
-    case Operations::DataSubType::c_single:
-      save_type = Operations::DataSubType::c_average;
-      break;
-    default:
-      save_type = op.save_type;
+  case Operations::DataSubType::single:
+    save_type = Operations::DataSubType::average;
+    break;
+  case Operations::DataSubType::c_single:
+    save_type = Operations::DataSubType::c_average;
+    break;
+  default:
+    save_type = op.save_type;
   }
 
   // Default key
-  std::string key = (op.string_params[0] == "_method_")
-                      ? "density_matrix"
-                      : op.string_params[0];
+  std::string key = (op.string_params[0] == "_method_") ? "density_matrix"
+                                                        : op.string_params[0];
   auto cr = this->creg(BaseState::get_global_shot_index(iChunk));
   if (last_op) {
     result.save_data_average(cr, key, move_to_matrix(iChunk),
@@ -854,21 +931,20 @@ void State<densmat_t>::apply_save_state(const int_t iChunk, const Operations::Op
   }
 }
 
-
 template <class densmat_t>
-cmatrix_t State<densmat_t>::reduced_density_matrix(const int_t iChunk, const reg_t& qubits, bool last_op) 
-{
+cmatrix_t State<densmat_t>::reduced_density_matrix(const int_t iChunk,
+                                                   const reg_t &qubits,
+                                                   bool last_op) {
   cmatrix_t reduced_state;
 
   // Check if tracing over all qubits
   if (qubits.empty()) {
     reduced_state = cmatrix_t(1, 1);
-    if(!BaseState::multi_chunk_distribution_){
+    if (!BaseState::multi_chunk_distribution_) {
       reduced_state[0] = BaseState::qregs_[iChunk].trace();
-    }
-    else{
+    } else {
       std::complex<double> sum = 0.0;
-      for(int_t i=0;i<BaseState::qregs_.size();i++){
+      for (int_t i = 0; i < BaseState::qregs_.size(); i++) {
         sum += BaseState::qregs_[i].trace();
       }
 #ifdef AER_MPI
@@ -881,27 +957,29 @@ cmatrix_t State<densmat_t>::reduced_density_matrix(const int_t iChunk, const reg
     auto qubits_sorted = qubits;
     std::sort(qubits_sorted.begin(), qubits_sorted.end());
 
-    if ((qubits.size() == BaseState::num_qubits_) && (qubits == qubits_sorted)) {
+    if ((qubits.size() == BaseState::num_qubits_) &&
+        (qubits == qubits_sorted)) {
       if (last_op) {
         reduced_state = move_to_matrix(iChunk);
       } else {
         reduced_state = copy_to_matrix(iChunk);
       }
     } else {
-      reduced_state = reduced_density_matrix_helper(iChunk, qubits, qubits_sorted);
+      reduced_state =
+          reduced_density_matrix_helper(iChunk, qubits, qubits_sorted);
     }
   }
   return reduced_state;
 }
 
 template <class densmat_t>
-cmatrix_t State<densmat_t>::reduced_density_matrix_helper(const int_t iChunkIn, const reg_t &qubits,
-                                          const reg_t &qubits_sorted) 
-{
-  if(!BaseState::multi_chunk_distribution_){
+cmatrix_t State<densmat_t>::reduced_density_matrix_helper(
+    const int_t iChunkIn, const reg_t &qubits, const reg_t &qubits_sorted) {
+  if (!BaseState::multi_chunk_distribution_) {
     // Get superoperator qubits
     const reg_t squbits = BaseState::qregs_[iChunkIn].superop_qubits(qubits);
-    const reg_t squbits_sorted = BaseState::qregs_[iChunkIn].superop_qubits(qubits_sorted);
+    const reg_t squbits_sorted =
+        BaseState::qregs_[iChunkIn].superop_qubits(qubits_sorted);
 
     // Get dimensions
     const size_t N = qubits.size();
@@ -931,62 +1009,71 @@ cmatrix_t State<densmat_t>::reduced_density_matrix_helper(const int_t iChunkIn,
   }
 
   int_t iChunk;
-  uint_t size = 1ull << (BaseState::chunk_bits_*2);
+  uint_t size = 1ull << (BaseState::chunk_bits_ * 2);
   uint_t mask = (1ull << (BaseState::chunk_bits_)) - 1;
   uint_t num_threads = BaseState::qregs_[0].get_omp_threads();
 
-  size_t size_required = (sizeof(std::complex<double>) << (qubits.size()*2)) + (sizeof(std::complex<double>) << (BaseState::chunk_bits_*2))*BaseState::num_local_chunks_;
-  if((size_required>>20) > Utils::get_system_memory_mb()){
-    throw std::runtime_error(std::string("There is not enough memory to store density matrix"));
+  size_t size_required =
+      (sizeof(std::complex<double>) << (qubits.size() * 2)) +
+      (sizeof(std::complex<double>) << (BaseState::chunk_bits_ * 2)) *
+          BaseState::num_local_chunks_;
+  if ((size_required >> 20) > Utils::get_system_memory_mb()) {
+    throw std::runtime_error(
+        std::string("There is not enough memory to store density matrix"));
   }
-  cmatrix_t reduced_state(1ull << qubits.size(),1ull << qubits.size(),true);
+  cmatrix_t reduced_state(1ull << qubits.size(), 1ull << qubits.size(), true);
 
-  if(BaseState::distributed_rank_ == 0){
+  if (BaseState::distributed_rank_ == 0) {
     auto tmp = BaseState::qregs_[0].copy_to_matrix();
-    for(iChunk=0;iChunk<BaseState::num_global_chunks_;iChunk++){
+    for (iChunk = 0; iChunk < BaseState::num_global_chunks_; iChunk++) {
       int_t i;
-      uint_t irow_chunk = (iChunk >> ((BaseState::num_qubits_ - BaseState::chunk_bits_))) << BaseState::chunk_bits_;
-      uint_t icol_chunk = (iChunk & ((1ull << ((BaseState::num_qubits_ - BaseState::chunk_bits_)))-1)) << BaseState::chunk_bits_;
-
-      if(iChunk < BaseState::num_local_chunks_)
+      uint_t irow_chunk =
+          (iChunk >> ((BaseState::num_qubits_ - BaseState::chunk_bits_)))
+          << BaseState::chunk_bits_;
+      uint_t icol_chunk =
+          (iChunk &
+           ((1ull << ((BaseState::num_qubits_ - BaseState::chunk_bits_))) - 1))
+          << BaseState::chunk_bits_;
+
+      if (iChunk < BaseState::num_local_chunks_)
         tmp = BaseState::qregs_[iChunk].copy_to_matrix();
 #ifdef AER_MPI
       else
-        BaseState::recv_data(tmp.data(),size,0,iChunk);
+        BaseState::recv_data(tmp.data(), size, 0, iChunk);
 #endif
-#pragma omp parallel for if(num_threads > 1) num_threads(num_threads)
-      for(i=0;i<size;i++){
+#pragma omp parallel for if (num_threads > 1) num_threads(num_threads)
+      for (i = 0; i < size; i++) {
         uint_t irow = (i >> (BaseState::chunk_bits_)) + irow_chunk;
         uint_t icol = (i & mask) + icol_chunk;
         uint_t irow_out = 0;
         uint_t icol_out = 0;
         int j;
-        for(j=0;j<qubits.size();j++){
-          if((irow >> qubits[j]) & 1){
+        for (j = 0; j < qubits.size(); j++) {
+          if ((irow >> qubits[j]) & 1) {
             irow &= ~(1ull << qubits[j]);
             irow_out += (1ull << j);
           }
-          if((icol >> qubits[j]) & 1){
+          if ((icol >> qubits[j]) & 1) {
             icol &= ~(1ull << qubits[j]);
             icol_out += (1ull << j);
           }
         }
-        if(irow == icol){   //only diagonal base can be reduced
+        if (irow == icol) { // only diagonal base can be reduced
           uint_t idx = ((irow_out) << qubits.size()) + icol_out;
 #pragma omp critical
           reduced_state[idx] += tmp[i];
         }
       }
     }
-  }
-  else{
+  } else {
 #ifdef AER_MPI
-    //send matrices to process 0
-    for(iChunk=0;iChunk<BaseState::num_global_chunks_;iChunk++){
+    // send matrices to process 0
+    for (iChunk = 0; iChunk < BaseState::num_global_chunks_; iChunk++) {
       uint_t iProc = BaseState::get_process_by_chunk(iChunk);
-      if(iProc == BaseState::distributed_rank_){
-        auto tmp = BaseState::qregs_[iChunk-BaseState::global_chunk_index_].copy_to_matrix();
-        BaseState::send_data(tmp.data(),size,iChunk,0);
+      if (iProc == BaseState::distributed_rank_) {
+        auto tmp = BaseState::qregs_[iChunk - BaseState::global_chunk_index_]
+                       .copy_to_matrix();
+        BaseState::send_data(tmp.data(), size, iChunk, 0);
       }
     }
 #endif
@@ -1000,9 +1087,9 @@ cmatrix_t State<densmat_t>::reduced_density_matrix_helper(const int_t iChunkIn,
 //=========================================================================
 
 template <class densmat_t>
-void State<densmat_t>::apply_snapshot(const int_t iChunk, const Operations::Op &op,
-                                      ExperimentResult &result,
-                                      bool last_op) {
+void State<densmat_t>::apply_snapshot(const int_t iChunk,
+                                      const Operations::Op &op,
+                                      ExperimentResult &result, bool last_op) {
 
   // Look for snapshot type in snapshotset
   auto it = snapshotset_.find(op.name);
@@ -1011,66 +1098,64 @@ void State<densmat_t>::apply_snapshot(const int_t iChunk, const Operations::Op &
         "DensityMatrixState::invalid snapshot instruction \'" + op.name +
         "\'.");
   switch (it->second) {
-    case Snapshots::densitymatrix:
-      snapshot_density_matrix(iChunk, op, result, last_op);
-      break;
-    case Snapshots::cmemory:
-      BaseState::snapshot_creg_memory(iChunk, op, result);
-      break;
-    case Snapshots::cregister:
-      BaseState::snapshot_creg_register(iChunk, op, result);
-      break;
-    case Snapshots::probs:
-      // get probs as hexadecimal
-      snapshot_probabilities(iChunk, op, result, false);
-      break;
-    case Snapshots::probs_var:
-      // get probs as hexadecimal
-      snapshot_probabilities(iChunk, op, result, true);
-      break;
-    case Snapshots::expval_pauli: {
-      snapshot_pauli_expval(iChunk, op, result, false);
-    } break;
-    case Snapshots::expval_pauli_var: {
-      snapshot_pauli_expval(iChunk, op, result, true);
-    } break;
-    /* TODO
-    case Snapshots::expval_matrix: {
-      snapshot_matrix_expval(op, result, false);
-    }  break;
-    case Snapshots::expval_matrix_var: {
-      snapshot_matrix_expval(op, result, true);
-    }  break;
-    */
-    default:
-      // We shouldn't get here unless there is a bug in the snapshotset
-      throw std::invalid_argument(
+  case Snapshots::densitymatrix:
+    snapshot_density_matrix(iChunk, op, result, last_op);
+    break;
+  case Snapshots::cmemory:
+    BaseState::snapshot_creg_memory(iChunk, op, result);
+    break;
+  case Snapshots::cregister:
+    BaseState::snapshot_creg_register(iChunk, op, result);
+    break;
+  case Snapshots::probs:
+    // get probs as hexadecimal
+    snapshot_probabilities(iChunk, op, result, false);
+    break;
+  case Snapshots::probs_var:
+    // get probs as hexadecimal
+    snapshot_probabilities(iChunk, op, result, true);
+    break;
+  case Snapshots::expval_pauli: {
+    snapshot_pauli_expval(iChunk, op, result, false);
+  } break;
+  case Snapshots::expval_pauli_var: {
+    snapshot_pauli_expval(iChunk, op, result, true);
+  } break;
+  /* TODO
+  case Snapshots::expval_matrix: {
+    snapshot_matrix_expval(op, result, false);
+  }  break;
+  case Snapshots::expval_matrix_var: {
+    snapshot_matrix_expval(op, result, true);
+  }  break;
+  */
+  default:
+    // We shouldn't get here unless there is a bug in the snapshotset
+    throw std::invalid_argument(
         "DensityMatrix::State::invalid snapshot instruction \'" + op.name +
         "\'.");
   }
 }
 
 template <class densmat_t>
-void State<densmat_t>::snapshot_probabilities(const int_t iChunk, const Operations::Op &op,
+void State<densmat_t>::snapshot_probabilities(const int_t iChunk,
+                                              const Operations::Op &op,
                                               ExperimentResult &result,
-                                              bool variance) 
-{
+                                              bool variance) {
   int_t ishot = BaseState::get_global_shot_index(iChunk);
   // get probs as hexadecimal
   auto probs = Utils::vec2ket(measure_probs(iChunk, op.qubits),
                               json_chop_threshold_, 16);
-  result.legacy_data.add_average_snapshot("probabilities",
-                            op.string_params[0],
-                            BaseState::cregs_[ishot].memory_hex(),
-                            std::move(probs),
-                            variance);
+  result.legacy_data.add_average_snapshot("probabilities", op.string_params[0],
+                                          BaseState::cregs_[ishot].memory_hex(),
+                                          std::move(probs), variance);
 }
 
 template <class densmat_t>
-void State<densmat_t>::snapshot_pauli_expval(const int_t iChunk, const Operations::Op &op,
+void State<densmat_t>::snapshot_pauli_expval(const int_t iChunk,
+                                             const Operations::Op &op,
                                              ExperimentResult &result,
-                                             bool variance) 
-{
+                                             bool variance) {
   // Check empty edge case
   if (op.params_expval_pauli.empty()) {
     throw std::invalid_argument(
@@ -1088,20 +1173,21 @@ void State<densmat_t>::snapshot_pauli_expval(const int_t iChunk, const Operation
 
   // Add to snapshot
   Utils::chop_inplace(expval, json_chop_threshold_);
-  result.legacy_data.add_average_snapshot("expectation_value", op.string_params[0],
-                            BaseState::cregs_[ishot].memory_hex(), expval, variance);
+  result.legacy_data.add_average_snapshot(
+      "expectation_value", op.string_params[0],
+      BaseState::cregs_[ishot].memory_hex(), expval, variance);
 }
 
 template <class densmat_t>
-void State<densmat_t>::snapshot_density_matrix(const int_t iChunk, const Operations::Op &op,
+void State<densmat_t>::snapshot_density_matrix(const int_t iChunk,
+                                               const Operations::Op &op,
                                                ExperimentResult &result,
-                                               bool last_op) 
-{
+                                               bool last_op) {
   int_t ishot = BaseState::get_global_shot_index(iChunk);
-  result.legacy_data.add_average_snapshot("density_matrix", op.string_params[0],
-                                          BaseState::cregs_[ishot].memory_hex(),
-                                          reduced_density_matrix(iChunk, op.qubits, last_op),
-                                          false);
+  result.legacy_data.add_average_snapshot(
+      "density_matrix", op.string_params[0],
+      BaseState::cregs_[ishot].memory_hex(),
+      reduced_density_matrix(iChunk, op.qubits, last_op), false);
 }
 
 //=========================================================================
@@ -1109,36 +1195,40 @@ void State<densmat_t>::snapshot_density_matrix(const int_t iChunk, const Operati
 //=========================================================================
 
 template <class densmat_t>
-void State<densmat_t>::apply_gate(const int_t iChunk, const Operations::Op &op) 
-{
-  if(!BaseState::global_chunk_indexing_){
-    reg_t qubits_in,qubits_out;
+void State<densmat_t>::apply_gate(const int_t iChunk,
+                                  const Operations::Op &op) {
+  if (!BaseState::global_chunk_indexing_) {
+    reg_t qubits_in, qubits_out;
     bool ctrl_chunk = true;
     bool ctrl_chunk_sp = true;
-    BaseState::get_inout_ctrl_qubits(op,qubits_out,qubits_in);
-    if(qubits_out.size() > 0){
+    BaseState::get_inout_ctrl_qubits(op, qubits_out, qubits_in);
+    if (qubits_out.size() > 0) {
       uint_t mask = 0;
-      for(int i=0;i<qubits_out.size();i++){
+      for (int i = 0; i < qubits_out.size(); i++) {
         mask |= (1ull << (qubits_out[i] - BaseState::chunk_bits_));
       }
-      if(((BaseState::global_chunk_index_ + iChunk) & mask) != mask){
+      if (((BaseState::global_chunk_index_ + iChunk) & mask) != mask) {
         ctrl_chunk = false;
       }
-      if((((BaseState::global_chunk_index_ + iChunk) >> (BaseState::num_qubits_ - BaseState::chunk_bits_)) & mask) != mask){
+      if ((((BaseState::global_chunk_index_ + iChunk) >>
+            (BaseState::num_qubits_ - BaseState::chunk_bits_)) &
+           mask) != mask) {
         ctrl_chunk_sp = false;
       }
-      if(!ctrl_chunk && !ctrl_chunk_sp)
-        return;   //do nothing for this chunk
-      else{
-        Operations::Op new_op = BaseState::remake_gate_in_chunk_qubits(op,qubits_in);
-        if(ctrl_chunk && ctrl_chunk_sp)
-          apply_gate(iChunk,new_op);  //apply gate by using op with internal qubits
-        else if(ctrl_chunk)
-          apply_gate_statevector(iChunk,new_op);
-        else{
-          for(int i=0;i<new_op.qubits.size();i++)
+      if (!ctrl_chunk && !ctrl_chunk_sp)
+        return; // do nothing for this chunk
+      else {
+        Operations::Op new_op =
+            BaseState::remake_gate_in_chunk_qubits(op, qubits_in);
+        if (ctrl_chunk && ctrl_chunk_sp)
+          apply_gate(iChunk,
+                     new_op); // apply gate by using op with internal qubits
+        else if (ctrl_chunk)
+          apply_gate_statevector(iChunk, new_op);
+        else {
+          for (int i = 0; i < new_op.qubits.size(); i++)
             new_op.qubits[i] += BaseState::chunk_bits_;
-          apply_gate_statevector(iChunk,new_op);
+          apply_gate_statevector(iChunk, new_op);
         }
         return;
       }
@@ -1151,195 +1241,212 @@ void State<densmat_t>::apply_gate(const int_t iChunk, const Operations::Op &op)
     throw std::invalid_argument(
         "DensityMatrixState::invalid gate instruction \'" + op.name + "\'.");
   switch (it->second) {
-    case Gates::u3:
-      apply_gate_u3(iChunk, op.qubits[0], std::real(op.params[0]),
-                    std::real(op.params[1]), std::real(op.params[2]));
-      break;
-    case Gates::u2:
-      apply_gate_u3(iChunk, op.qubits[0], M_PI / 2., std::real(op.params[0]),
-                    std::real(op.params[1]));
-      break;
-    case Gates::u1:
-      apply_phase(iChunk, op.qubits[0], std::exp(complex_t(0., 1.) * op.params[0]));
-      break;
-    case Gates::cx:
-      BaseState::qregs_[iChunk].apply_cnot(op.qubits[0], op.qubits[1]);
-      break;
-    case Gates::cy:
-      BaseState::qregs_[iChunk].apply_cy(op.qubits[0], op.qubits[1]);
-      break;
-    case Gates::cz:
-      BaseState::qregs_[iChunk].apply_cphase(op.qubits[0], op.qubits[1], -1);
-      break;
-    case Gates::cp:
-      BaseState::qregs_[iChunk].apply_cphase(op.qubits[0], op.qubits[1],
-                                    std::exp(complex_t(0., 1.) * op.params[0]));
-      break;
-    case Gates::id:
-      break;
-    case Gates::x:
-      BaseState::qregs_[iChunk].apply_x(op.qubits[0]);
-      break;
-    case Gates::y:
-      BaseState::qregs_[iChunk].apply_y(op.qubits[0]);
-      break;
-    case Gates::z:
-      apply_phase(iChunk, op.qubits[0], -1);
-      break;
-    case Gates::h:
-      apply_gate_u3(iChunk, op.qubits[0], M_PI / 2., 0., M_PI);
-      break;
-    case Gates::s:
-      apply_phase(iChunk, op.qubits[0], complex_t(0., 1.));
-      break;
-    case Gates::sdg:
-      apply_phase(iChunk, op.qubits[0], complex_t(0., -1.));
-      break;
-    case Gates::sx:
-      BaseState::qregs_[iChunk].apply_unitary_matrix(op.qubits, Linalg::VMatrix::SX);
-      break;
-    case Gates::sxdg:
-      BaseState::qregs_[iChunk].apply_unitary_matrix(op.qubits, Linalg::VMatrix::SXDG);
-      break;
-    case Gates::t: {
-      const double isqrt2{1. / std::sqrt(2)};
-      apply_phase(iChunk, op.qubits[0], complex_t(isqrt2, isqrt2));
-    } break;
-    case Gates::tdg: {
-      const double isqrt2{1. / std::sqrt(2)};
-      apply_phase(iChunk, op.qubits[0], complex_t(isqrt2, -isqrt2));
-    } break;
-    case Gates::swap: {
-      BaseState::qregs_[iChunk].apply_swap(op.qubits[0], op.qubits[1]);
-    } break;
-    case Gates::ccx:
-      BaseState::qregs_[iChunk].apply_toffoli(op.qubits[0], op.qubits[1], op.qubits[2]);
-      break;
-    case Gates::r:
-      BaseState::qregs_[iChunk].apply_unitary_matrix(op.qubits, Linalg::VMatrix::r(op.params[0], op.params[1]));
-      break;
-    case Gates::rx:
-      BaseState::qregs_[iChunk].apply_unitary_matrix(op.qubits, Linalg::VMatrix::rx(op.params[0]));
-      break;
-    case Gates::ry:
-      BaseState::qregs_[iChunk].apply_unitary_matrix(op.qubits, Linalg::VMatrix::ry(op.params[0]));
-      break;
-    case Gates::rz:
-      apply_diagonal_unitary_matrix(iChunk, op.qubits, Linalg::VMatrix::rz_diag(op.params[0]));
-      break;
-    case Gates::rxx:
-      BaseState::qregs_[iChunk].apply_unitary_matrix(op.qubits, Linalg::VMatrix::rxx(op.params[0]));
-      break;
-    case Gates::ryy:
-      BaseState::qregs_[iChunk].apply_unitary_matrix(op.qubits, Linalg::VMatrix::ryy(op.params[0]));
-      break;
-    case Gates::rzz:
-      apply_diagonal_unitary_matrix(iChunk, op.qubits, Linalg::VMatrix::rzz_diag(op.params[0]));
-      break;
-    case Gates::rzx:
-      BaseState::qregs_[iChunk].apply_unitary_matrix(op.qubits, Linalg::VMatrix::rzx(op.params[0]));
-      break;
-    case Gates::pauli:
-      apply_pauli(iChunk, op.qubits, op.string_params[0]);
-      break;
-    default:
-      // We shouldn't reach here unless there is a bug in gateset
-      throw std::invalid_argument(
+  case Gates::u3:
+    apply_gate_u3(iChunk, op.qubits[0], std::real(op.params[0]),
+                  std::real(op.params[1]), std::real(op.params[2]));
+    break;
+  case Gates::u2:
+    apply_gate_u3(iChunk, op.qubits[0], M_PI / 2., std::real(op.params[0]),
+                  std::real(op.params[1]));
+    break;
+  case Gates::u1:
+    apply_phase(iChunk, op.qubits[0],
+                std::exp(complex_t(0., 1.) * op.params[0]));
+    break;
+  case Gates::cx:
+    BaseState::qregs_[iChunk].apply_cnot(op.qubits[0], op.qubits[1]);
+    break;
+  case Gates::cy:
+    BaseState::qregs_[iChunk].apply_cy(op.qubits[0], op.qubits[1]);
+    break;
+  case Gates::cz:
+    BaseState::qregs_[iChunk].apply_cphase(op.qubits[0], op.qubits[1], -1);
+    break;
+  case Gates::cp:
+    BaseState::qregs_[iChunk].apply_cphase(
+        op.qubits[0], op.qubits[1], std::exp(complex_t(0., 1.) * op.params[0]));
+    break;
+  case Gates::id:
+    break;
+  case Gates::x:
+    BaseState::qregs_[iChunk].apply_x(op.qubits[0]);
+    break;
+  case Gates::y:
+    BaseState::qregs_[iChunk].apply_y(op.qubits[0]);
+    break;
+  case Gates::z:
+    apply_phase(iChunk, op.qubits[0], -1);
+    break;
+  case Gates::h:
+    apply_gate_u3(iChunk, op.qubits[0], M_PI / 2., 0., M_PI);
+    break;
+  case Gates::s:
+    apply_phase(iChunk, op.qubits[0], complex_t(0., 1.));
+    break;
+  case Gates::sdg:
+    apply_phase(iChunk, op.qubits[0], complex_t(0., -1.));
+    break;
+  case Gates::sx:
+    BaseState::qregs_[iChunk].apply_unitary_matrix(op.qubits,
+                                                   Linalg::VMatrix::SX);
+    break;
+  case Gates::sxdg:
+    BaseState::qregs_[iChunk].apply_unitary_matrix(op.qubits,
+                                                   Linalg::VMatrix::SXDG);
+    break;
+  case Gates::t: {
+    const double isqrt2{1. / std::sqrt(2)};
+    apply_phase(iChunk, op.qubits[0], complex_t(isqrt2, isqrt2));
+  } break;
+  case Gates::tdg: {
+    const double isqrt2{1. / std::sqrt(2)};
+    apply_phase(iChunk, op.qubits[0], complex_t(isqrt2, -isqrt2));
+  } break;
+  case Gates::swap: {
+    BaseState::qregs_[iChunk].apply_swap(op.qubits[0], op.qubits[1]);
+  } break;
+  case Gates::ccx:
+    BaseState::qregs_[iChunk].apply_toffoli(op.qubits[0], op.qubits[1],
+                                            op.qubits[2]);
+    break;
+  case Gates::r:
+    BaseState::qregs_[iChunk].apply_unitary_matrix(
+        op.qubits, Linalg::VMatrix::r(op.params[0], op.params[1]));
+    break;
+  case Gates::rx:
+    BaseState::qregs_[iChunk].apply_unitary_matrix(
+        op.qubits, Linalg::VMatrix::rx(op.params[0]));
+    break;
+  case Gates::ry:
+    BaseState::qregs_[iChunk].apply_unitary_matrix(
+        op.qubits, Linalg::VMatrix::ry(op.params[0]));
+    break;
+  case Gates::rz:
+    apply_diagonal_unitary_matrix(iChunk, op.qubits,
+                                  Linalg::VMatrix::rz_diag(op.params[0]));
+    break;
+  case Gates::rxx:
+    BaseState::qregs_[iChunk].apply_unitary_matrix(
+        op.qubits, Linalg::VMatrix::rxx(op.params[0]));
+    break;
+  case Gates::ryy:
+    BaseState::qregs_[iChunk].apply_unitary_matrix(
+        op.qubits, Linalg::VMatrix::ryy(op.params[0]));
+    break;
+  case Gates::rzz:
+    apply_diagonal_unitary_matrix(iChunk, op.qubits,
+                                  Linalg::VMatrix::rzz_diag(op.params[0]));
+    break;
+  case Gates::rzx:
+    BaseState::qregs_[iChunk].apply_unitary_matrix(
+        op.qubits, Linalg::VMatrix::rzx(op.params[0]));
+    break;
+  case Gates::pauli:
+    apply_pauli(iChunk, op.qubits, op.string_params[0]);
+    break;
+  default:
+    // We shouldn't reach here unless there is a bug in gateset
+    throw std::invalid_argument(
         "DensityMatrix::State::invalid gate instruction \'" + op.name + "\'.");
   }
 }
 
 template <class densmat_t>
-void State<densmat_t>::apply_gate_statevector(const int_t iChunk, const Operations::Op &op)
-{
+void State<densmat_t>::apply_gate_statevector(const int_t iChunk,
+                                              const Operations::Op &op) {
   // Look for gate name in gateset
   auto it = gateset_.find(op.name);
   if (it == gateset_.end())
     throw std::invalid_argument(
         "DensityMatrixState::invalid gate instruction \'" + op.name + "\'.");
   switch (it->second) {
-    case Gates::x:
-    case Gates::cx:
-      BaseState::qregs_[iChunk].apply_mcx(op.qubits);
-      break;
-    case Gates::u1:
-      if(op.qubits[op.qubits.size()-1] < BaseState::chunk_bits_){
-        BaseState::qregs_[iChunk].apply_mcphase(op.qubits,
-                                    std::exp(complex_t(0., 1.) * op.params[0]));
-      }
-      else{
-        BaseState::qregs_[iChunk].apply_mcphase(op.qubits,
-                                    std::conj(std::exp(complex_t(0., 1.) * op.params[0])));
-      }
-      break;
-    case Gates::y:
-      BaseState::qregs_[iChunk].apply_mcy(op.qubits);
-      break;
-    case Gates::z:
-      BaseState::qregs_[iChunk].apply_mcphase(op.qubits, -1);
-      break;
-    default:
-      // We shouldn't reach here unless there is a bug in gateset
-      throw std::invalid_argument(
+  case Gates::x:
+  case Gates::cx:
+    BaseState::qregs_[iChunk].apply_mcx(op.qubits);
+    break;
+  case Gates::u1:
+    if (op.qubits[op.qubits.size() - 1] < BaseState::chunk_bits_) {
+      BaseState::qregs_[iChunk].apply_mcphase(
+          op.qubits, std::exp(complex_t(0., 1.) * op.params[0]));
+    } else {
+      BaseState::qregs_[iChunk].apply_mcphase(
+          op.qubits, std::conj(std::exp(complex_t(0., 1.) * op.params[0])));
+    }
+    break;
+  case Gates::y:
+    BaseState::qregs_[iChunk].apply_mcy(op.qubits);
+    break;
+  case Gates::z:
+    BaseState::qregs_[iChunk].apply_mcphase(op.qubits, -1);
+    break;
+  default:
+    // We shouldn't reach here unless there is a bug in gateset
+    throw std::invalid_argument(
         "DensityMatrix::State::invalid gate instruction \'" + op.name + "\'.");
   }
 }
 
 template <class densmat_t>
-void State<densmat_t>::apply_matrix(const int_t iChunk, const reg_t &qubits, const cmatrix_t &mat) {
+void State<densmat_t>::apply_matrix(const int_t iChunk, const reg_t &qubits,
+                                    const cmatrix_t &mat) {
   if (mat.GetRows() == 1) {
-    apply_diagonal_unitary_matrix(iChunk, 
-        qubits, Utils::vectorize_matrix(mat));
+    apply_diagonal_unitary_matrix(iChunk, qubits, Utils::vectorize_matrix(mat));
   } else {
-    BaseState::qregs_[iChunk].apply_unitary_matrix(qubits, Utils::vectorize_matrix(mat));
+    BaseState::qregs_[iChunk].apply_unitary_matrix(
+        qubits, Utils::vectorize_matrix(mat));
   }
 }
 
 template <class densmat_t>
-void State<densmat_t>::apply_gate_u3(const int_t iChunk, uint_t qubit, double theta, double phi,
-                                     double lambda) {
+void State<densmat_t>::apply_gate_u3(const int_t iChunk, uint_t qubit,
+                                     double theta, double phi, double lambda) {
   BaseState::qregs_[iChunk].apply_unitary_matrix(
       reg_t({qubit}), Linalg::VMatrix::u3(theta, phi, lambda));
 }
 
 template <class densmat_t>
-void State<densmat_t>::apply_diagonal_unitary_matrix(const int_t iChunk, const reg_t &qubits, const cvector_t & diag)
-{
-  if(BaseState::global_chunk_indexing_ || !BaseState::multi_chunk_distribution_){
-    //GPU computes all chunks in one kernel, so pass qubits and diagonal matrix as is
-    BaseState::qregs_[iChunk].apply_diagonal_unitary_matrix(qubits,diag);
-  }
-  else{
+void State<densmat_t>::apply_diagonal_unitary_matrix(const int_t iChunk,
+                                                     const reg_t &qubits,
+                                                     const cvector_t &diag) {
+  if (BaseState::global_chunk_indexing_ ||
+      !BaseState::multi_chunk_distribution_) {
+    // GPU computes all chunks in one kernel, so pass qubits and diagonal matrix
+    // as is
+    BaseState::qregs_[iChunk].apply_diagonal_unitary_matrix(qubits, diag);
+  } else {
     reg_t qubits_in = qubits;
     reg_t qubits_row = qubits;
     cvector_t diag_in = diag;
     cvector_t diag_row = diag;
 
-    BaseState::block_diagonal_matrix(iChunk,qubits_in,diag_in);
+    BaseState::block_diagonal_matrix(iChunk, qubits_in, diag_in);
 
-    if(qubits_in.size() == qubits.size()){
-      BaseState::qregs_[iChunk].apply_diagonal_unitary_matrix(qubits,diag);
-    }
-    else{
-      for(int_t i=0;i<qubits.size();i++){
-        if(qubits[i] >= BaseState::chunk_bits_)
-          qubits_row[i] = qubits[i] + BaseState::num_qubits_ - BaseState::chunk_bits_;
+    if (qubits_in.size() == qubits.size()) {
+      BaseState::qregs_[iChunk].apply_diagonal_unitary_matrix(qubits, diag);
+    } else {
+      for (int_t i = 0; i < qubits.size(); i++) {
+        if (qubits[i] >= BaseState::chunk_bits_)
+          qubits_row[i] =
+              qubits[i] + BaseState::num_qubits_ - BaseState::chunk_bits_;
       }
-      BaseState::block_diagonal_matrix(iChunk,qubits_row,diag_row);
+      BaseState::block_diagonal_matrix(iChunk, qubits_row, diag_row);
 
-      reg_t qubits_chunk(qubits_in.size()*2);
-      for(int_t i=0;i<qubits_in.size();i++){
+      reg_t qubits_chunk(qubits_in.size() * 2);
+      for (int_t i = 0; i < qubits_in.size(); i++) {
         qubits_chunk[i] = qubits_in[i];
-        qubits_chunk[i+qubits_in.size()] = qubits_in[i] + BaseState::chunk_bits_;
+        qubits_chunk[i + qubits_in.size()] =
+            qubits_in[i] + BaseState::chunk_bits_;
       }
-      BaseState::qregs_[iChunk].apply_diagonal_matrix(qubits_chunk,AER::Utils::tensor_product(AER::Utils::conjugate(diag_row),diag_in));
+      BaseState::qregs_[iChunk].apply_diagonal_matrix(
+          qubits_chunk,
+          AER::Utils::tensor_product(AER::Utils::conjugate(diag_row), diag_in));
     }
   }
 }
 
 template <class densmat_t>
-void State<densmat_t>::apply_phase(const int_t iChunk, const uint_t qubit, const complex_t phase)
-{
+void State<densmat_t>::apply_phase(const int_t iChunk, const uint_t qubit,
+                                   const complex_t phase) {
   cvector_t diag(2);
   diag[0] = 1.0;
   diag[1] = phase;
@@ -1347,17 +1454,16 @@ void State<densmat_t>::apply_phase(const int_t iChunk, const uint_t qubit, const
 }
 
 template <class densmat_t>
-void State<densmat_t>::apply_phase(const int_t iChunk, const reg_t& qubits, const complex_t phase)
-{
-  cvector_t diag((1 << qubits.size()),1.0);
+void State<densmat_t>::apply_phase(const int_t iChunk, const reg_t &qubits,
+                                   const complex_t phase) {
+  cvector_t diag((1 << qubits.size()), 1.0);
   diag[(1 << qubits.size()) - 1] = phase;
   apply_diagonal_unitary_matrix(iChunk, qubits, diag);
 }
 
 template <class densmat_t>
 void State<densmat_t>::apply_pauli(const int_t iChunk, const reg_t &qubits,
-                                   const std::string &pauli) 
-{
+                                   const std::string &pauli) {
   // Pauli as a superoperator is (-1)^num_y P\otimes P
   complex_t coeff = (std::count(pauli.begin(), pauli.end(), 'Y') % 2) ? -1 : 1;
   BaseState::qregs_[iChunk].apply_pauli(
@@ -1369,9 +1475,9 @@ void State<densmat_t>::apply_pauli(const int_t iChunk, const reg_t &qubits,
 //=========================================================================
 
 template <class densmat_t>
-void State<densmat_t>::apply_measure(const int_t iChunk, const reg_t &qubits, const reg_t &cmemory,
-                                     const reg_t &cregister, RngEngine &rng) 
-{
+void State<densmat_t>::apply_measure(const int_t iChunk, const reg_t &qubits,
+                                     const reg_t &cmemory,
+                                     const reg_t &cregister, RngEngine &rng) {
   int_t ishot = BaseState::get_global_shot_index(iChunk);
   // Actual measurement outcome
   const auto meas = sample_measure_with_prob(iChunk, qubits, rng);
@@ -1382,54 +1488,57 @@ void State<densmat_t>::apply_measure(const int_t iChunk, const reg_t &qubits, co
 }
 
 template <class densmat_t>
-rvector_t State<densmat_t>::measure_probs(const int_t iChunk, const reg_t &qubits) const 
-{
-  if(!BaseState::multi_chunk_distribution_)
+rvector_t State<densmat_t>::measure_probs(const int_t iChunk,
+                                          const reg_t &qubits) const {
+  if (!BaseState::multi_chunk_distribution_)
     return BaseState::qregs_[iChunk].probabilities(qubits);
 
   uint_t dim = 1ull << qubits.size();
-  rvector_t sum(dim,0.0);
-  int_t i,j,k;
+  rvector_t sum(dim, 0.0);
+  int_t i, j, k;
   reg_t qubits_in_chunk;
   reg_t qubits_out_chunk;
 
-  for(i=0;i<qubits.size();i++){
-    if(qubits[i] < BaseState::chunk_bits_){
+  for (i = 0; i < qubits.size(); i++) {
+    if (qubits[i] < BaseState::chunk_bits_) {
       qubits_in_chunk.push_back(qubits[i]);
-    }
-    else{
+    } else {
       qubits_out_chunk.push_back(qubits[i]);
     }
   }
 
-  if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0){
-#pragma omp parallel for private(i,j,k)
-    for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-      for(i = BaseState::top_chunk_of_group_[ig];i < BaseState::top_chunk_of_group_[ig + 1];i++){
-        uint_t irow,icol;
-        irow = (BaseState::global_chunk_index_ + i) >> ((BaseState::num_qubits_ - BaseState::chunk_bits_));
-        icol = (BaseState::global_chunk_index_ + i) - (irow << ((BaseState::num_qubits_ - BaseState::chunk_bits_)));
-
-        if(irow == icol){   //diagonal chunk
-          if(qubits_in_chunk.size() > 0){
+  if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0) {
+#pragma omp parallel for private(i, j, k)
+    for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+      for (i = BaseState::top_chunk_of_group_[ig];
+           i < BaseState::top_chunk_of_group_[ig + 1]; i++) {
+        uint_t irow, icol;
+        irow = (BaseState::global_chunk_index_ + i) >>
+               ((BaseState::num_qubits_ - BaseState::chunk_bits_));
+        icol = (BaseState::global_chunk_index_ + i) -
+               (irow << ((BaseState::num_qubits_ - BaseState::chunk_bits_)));
+
+        if (irow == icol) { // diagonal chunk
+          if (qubits_in_chunk.size() > 0) {
             auto chunkSum = BaseState::qregs_[i].probabilities(qubits_in_chunk);
-            if(qubits_in_chunk.size() == qubits.size()){
-              for(j=0;j<dim;j++){
+            if (qubits_in_chunk.size() == qubits.size()) {
+              for (j = 0; j < dim; j++) {
 #pragma omp atomic
                 sum[j] += chunkSum[j];
               }
-            }
-            else{
-              for(j=0;j<chunkSum.size();j++){
+            } else {
+              for (j = 0; j < chunkSum.size(); j++) {
                 int idx = 0;
                 int i_in = 0;
-                for(k=0;k<qubits.size();k++){
-                  if(qubits[k] < (BaseState::chunk_bits_)){
+                for (k = 0; k < qubits.size(); k++) {
+                  if (qubits[k] < (BaseState::chunk_bits_)) {
                     idx += (((j >> i_in) & 1) << k);
                     i_in++;
-                  }
-                  else{
-                    if((((i + BaseState::global_chunk_index_) << (BaseState::chunk_bits_)) >> qubits[k]) & 1){
+                  } else {
+                    if ((((i + BaseState::global_chunk_index_)
+                          << (BaseState::chunk_bits_)) >>
+                         qubits[k]) &
+                        1) {
                       idx += 1ull << k;
                     }
                   }
@@ -1438,12 +1547,14 @@ rvector_t State<densmat_t>::measure_probs(const int_t iChunk, const reg_t &qubit
                 sum[idx] += chunkSum[j];
               }
             }
-          }
-          else{ //there is no bit in chunk
+          } else { // there is no bit in chunk
             auto tr = std::real(BaseState::qregs_[i].trace());
             int idx = 0;
-            for(k=0;k<qubits_out_chunk.size();k++){
-              if((((i + BaseState::global_chunk_index_) << (BaseState::chunk_bits_)) >> qubits_out_chunk[k]) & 1){
+            for (k = 0; k < qubits_out_chunk.size(); k++) {
+              if ((((i + BaseState::global_chunk_index_)
+                    << (BaseState::chunk_bits_)) >>
+                   qubits_out_chunk[k]) &
+                  1) {
                 idx += 1ull << k;
               }
             }
@@ -1453,32 +1564,34 @@ rvector_t State<densmat_t>::measure_probs(const int_t iChunk, const reg_t &qubit
         }
       }
     }
-  }
-  else{
-    for(i=0;i<BaseState::qregs_.size();i++){
-      uint_t irow,icol;
-      irow = (BaseState::global_chunk_index_ + i) >> ((BaseState::num_qubits_ - BaseState::chunk_bits_));
-      icol = (BaseState::global_chunk_index_ + i) - (irow << ((BaseState::num_qubits_ - BaseState::chunk_bits_)));
-
-      if(irow == icol){   //diagonal chunk
-        if(qubits_in_chunk.size() > 0){
+  } else {
+    for (i = 0; i < BaseState::qregs_.size(); i++) {
+      uint_t irow, icol;
+      irow = (BaseState::global_chunk_index_ + i) >>
+             ((BaseState::num_qubits_ - BaseState::chunk_bits_));
+      icol = (BaseState::global_chunk_index_ + i) -
+             (irow << ((BaseState::num_qubits_ - BaseState::chunk_bits_)));
+
+      if (irow == icol) { // diagonal chunk
+        if (qubits_in_chunk.size() > 0) {
           auto chunkSum = BaseState::qregs_[i].probabilities(qubits_in_chunk);
-          if(qubits_in_chunk.size() == qubits.size()){
-            for(j=0;j<dim;j++){
+          if (qubits_in_chunk.size() == qubits.size()) {
+            for (j = 0; j < dim; j++) {
               sum[j] += chunkSum[j];
             }
-          }
-          else{
-            for(j=0;j<chunkSum.size();j++){
+          } else {
+            for (j = 0; j < chunkSum.size(); j++) {
               int idx = 0;
               int i_in = 0;
-              for(k=0;k<qubits.size();k++){
-                if(qubits[k] < (BaseState::chunk_bits_)){
+              for (k = 0; k < qubits.size(); k++) {
+                if (qubits[k] < (BaseState::chunk_bits_)) {
                   idx += (((j >> i_in) & 1) << k);
                   i_in++;
-                }
-                else{
-                  if((((i + BaseState::global_chunk_index_) << (BaseState::chunk_bits_)) >> qubits[k]) & 1){
+                } else {
+                  if ((((i + BaseState::global_chunk_index_)
+                        << (BaseState::chunk_bits_)) >>
+                       qubits[k]) &
+                      1) {
                     idx += 1ull << k;
                   }
                 }
@@ -1486,12 +1599,14 @@ rvector_t State<densmat_t>::measure_probs(const int_t iChunk, const reg_t &qubit
               sum[idx] += chunkSum[j];
             }
           }
-        }
-        else{ //there is no bit in chunk
+        } else { // there is no bit in chunk
           auto tr = std::real(BaseState::qregs_[i].trace());
           int idx = 0;
-          for(k=0;k<qubits_out_chunk.size();k++){
-            if((((i + BaseState::global_chunk_index_) << (BaseState::chunk_bits_)) >> qubits_out_chunk[k]) & 1){
+          for (k = 0; k < qubits_out_chunk.size(); k++) {
+            if ((((i + BaseState::global_chunk_index_)
+                  << (BaseState::chunk_bits_)) >>
+                 qubits_out_chunk[k]) &
+                1) {
               idx += 1ull << k;
             }
           }
@@ -1506,20 +1621,16 @@ rvector_t State<densmat_t>::measure_probs(const int_t iChunk, const reg_t &qubit
 #endif
 
   return sum;
-  
 }
 
 template <class densmat_t>
-void State<densmat_t>::apply_reset(const int_t iChunk, const reg_t &qubits) 
-{
+void State<densmat_t>::apply_reset(const int_t iChunk, const reg_t &qubits) {
   BaseState::qregs_[iChunk].apply_reset(qubits);
 }
 
 template <class densmat_t>
-std::pair<uint_t, double>
-State<densmat_t>::sample_measure_with_prob(const int_t iChunk, const reg_t &qubits,
-                                           RngEngine &rng) 
-{
+std::pair<uint_t, double> State<densmat_t>::sample_measure_with_prob(
+    const int_t iChunk, const reg_t &qubits, RngEngine &rng) {
   rvector_t probs = measure_probs(iChunk, qubits);
   // Randomly pick outcome and return pair
   uint_t outcome = rng.rand_int(probs);
@@ -1527,11 +1638,11 @@ State<densmat_t>::sample_measure_with_prob(const int_t iChunk, const reg_t &qubi
 }
 
 template <class densmat_t>
-void State<densmat_t>::measure_reset_update(const int_t iChunk, const reg_t &qubits,
+void State<densmat_t>::measure_reset_update(const int_t iChunk,
+                                            const reg_t &qubits,
                                             const uint_t final_state,
                                             const uint_t meas_state,
-                                            const double meas_prob) 
-{
+                                            const double meas_prob) {
   // Update a state vector based on an outcome pair [m, p] from
   // sample_measure_with_prob function, and a desired post-measurement
   // final_state Single-qubit case
@@ -1539,43 +1650,42 @@ void State<densmat_t>::measure_reset_update(const int_t iChunk, const reg_t &qub
     // Diagonal matrix for projecting and renormalizing to measurement outcome
     cvector_t mdiag(2, 0.);
     mdiag[meas_state] = 1. / std::sqrt(meas_prob);
-    if(!BaseState::multi_chunk_distribution_)
+    if (!BaseState::multi_chunk_distribution_)
       apply_diagonal_unitary_matrix(iChunk, qubits, mdiag);
-    else{
-      if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1){
-#pragma omp parallel for 
-        for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-          for(int_t i = BaseState::top_chunk_of_group_[ig];i < BaseState::top_chunk_of_group_[ig + 1];i++)
+    else {
+      if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1) {
+#pragma omp parallel for
+        for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+          for (int_t i = BaseState::top_chunk_of_group_[ig];
+               i < BaseState::top_chunk_of_group_[ig + 1]; i++)
             apply_diagonal_unitary_matrix(i, qubits, mdiag);
         }
-      }
-      else{
-        for(int_t i=0;i<BaseState::qregs_.size();i++)
+      } else {
+        for (int_t i = 0; i < BaseState::qregs_.size(); i++)
           apply_diagonal_unitary_matrix(i, qubits, mdiag);
       }
     }
 
     // If it doesn't agree with the reset state update
     if (final_state != meas_state) {
-      if(!BaseState::multi_chunk_distribution_)
+      if (!BaseState::multi_chunk_distribution_)
         BaseState::qregs_[iChunk].apply_x(qubits[0]);
-      else{
-        if(qubits[0] < BaseState::chunk_bits_){
-          if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1){
-#pragma omp parallel for 
-            for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-              for(int_t i = BaseState::top_chunk_of_group_[ig];i < BaseState::top_chunk_of_group_[ig + 1];i++)
+      else {
+        if (qubits[0] < BaseState::chunk_bits_) {
+          if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1) {
+#pragma omp parallel for
+            for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+              for (int_t i = BaseState::top_chunk_of_group_[ig];
+                   i < BaseState::top_chunk_of_group_[ig + 1]; i++)
                 BaseState::qregs_[i].apply_x(qubits[0]);
             }
-          }
-          else{
-            for(int_t i=0;i<BaseState::qregs_.size();i++)
+          } else {
+            for (int_t i = 0; i < BaseState::qregs_.size(); i++)
               BaseState::qregs_[i].apply_x(qubits[0]);
           }
-        }
-        else{
+        } else {
           BaseState::apply_chunk_x(qubits[0]);
-          BaseState::apply_chunk_x(qubits[0]+BaseState::chunk_bits_);
+          BaseState::apply_chunk_x(qubits[0] + BaseState::chunk_bits_);
         }
       }
     }
@@ -1586,18 +1696,18 @@ void State<densmat_t>::measure_reset_update(const int_t iChunk, const reg_t &qub
     const size_t dim = 1ULL << qubits.size();
     cvector_t mdiag(dim, 0.);
     mdiag[meas_state] = 1. / std::sqrt(meas_prob);
-    if(!BaseState::multi_chunk_distribution_)
+    if (!BaseState::multi_chunk_distribution_)
       apply_diagonal_unitary_matrix(iChunk, qubits, mdiag);
-    else{
-      if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1){
-#pragma omp parallel for 
-        for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-          for(int_t i = BaseState::top_chunk_of_group_[ig];i < BaseState::top_chunk_of_group_[ig + 1];i++)
+    else {
+      if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1) {
+#pragma omp parallel for
+        for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+          for (int_t i = BaseState::top_chunk_of_group_[ig];
+               i < BaseState::top_chunk_of_group_[ig + 1]; i++)
             apply_diagonal_unitary_matrix(i, qubits, mdiag);
         }
-      }
-      else{
-        for(int_t i=0;i<BaseState::qregs_.size();i++)
+      } else {
+        for (int_t i = 0; i < BaseState::qregs_.size(); i++)
           apply_diagonal_unitary_matrix(i, qubits, mdiag);
       }
     }
@@ -1614,37 +1724,38 @@ void State<densmat_t>::measure_reset_update(const int_t iChunk, const reg_t &qub
           perm[j * dim + j] = 1.;
       }
       // apply permutation to swap state
-      if(!BaseState::multi_chunk_distribution_)
+      if (!BaseState::multi_chunk_distribution_)
         BaseState::qregs_[iChunk].apply_unitary_matrix(qubits, perm);
-      else{
+      else {
         reg_t qubits_in_chunk;
         reg_t qubits_out_chunk;
 
-        for(int_t i=0;i<qubits.size();i++){
-          if(qubits[i] < BaseState::chunk_bits_){
+        for (int_t i = 0; i < qubits.size(); i++) {
+          if (qubits[i] < BaseState::chunk_bits_) {
             qubits_in_chunk.push_back(qubits[i]);
-          }
-          else{
+          } else {
             qubits_out_chunk.push_back(qubits[i]);
           }
         }
-        if(qubits_in_chunk.size() > 0){   //in chunk exchange
-          if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1){
-#pragma omp parallel for 
-            for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-              for(int_t i = BaseState::top_chunk_of_group_[ig];i < BaseState::top_chunk_of_group_[ig + 1];i++)
+        if (qubits_in_chunk.size() > 0) { // in chunk exchange
+          if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1) {
+#pragma omp parallel for
+            for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+              for (int_t i = BaseState::top_chunk_of_group_[ig];
+                   i < BaseState::top_chunk_of_group_[ig + 1]; i++)
                 BaseState::qregs_[i].apply_unitary_matrix(qubits, perm);
             }
-          }
-          else{
-            for(int_t i=0;i<BaseState::qregs_.size();i++)
+          } else {
+            for (int_t i = 0; i < BaseState::qregs_.size(); i++)
               BaseState::qregs_[i].apply_unitary_matrix(qubits, perm);
           }
         }
-        if(qubits_out_chunk.size() > 0){  //out of chunk exchange
-          for(int_t i=0;i<qubits_out_chunk.size();i++){
+        if (qubits_out_chunk.size() > 0) { // out of chunk exchange
+          for (int_t i = 0; i < qubits_out_chunk.size(); i++) {
             BaseState::apply_chunk_x(qubits_out_chunk[i]);
-            BaseState::apply_chunk_x(qubits_out_chunk[i]+(BaseState::num_qubits_ - BaseState::chunk_bits_));
+            BaseState::apply_chunk_x(
+                qubits_out_chunk[i] +
+                (BaseState::num_qubits_ - BaseState::chunk_bits_));
           }
         }
       }
@@ -1655,49 +1766,52 @@ void State<densmat_t>::measure_reset_update(const int_t iChunk, const reg_t &qub
 template <class densmat_t>
 std::vector<reg_t> State<densmat_t>::sample_measure(const reg_t &qubits,
                                                     uint_t shots,
-                                                    RngEngine &rng) 
-{
+                                                    RngEngine &rng) {
   // Generate flat register for storing
   std::vector<double> rnds;
   rnds.reserve(shots);
   for (uint_t i = 0; i < shots; ++i)
     rnds.push_back(rng.rand(0, 1));
-  reg_t allbit_samples(shots,0);
+  reg_t allbit_samples(shots, 0);
 
-  if(!BaseState::multi_chunk_distribution_)
+  if (!BaseState::multi_chunk_distribution_)
     allbit_samples = BaseState::qregs_[0].sample_measure(rnds);
-  else{
-    int_t i,j;
-    std::vector<double> chunkSum(BaseState::qregs_.size()+1,0);
-    double sum,localSum;
-   //calculate per chunk sum
-    if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1){
-#pragma omp parallel for private(i) 
-      for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-        for(i = BaseState::top_chunk_of_group_[ig];i < BaseState::top_chunk_of_group_[ig + 1];i++){
-          uint_t irow,icol;
-          irow = (BaseState::global_chunk_index_ + i) >> ((BaseState::num_qubits_ - BaseState::chunk_bits_));
-          icol = (BaseState::global_chunk_index_ + i) - (irow << ((BaseState::num_qubits_ - BaseState::chunk_bits_)));
-          if(irow == icol)   //only diagonal chunk has probabilities
-            chunkSum[i] = std::real( BaseState::qregs_[i].trace() );
+  else {
+    int_t i, j;
+    std::vector<double> chunkSum(BaseState::qregs_.size() + 1, 0);
+    double sum, localSum;
+    // calculate per chunk sum
+    if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1) {
+#pragma omp parallel for private(i)
+      for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+        for (i = BaseState::top_chunk_of_group_[ig];
+             i < BaseState::top_chunk_of_group_[ig + 1]; i++) {
+          uint_t irow, icol;
+          irow = (BaseState::global_chunk_index_ + i) >>
+                 ((BaseState::num_qubits_ - BaseState::chunk_bits_));
+          icol = (BaseState::global_chunk_index_ + i) -
+                 (irow << ((BaseState::num_qubits_ - BaseState::chunk_bits_)));
+          if (irow == icol) // only diagonal chunk has probabilities
+            chunkSum[i] = std::real(BaseState::qregs_[i].trace());
           else
             chunkSum[i] = 0.0;
         }
       }
-    }
-    else{
-      for(i=0;i<BaseState::qregs_.size();i++){
-        uint_t irow,icol;
-        irow = (BaseState::global_chunk_index_ + i) >> ((BaseState::num_qubits_ - BaseState::chunk_bits_));
-        icol = (BaseState::global_chunk_index_ + i) - (irow << ((BaseState::num_qubits_ - BaseState::chunk_bits_)));
-        if(irow == icol)   //only diagonal chunk has probabilities
-          chunkSum[i] = std::real( BaseState::qregs_[i].trace() );
+    } else {
+      for (i = 0; i < BaseState::qregs_.size(); i++) {
+        uint_t irow, icol;
+        irow = (BaseState::global_chunk_index_ + i) >>
+               ((BaseState::num_qubits_ - BaseState::chunk_bits_));
+        icol = (BaseState::global_chunk_index_ + i) -
+               (irow << ((BaseState::num_qubits_ - BaseState::chunk_bits_)));
+        if (irow == icol) // only diagonal chunk has probabilities
+          chunkSum[i] = std::real(BaseState::qregs_[i].trace());
         else
           chunkSum[i] = 0.0;
       }
     }
     localSum = 0.0;
-    for(i=0;i<BaseState::qregs_.size();i++){
+    for (i = 0; i < BaseState::qregs_.size(); i++) {
       sum = localSum;
       localSum += chunkSum[i];
       chunkSum[i] = sum;
@@ -1705,50 +1819,55 @@ std::vector<reg_t> State<densmat_t>::sample_measure(const reg_t &qubits,
     chunkSum[BaseState::qregs_.size()] = localSum;
 
     double globalSum = 0.0;
-    if(BaseState::nprocs_ > 1){
+    if (BaseState::nprocs_ > 1) {
       std::vector<double> procTotal(BaseState::nprocs_);
 
-      for(i=0;i<BaseState::nprocs_;i++){
+      for (i = 0; i < BaseState::nprocs_; i++) {
         procTotal[i] = localSum;
       }
       BaseState::gather_value(procTotal);
 
-      for(i=0;i<BaseState::myrank_;i++){
+      for (i = 0; i < BaseState::myrank_; i++) {
         globalSum += procTotal[i];
       }
     }
 
-    reg_t local_samples(shots,0);
+    reg_t local_samples(shots, 0);
 
-    //get rnds positions for each chunk
-    for(i=0;i<BaseState::qregs_.size();i++){
-      uint_t irow,icol;
-      irow = (BaseState::global_chunk_index_ + i) >> ((BaseState::num_qubits_ - BaseState::chunk_bits_));
-      icol = (BaseState::global_chunk_index_ + i) - (irow << ((BaseState::num_qubits_ - BaseState::chunk_bits_)));
-      if(irow != icol)
+    // get rnds positions for each chunk
+    for (i = 0; i < BaseState::qregs_.size(); i++) {
+      uint_t irow, icol;
+      irow = (BaseState::global_chunk_index_ + i) >>
+             ((BaseState::num_qubits_ - BaseState::chunk_bits_));
+      icol = (BaseState::global_chunk_index_ + i) -
+             (irow << ((BaseState::num_qubits_ - BaseState::chunk_bits_)));
+      if (irow != icol)
         continue;
 
       uint_t nIn;
       std::vector<uint_t> vIdx;
       std::vector<double> vRnd;
 
-      //find rnds in this chunk
+      // find rnds in this chunk
       nIn = 0;
-      for(j=0;j<shots;j++){
-        if(rnds[j] >= chunkSum[i] + globalSum && rnds[j] < chunkSum[i+1] + globalSum){
+      for (j = 0; j < shots; j++) {
+        if (rnds[j] >= chunkSum[i] + globalSum &&
+            rnds[j] < chunkSum[i + 1] + globalSum) {
           vRnd.push_back(rnds[j] - (globalSum + chunkSum[i]));
           vIdx.push_back(j);
           nIn++;
         }
       }
 
-      if(nIn > 0){
+      if (nIn > 0) {
         auto chunkSamples = BaseState::qregs_[i].sample_measure(vRnd);
         uint_t ir;
-        ir = (BaseState::global_chunk_index_ + i) >> ((BaseState::num_qubits_ - BaseState::chunk_bits_));
+        ir = (BaseState::global_chunk_index_ + i) >>
+             ((BaseState::num_qubits_ - BaseState::chunk_bits_));
 
-        for(j=0;j<chunkSamples.size();j++){
-          local_samples[vIdx[j]] = (ir << BaseState::chunk_bits_) + chunkSamples[j];
+        for (j = 0; j < chunkSamples.size(); j++) {
+          local_samples[vIdx[j]] =
+              (ir << BaseState::chunk_bits_) + chunkSamples[j];
         }
       }
     }
@@ -1774,52 +1893,46 @@ std::vector<reg_t> State<densmat_t>::sample_measure(const reg_t &qubits,
   return all_samples;
 }
 
-
 //=========================================================================
 // Implementation: Kraus Noise
 //=========================================================================
 
 template <class densmat_t>
 void State<densmat_t>::apply_kraus(const int_t iChunk, const reg_t &qubits,
-                                   const std::vector<cmatrix_t> &kmats) 
-{
+                                   const std::vector<cmatrix_t> &kmats) {
   BaseState::qregs_[iChunk].apply_superop_matrix(
       qubits, Utils::vectorize_matrix(Utils::kraus_superop(kmats)));
 }
 
-
 //-----------------------------------------------------------------------
-//Functions for multi-chunk distribution
+// Functions for multi-chunk distribution
 //-----------------------------------------------------------------------
-//swap between chunks
+// swap between chunks
 template <class densmat_t>
-void State<densmat_t>::apply_chunk_swap(const reg_t &qubits)
-{
-  uint_t q0,q1;
+void State<densmat_t>::apply_chunk_swap(const reg_t &qubits) {
+  uint_t q0, q1;
   q0 = qubits[0];
   q1 = qubits[1];
 
-  std::swap(BaseState::qubit_map_[q0],BaseState::qubit_map_[q1]);
+  std::swap(BaseState::qubit_map_[q0], BaseState::qubit_map_[q1]);
 
-  if(qubits[0] >= BaseState::chunk_bits_){
+  if (qubits[0] >= BaseState::chunk_bits_) {
     q0 += BaseState::chunk_bits_;
   }
-  if(qubits[1] >= BaseState::chunk_bits_){
+  if (qubits[1] >= BaseState::chunk_bits_) {
     q1 += BaseState::chunk_bits_;
   }
   reg_t qs0 = {{q0, q1}};
   BaseState::apply_chunk_swap(qs0);
 
-  if(qubits[0] >= BaseState::chunk_bits_){
+  if (qubits[0] >= BaseState::chunk_bits_) {
     q0 += (BaseState::num_qubits_ - BaseState::chunk_bits_);
-  }
-  else{
+  } else {
     q0 += BaseState::chunk_bits_;
   }
-  if(qubits[1] >= BaseState::chunk_bits_){
+  if (qubits[1] >= BaseState::chunk_bits_) {
     q1 += (BaseState::num_qubits_ - BaseState::chunk_bits_);
-  }
-  else{
+  } else {
     q1 += BaseState::chunk_bits_;
   }
   reg_t qs1 = {{q0, q1}};
@@ -1827,33 +1940,31 @@ void State<densmat_t>::apply_chunk_swap(const reg_t &qubits)
 }
 
 template <class densmat_t>
-void State<densmat_t>::apply_multi_chunk_swap(const reg_t &qubits)
-{
+void State<densmat_t>::apply_multi_chunk_swap(const reg_t &qubits) {
   reg_t qubits_density;
 
-  for(int_t i=0;i<qubits.size();i+=2){
-    uint_t q0,q1;
-    q0 = qubits[i*2];
-    q1 = qubits[i*2+1];
+  for (int_t i = 0; i < qubits.size(); i += 2) {
+    uint_t q0, q1;
+    q0 = qubits[i * 2];
+    q1 = qubits[i * 2 + 1];
 
-    std::swap(BaseState::qubit_map_[q0],BaseState::qubit_map_[q1]);
+    std::swap(BaseState::qubit_map_[q0], BaseState::qubit_map_[q1]);
 
-    if(q1 >= BaseState::chunk_bits_){
+    if (q1 >= BaseState::chunk_bits_) {
       q1 += BaseState::chunk_bits_;
     }
     qubits_density.push_back(q0);
     qubits_density.push_back(q1);
 
     q0 += BaseState::chunk_bits_;
-    if(q1 >= BaseState::chunk_bits_){
-      q1 += (BaseState::num_qubits_ - BaseState::chunk_bits_*2);
+    if (q1 >= BaseState::chunk_bits_) {
+      q1 += (BaseState::num_qubits_ - BaseState::chunk_bits_ * 2);
     }
   }
 
   BaseState::apply_multi_chunk_swap(qubits_density);
 }
 
-
 //-------------------------------------------------------------------------
 } // end namespace DensityMatrix
 //-------------------------------------------------------------------------
diff --git a/src/simulators/density_matrix/densitymatrix_thrust.hpp b/src/simulators/density_matrix/densitymatrix_thrust.hpp
old mode 100755
new mode 100644
index a57c32909a..03c0ca5982
--- a/src/simulators/density_matrix/densitymatrix_thrust.hpp
+++ b/src/simulators/density_matrix/densitymatrix_thrust.hpp
@@ -15,7 +15,6 @@
 #ifndef _qv_density_matrix_thrust_hpp_
 #define _qv_density_matrix_thrust_hpp_
 
-
 #include "framework/utils.hpp"
 #include "simulators/unitary/unitarymatrix_thrust.hpp"
 
@@ -26,7 +25,7 @@ namespace QV {
 // DensityMatrixThrust class
 //============================================================================
 
-// This class is derived from the UnitaryMatrix class and stores an N-qubit 
+// This class is derived from the UnitaryMatrix class and stores an N-qubit
 // matrix as a 2*N-qubit vector.
 // The vector is formed using column-stacking vectorization as under this
 // convention left-matrix multiplication on qubit-n is equal to multiplication
@@ -44,7 +43,7 @@ class DensityMatrixThrust : public UnitaryMatrixThrust<data_t> {
   // Constructors and Destructor
   //-----------------------------------------------------------------------
 
-  DensityMatrixThrust() : DensityMatrixThrust(0) {};
+  DensityMatrixThrust() : DensityMatrixThrust(0){};
   explicit DensityMatrixThrust(size_t num_qubits);
 
   //-----------------------------------------------------------------------
@@ -53,11 +52,11 @@ class DensityMatrixThrust : public UnitaryMatrixThrust<data_t> {
 
   // Return the string name of the class
 #ifdef AER_THRUST_CUDA
-  static std::string name() {return "density_matrix_gpu";}
+  static std::string name() { return "density_matrix_gpu"; }
 #else
-  static std::string name() {return "density_matrix_thrust";}
+  static std::string name() { return "density_matrix_thrust"; }
 #endif
-  virtual bool is_density_matrix(void) {return true;}
+  virtual bool is_density_matrix(void) { return true; }
 
   // Initializes the current vector so that all qubits are in the |0> state.
   void initialize();
@@ -66,12 +65,10 @@ class DensityMatrixThrust : public UnitaryMatrixThrust<data_t> {
   // The vector can be either a statevector or a vectorized density matrix
   // If the length of the data vector does not match either case for the
   // number of qubits an exception is raised.
-  template <typename list_t>
-  void initialize_from_vector(const list_t &data);
-
+  template <typename list_t> void initialize_from_vector(const list_t &data);
 
   // Returns the number of qubits for the superoperator
-  virtual uint_t num_qubits() const override {return BaseMatrix::num_qubits_;}
+  virtual uint_t num_qubits() const override { return BaseMatrix::num_qubits_; }
 
   // Convert qubit indicies to vectorized-density matrix qubitvector indices
   // For the QubitVector apply matrix function
@@ -82,20 +79,24 @@ class DensityMatrixThrust : public UnitaryMatrixThrust<data_t> {
   //-----------------------------------------------------------------------
 
   // Apply a N-qubit unitary matrix to the state vector.
-  // The matrix is input as vector of the column-major vectorized N-qubit matrix.
+  // The matrix is input as vector of the column-major vectorized N-qubit
+  // matrix.
   void apply_unitary_matrix(const reg_t &qubits, const cvector_t<double> &mat);
 
   // Apply a N-qubit superoperator matrix to the state vector.
-  // The matrix is input as vector of the column-major vectorized N-qubit superop.
+  // The matrix is input as vector of the column-major vectorized N-qubit
+  // superop.
   void apply_superop_matrix(const reg_t &qubits, const cvector_t<double> &mat);
 
   // Apply a N-qubit diagonal unitary matrix to the state vector.
   // The matrix is input as vector of the matrix diagonal.
-  void apply_diagonal_unitary_matrix(const reg_t &qubits, const cvector_t<double> &mat);
+  void apply_diagonal_unitary_matrix(const reg_t &qubits,
+                                     const cvector_t<double> &mat);
 
   // Apply a N-qubit diagonal superoperator matrix to the state vector.
   // The matrix is input as vector of the matrix diagonal.
-  void apply_diagonal_superop_matrix(const reg_t &qubits, const cvector_t<double> &mat);
+  void apply_diagonal_superop_matrix(const reg_t &qubits,
+                                     const cvector_t<double> &mat);
 
   //-----------------------------------------------------------------------
   // Apply Specialized Gates
@@ -104,7 +105,7 @@ class DensityMatrixThrust : public UnitaryMatrixThrust<data_t> {
   // Apply a 2-qubit Controlled-NOT gate to the state vector
   void apply_cnot(const uint_t qctrl, const uint_t qtrgt);
 
- // Apply a 2-qubit Controlled-Y gate to the state vector
+  // Apply a 2-qubit Controlled-Y gate to the state vector
   void apply_cy(const uint_t qctrl, const uint_t qtrgt);
 
   // Apply 2-qubit controlled-phase gate
@@ -123,7 +124,8 @@ class DensityMatrixThrust : public UnitaryMatrixThrust<data_t> {
   void apply_phase(const uint_t q, const complex_t &phase);
 
   // Apply a 3-qubit toffoli gate
-  void apply_toffoli(const uint_t qctrl0, const uint_t qctrl1, const uint_t qtrgt);
+  void apply_toffoli(const uint_t qctrl0, const uint_t qctrl1,
+                     const uint_t qtrgt);
 
   //-----------------------------------------------------------------------
   // Z-measurement outcome probabilities
@@ -142,11 +144,12 @@ class DensityMatrixThrust : public UnitaryMatrixThrust<data_t> {
   // generating samples.
   virtual reg_t sample_measure(const std::vector<double> &rnds) const override;
 
-  //optimized 1 qubit measure (async)
-  virtual void apply_batched_measure(const reg_t& qubits,std::vector<RngEngine>& rng,const reg_t& cmemory,const reg_t& cregs);
-
+  // optimized 1 qubit measure (async)
+  virtual void apply_batched_measure(const reg_t &qubits,
+                                     std::vector<RngEngine> &rng,
+                                     const reg_t &cmemory, const reg_t &cregs);
 
-  virtual void apply_reset(const reg_t& qubits);
+  virtual void apply_reset(const reg_t &qubits);
 
   //-----------------------------------------------------------------------
   // Expectation Values
@@ -154,16 +157,19 @@ class DensityMatrixThrust : public UnitaryMatrixThrust<data_t> {
 
   // Return the expectation value of an N-qubit Pauli matrix.
   // The Pauli is input as a length N string of I,X,Y,Z characters.
-  double expval_pauli(const reg_t &qubits, const std::string &pauli,const complex_t initial_phase=1.0) const;
-  double expval_pauli_non_diagonal_chunk(const reg_t &qubits, const std::string &pauli,const complex_t initial_phase=1.0) const;
+  double expval_pauli(const reg_t &qubits, const std::string &pauli,
+                      const complex_t initial_phase = 1.0) const;
+  double
+  expval_pauli_non_diagonal_chunk(const reg_t &qubits, const std::string &pauli,
+                                  const complex_t initial_phase = 1.0) const;
 
 protected:
   // Construct a vectorized superoperator from a vectorized matrix
   // This is equivalent to vec(tensor(conj(A), A))
   cvector_t<double> vmat2vsuperop(const cvector_t<double> &vmat) const;
 
-  // Qubit threshold for when apply unitary will apply as two matrix multiplications
-  // rather than as a 2n-qubit superoperator matrix.
+  // Qubit threshold for when apply unitary will apply as two matrix
+  // multiplications rather than as a 2n-qubit superoperator matrix.
   size_t apply_unitary_threshold_ = 4;
 
 #ifdef AER_DEBUG
@@ -177,22 +183,19 @@ class DensityMatrixThrust : public UnitaryMatrixThrust<data_t> {
  *
  ******************************************************************************/
 
-
 //------------------------------------------------------------------------------
 // Constructors & Destructor
 //------------------------------------------------------------------------------
 
 template <typename data_t>
 DensityMatrixThrust<data_t>::DensityMatrixThrust(size_t num_qubits)
-  : UnitaryMatrixThrust<data_t>(num_qubits) {};
+    : UnitaryMatrixThrust<data_t>(num_qubits){};
 
 //------------------------------------------------------------------------------
 // Utility
 //------------------------------------------------------------------------------
 
-template <typename data_t>
-void DensityMatrixThrust<data_t>::initialize() 
-{
+template <typename data_t> void DensityMatrixThrust<data_t>::initialize() {
   BaseVector::initialize();
 }
 
@@ -205,15 +208,16 @@ void DensityMatrixThrust<data_t>::initialize_from_vector(const list_t &vec) {
   } else if (BaseVector::data_size_ == vec.size() * vec.size()) {
     // Convert statevector into density matrix
     BaseVector::initialize_from_vector(
-      AER::Utils::tensor_product(AER::Utils::conjugate(vec), vec));
+        AER::Utils::tensor_product(AER::Utils::conjugate(vec), vec));
 
   } else {
-    throw std::runtime_error("DensityMatrixThrust::initialize input vector is incorrect length. Expected: " +
-                             std::to_string(BaseVector::data_size_) + " Received: " +
-                             std::to_string(vec.size()));
+    throw std::runtime_error("DensityMatrixThrust::initialize input vector is "
+                             "incorrect length. Expected: " +
+                             std::to_string(BaseVector::data_size_) +
+                             " Received: " + std::to_string(vec.size()));
   }
 #ifdef AER_DEBUG
-	BaseVector::DebugMsg(" density::initialize_from_vector");
+  BaseVector::DebugMsg(" density::initialize_from_vector");
 #endif
 }
 
@@ -226,54 +230,55 @@ reg_t DensityMatrixThrust<data_t>::superop_qubits(const reg_t &qubits) const {
   reg_t superop_qubits = qubits;
   // Number of qubits
   const auto nq = num_qubits();
-  for (const auto &q: qubits) {
+  for (const auto &q : qubits) {
     superop_qubits.push_back(q + nq);
   }
   return superop_qubits;
 }
 
 template <typename data_t>
-cvector_t<double> DensityMatrixThrust<data_t>::vmat2vsuperop(const cvector_t<double> &vmat) const {
+cvector_t<double> DensityMatrixThrust<data_t>::vmat2vsuperop(
+    const cvector_t<double> &vmat) const {
   // Get dimension of unvectorized matrix
   size_t dim = size_t(std::sqrt(vmat.size()));
   cvector_t<double> ret(dim * dim * dim * dim, 0.);
-  for (size_t i=0; i < dim; i++)
-    for (size_t j=0; j < dim; j++)
-      for (size_t k=0; k < dim; k++)
-        for (size_t l=0; l < dim; l++)
-          ret[dim*i+k+(dim*dim)*(dim*j+l)] = std::conj(vmat[i+dim*j])*vmat[k+dim*l];
+  for (size_t i = 0; i < dim; i++)
+    for (size_t j = 0; j < dim; j++)
+      for (size_t k = 0; k < dim; k++)
+        for (size_t l = 0; l < dim; l++)
+          ret[dim * i + k + (dim * dim) * (dim * j + l)] =
+              std::conj(vmat[i + dim * j]) * vmat[k + dim * l];
   return ret;
 }
 
 template <typename data_t>
-void DensityMatrixThrust<data_t>::apply_superop_matrix(const reg_t &qubits,
-                                                 const cvector_t<double> &mat) {
+void DensityMatrixThrust<data_t>::apply_superop_matrix(
+    const reg_t &qubits, const cvector_t<double> &mat) {
   BaseVector::apply_matrix(superop_qubits(qubits), mat);
 #ifdef AER_DEBUG
-	BaseVector::DebugMsg(" density::apply_superop_matrix",qubits);
+  BaseVector::DebugMsg(" density::apply_superop_matrix", qubits);
 #endif
 }
 
 template <typename data_t>
-void DensityMatrixThrust<data_t>::apply_diagonal_superop_matrix(const reg_t &qubits,
-                                                          const cvector_t<double> &diag) {
+void DensityMatrixThrust<data_t>::apply_diagonal_superop_matrix(
+    const reg_t &qubits, const cvector_t<double> &diag) {
   BaseVector::apply_diagonal_matrix(superop_qubits(qubits), diag);
 #ifdef AER_DEBUG
-	BaseVector::DebugMsg(" density::apply_diagonal_superop_matrix",qubits);
+  BaseVector::DebugMsg(" density::apply_diagonal_superop_matrix", qubits);
 #endif
 }
 
-
 template <typename data_t>
-class DensityMatrixUnitary2x2 : public Chunk::GateFuncBase<data_t>
-{
+class DensityMatrixUnitary2x2 : public Chunk::GateFuncBase<data_t> {
 protected:
-  thrust::complex<double> m0,m1,m2,m3;
+  thrust::complex<double> m0, m1, m2, m3;
   uint_t offset_;
   uint_t offset_sp_;
+
 public:
-  DensityMatrixUnitary2x2(const cvector_t<double>& mat,int qubit,int qubit_sp)
-  {
+  DensityMatrixUnitary2x2(const cvector_t<double> &mat, int qubit,
+                          int qubit_sp) {
     m0 = mat[0];
     m1 = mat[1];
     m2 = mat[2];
@@ -283,20 +288,16 @@ class DensityMatrixUnitary2x2 : public Chunk::GateFuncBase<data_t>
     offset_sp_ = 1ull << qubit_sp;
   }
 
-  int qubits_count(void)
-  {
-    return 2;
-  }
+  int qubits_count(void) { return 2; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    uint_t i0,i1,i2;
-    thrust::complex<data_t>* vec0;
-    thrust::complex<data_t>* vec1;
-    thrust::complex<data_t>* vec2;
-    thrust::complex<data_t>* vec3;
-    thrust::complex<data_t> q0,q1,q2,q3;
-    thrust::complex<data_t> t0,t1,t2,t3;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    uint_t i0, i1, i2;
+    thrust::complex<data_t> *vec0;
+    thrust::complex<data_t> *vec1;
+    thrust::complex<data_t> *vec2;
+    thrust::complex<data_t> *vec3;
+    thrust::complex<data_t> q0, q1, q2, q3;
+    thrust::complex<data_t> t0, t1, t2, t3;
 
     vec0 = this->data_;
 
@@ -327,25 +328,19 @@ class DensityMatrixUnitary2x2 : public Chunk::GateFuncBase<data_t>
     vec3[i0] = thrust::conj(m1) * t1 + thrust::conj(m3) * t3;
   }
 
-  const char* name(void)
-  {
-    return "density_unitary2x2";
-  }
-
+  const char *name(void) { return "density_unitary2x2"; }
 };
 
-
 template <typename data_t>
-void DensityMatrixThrust<data_t>::apply_unitary_matrix(const reg_t &qubits,
-                                                 const cvector_t<double> &mat) 
-{
-  if(qubits.size() == 1){   //2x2
-    BaseVector::apply_function(DensityMatrixUnitary2x2<data_t>(mat,qubits[0],qubits[0] + num_qubits()));
-  }
-  else{
+void DensityMatrixThrust<data_t>::apply_unitary_matrix(
+    const reg_t &qubits, const cvector_t<double> &mat) {
+  if (qubits.size() == 1) { // 2x2
+    BaseVector::apply_function(DensityMatrixUnitary2x2<data_t>(
+        mat, qubits[0], qubits[0] + num_qubits()));
+  } else {
     // Apply as two N-qubit matrix mults
     reg_t conj_qubits;
-    for (const auto q: qubits) {
+    for (const auto q : qubits) {
       conj_qubits.push_back(q + num_qubits());
     }
 
@@ -361,40 +356,35 @@ void DensityMatrixThrust<data_t>::apply_unitary_matrix(const reg_t &qubits,
   }
 
 #ifdef AER_DEBUG
-  BaseVector::DebugMsg(" density::apply_unitary_matrix",qubits);
+  BaseVector::DebugMsg(" density::apply_unitary_matrix", qubits);
   DebugDump();
 #endif
 }
 
 template <typename data_t>
-class DensityDiagMatMult2x2 : public Chunk::GateFuncBase<data_t>
-{
+class DensityDiagMatMult2x2 : public Chunk::GateFuncBase<data_t> {
 protected:
   uint_t offset;
   uint_t offset_sp;
-  thrust::complex<double> m0,m1;
+  thrust::complex<double> m0, m1;
+
 public:
-  DensityDiagMatMult2x2(const cvector_t<double>& mat,uint_t q,uint_t qs)
-  {
+  DensityDiagMatMult2x2(const cvector_t<double> &mat, uint_t q, uint_t qs) {
     offset = 1ull << q;
     offset_sp = 1ull << (q + qs);
 
     m0 = mat[0];
     m1 = mat[1];
   }
-  int qubits_count(void)
-  {
-    return 2;
-  }
+  int qubits_count(void) { return 2; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    uint_t i0,i1,i2;
-    thrust::complex<data_t>* vec0;
-    thrust::complex<data_t>* vec1;
-    thrust::complex<data_t>* vec2;
-    thrust::complex<data_t>* vec3;
-    thrust::complex<data_t> q0,q1,q2,q3,q0t,q1t,q2t,q3t;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    uint_t i0, i1, i2;
+    thrust::complex<data_t> *vec0;
+    thrust::complex<data_t> *vec1;
+    thrust::complex<data_t> *vec2;
+    thrust::complex<data_t> *vec3;
+    thrust::complex<data_t> q0, q1, q2, q3, q0t, q1t, q2t, q3t;
 
     vec0 = this->data_;
     vec1 = vec0 + offset;
@@ -425,51 +415,45 @@ class DensityDiagMatMult2x2 : public Chunk::GateFuncBase<data_t>
     vec1[i0] = thrust::conj(m0) * q1t;
     vec3[i0] = thrust::conj(m1) * q3t;
   }
-  const char* name(void)
-  {
-    return "DensityDiagMatMult2x2";
-  }
+  const char *name(void) { return "DensityDiagMatMult2x2"; }
 };
 
 template <typename data_t>
-class DensityDiagMatMultNxN : public Chunk::GateFuncBase<data_t>
-{
+class DensityDiagMatMultNxN : public Chunk::GateFuncBase<data_t> {
 protected:
   int nqubits_;
   int total_bits_;
   int chunk_bits_;
+
 public:
-  DensityDiagMatMultNxN(const reg_t &qb,int total,int chunk)
-  {
+  DensityDiagMatMultNxN(const reg_t &qb, int total, int chunk) {
     nqubits_ = qb.size();
     total_bits_ = total;
     chunk_bits_ = chunk;
   }
 
-  bool is_diagonal(void)
-  {
-    return true;
-  }
+  bool is_diagonal(void) { return true; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    uint_t j,imr,imc;
-    thrust::complex<data_t>* vec;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    uint_t j, imr, imc;
+    thrust::complex<data_t> *vec;
     thrust::complex<data_t> q;
-    thrust::complex<double>* pMat;
-    uint_t* qubits;
-    uint_t irow,icol,gid,local_mask;
-    uint_t irow_chunk,icol_chunk;
+    thrust::complex<double> *pMat;
+    uint_t *qubits;
+    uint_t irow, icol, gid, local_mask;
+    uint_t irow_chunk, icol_chunk;
 
     vec = this->data_;
     gid = this->base_index_;
 
-    irow_chunk = ((gid + i) >> (chunk_bits_*2)) >> (total_bits_ - chunk_bits_);
-    icol_chunk = ((gid + i) >> (chunk_bits_*2)) & ((1ull << (total_bits_ - chunk_bits_))-1);
+    irow_chunk =
+        ((gid + i) >> (chunk_bits_ * 2)) >> (total_bits_ - chunk_bits_);
+    icol_chunk = ((gid + i) >> (chunk_bits_ * 2)) &
+                 ((1ull << (total_bits_ - chunk_bits_)) - 1);
 
-    local_mask = (1ull << (chunk_bits_*2)) - 1;
+    local_mask = (1ull << (chunk_bits_ * 2)) - 1;
     irow = (i & local_mask) >> chunk_bits_;
-    icol = (i & local_mask) & ((1ull << chunk_bits_)-1);
+    icol = (i & local_mask) & ((1ull << chunk_bits_) - 1);
 
     irow += (irow_chunk << chunk_bits_);
     icol += (icol_chunk << chunk_bits_);
@@ -479,34 +463,31 @@ class DensityDiagMatMultNxN : public Chunk::GateFuncBase<data_t>
 
     imr = 0;
     imc = 0;
-    for(j=0;j<nqubits_;j++){
-      if(((irow >> qubits[j]) & 1) != 0){
+    for (j = 0; j < nqubits_; j++) {
+      if (((irow >> qubits[j]) & 1) != 0) {
         imr += (1 << j);
       }
-      if(((icol >> qubits[j]) & 1) != 0){
+      if (((icol >> qubits[j]) & 1) != 0) {
         imc += (1 << j);
       }
     }
 
     q = vec[i];
-    vec[i] = thrust::conj(pMat[imr])*pMat[imc]*q;
-  }
-  const char* name(void)
-  {
-    return "DensityDiagMatMultNxN";
+    vec[i] = thrust::conj(pMat[imr]) * pMat[imc] * q;
   }
+  const char *name(void) { return "DensityDiagMatMultNxN"; }
 };
 
 template <typename data_t>
-void DensityMatrixThrust<data_t>::apply_diagonal_unitary_matrix(const reg_t &qubits,
-                                                          const cvector_t<double> &diag) 
-{
+void DensityMatrixThrust<data_t>::apply_diagonal_unitary_matrix(
+    const reg_t &qubits, const cvector_t<double> &diag) {
   BaseVector::chunk_.StoreMatrix(diag);
   BaseVector::chunk_.StoreUintParams(qubits);
-  BaseVector::apply_function(DensityDiagMatMultNxN<data_t>(qubits, BaseVector::chunk_manager_->num_qubits()/2, num_qubits()));
+  BaseVector::apply_function(DensityDiagMatMultNxN<data_t>(
+      qubits, BaseVector::chunk_manager_->num_qubits() / 2, num_qubits()));
 
 #ifdef AER_DEBUG
-  BaseVector::DebugMsg(" density::apply_diagonal_unitary_matrix",qubits);
+  BaseVector::DebugMsg(" density::apply_diagonal_unitary_matrix", qubits);
   BaseVector::DebugDump();
 #endif
 }
@@ -515,8 +496,7 @@ void DensityMatrixThrust<data_t>::apply_diagonal_unitary_matrix(const reg_t &qub
 // Apply Specialized Gates
 //-----------------------------------------------------------------------
 template <typename data_t>
-class DensityMCX : public Chunk::GateFuncBase<data_t>
-{
+class DensityMCX : public Chunk::GateFuncBase<data_t> {
 protected:
   int total_qubits_;
   int chunk_qubits_;
@@ -524,71 +504,61 @@ class DensityMCX : public Chunk::GateFuncBase<data_t>
   uint_t offset_sp_;
   uint_t cmask_;
   bool enable_batch_;
+
 public:
-  DensityMCX(reg_t& qubits, uint_t num_cqubits, uint_t num_qubits,bool batch)
-  {
+  DensityMCX(reg_t &qubits, uint_t num_cqubits, uint_t num_qubits, bool batch) {
     total_qubits_ = num_qubits;
     chunk_qubits_ = num_cqubits;
 
-    offset_ = 1ull << qubits[qubits.size()-1];
-    offset_sp_ = 1ull << (qubits[qubits.size()-1] + chunk_qubits_);
+    offset_ = 1ull << qubits[qubits.size() - 1];
+    offset_sp_ = 1ull << (qubits[qubits.size() - 1] + chunk_qubits_);
     cmask_ = 0;
-    for(int i=0;i<qubits.size()-1;i++)
+    for (int i = 0; i < qubits.size() - 1; i++)
       cmask_ |= (1ull << qubits[i]);
     enable_batch_ = batch;
   }
-  bool is_diagonal(void)
-  {
-    return true;
-  }
-  bool batch_enable(void) override
-  {
-    return enable_batch_;
-  }
+  bool is_diagonal(void) { return true; }
+  bool batch_enable(void) override { return enable_batch_; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    thrust::complex<data_t>* vec0;
-    thrust::complex<data_t>* vec1 = nullptr;
-    thrust::complex<data_t> q0,q1;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    thrust::complex<data_t> *vec0;
+    thrust::complex<data_t> *vec1 = nullptr;
+    thrust::complex<data_t> q0, q1;
 
-    uint_t irow,icol,gid,local_mask,gcid;
-    uint_t irow_chunk,icol_chunk;
+    uint_t irow, icol, gid, local_mask, gcid;
+    uint_t irow_chunk, icol_chunk;
 
     gid = this->base_index_;
 
-    gcid = (gid + i) >> (chunk_qubits_*2);
+    gcid = (gid + i) >> (chunk_qubits_ * 2);
     irow_chunk = gcid >> (total_qubits_ - chunk_qubits_);
-    icol_chunk = gcid & ((1ull << (total_qubits_ - chunk_qubits_))-1);
+    icol_chunk = gcid & ((1ull << (total_qubits_ - chunk_qubits_)) - 1);
 
-    local_mask = (1ull << (chunk_qubits_*2)) - 1;
+    local_mask = (1ull << (chunk_qubits_ * 2)) - 1;
     irow = (i & local_mask) >> chunk_qubits_;
-    icol = (i & local_mask) & ((1ull << chunk_qubits_)-1);
+    icol = (i & local_mask) & ((1ull << chunk_qubits_) - 1);
 
     irow += (irow_chunk << chunk_qubits_);
     icol += (icol_chunk << chunk_qubits_);
 
     vec0 = this->data_;
-    if((icol & cmask_) == cmask_){
-      if((irow & cmask_) == cmask_){
-        if(i < (i ^ offset_)){
-          if(i < (i ^ offset_sp_)){
+    if ((icol & cmask_) == cmask_) {
+      if ((irow & cmask_) == cmask_) {
+        if (i < (i ^ offset_)) {
+          if (i < (i ^ offset_sp_)) {
             vec1 = vec0 + offset_sp_ + offset_;
-          }
-          else{
+          } else {
             vec1 = vec0 - offset_sp_ + offset_;
           }
         }
-      }
-      else if(i < (i ^ offset_)){
+      } else if (i < (i ^ offset_)) {
         vec1 = vec0 + offset_;
       }
-    }
-    else if((irow & cmask_) == cmask_ && i < (i ^ offset_sp_)){
+    } else if ((irow & cmask_) == cmask_ && i < (i ^ offset_sp_)) {
       vec1 = vec0 + offset_sp_;
     }
 
-    if(vec1 != nullptr){
+    if (vec1 != nullptr) {
       q0 = vec0[i];
       q1 = vec1[i];
 
@@ -596,17 +566,16 @@ class DensityMCX : public Chunk::GateFuncBase<data_t>
       vec1[i] = q0;
     }
   }
-  const char* name(void)
-  {
-    return "DensityMCXY";
-  }
+  const char *name(void) { return "DensityMCXY"; }
 };
 
 template <typename data_t>
-void DensityMatrixThrust<data_t>::apply_cnot(const uint_t qctrl, const uint_t qtrgt) 
-{
+void DensityMatrixThrust<data_t>::apply_cnot(const uint_t qctrl,
+                                             const uint_t qtrgt) {
   reg_t qubits = {qctrl, qtrgt};
-  BaseVector::apply_function(DensityMCX<data_t>(qubits, num_qubits(), BaseVector::chunk_manager_->num_qubits()/2, !BaseVector::cuStateVec_enable_));
+  BaseVector::apply_function(DensityMCX<data_t>(
+      qubits, num_qubits(), BaseVector::chunk_manager_->num_qubits() / 2,
+      !BaseVector::cuStateVec_enable_));
 
 #ifdef AER_DEBUG
   BaseVector::DebugMsg(" density::apply_cnot");
@@ -615,8 +584,7 @@ void DensityMatrixThrust<data_t>::apply_cnot(const uint_t qctrl, const uint_t qt
 }
 
 template <typename data_t>
-class DensityMCY : public Chunk::GateFuncBase<data_t>
-{
+class DensityMCY : public Chunk::GateFuncBase<data_t> {
 protected:
   int total_qubits_;
   int chunk_qubits_;
@@ -624,98 +592,87 @@ class DensityMCY : public Chunk::GateFuncBase<data_t>
   uint_t offset_sp_;
   uint_t cmask_;
   bool enable_batch_;
+
 public:
-  DensityMCY(reg_t& qubits, uint_t num_cqubits, uint_t num_qubits, bool batch)
-  {
+  DensityMCY(reg_t &qubits, uint_t num_cqubits, uint_t num_qubits, bool batch) {
     total_qubits_ = num_qubits;
     chunk_qubits_ = num_cqubits;
 
-    offset_ = 1ull << qubits[qubits.size()-1];
-    offset_sp_ = 1ull << (qubits[qubits.size()-1] + chunk_qubits_);
+    offset_ = 1ull << qubits[qubits.size() - 1];
+    offset_sp_ = 1ull << (qubits[qubits.size() - 1] + chunk_qubits_);
     cmask_ = 0;
-    for(int i=0;i<qubits.size()-1;i++)
+    for (int i = 0; i < qubits.size() - 1; i++)
       cmask_ |= (1ull << qubits[i]);
     enable_batch_ = batch;
   }
-  bool is_diagonal(void)
-  {
-    return true;
-  }
-  bool batch_enable(void) override
-  {
-    return enable_batch_;
-  }
+  bool is_diagonal(void) { return true; }
+  bool batch_enable(void) override { return enable_batch_; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    thrust::complex<data_t>* vec0;
-    thrust::complex<data_t>* vec1 = nullptr;
-    thrust::complex<data_t> q0,q1,t0,t1;
-    thrust::complex<data_t> s0,s1;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    thrust::complex<data_t> *vec0;
+    thrust::complex<data_t> *vec1 = nullptr;
+    thrust::complex<data_t> q0, q1, t0, t1;
+    thrust::complex<data_t> s0, s1;
 
-    uint_t irow,icol,gid,local_mask,gcid;
-    uint_t irow_chunk,icol_chunk;
+    uint_t irow, icol, gid, local_mask, gcid;
+    uint_t irow_chunk, icol_chunk;
 
     gid = this->base_index_;
 
-    gcid = (gid + i) >> (chunk_qubits_*2);
+    gcid = (gid + i) >> (chunk_qubits_ * 2);
     irow_chunk = gcid >> (total_qubits_ - chunk_qubits_);
-    icol_chunk = gcid & ((1ull << (total_qubits_ - chunk_qubits_))-1);
+    icol_chunk = gcid & ((1ull << (total_qubits_ - chunk_qubits_)) - 1);
 
-    local_mask = (1ull << (chunk_qubits_*2)) - 1;
+    local_mask = (1ull << (chunk_qubits_ * 2)) - 1;
     irow = (i & local_mask) >> chunk_qubits_;
-    icol = (i & local_mask) & ((1ull << chunk_qubits_)-1);
+    icol = (i & local_mask) & ((1ull << chunk_qubits_) - 1);
 
     irow += (irow_chunk << chunk_qubits_);
     icol += (icol_chunk << chunk_qubits_);
 
     vec0 = this->data_;
-    if((icol & cmask_) == cmask_){
-      if((irow & cmask_) == cmask_){
-        if(i < (i ^ offset_)){
-          if(i < (i ^ offset_sp_)){
+    if ((icol & cmask_) == cmask_) {
+      if ((irow & cmask_) == cmask_) {
+        if (i < (i ^ offset_)) {
+          if (i < (i ^ offset_sp_)) {
             vec1 = vec0 + offset_sp_ + offset_;
             s0 = 1.0;
             s1 = 1.0;
-          }
-          else{
+          } else {
             vec1 = vec0 - offset_sp_ + offset_;
             s0 = -1.0;
             s1 = -1.0;
           }
         }
-      }
-      else if(i < (i ^ offset_)){
+      } else if (i < (i ^ offset_)) {
         vec1 = vec0 + offset_;
-        s0 = thrust::complex<double>(0.0,-1.0);
-        s1 = thrust::complex<double>(0.0,1.0);
+        s0 = thrust::complex<double>(0.0, -1.0);
+        s1 = thrust::complex<double>(0.0, 1.0);
       }
-    }
-    else if((irow & cmask_) == cmask_ && i < (i ^ offset_sp_)){
+    } else if ((irow & cmask_) == cmask_ && i < (i ^ offset_sp_)) {
       vec1 = vec0 + offset_sp_;
-      s0 = thrust::complex<double>(0.0,1.0);
-      s1 = thrust::complex<double>(0.0,-1.0);
+      s0 = thrust::complex<double>(0.0, 1.0);
+      s1 = thrust::complex<double>(0.0, -1.0);
     }
 
-    if(vec1 != nullptr){
+    if (vec1 != nullptr) {
       q0 = vec0[i];
       q1 = vec1[i];
 
-      vec0[i] = s0*q1;
-      vec1[i] = s1*q0;
+      vec0[i] = s0 * q1;
+      vec1[i] = s1 * q0;
     }
   }
-  const char* name(void)
-  {
-    return "DensityMCXY";
-  }
+  const char *name(void) { return "DensityMCXY"; }
 };
 
 template <typename data_t>
-void DensityMatrixThrust<data_t>::apply_cy(const uint_t qctrl, const uint_t qtrgt)
-{
+void DensityMatrixThrust<data_t>::apply_cy(const uint_t qctrl,
+                                           const uint_t qtrgt) {
   reg_t qubits = {qctrl, qtrgt};
-  BaseVector::apply_function(DensityMCY<data_t>(qubits, num_qubits(), BaseVector::chunk_manager_->num_qubits()/2, !BaseVector::cuStateVec_enable_));
+  BaseVector::apply_function(DensityMCY<data_t>(
+      qubits, num_qubits(), BaseVector::chunk_manager_->num_qubits() / 2,
+      !BaseVector::cuStateVec_enable_));
 
 #ifdef AER_DEBUG
   BaseVector::DebugMsg(" density::apply_cy");
@@ -724,64 +681,61 @@ void DensityMatrixThrust<data_t>::apply_cy(const uint_t qctrl, const uint_t qtrg
 }
 
 template <typename data_t>
-class DensityPhase : public Chunk::GateFuncBase<data_t>
-{
+class DensityPhase : public Chunk::GateFuncBase<data_t> {
 protected:
   thrust::complex<double> phase_;
   int qubit_;
   int total_bits_;
   int chunk_bits_;
+
 public:
-  DensityPhase(int qubit,thrust::complex<double>* phase,int total,int chunk)
-  {
+  DensityPhase(int qubit, thrust::complex<double> *phase, int total,
+               int chunk) {
     qubit_ = qubit;
     phase_ = *phase;
     total_bits_ = total;
     chunk_bits_ = chunk;
   }
 
-  bool is_diagonal(void)
-  {
-    return true;
-  }
+  bool is_diagonal(void) { return true; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    thrust::complex<data_t>* vec;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    thrust::complex<data_t> *vec;
     thrust::complex<data_t> q;
-    uint_t irow,icol,gid,local_mask;
-    uint_t irow_chunk,icol_chunk;
+    uint_t irow, icol, gid, local_mask;
+    uint_t irow_chunk, icol_chunk;
 
     vec = this->data_;
     gid = this->base_index_;
 
-    irow_chunk = ((gid + i) >> (chunk_bits_*2)) >> (total_bits_ - chunk_bits_);
-    icol_chunk = ((gid + i) >> (chunk_bits_*2)) & ((1ull << (total_bits_ - chunk_bits_))-1);
+    irow_chunk =
+        ((gid + i) >> (chunk_bits_ * 2)) >> (total_bits_ - chunk_bits_);
+    icol_chunk = ((gid + i) >> (chunk_bits_ * 2)) &
+                 ((1ull << (total_bits_ - chunk_bits_)) - 1);
 
-    local_mask = (1ull << (chunk_bits_*2)) - 1;
+    local_mask = (1ull << (chunk_bits_ * 2)) - 1;
     irow = (i & local_mask) >> chunk_bits_;
-    icol = (i & local_mask) & ((1ull << chunk_bits_)-1);
+    icol = (i & local_mask) & ((1ull << chunk_bits_) - 1);
 
     irow += (irow_chunk << chunk_bits_);
     icol += (icol_chunk << chunk_bits_);
 
     q = vec[i];
-    if((icol >> qubit_) & 1)
-      q = phase_*q;
-    if((irow >> qubit_) & 1)
-      q = thrust::conj(phase_)*q;
+    if ((icol >> qubit_) & 1)
+      q = phase_ * q;
+    if ((irow >> qubit_) & 1)
+      q = thrust::conj(phase_) * q;
     vec[i] = q;
   }
-  const char* name(void)
-  {
-    return "DensityPhase";
-  }
+  const char *name(void) { return "DensityPhase"; }
 };
 
 template <typename data_t>
-void DensityMatrixThrust<data_t>::apply_phase(const uint_t q,const complex_t &phase) 
-{
-  BaseVector::apply_function(DensityPhase<data_t>(q, (thrust::complex<double>*)&phase, BaseVector::chunk_manager_->num_qubits()/2, num_qubits() ));
+void DensityMatrixThrust<data_t>::apply_phase(const uint_t q,
+                                              const complex_t &phase) {
+  BaseVector::apply_function(DensityPhase<data_t>(
+      q, (thrust::complex<double> *)&phase,
+      BaseVector::chunk_manager_->num_qubits() / 2, num_qubits()));
 
 #ifdef AER_DEBUG
   BaseVector::DebugMsg(" density::apply_phase");
@@ -790,8 +744,7 @@ void DensityMatrixThrust<data_t>::apply_phase(const uint_t q,const complex_t &ph
 }
 
 template <typename data_t>
-class DensityCPhase : public Chunk::GateFuncBase<data_t>
-{
+class DensityCPhase : public Chunk::GateFuncBase<data_t> {
 protected:
   uint_t offset;
   uint_t offset_sp;
@@ -799,9 +752,10 @@ class DensityCPhase : public Chunk::GateFuncBase<data_t>
   uint_t cmask_sp;
   thrust::complex<double> phase_;
   bool enable_batch_;
+
 public:
-  DensityCPhase(uint_t qc,uint_t qt,uint_t qs,std::complex<double> phase, bool batch)
-  {
+  DensityCPhase(uint_t qc, uint_t qt, uint_t qs, std::complex<double> phase,
+                bool batch) {
     offset = 1ull << qt;
     offset_sp = 1ull << (qt + qs);
     cmask = 1ull << qc;
@@ -810,23 +764,16 @@ class DensityCPhase : public Chunk::GateFuncBase<data_t>
     enable_batch_ = batch;
   }
 
-  int qubits_count(void)
-  {
-    return 2;
-  }
-  bool batch_enable(void) override
-  {
-    return enable_batch_;
-  }
+  int qubits_count(void) { return 2; }
+  bool batch_enable(void) override { return enable_batch_; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    uint_t i0,i1,i2;
-    thrust::complex<data_t>* vec0;
-    thrust::complex<data_t>* vec1;
-    thrust::complex<data_t>* vec2;
-    thrust::complex<data_t>* vec3;
-    thrust::complex<data_t> q0,q1,q2,q3;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    uint_t i0, i1, i2;
+    thrust::complex<data_t> *vec0;
+    thrust::complex<data_t> *vec1;
+    thrust::complex<data_t> *vec2;
+    thrust::complex<data_t> *vec3;
+    thrust::complex<data_t> q0, q1, q2, q3;
 
     vec0 = this->data_;
     vec1 = vec0 + offset;
@@ -841,52 +788,46 @@ class DensityCPhase : public Chunk::GateFuncBase<data_t>
     i0 = i0 + i1 + i2;
 
     q3 = vec3[i0];
-    if((i0 & cmask) == cmask){
+    if ((i0 & cmask) == cmask) {
       q1 = vec1[i0];
-      vec1[i0] = phase_*q1;
+      vec1[i0] = phase_ * q1;
 
-      q3 = phase_*q3;
+      q3 = phase_ * q3;
     }
-    if((i0 & cmask_sp) == cmask_sp){
+    if ((i0 & cmask_sp) == cmask_sp) {
       q2 = vec2[i0];
-      vec2[i0] = thrust::conj(phase_)*q2;
+      vec2[i0] = thrust::conj(phase_) * q2;
 
-      q3 = thrust::conj(phase_)*q3;
+      q3 = thrust::conj(phase_) * q3;
     }
     vec3[i0] = q3;
   }
-  const char* name(void)
-  {
-    return "DensityCPhase";
-  }
+  const char *name(void) { return "DensityCPhase"; }
 };
 
 template <typename data_t>
 void DensityMatrixThrust<data_t>::apply_cphase(const uint_t q0, const uint_t q1,
-                                         const complex_t &phase) 
-{
-  BaseVector::apply_function(DensityCPhase<data_t>(q0, q1, num_qubits(), phase , !BaseVector::cuStateVec_enable_));
+                                               const complex_t &phase) {
+  BaseVector::apply_function(DensityCPhase<data_t>(
+      q0, q1, num_qubits(), phase, !BaseVector::cuStateVec_enable_));
 
 #ifdef AER_DEBUG
-	BaseVector::DebugMsg(" density::apply_cphase");
+  BaseVector::DebugMsg(" density::apply_cphase");
 #endif
 }
 
 template <typename data_t>
 void DensityMatrixThrust<data_t>::apply_swap(const uint_t q0, const uint_t q1) {
   std::vector<std::pair<uint_t, uint_t>> pairs = {
-   {{1, 2}, {4, 8}, {5, 10}, {6, 9}, {7, 11}, {13, 14}}
-  };
+      {{1, 2}, {4, 8}, {5, 10}, {6, 9}, {7, 11}, {13, 14}}};
   const reg_t qubits = {{q0, q1, q0 + num_qubits(), q1 + num_qubits()}};
   BaseVector::apply_permutation_matrix(qubits, pairs);
 #ifdef AER_DEBUG
-	BaseVector::DebugMsg(" density::apply_swap",qubits);
+  BaseVector::DebugMsg(" density::apply_swap", qubits);
 #endif
 }
 
-template <typename data_t>
-class DensityX : public Chunk::GateFuncBase<data_t>
-{
+template <typename data_t> class DensityX : public Chunk::GateFuncBase<data_t> {
 protected:
   uint_t mask0;
   uint_t mask1;
@@ -894,32 +835,26 @@ class DensityX : public Chunk::GateFuncBase<data_t>
   uint_t offset1;
 
 public:
-  DensityX(int q0,int q1)
-  {
+  DensityX(int q0, int q1) {
     offset0 = 1ull << q0;
     offset1 = 1ull << q1;
-    if(q0 < q1){
+    if (q0 < q1) {
       mask0 = (1ull << q0) - 1;
       mask1 = (1ull << q1) - 1;
-    }
-    else{
+    } else {
       mask0 = (1ull << q1) - 1;
       mask1 = (1ull << q0) - 1;
     }
   }
-  int qubits_count(void)
-  {
-    return 2;
-  }
+  int qubits_count(void) { return 2; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    uint_t i0,i1,i2;
-    thrust::complex<data_t>* vec0;
-    thrust::complex<data_t>* vec1;
-    thrust::complex<data_t>* vec2;
-    thrust::complex<data_t>* vec3;
-    thrust::complex<data_t> q0,q1,q2,q3;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    uint_t i0, i1, i2;
+    thrust::complex<data_t> *vec0;
+    thrust::complex<data_t> *vec1;
+    thrust::complex<data_t> *vec2;
+    thrust::complex<data_t> *vec3;
+    thrust::complex<data_t> q0, q1, q2, q3;
 
     vec0 = this->data_;
     vec1 = vec0 + offset0;
@@ -943,26 +878,20 @@ class DensityX : public Chunk::GateFuncBase<data_t>
     vec2[i0] = q1;
     vec3[i0] = q0;
   }
-  const char* name(void)
-  {
-    return "DensityX";
-  }
+  const char *name(void) { return "DensityX"; }
 };
 
 template <typename data_t>
-void DensityMatrixThrust<data_t>::apply_x(const uint_t qubit) 
-{
-  BaseVector::apply_function(DensityX<data_t>(qubit, qubit + num_qubits()) );
+void DensityMatrixThrust<data_t>::apply_x(const uint_t qubit) {
+  BaseVector::apply_function(DensityX<data_t>(qubit, qubit + num_qubits()));
 
 #ifdef AER_DEBUG
-  BaseVector::DebugMsg(" density::apply_x",(int)qubit);
+  BaseVector::DebugMsg(" density::apply_x", (int)qubit);
   DebugDump();
 #endif
 }
 
-template <typename data_t>
-class DensityY : public Chunk::GateFuncBase<data_t>
-{
+template <typename data_t> class DensityY : public Chunk::GateFuncBase<data_t> {
 protected:
   uint_t mask0;
   uint_t mask1;
@@ -970,32 +899,26 @@ class DensityY : public Chunk::GateFuncBase<data_t>
   uint_t offset1;
 
 public:
-  DensityY(int q0,int q1)
-  {
+  DensityY(int q0, int q1) {
     offset0 = 1ull << q0;
     offset1 = 1ull << q1;
-    if(q0 < q1){
+    if (q0 < q1) {
       mask0 = (1ull << q0) - 1;
       mask1 = (1ull << q1) - 1;
-    }
-    else{
+    } else {
       mask0 = (1ull << q1) - 1;
       mask1 = (1ull << q0) - 1;
     }
   }
-  int qubits_count(void)
-  {
-    return 2;
-  }
+  int qubits_count(void) { return 2; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    uint_t i0,i1,i2;
-    thrust::complex<data_t>* vec0;
-    thrust::complex<data_t>* vec1;
-    thrust::complex<data_t>* vec2;
-    thrust::complex<data_t>* vec3;
-    thrust::complex<data_t> q0,q1,q2,q3;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    uint_t i0, i1, i2;
+    thrust::complex<data_t> *vec0;
+    thrust::complex<data_t> *vec1;
+    thrust::complex<data_t> *vec2;
+    thrust::complex<data_t> *vec3;
+    thrust::complex<data_t> q0, q1, q2, q3;
 
     vec0 = this->data_;
     vec1 = vec0 + offset0;
@@ -1019,74 +942,61 @@ class DensityY : public Chunk::GateFuncBase<data_t>
     vec2[i0] = -q1;
     vec3[i0] = q0;
   }
-  const char* name(void)
-  {
-    return "DensityY";
-  }
+  const char *name(void) { return "DensityY"; }
 };
 
 template <typename data_t>
-void DensityMatrixThrust<data_t>::apply_y(const uint_t qubit) 
-{
+void DensityMatrixThrust<data_t>::apply_y(const uint_t qubit) {
   const reg_t qubits = {{qubit, qubit + num_qubits()}};
 
-	BaseVector::apply_function(DensityY<data_t>(qubits[0], qubits[1]) );
+  BaseVector::apply_function(DensityY<data_t>(qubits[0], qubits[1]));
 
 #ifdef AER_DEBUG
-  BaseVector::DebugMsg(" density::apply_y",qubits);
+  BaseVector::DebugMsg(" density::apply_y", qubits);
   DebugDump();
 #endif
 }
 
 template <typename data_t>
 void DensityMatrixThrust<data_t>::apply_toffoli(const uint_t qctrl0,
-                                          const uint_t qctrl1,
-                                          const uint_t qtrgt) 
-{
+                                                const uint_t qctrl1,
+                                                const uint_t qtrgt) {
   reg_t qubits = {qctrl0, qctrl1, qtrgt};
-  BaseVector::apply_function(DensityMCX<data_t>(qubits, num_qubits(), BaseVector::chunk_manager_->num_qubits()/2, !BaseVector::cuStateVec_enable_));
+  BaseVector::apply_function(DensityMCX<data_t>(
+      qubits, num_qubits(), BaseVector::chunk_manager_->num_qubits() / 2,
+      !BaseVector::cuStateVec_enable_));
 
 #ifdef AER_DEBUG
-	BaseVector::DebugMsg(" density::apply_toffoli",qubits);
+  BaseVector::DebugMsg(" density::apply_toffoli", qubits);
 #endif
-
 }
 
 //-----------------------------------------------------------------------
 // Expectation Values
 //-----------------------------------------------------------------------
 
-//special case Z only
+// special case Z only
 template <typename data_t>
-class expval_pauli_Z_func_dm : public Chunk::GateFuncBase<data_t>
-{
+class expval_pauli_Z_func_dm : public Chunk::GateFuncBase<data_t> {
 protected:
   uint_t z_mask_;
   uint_t diag_stride_;
+
 public:
-  expval_pauli_Z_func_dm(uint_t z,uint_t stride)
-  {
+  expval_pauli_Z_func_dm(uint_t z, uint_t stride) {
     z_mask_ = z;
     diag_stride_ = 1 + stride;
   }
 
-  bool is_diagonal(void)
-  {
-    return true;
-  }
-  bool batch_enable(void)
-  {
-    return false;
-  }
-  uint_t size(int num_qubits)
-  {
+  bool is_diagonal(void) { return true; }
+  bool batch_enable(void) { return false; }
+  uint_t size(int num_qubits) {
     this->chunk_bits_ = num_qubits;
     return diag_stride_ - 1;
   }
 
-  __host__ __device__ double operator()(const uint_t &i) const
-  {
-    thrust::complex<data_t>* vec;
+  __host__ __device__ double operator()(const uint_t &i) const {
+    thrust::complex<data_t> *vec;
     thrust::complex<data_t> q0;
     double ret = 0.0;
 
@@ -1094,22 +1004,18 @@ class expval_pauli_Z_func_dm : public Chunk::GateFuncBase<data_t>
     q0 = vec[i * diag_stride_];
     ret = q0.real();
 
-    if(z_mask_ != 0){
-      if(Chunk::pop_count_kernel(i & z_mask_) & 1)
+    if (z_mask_ != 0) {
+      if (Chunk::pop_count_kernel(i & z_mask_) & 1)
         ret = -ret;
     }
 
     return ret;
   }
-  const char* name(void)
-  {
-    return "expval_pauli_Z";
-  }
+  const char *name(void) { return "expval_pauli_Z"; }
 };
 
 template <typename data_t>
-class expval_pauli_XYZ_func_dm : public Chunk::GateFuncBase<data_t>
-{
+class expval_pauli_XYZ_func_dm : public Chunk::GateFuncBase<data_t> {
 protected:
   uint_t x_mask_;
   uint_t z_mask_;
@@ -1117,31 +1023,27 @@ class expval_pauli_XYZ_func_dm : public Chunk::GateFuncBase<data_t>
   uint_t mask_u_;
   thrust::complex<data_t> phase_;
   uint_t rows_;
+
 public:
-  expval_pauli_XYZ_func_dm(uint_t x,uint_t z,uint_t x_max,std::complex<data_t> p,uint_t stride)
-  {
+  expval_pauli_XYZ_func_dm(uint_t x, uint_t z, uint_t x_max,
+                           std::complex<data_t> p, uint_t stride) {
     rows_ = stride;
     x_mask_ = x;
     z_mask_ = z;
     phase_ = p;
 
-    mask_u_ = ~((1ull << (x_max+1)) - 1);
+    mask_u_ = ~((1ull << (x_max + 1)) - 1);
     mask_l_ = (1ull << x_max) - 1;
   }
 
-  uint_t size(int num_qubits)
-  {
+  uint_t size(int num_qubits) {
     this->chunk_bits_ = num_qubits;
     return (rows_ >> 1);
   }
-  bool batch_enable(void)
-  {
-    return false;
-  }
+  bool batch_enable(void) { return false; }
 
-  __host__ __device__ double operator()(const uint_t &i) const
-  {
-    thrust::complex<data_t>* vec;
+  __host__ __device__ double operator()(const uint_t &i) const {
+    thrust::complex<data_t> *vec;
     thrust::complex<data_t> q0;
     double ret = 0.0;
     uint_t idx_vec, idx_mat;
@@ -1154,22 +1056,20 @@ class expval_pauli_XYZ_func_dm : public Chunk::GateFuncBase<data_t>
     q0 = vec[idx_mat];
     q0 = 2 * phase_ * q0;
     ret = q0.real();
-    if(z_mask_ != 0){
-      if(Chunk::pop_count_kernel(idx_vec & z_mask_) & 1)
+    if (z_mask_ != 0) {
+      if (Chunk::pop_count_kernel(idx_vec & z_mask_) & 1)
         ret = -ret;
     }
     return ret;
   }
-  const char* name(void)
-  {
-    return "expval_pauli_XYZ";
-  }
+  const char *name(void) { return "expval_pauli_XYZ"; }
 };
 
 template <typename data_t>
-double DensityMatrixThrust<data_t>::expval_pauli(const reg_t &qubits,
-                                                 const std::string &pauli,const complex_t initial_phase) const 
-{
+double
+DensityMatrixThrust<data_t>::expval_pauli(const reg_t &qubits,
+                                          const std::string &pauli,
+                                          const complex_t initial_phase) const {
   uint_t x_mask, z_mask, num_y, x_max;
   std::tie(x_mask, z_mask, num_y, x_max) = pauli_masks_and_phase(qubits, pauli);
 
@@ -1180,9 +1080,9 @@ double DensityMatrixThrust<data_t>::expval_pauli(const reg_t &qubits,
 
   double ret;
   // specialize x_max == 0
-  if(x_mask == 0) {
-    BaseVector::apply_function_sum(&ret,
-      expval_pauli_Z_func_dm<data_t>(z_mask, BaseMatrix::rows_) );
+  if (x_mask == 0) {
+    BaseVector::apply_function_sum(
+        &ret, expval_pauli_Z_func_dm<data_t>(z_mask, BaseMatrix::rows_));
     return ret;
   }
 
@@ -1190,41 +1090,38 @@ double DensityMatrixThrust<data_t>::expval_pauli(const reg_t &qubits,
   // This is (-1j) ** number of Y terms modulo 4
   auto phase = std::complex<data_t>(initial_phase);
   add_y_phase(num_y, phase);
-  BaseVector::apply_function_sum(&ret,
-    expval_pauli_XYZ_func_dm<data_t>(x_mask, z_mask, x_max, phase, BaseMatrix::rows_) );
+  BaseVector::apply_function_sum(
+      &ret, expval_pauli_XYZ_func_dm<data_t>(x_mask, z_mask, x_max, phase,
+                                             BaseMatrix::rows_));
   return ret;
 }
 
 template <typename data_t>
-class expval_pauli_XYZ_func_dm_non_diagonal : public Chunk::GateFuncBase<data_t>
-{
+class expval_pauli_XYZ_func_dm_non_diagonal
+    : public Chunk::GateFuncBase<data_t> {
 protected:
   uint_t x_mask_;
   uint_t z_mask_;
   thrust::complex<data_t> phase_;
   uint_t rows_;
+
 public:
-  expval_pauli_XYZ_func_dm_non_diagonal(uint_t x,uint_t z,uint_t x_max,std::complex<data_t> p,uint_t stride)
-  {
+  expval_pauli_XYZ_func_dm_non_diagonal(uint_t x, uint_t z, uint_t x_max,
+                                        std::complex<data_t> p, uint_t stride) {
     rows_ = stride;
     x_mask_ = x;
     z_mask_ = z;
     phase_ = p;
   }
 
-  uint_t size(int num_qubits)
-  {
+  uint_t size(int num_qubits) {
     this->chunk_bits_ = num_qubits;
     return rows_;
   }
-  bool batch_enable(void)
-  {
-    return false;
-  }
+  bool batch_enable(void) { return false; }
 
-  __host__ __device__ double operator()(const uint_t &i) const
-  {
-    thrust::complex<data_t>* vec;
+  __host__ __device__ double operator()(const uint_t &i) const {
+    thrust::complex<data_t> *vec;
     thrust::complex<data_t> q0;
     double ret = 0.0;
     uint_t idx_mat;
@@ -1236,22 +1133,19 @@ class expval_pauli_XYZ_func_dm_non_diagonal : public Chunk::GateFuncBase<data_t>
     q0 = vec[idx_mat];
     q0 = phase_ * q0;
     ret = q0.real();
-    if(z_mask_ != 0){
-      if(Chunk::pop_count_kernel(i & z_mask_) & 1)
+    if (z_mask_ != 0) {
+      if (Chunk::pop_count_kernel(i & z_mask_) & 1)
         ret = -ret;
     }
     return ret;
   }
-  const char* name(void)
-  {
-    return "expval_pauli_XYZ";
-  }
+  const char *name(void) { return "expval_pauli_XYZ"; }
 };
 
 template <typename data_t>
-double DensityMatrixThrust<data_t>::expval_pauli_non_diagonal_chunk(const reg_t &qubits,
-                                                 const std::string &pauli,const complex_t initial_phase) const 
-{
+double DensityMatrixThrust<data_t>::expval_pauli_non_diagonal_chunk(
+    const reg_t &qubits, const std::string &pauli,
+    const complex_t initial_phase) const {
   uint_t x_mask, z_mask, num_y, x_max;
   std::tie(x_mask, z_mask, num_y, x_max) = pauli_masks_and_phase(qubits, pauli);
 
@@ -1260,8 +1154,9 @@ double DensityMatrixThrust<data_t>::expval_pauli_non_diagonal_chunk(const reg_t
   auto phase = std::complex<data_t>(initial_phase);
   add_y_phase(num_y, phase);
   double ret;
-  BaseVector::apply_function_sum(&ret,
-    expval_pauli_XYZ_func_dm_non_diagonal<data_t>(x_mask, z_mask, x_max, phase, BaseMatrix::rows_) );
+  BaseVector::apply_function_sum(
+      &ret, expval_pauli_XYZ_func_dm_non_diagonal<data_t>(
+                x_mask, z_mask, x_max, phase, BaseMatrix::rows_));
 
   return ret;
 }
@@ -1270,25 +1165,22 @@ double DensityMatrixThrust<data_t>::expval_pauli_non_diagonal_chunk(const reg_t
 //-----------------------------------------------------------------------
 
 template <typename data_t>
-double DensityMatrixThrust<data_t>::probability(const uint_t outcome) const 
-{
+double DensityMatrixThrust<data_t>::probability(const uint_t outcome) const {
   const auto shift = BaseMatrix::num_rows() + 1;
   std::complex<data_t> ret;
   ret = (std::complex<data_t>)BaseVector::chunk_.Get(outcome * shift);
   return std::real(ret);
 }
 
-
 template <typename data_t>
-class density_probability_func : public Chunk::GateFuncBase<data_t>
-{
+class density_probability_func : public Chunk::GateFuncBase<data_t> {
 protected:
   uint_t qubit_sp_;
   uint_t mask_;
   uint_t cmask_;
+
 public:
-  density_probability_func(const reg_t &qubits,int i,uint_t sp)
-  {
+  density_probability_func(const reg_t &qubits, int i, uint_t sp) {
     int k;
     int nq = qubits.size();
 
@@ -1296,36 +1188,31 @@ class density_probability_func : public Chunk::GateFuncBase<data_t>
 
     mask_ = 0;
     cmask_ = 0;
-    for(k=0;k<nq;k++){
+    for (k = 0; k < nq; k++) {
       mask_ |= (1ull << qubits[k]);
 
-      if(((i >> k) & 1) != 0){
+      if (((i >> k) & 1) != 0) {
         cmask_ |= (1ull << qubits[k]);
       }
     }
   }
 
-  bool is_diagonal(void)
-  {
-    return true;
-  }
-  uint_t size(int num_qubits)
-  {
+  bool is_diagonal(void) { return true; }
+  uint_t size(int num_qubits) {
     this->chunk_bits_ = num_qubits;
     return (1ull << qubit_sp_);
   }
 
-  __host__ __device__ double operator()(const uint_t &i) const
-  {
+  __host__ __device__ double operator()(const uint_t &i) const {
     thrust::complex<data_t> q;
-    thrust::complex<data_t>* vec;
+    thrust::complex<data_t> *vec;
     double ret = 0.0;
 
     uint_t iChunk = i >> qubit_sp_;
-    uint_t lid = i - (iChunk  << qubit_sp_);
+    uint_t lid = i - (iChunk << qubit_sp_);
     uint_t idx = (iChunk << this->chunk_bits_) + (lid << qubit_sp_) + lid;
 
-    if((lid & mask_) == cmask_){
+    if ((lid & mask_) == cmask_) {
       vec = this->data_;
       q = vec[idx];
       ret = q.real();
@@ -1333,15 +1220,12 @@ class density_probability_func : public Chunk::GateFuncBase<data_t>
     return ret;
   }
 
-  const char* name(void)
-  {
-    return "density probabilities";
-  }
+  const char *name(void) { return "density probabilities"; }
 };
 
 template <typename data_t>
-std::vector<double> DensityMatrixThrust<data_t>::probabilities(const reg_t &qubits) const 
-{
+std::vector<double>
+DensityMatrixThrust<data_t>::probabilities(const reg_t &qubits) const {
   const size_t N = qubits.size();
   const int_t DIM = 1 << N;
 
@@ -1353,20 +1237,21 @@ std::vector<double> DensityMatrixThrust<data_t>::probabilities(const reg_t &qubi
   std::vector<double> probs(DIM, 0.);
 
   int i;
-  for(i=0;i<DIM;i++){
-    BaseVector::apply_function_sum(&probs[i],density_probability_func<data_t>(qubits,i,num_qubits()));
+  for (i = 0; i < DIM; i++) {
+    BaseVector::apply_function_sum(
+        &probs[i], density_probability_func<data_t>(qubits, i, num_qubits()));
   }
 
   return probs;
 }
 
 template <typename data_t>
-reg_t DensityMatrixThrust<data_t>::sample_measure(const std::vector<double> &rnds) const 
-{
+reg_t DensityMatrixThrust<data_t>::sample_measure(
+    const std::vector<double> &rnds) const {
   uint_t count = 1;
-  if(!BaseVector::multi_chunk_distribution_){
-    if(BaseVector::enable_batch_ && BaseVector::chunk_.pos() != 0){
-      return reg_t();   //first chunk execute all in batch
+  if (!BaseVector::multi_chunk_distribution_) {
+    if (BaseVector::enable_batch_ && BaseVector::chunk_.pos() != 0) {
+      return reg_t(); // first chunk execute all in batch
     }
     count = BaseVector::chunk_.container()->num_chunks();
   }
@@ -1376,28 +1261,27 @@ reg_t DensityMatrixThrust<data_t>::sample_measure(const std::vector<double> &rnd
 #ifdef AER_DEBUG
   reg_t samples;
 
-  samples = BaseVector::chunk_.sample_measure(rnds,nrows+1,false,count);
+  samples = BaseVector::chunk_.sample_measure(rnds, nrows + 1, false, count);
 
-  BaseVector::DebugMsg("sample_measure",samples);
+  BaseVector::DebugMsg("sample_measure", samples);
   return samples;
 #else
-  return BaseVector::chunk_.sample_measure(rnds,nrows+1,false,count);
+  return BaseVector::chunk_.sample_measure(rnds, nrows + 1, false, count);
 #endif
 }
 
 template <typename data_t>
-class density_reset_after_measure_func : public Chunk::GateFuncBase<data_t>
-{
+class density_reset_after_measure_func : public Chunk::GateFuncBase<data_t> {
 protected:
   uint_t num_qubits_;
   uint_t qubit_sp_;
-  double* probs_;
+  double *probs_;
   uint_t iter_;
   uint_t prob_buf_size_;
-public:
 
-  density_reset_after_measure_func(uint_t nq,uint_t qsp,double* probs,uint_t prob_size,uint_t iter)
-  {
+public:
+  density_reset_after_measure_func(uint_t nq, uint_t qsp, double *probs,
+                                   uint_t prob_size, uint_t iter) {
     num_qubits_ = nq;
     qubit_sp_ = qsp;
     probs_ = probs;
@@ -1405,222 +1289,221 @@ class density_reset_after_measure_func : public Chunk::GateFuncBase<data_t>
     prob_buf_size_ = prob_size;
   }
 
-  bool is_diagonal(void)
-  {
-    return true;
-  }
+  bool is_diagonal(void) { return true; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
+  __host__ __device__ void operator()(const uint_t &i) const {
     thrust::complex<data_t> q;
-    thrust::complex<data_t>* vec;
+    thrust::complex<data_t> *vec;
     double scale;
-    uint_t* qubits;
+    uint_t *qubits;
     uint_t j;
 
     uint_t iChunk = (i >> this->chunk_bits_);
-    scale = 1.0/probs_[iChunk + QV_RESET_CURRENT_PROB*prob_buf_size_];
+    scale = 1.0 / probs_[iChunk + QV_RESET_CURRENT_PROB * prob_buf_size_];
 
     vec = this->data_;
     qubits = this->params_;
 
     uint_t my_bit = 0;
     uint_t my_bit_sp = 0;
-    for(j=0;j<num_qubits_;j++){
-      my_bit += ( ((i >> qubits[j]) & 1) << j);
-      my_bit_sp += ( ((i >> (qubits[j] + qubit_sp_)) & 1) << j);
+    for (j = 0; j < num_qubits_; j++) {
+      my_bit += (((i >> qubits[j]) & 1) << j);
+      my_bit_sp += (((i >> (qubits[j] + qubit_sp_)) & 1) << j);
     }
-    if(iter_ == my_bit && iter_ == my_bit_sp)
-      vec[i] = scale*vec[i];
+    if (iter_ == my_bit && iter_ == my_bit_sp)
+      vec[i] = scale * vec[i];
     else
       vec[i] = 0.0;
   }
-  const char* name(void)
-  {
-    return "density_reset_after_measure";
-  }
+  const char *name(void) { return "density_reset_after_measure"; }
 };
 
 template <typename data_t>
-void DensityMatrixThrust<data_t>::apply_batched_measure(const reg_t& qubits,std::vector<RngEngine>& rng,const reg_t& cmemory,const reg_t& cregs)
-{
+void DensityMatrixThrust<data_t>::apply_batched_measure(
+    const reg_t &qubits, std::vector<RngEngine> &rng, const reg_t &cmemory,
+    const reg_t &cregs) {
   const int_t DIM = 1 << qubits.size();
-  uint_t i,count = 1;
-  if(BaseVector::enable_batch_){
-    if(BaseVector::chunk_.pos() != 0){
-      return;   //first chunk execute all in batch
+  uint_t i, count = 1;
+  if (BaseVector::enable_batch_) {
+    if (BaseVector::chunk_.pos() != 0) {
+      return; // first chunk execute all in batch
     }
   }
   count = BaseVector::chunk_.container()->num_chunks();
 
-  //total probability
-  BaseVector::apply_function_sum(nullptr,Chunk::trace_func<data_t>(BaseMatrix::rows_),true);
-  BaseVector::apply_function(set_probability_buffer_for_reset_func<data_t>(BaseVector::chunk_.probability_buffer(),BaseVector::chunk_.container()->num_chunks(),
-                                                                           BaseVector::chunk_.reduce_buffer(),BaseVector::chunk_.reduce_buffer_size()) );
+  // total probability
+  BaseVector::apply_function_sum(
+      nullptr, Chunk::trace_func<data_t>(BaseMatrix::rows_), true);
+  BaseVector::apply_function(set_probability_buffer_for_reset_func<data_t>(
+      BaseVector::chunk_.probability_buffer(),
+      BaseVector::chunk_.container()->num_chunks(),
+      BaseVector::chunk_.reduce_buffer(),
+      BaseVector::chunk_.reduce_buffer_size()));
 
   reg_t params(qubits.size() + cmemory.size() + cregs.size());
-  for(i=0;i<qubits.size();i++){
+  for (i = 0; i < qubits.size(); i++) {
     params[i] = qubits[i];
   }
-  for(i=0;i<cmemory.size();i++){
-    params[i+qubits.size()] = cmemory[i] + BaseVector::num_creg_bits_;
+  for (i = 0; i < cmemory.size(); i++) {
+    params[i + qubits.size()] = cmemory[i] + BaseVector::num_creg_bits_;
   }
-  for(i=0;i<cregs.size();i++){
-    params[cmemory.size()+qubits.size()+i] = cregs[i];
+  for (i = 0; i < cregs.size(); i++) {
+    params[cmemory.size() + qubits.size() + i] = cregs[i];
   }
   BaseVector::chunk_.StoreUintParams(params);
 
-  //probability
+  // probability
   std::vector<double> r(count);
-  for(i=0;i<count;i++){
+  for (i = 0; i < count; i++) {
     r[i] = rng[i].rand();
   }
-  BaseVector::chunk_.container()->copy_to_probability_buffer(r,QV_RESET_TARGET_PROB);
+  BaseVector::chunk_.container()->copy_to_probability_buffer(
+      r, QV_RESET_TARGET_PROB);
 
-  //set system register[0] to 1 used for conditional register
+  // set system register[0] to 1 used for conditional register
   uint_t system_reg = BaseVector::num_creg_bits_ + BaseVector::num_cmem_bits_;
-  BaseVector::store_cregister(system_reg,1);
+  BaseVector::store_cregister(system_reg, 1);
   BaseVector::chunk_.keep_conditional(true);
 
-  for(i=0;i<DIM-1;i++){
+  for (i = 0; i < DIM - 1; i++) {
     BaseVector::chunk_.set_conditional(system_reg);
-    BaseVector::apply_function_sum(nullptr,density_probability_func<data_t>(qubits,i,num_qubits()),true);
-
-    BaseVector::apply_function(check_measure_probability_func<data_t>(qubits.size(),BaseVector::chunk_.probability_buffer(),BaseVector::chunk_.container()->num_chunks(),
-                                                                        BaseVector::chunk_.reduce_buffer(),BaseVector::chunk_.reduce_buffer_size(),
-                                                                        i,cmemory.size(),cregs.size()) );
-
-    BaseVector::chunk_.set_conditional(system_reg+1);
-    BaseVector::apply_function(density_reset_after_measure_func<data_t>(qubits.size(),num_qubits(),BaseVector::chunk_.probability_buffer(),BaseVector::chunk_.container()->num_chunks(),i ));
-    BaseVector::store_cregister(system_reg+1,0);
-  }
-  //for last case
+    BaseVector::apply_function_sum(
+        nullptr, density_probability_func<data_t>(qubits, i, num_qubits()),
+        true);
+
+    BaseVector::apply_function(check_measure_probability_func<data_t>(
+        qubits.size(), BaseVector::chunk_.probability_buffer(),
+        BaseVector::chunk_.container()->num_chunks(),
+        BaseVector::chunk_.reduce_buffer(),
+        BaseVector::chunk_.reduce_buffer_size(), i, cmemory.size(),
+        cregs.size()));
+
+    BaseVector::chunk_.set_conditional(system_reg + 1);
+    BaseVector::apply_function(density_reset_after_measure_func<data_t>(
+        qubits.size(), num_qubits(), BaseVector::chunk_.probability_buffer(),
+        BaseVector::chunk_.container()->num_chunks(), i));
+    BaseVector::store_cregister(system_reg + 1, 0);
+  }
+  // for last case
   BaseVector::chunk_.keep_conditional(false);
   BaseVector::chunk_.set_conditional(system_reg);
-  BaseVector::apply_function(density_reset_after_measure_func<data_t>(qubits.size(),num_qubits(),BaseVector::chunk_.probability_buffer(),BaseVector::chunk_.container()->num_chunks(),DIM-1 ));
+  BaseVector::apply_function(density_reset_after_measure_func<data_t>(
+      qubits.size(), num_qubits(), BaseVector::chunk_.probability_buffer(),
+      BaseVector::chunk_.container()->num_chunks(), DIM - 1));
 
   BaseVector::chunk_.container()->request_creg_update();
 }
 
 template <typename data_t>
-class density_reset_func : public Chunk::GateFuncBase<data_t>
-{
+class density_reset_func : public Chunk::GateFuncBase<data_t> {
 protected:
   uint_t num_qubits_;
   uint_t qubit_sp_;
-public:
 
-  density_reset_func(uint_t q,uint_t qsp)
-  {
+public:
+  density_reset_func(uint_t q, uint_t qsp) {
     num_qubits_ = q;
     qubit_sp_ = qsp;
   }
 
-  bool is_diagonal(void)
-  {
-    return true;
-  }
-  uint_t size(int nq)
-  {
-    this->chunk_bits_ = nq - 2*num_qubits_;
-    return (1ull << (nq-2*num_qubits_) );
+  bool is_diagonal(void) { return true; }
+  uint_t size(int nq) {
+    this->chunk_bits_ = nq - 2 * num_qubits_;
+    return (1ull << (nq - 2 * num_qubits_));
   }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
+  __host__ __device__ void operator()(const uint_t &i) const {
     thrust::complex<data_t> q;
-    thrust::complex<data_t>* vec;
-    uint_t idx,ii,t,j,k;
-    uint_t* qubits;
-    uint_t* qubits_sorted;
+    thrust::complex<data_t> *vec;
+    uint_t idx, ii, t, j, k;
+    uint_t *qubits;
+    uint_t *qubits_sorted;
 
     qubits_sorted = this->params_;
     qubits = qubits_sorted + num_qubits_;
 
-    //calc base index
+    // calc base index
     idx = 0;
     ii = i;
-    for(j=0;j<num_qubits_;j++){
+    for (j = 0; j < num_qubits_; j++) {
       t = ii & ((1ull << qubits_sorted[j]) - 1);
       idx += t;
       ii = (ii - t) << 1;
     }
-    for(j=0;j<num_qubits_;j++){
+    for (j = 0; j < num_qubits_; j++) {
       t = ii & ((1ull << (qubits_sorted[j] + qubit_sp_)) - 1);
       idx += t;
       ii = (ii - t) << 1;
     }
     idx += ii;
 
-    //collect diagonal elements and reset elements
+    // collect diagonal elements and reset elements
     vec = this->data_;
     q = vec[idx];
-    for(j=1;j<(1ull << (num_qubits_*2));j++){
+    for (j = 1; j < (1ull << (num_qubits_ * 2)); j++) {
       ii = idx;
-      for(k=0;k<num_qubits_;k++){
-        if(((j >> k) & 1) != 0){
+      for (k = 0; k < num_qubits_; k++) {
+        if (((j >> k) & 1) != 0) {
           ii += (1ull << qubits[k]);
         }
       }
-      for(k=0;k<num_qubits_;k++){
-        if(((j >> (k+num_qubits_)) & 1) != 0){
-          ii += (1ull << (qubits[k]+qubit_sp_));
+      for (k = 0; k < num_qubits_; k++) {
+        if (((j >> (k + num_qubits_)) & 1) != 0) {
+          ii += (1ull << (qubits[k] + qubit_sp_));
         }
       }
-      if((j & ((1ull << num_qubits_) - 1)) == (j >> num_qubits_))
+      if ((j & ((1ull << num_qubits_) - 1)) == (j >> num_qubits_))
         q += vec[ii];
       vec[ii] = 0.0;
     }
     vec[idx] = q;
   }
-  const char* name(void)
-  {
-    return "reset";
-  }
+  const char *name(void) { return "reset"; }
 };
 
 template <typename data_t>
-void DensityMatrixThrust<data_t>::apply_reset(const reg_t& qubits)
-{
-  if(((BaseVector::multi_chunk_distribution_ && BaseVector::chunk_.device() >= 0) || BaseVector::enable_batch_) && BaseVector::chunk_.pos() != 0)
-    return;   //first chunk execute all in batch
+void DensityMatrixThrust<data_t>::apply_reset(const reg_t &qubits) {
+  if (((BaseVector::multi_chunk_distribution_ &&
+        BaseVector::chunk_.device() >= 0) ||
+       BaseVector::enable_batch_) &&
+      BaseVector::chunk_.pos() != 0)
+    return; // first chunk execute all in batch
 
   auto qubits_sorted = qubits;
   std::sort(qubits_sorted.begin(), qubits_sorted.end());
 
-  for(int_t i=0;i<qubits.size();i++){
+  for (int_t i = 0; i < qubits.size(); i++) {
     qubits_sorted.push_back(qubits[i]);
   }
   BaseVector::chunk_.StoreUintParams(qubits_sorted);
 
-  BaseVector::apply_function(density_reset_func<data_t>(qubits.size(),num_qubits()));
+  BaseVector::apply_function(
+      density_reset_func<data_t>(qubits.size(), num_qubits()));
 }
 
 #ifdef AER_DEBUG
 template <typename data_t>
-void DensityMatrixThrust<data_t>::DebugDump(void) const
-{
+void DensityMatrixThrust<data_t>::DebugDump(void) const {
   thrust::complex<data_t> t;
-  uint_t i,idx,n;
+  uint_t i, idx, n;
 
   BaseVector::chunk_.synchronize();
 
   n = 16;
-  if(n > (1ull << num_qubits()))
+  if (n > (1ull << num_qubits()))
     n = (1ull << num_qubits());
-  for(i=0;i<n;i++){
-    idx = i*(1ull << num_qubits())/n;
-    t = BaseVector::chunk_.Get(idx*(BaseMatrix::rows_+1));
-    spdlog::debug("   {0:05b} | {1:e}, {2:e}",idx,t.real(),t.imag());
+  for (i = 0; i < n; i++) {
+    idx = i * (1ull << num_qubits()) / n;
+    t = BaseVector::chunk_.Get(idx * (BaseMatrix::rows_ + 1));
+    spdlog::debug("   {0:05b} | {1:e}, {2:e}", idx, t.real(), t.imag());
   }
-  if(n < (1ull << num_qubits())){
-    idx = (1ull << num_qubits())-1;
-    t = BaseVector::chunk_.Get(idx*(BaseMatrix::rows_+1));
-    spdlog::debug("   {0:05b} | {1:e}, {2:e}",idx,t.real(),t.imag());
+  if (n < (1ull << num_qubits())) {
+    idx = (1ull << num_qubits()) - 1;
+    t = BaseVector::chunk_.Get(idx * (BaseMatrix::rows_ + 1));
+    spdlog::debug("   {0:05b} | {1:e}, {2:e}", idx, t.real(), t.imag());
   }
 }
 
-
 #endif
 
 //------------------------------------------------------------------------------
@@ -1630,11 +1513,11 @@ void DensityMatrixThrust<data_t>::DebugDump(void) const
 
 // ostream overload for templated qubitvector
 template <typename data_t>
-inline std::ostream &operator<<(std::ostream &out, const AER::QV::DensityMatrixThrust<data_t>&m) {
+inline std::ostream &operator<<(std::ostream &out,
+                                const AER::QV::DensityMatrixThrust<data_t> &m) {
   out << m.copy_to_matrix();
   return out;
 }
 
 //------------------------------------------------------------------------------
 #endif // end module
-
diff --git a/src/simulators/extended_stabilizer/ch_runner.hpp b/src/simulators/extended_stabilizer/ch_runner.hpp
index b9303e727e..78eb03a81c 100644
--- a/src/simulators/extended_stabilizer/ch_runner.hpp
+++ b/src/simulators/extended_stabilizer/ch_runner.hpp
@@ -15,8 +15,8 @@
 #ifndef chsimulator_runner_hpp
 #define chsimulator_runner_hpp
 
-#include "chlib/core.hpp"
 #include "chlib/chstabilizer.hpp"
+#include "chlib/core.hpp"
 #include "gates.hpp"
 
 #include "framework/json.hpp"
@@ -24,14 +24,13 @@
 #include "framework/rng.hpp"
 #include "framework/types.hpp"
 
-
 #define _USE_MATH_DEFINES
 #include <cmath>
 
 #include <algorithm>
+#include <complex>
 #include <cstdint>
 #include <functional>
-#include <complex>
 #include <vector>
 
 #ifdef _OPENMP
@@ -42,8 +41,8 @@ namespace CHSimulator {
 
 using chstabilizer_t = StabilizerState;
 
-const double T_ANGLE = M_PI/4.;
-const double TDG_ANGLE = -1.*M_PI/4.;
+const double T_ANGLE = M_PI / 4.;
+const double TDG_ANGLE = -1. * M_PI / 4.;
 
 const U1Sample t_sample(T_ANGLE);
 const U1Sample tdg_sample(TDG_ANGLE);
@@ -52,8 +51,7 @@ const uint_t ZERO = 0ULL;
 
 thread_local std::unordered_map<double, U1Sample> Z_ROTATIONS;
 
-class Runner
-{
+class Runner {
 private:
   uint_t n_qubits_ = 0;
   uint_t num_states_ = 0;
@@ -74,34 +72,31 @@ class Runner
   json_t serialize_state(uint_t rank) const;
 
 public:
-  Runner(): n_qubits_(0), num_states_(0) {};
+  Runner() : n_qubits_(0), num_states_(0){};
   Runner(uint_t n_qubits);
   virtual ~Runner() = default;
 
   void initialize(uint_t n_qubits);
   void initialize_omp(uint_t n_threads, uint_t threshold_rank);
 
-  bool empty() const
-  {
-    return (n_qubits_ == 0 || num_states_ == 0);
-  }
+  bool empty() const { return (n_qubits_ == 0 || num_states_ == 0); }
 
   uint_t get_num_states() const;
   uint_t get_n_qubits() const;
   bool check_omp_threshold();
 
-  //Convert each state to a json object and return it.
+  // Convert each state to a json object and return it.
   std::vector<std::string> serialize_decomposition() const;
 
-  //Creates num_states_ copies of the 'base state' in the runner
-  //This will be either the |0>^n state, or a stabilizer state
-  //produced by applying the first m Clifford gates of the
-  //circuit. 
+  // Creates num_states_ copies of the 'base state' in the runner
+  // This will be either the |0>^n state, or a stabilizer state
+  // produced by applying the first m Clifford gates of the
+  // circuit.
   void initialize_decomposition(uint_t n_states, double delta);
-  //Check if the coefficient omega is 0
+  // Check if the coefficient omega is 0
   bool check_eps(uint_t rank);
 
-  //Methods for applying gates
+  // Methods for applying gates
   void apply_cx(uint_t control, uint_t target, uint_t rank);
   void apply_cz(uint_t control, uint_t target, uint_t rank);
   void apply_swap(uint_t qubit_1, uint_t qubit_2, uint_t rank);
@@ -113,422 +108,369 @@ class Runner
   void apply_x(uint_t qubit, uint_t rank);
   void apply_y(uint_t qubit, uint_t rank);
   void apply_z(uint_t qubit, uint_t rank);
-  //Methods for non-clifford gates, including parameters for the Sampling
+  // Methods for non-clifford gates, including parameters for the Sampling
   void apply_t(uint_t qubit, double r, int rank);
   void apply_tdag(uint_t qubit, double r, int rank);
   void apply_u1(uint_t qubit, complex_t lambda, double r, int rank);
-  void apply_ccx(uint_t control_1, uint_t control_2, uint_t target, uint_t branch, int rank);
-  void apply_ccz(uint_t control_1, uint_t control_2, uint_t target, uint_t branch, int rank);
-  //Measure a Pauli projector on each term in the decomposition and update their coefficients
-  // omega.
+  void apply_ccx(uint_t control_1, uint_t control_2, uint_t target,
+                 uint_t branch, int rank);
+  void apply_ccz(uint_t control_1, uint_t control_2, uint_t target,
+                 uint_t branch, int rank);
+  // Measure a Pauli projector on each term in the decomposition and update
+  // their coefficients
+  //  omega.
   void apply_pauli(pauli_t &P);
   void apply_pauli_projector(const std::vector<pauli_t> &generators);
-  void apply_pauli_projector(const std::vector<pauli_t> &generators, uint_t rank);
-  //Routine for Norm Estimation, thin wrapper for the CHSimulator method that uses AER::RngEngine
-  //to set up the estimation routine.
-  double norm_estimation(uint_t n_samples, uint_t n_repetitions, AER::RngEngine &rng);
-  double norm_estimation(uint_t n_samples, uint_t n_repetitions, std::vector<pauli_t> generators, AER::RngEngine &rng);
-
-  //Metropolis Estimation for sampling from the output distribution
+  void apply_pauli_projector(const std::vector<pauli_t> &generators,
+                             uint_t rank);
+  // Routine for Norm Estimation, thin wrapper for the CHSimulator method that
+  // uses AER::RngEngine to set up the estimation routine.
+  double norm_estimation(uint_t n_samples, uint_t n_repetitions,
+                         AER::RngEngine &rng);
+  double norm_estimation(uint_t n_samples, uint_t n_repetitions,
+                         std::vector<pauli_t> generators, AER::RngEngine &rng);
+
+  // Metropolis Estimation for sampling from the output distribution
   uint_t metropolis_estimation(uint_t n_steps, AER::RngEngine &rng);
-  std::vector<uint_t> metropolis_estimation(uint_t n_steps, uint_t n_shots, AER::RngEngine &rng);
+  std::vector<uint_t> metropolis_estimation(uint_t n_steps, uint_t n_shots,
+                                            AER::RngEngine &rng);
   // NE Sampling Routines
-  uint_t ne_single_sample(uint_t default_samples, uint_t repetitions, bool preserve_states,
-                        const AER::reg_t &qubits, AER::RngEngine &rng);
-
-  std::vector<double> ne_probabilities(uint_t default_samples, uint_t repetitions,
-                        const AER::reg_t &qubits, AER::RngEngine &rng);
-  //Efficient Sampler for the output distribution of a stabilizer state
+  uint_t ne_single_sample(uint_t default_samples, uint_t repetitions,
+                          bool preserve_states, const AER::reg_t &qubits,
+                          AER::RngEngine &rng);
+
+  std::vector<double> ne_probabilities(uint_t default_samples,
+                                       uint_t repetitions,
+                                       const AER::reg_t &qubits,
+                                       AER::RngEngine &rng);
+  // Efficient Sampler for the output distribution of a stabilizer state
   uint_t stabilizer_sampler(AER::RngEngine &rng);
   std::vector<uint_t> stabilizer_sampler(uint_t n_shots, AER::RngEngine &rng);
-  //Utilities for the state-vector snapshot.
+  // Utilities for the state-vector snapshot.
   complex_t amplitude(uint_t x_measure);
   AER::Vector<complex_t> statevector();
-
 };
 
 //=========================================================================
 // Implementation
 //=========================================================================
 
-Runner::Runner(uint_t num_qubits)
-{
-  initialize(num_qubits);
-}
+Runner::Runner(uint_t num_qubits) { initialize(num_qubits); }
 
-void Runner::initialize(uint_t num_qubits)
-{
+void Runner::initialize(uint_t num_qubits) {
   states_.clear();
   coefficients_.clear();
   n_qubits_ = num_qubits;
   num_states_ = 1;
   num_threads_ = 1;
   states_ = std::vector<chstabilizer_t>(1, chstabilizer_t(num_qubits));
-  coefficients_.push_back(complex_t(1.,0.));
+  coefficients_.push_back(complex_t(1., 0.));
 }
 
-void Runner::initialize_decomposition(uint_t n_states, double delta)
-{
+void Runner::initialize_decomposition(uint_t n_states, double delta) {
   num_states_ = n_states;
   states_.reserve(num_states_);
   coefficients_.reserve(num_states_);
-  if(states_.size() > 1 || coefficients_.size() > 1)
-  {
-    throw std::runtime_error(std::string("CHSimulator::Runner was initialized without") + 
-                             std::string("being properly cleared since the last ") +
-                             std::string("experiment."));
+  if (states_.size() > 1 || coefficients_.size() > 1) {
+    throw std::runtime_error(
+        std::string("CHSimulator::Runner was initialized without") +
+        std::string("being properly cleared since the last ") +
+        std::string("experiment."));
   }
-  coefficients_[0] = complex_t(1./ delta,0.);
+  coefficients_[0] = complex_t(1. / delta, 0.);
   chstabilizer_t base_sate(states_[0]);
   complex_t coeff(coefficients_[0]);
-  for(uint_t i=1; i<num_states_; i++)
-  {
+  for (uint_t i = 1; i < num_states_; i++) {
     states_.push_back(base_sate);
     coefficients_.push_back(coeff);
   }
 }
 
-void Runner::initialize_omp(uint_t n_threads, uint_t threshold_rank)
-{
-  num_threads_ = (n_threads == 0 ? 1: n_threads);
+void Runner::initialize_omp(uint_t n_threads, uint_t threshold_rank) {
+  num_threads_ = (n_threads == 0 ? 1 : n_threads);
   omp_threshold_ = threshold_rank;
 }
 
-uint_t Runner::get_num_states() const
-{
-  return num_states_;
-}
+uint_t Runner::get_num_states() const { return num_states_; }
 
-uint_t Runner::get_n_qubits() const
-{
-  return n_qubits_;
-}
+uint_t Runner::get_n_qubits() const { return n_qubits_; }
 
-bool Runner::check_omp_threshold()
-{
-  return num_states_ > omp_threshold_;
-}
+bool Runner::check_omp_threshold() { return num_states_ > omp_threshold_; }
 
 //-------------------------------------------------------------------------
 // Operations on the decomposition
 //-------------------------------------------------------------------------
 
-void Runner::apply_pauli(pauli_t &P)
-{
+void Runner::apply_pauli(pauli_t &P) {
   const int_t END = num_states_;
-  #pragma omp parallel for if (num_states_ > omp_threshold_ && num_threads_ > 1) num_threads(num_threads_)
-  for(int_t i=0; i<END; i++)
-  {
+#pragma omp parallel for if (num_states_ > omp_threshold_ && num_threads_ > 1) \
+    num_threads(num_threads_)
+  for (int_t i = 0; i < END; i++) {
     states_[i].MeasurePauli(P);
   }
 }
 
-void Runner::apply_pauli_projector(const std::vector<pauli_t> &generators)
-{
+void Runner::apply_pauli_projector(const std::vector<pauli_t> &generators) {
   const int_t END = num_states_;
-  #pragma omp parallel for if(num_states_ > omp_threshold_ && num_threads_ > 1) num_threads(num_threads_)
-  for(int_t i=0; i<END; i++)
-  {
+#pragma omp parallel for if (num_states_ > omp_threshold_ && num_threads_ > 1) \
+    num_threads(num_threads_)
+  for (int_t i = 0; i < END; i++) {
     apply_pauli_projector(generators, i);
   }
 }
 
-void Runner::apply_pauli_projector(const std::vector<pauli_t> &generators, uint_t rank)
-{
+void Runner::apply_pauli_projector(const std::vector<pauli_t> &generators,
+                                   uint_t rank) {
   states_[rank].MeasurePauliProjector(generators);
 }
 
-bool Runner::check_eps(uint_t rank)
-{
-  return (states_[rank].Omega().eps == 1);
-}
+bool Runner::check_eps(uint_t rank) { return (states_[rank].Omega().eps == 1); }
 
-void Runner::apply_cx(uint_t control, uint_t target, uint_t rank)
-{
+void Runner::apply_cx(uint_t control, uint_t target, uint_t rank) {
   states_[rank].CX(control, target);
 }
 
-void Runner::apply_cz(uint_t control, uint_t target, uint_t rank)
-{
+void Runner::apply_cz(uint_t control, uint_t target, uint_t rank) {
   states_[rank].CZ(control, target);
 }
 
-void Runner::apply_swap(uint_t qubit_1, uint_t qubit_2, uint_t rank)
-{
+void Runner::apply_swap(uint_t qubit_1, uint_t qubit_2, uint_t rank) {
   states_[rank].CX(qubit_1, qubit_2);
   states_[rank].CX(qubit_2, qubit_1);
   states_[rank].CX(qubit_1, qubit_2);
 }
 
+void Runner::apply_h(uint_t qubit, uint_t rank) { states_[rank].H(qubit); }
 
-void Runner::apply_h(uint_t qubit, uint_t rank)
-{
-  states_[rank].H(qubit);
-}
-
-void Runner::apply_s(uint_t qubit, uint_t rank)
-{
-  states_[rank].S(qubit);
-}
+void Runner::apply_s(uint_t qubit, uint_t rank) { states_[rank].S(qubit); }
 
-void Runner::apply_sdag(uint_t qubit, uint_t rank)
-{
+void Runner::apply_sdag(uint_t qubit, uint_t rank) {
   states_[rank].Sdag(qubit);
 }
 
-void Runner::apply_sx(uint_t qubit, uint_t rank)
-{
+void Runner::apply_sx(uint_t qubit, uint_t rank) {
   states_[rank].Sdag(qubit);
   states_[rank].H(qubit);
   states_[rank].Sdag(qubit);
 }
 
-void Runner::apply_sxdg(uint_t qubit, uint_t rank)
-{
+void Runner::apply_sxdg(uint_t qubit, uint_t rank) {
   states_[rank].S(qubit);
   states_[rank].H(qubit);
   states_[rank].S(qubit);
 }
 
-void Runner::apply_x(uint_t qubit, uint_t rank)
-{
-  states_[rank].X(qubit);
-}
+void Runner::apply_x(uint_t qubit, uint_t rank) { states_[rank].X(qubit); }
 
-void Runner::apply_y(uint_t qubit, uint_t rank)
-{
-  states_[rank].Y(qubit);
-}
+void Runner::apply_y(uint_t qubit, uint_t rank) { states_[rank].Y(qubit); }
 
-void Runner::apply_z(uint_t qubit, uint_t rank)
-{
-  states_[rank].Z(qubit);
-}
+void Runner::apply_z(uint_t qubit, uint_t rank) { states_[rank].Z(qubit); }
 
-void Runner::apply_t(uint_t qubit, double r, int rank)
-{
+void Runner::apply_t(uint_t qubit, double r, int rank) {
   sample_branch_t branch = t_sample.sample(r);
   coefficients_[rank] *= branch.first;
-  if (branch.second == Gates::s)
-  {
+  if (branch.second == Gates::s) {
     states_[rank].S(qubit);
   }
 }
-void Runner::apply_tdag(uint_t qubit, double r, int rank)
-{
+void Runner::apply_tdag(uint_t qubit, double r, int rank) {
   sample_branch_t branch = tdg_sample.sample(r);
   coefficients_[rank] *= branch.first;
-  if (branch.second == Gates::sdg)
-  {
+  if (branch.second == Gates::sdg) {
     states_[rank].Sdag(qubit);
   }
 }
 
-void Runner::apply_u1(uint_t qubit, complex_t param, double r, int rank)
-{
+void Runner::apply_u1(uint_t qubit, complex_t param, double r, int rank) {
   double lambda = std::real(param);
-  auto it = Z_ROTATIONS.find(lambda); //Look for cached z_rotations
+  auto it = Z_ROTATIONS.find(lambda); // Look for cached z_rotations
   sample_branch_t branch;
-  if (it == Z_ROTATIONS.end())
-  {
+  if (it == Z_ROTATIONS.end()) {
     U1Sample rotation(lambda);
     Z_ROTATIONS.insert({lambda, rotation});
     branch = rotation.sample(r);
-  }
-  else
-  {
+  } else {
     branch = it->second.sample(r);
   }
   coefficients_[rank] *= branch.first;
-  switch(branch.second)
-  {
-    case Gates::s:
-      states_[rank].S(qubit);
-      break;
-    case Gates::sdg:
-      states_[rank].Sdag(qubit);
-      break;
-    case Gates::z:
-      states_[rank].Z(qubit);
-      break;
-    default:
-      break;
-  }
-}
-
-void Runner::apply_ccx(uint_t control_1, uint_t control_2, uint_t target, uint_t branch, int rank)
-{
-  switch(branch) //Decomposition of the CCX gate into Cliffords
-  {
-    case 1:
-      states_[rank].CZ(control_1, control_2);
-      break;
-    case 2:
-      states_[rank].CX(control_1, target);
-      break;
-    case 3:
-      states_[rank].CX(control_2, target);
-      break;
-    case 4:
-      states_[rank].CZ(control_1, control_2);
-      states_[rank].CX(control_1, target);
-      states_[rank].Z(control_1);
-      break;
-    case 5:
-      states_[rank].CZ(control_1, control_2);
-      states_[rank].CX(control_2, target);
-      states_[rank].Z(control_2);
-      break;
-    case 6:
-      states_[rank].CX(control_1, target);
-      states_[rank].CX(control_2, target);
-      states_[rank].X(target);
-      break;
-    case 7:
-      states_[rank].CZ(control_1, control_2);
-      states_[rank].CX(control_1, target);
-      states_[rank].CX(control_2, target);
-      states_[rank].Z(control_1);
-      states_[rank].Z(control_2);
-      states_[rank].X(target);
-      coefficients_[rank] *= -1; //Additional phase
-      break;
-    default: //Identity
-      break;
-  }
-}
-
-void Runner::apply_ccz(uint_t control_1, uint_t control_2, uint_t target, uint_t branch, int rank)
-{
-  switch(branch) //Decomposition of the CCZ gate into Cliffords
-  {
-    case 1:
-      states_[rank].CZ(control_1, control_2);
-      break;
-    case 2:
-      states_[rank].CZ(control_1, target);
-      break;
-    case 3:
-      states_[rank].CZ(control_2, target);
-      break;
-    case 4:
-      states_[rank].CZ(control_1, control_2);
-      states_[rank].CZ(control_1, target);
-      states_[rank].Z(control_1);
-      break;
-    case 5:
-      states_[rank].CZ(control_1, control_2);
-      states_[rank].CZ(control_2, target);
-      states_[rank].Z(control_2);
-      break;
-    case 6:
-      states_[rank].CZ(control_1, target);
-      states_[rank].CZ(control_2, target);
-      states_[rank].Z(target);
-      break;
-    case 7:
-      states_[rank].CZ(control_1, control_2);
-      states_[rank].CZ(control_1, target);
-      states_[rank].CZ(control_2, target);
-      states_[rank].Z(control_1);
-      states_[rank].Z(control_2);
-      states_[rank].Z(target);
-      coefficients_[rank] *= -1; //Additional phase
-      break;
-    default: //Identity
-      break;
+  switch (branch.second) {
+  case Gates::s:
+    states_[rank].S(qubit);
+    break;
+  case Gates::sdg:
+    states_[rank].Sdag(qubit);
+    break;
+  case Gates::z:
+    states_[rank].Z(qubit);
+    break;
+  default:
+    break;
+  }
+}
+
+void Runner::apply_ccx(uint_t control_1, uint_t control_2, uint_t target,
+                       uint_t branch, int rank) {
+  switch (branch) // Decomposition of the CCX gate into Cliffords
+  {
+  case 1:
+    states_[rank].CZ(control_1, control_2);
+    break;
+  case 2:
+    states_[rank].CX(control_1, target);
+    break;
+  case 3:
+    states_[rank].CX(control_2, target);
+    break;
+  case 4:
+    states_[rank].CZ(control_1, control_2);
+    states_[rank].CX(control_1, target);
+    states_[rank].Z(control_1);
+    break;
+  case 5:
+    states_[rank].CZ(control_1, control_2);
+    states_[rank].CX(control_2, target);
+    states_[rank].Z(control_2);
+    break;
+  case 6:
+    states_[rank].CX(control_1, target);
+    states_[rank].CX(control_2, target);
+    states_[rank].X(target);
+    break;
+  case 7:
+    states_[rank].CZ(control_1, control_2);
+    states_[rank].CX(control_1, target);
+    states_[rank].CX(control_2, target);
+    states_[rank].Z(control_1);
+    states_[rank].Z(control_2);
+    states_[rank].X(target);
+    coefficients_[rank] *= -1; // Additional phase
+    break;
+  default: // Identity
+    break;
+  }
+}
+
+void Runner::apply_ccz(uint_t control_1, uint_t control_2, uint_t target,
+                       uint_t branch, int rank) {
+  switch (branch) // Decomposition of the CCZ gate into Cliffords
+  {
+  case 1:
+    states_[rank].CZ(control_1, control_2);
+    break;
+  case 2:
+    states_[rank].CZ(control_1, target);
+    break;
+  case 3:
+    states_[rank].CZ(control_2, target);
+    break;
+  case 4:
+    states_[rank].CZ(control_1, control_2);
+    states_[rank].CZ(control_1, target);
+    states_[rank].Z(control_1);
+    break;
+  case 5:
+    states_[rank].CZ(control_1, control_2);
+    states_[rank].CZ(control_2, target);
+    states_[rank].Z(control_2);
+    break;
+  case 6:
+    states_[rank].CZ(control_1, target);
+    states_[rank].CZ(control_2, target);
+    states_[rank].Z(target);
+    break;
+  case 7:
+    states_[rank].CZ(control_1, control_2);
+    states_[rank].CZ(control_1, target);
+    states_[rank].CZ(control_2, target);
+    states_[rank].Z(control_1);
+    states_[rank].Z(control_2);
+    states_[rank].Z(target);
+    coefficients_[rank] *= -1; // Additional phase
+    break;
+  default: // Identity
+    break;
   }
 }
 
 //-------------------------------------------------------------------------
-//Measurement
+// Measurement
 //-------------------------------------------------------------------------
 
-double Runner::norm_estimation(uint_t n_samples, uint_t repetitions, AER::RngEngine &rng)
-{
+double Runner::norm_estimation(uint_t n_samples, uint_t repetitions,
+                               AER::RngEngine &rng) {
 
   const int_t NSAMPLES = n_samples;
   const int_t NQUBITS = n_qubits_;
   std::vector<double> xi_samples(repetitions, 0.);
-  for(uint_t m=0; m < repetitions; m++)
-  {
+  for (uint_t m = 0; m < repetitions; m++) {
     std::vector<uint_t> adiag_1(n_samples, 0ULL);
     std::vector<uint_t> adiag_2(n_samples, 0ULL);
-    std::vector< std::vector<uint_t> > a(n_samples, std::vector<uint_t>(n_qubits_, 0ULL));
-    #pragma omp parallel if (num_threads_ > 1) num_threads(num_threads_)
+    std::vector<std::vector<uint_t>> a(n_samples,
+                                       std::vector<uint_t>(n_qubits_, 0ULL));
+#pragma omp parallel if (num_threads_ > 1) num_threads(num_threads_)
     {
-      #ifdef _WIN32
-        #pragma omp for
-      #else
-        #pragma omp for collapse(2)
-      #endif
-      for (int_t l=0; l<NSAMPLES; l++)
-      {
-        for (int_t i=0; i<NQUBITS; i++)
-        {
-          for (int_t j=i; j<NQUBITS; j++)
-          {
-              if(rng.rand() < 0.5)
-              {
-                  a[l][i] |= (1ULL << j);
-                  a[l][j] |= (1ULL << i);
-              }
+#ifdef _WIN32
+#pragma omp for
+#else
+#pragma omp for collapse(2)
+#endif
+      for (int_t l = 0; l < NSAMPLES; l++) {
+        for (int_t i = 0; i < NQUBITS; i++) {
+          for (int_t j = i; j < NQUBITS; j++) {
+            if (rng.rand() < 0.5) {
+              a[l][i] |= (1ULL << j);
+              a[l][j] |= (1ULL << i);
+            }
           }
           adiag_1[l] |= (a[l][i] & (1ULL << i));
-          if (rng.rand() < 0.5)
-          {
-              adiag_2[l] |= (1ULL << i);
+          if (rng.rand() < 0.5) {
+            adiag_2[l] |= (1ULL << i);
           }
         }
       }
     } // end omp parallel
-    double xi = ParallelNormEstimate(states_, coefficients_, adiag_1, adiag_2, a, num_threads_);
+    double xi = ParallelNormEstimate(states_, coefficients_, adiag_1, adiag_2,
+                                     a, num_threads_);
     xi_samples[m] = xi;
   }
   // Get median of the xi samples
   std::sort(xi_samples.begin(), xi_samples.end());
   int mid_point = repetitions / 2;
-  return repetitions % 2 == 0 ? (xi_samples[mid_point] + xi_samples[mid_point - 1]) / 2. : xi_samples[mid_point];
-
+  return repetitions % 2 == 0
+             ? (xi_samples[mid_point] + xi_samples[mid_point - 1]) / 2.
+             : xi_samples[mid_point];
 }
 
-double Runner::norm_estimation(uint_t n_samples, uint_t repetitions, std::vector<pauli_t> generators, AER::RngEngine &rng)
-{
+double Runner::norm_estimation(uint_t n_samples, uint_t repetitions,
+                               std::vector<pauli_t> generators,
+                               AER::RngEngine &rng) {
   apply_pauli_projector(generators);
   return norm_estimation(n_samples, repetitions, rng);
 }
 
-uint_t Runner::ne_single_sample(uint_t default_samples,
-                              uint_t repetitions,
-                              bool preserve_states,
-                              const AER::reg_t &qubits,
-                              AER::RngEngine &rng)
-{
+uint_t Runner::ne_single_sample(uint_t default_samples, uint_t repetitions,
+                                bool preserve_states, const AER::reg_t &qubits,
+                                AER::RngEngine &rng) {
   uint_t n_samples = std::llrint(4 * std::pow(qubits.size(), 2));
-  if (default_samples > n_samples)
-  {
+  if (default_samples > n_samples) {
     n_samples = default_samples;
   }
   double denominator = norm_estimation(n_samples, repetitions, rng);
   std::vector<pauli_t> generators;
   std::vector<chstabilizer_t> states_cache(states_);
   uint_t out_string = ZERO;
-  for (uint_t i=0; i<qubits.size(); i++)
-  {
+  for (uint_t i = 0; i < qubits.size(); i++) {
     pauli_t generator;
     generator.Z = (1ULL << qubits[i]);
     apply_pauli(generator);
     // Compute probability this bit is 0, given the previous assignemnts
     double numerator = norm_estimation(n_samples, repetitions, rng);
     double p_zero_given_observations = numerator / denominator;
-    if (rng.rand() < p_zero_given_observations)
-    {
+    if (rng.rand() < p_zero_given_observations) {
       // We sample a 0 for this bit
       generators.push_back(generator);
       denominator = numerator;
-    }
-    else
-    {
+    } else {
       // We sample a 1, we need to update the states with this projection
       generator.e = 2;
       generators.push_back(generator);
@@ -544,77 +486,69 @@ uint_t Runner::ne_single_sample(uint_t default_samples,
   return out_string;
 }
 
-std::vector<double> Runner::ne_probabilities(uint_t default_samples, uint_t repetitions,
-                              const AER::reg_t &qubits, AER::RngEngine &rng)
-{
+std::vector<double> Runner::ne_probabilities(uint_t default_samples,
+                                             uint_t repetitions,
+                                             const AER::reg_t &qubits,
+                                             AER::RngEngine &rng) {
   uint_t n_probs = 1ULL << qubits.size();
   std::vector<double> probs(n_probs, 0.);
   std::vector<chstabilizer_t> states_cache(states_);
   std::vector<pauli_t> generators;
-  for (uint_t i=0; i<qubits.size(); i++)
-  {
+  for (uint_t i = 0; i < qubits.size(); i++) {
     pauli_t generator;
     generator.Z = 1ULL << qubits[i];
     generators.push_back(generator);
   }
   double norm = norm_estimation(default_samples, repetitions, rng);
-  for (uint_t i=0; i<n_probs; i++)
-  {
+  for (uint_t i = 0; i < n_probs; i++) {
     // Setup the generators to compute this output probability
-    for (uint_t j=0; j<qubits.size(); j++)
-    {
+    for (uint_t j = 0; j < qubits.size(); j++) {
       if ((i >> j) & 1ULL) {
         generators[j].e = 2;
-      }
-      else
-      {
+      } else {
         generators[j].e = 0;
       }
     }
-    double p_estimate = norm_estimation(default_samples, repetitions, generators, rng);
+    double p_estimate =
+        norm_estimation(default_samples, repetitions, generators, rng);
     probs[i] = p_estimate / norm;
     states_ = states_cache;
   }
   return probs;
 }
 
-uint_t Runner::metropolis_estimation(uint_t n_steps, AER::RngEngine &rng)
-{
+uint_t Runner::metropolis_estimation(uint_t n_steps, AER::RngEngine &rng) {
   init_metropolis(rng);
-  for (uint_t i=0; i<n_steps; i++)
-  {
+  for (uint_t i = 0; i < n_steps; i++) {
     metropolis_step(rng);
   }
   return x_string_;
 }
 
-std::vector<uint_t> Runner::metropolis_estimation(uint_t n_steps, uint_t n_shots, AER::RngEngine &rng)
-{
+std::vector<uint_t> Runner::metropolis_estimation(uint_t n_steps,
+                                                  uint_t n_shots,
+                                                  AER::RngEngine &rng) {
   std::vector<uint_t> shots(n_shots, zer);
   shots[0] = metropolis_estimation(n_steps, rng);
-  for (uint_t i=1; i<n_shots; i++)
-  {
+  for (uint_t i = 1; i < n_shots; i++) {
     metropolis_step(rng);
     shots[i] = x_string_;
   }
   return shots;
 }
 
-void Runner::init_metropolis(AER::RngEngine &rng)
-{
+void Runner::init_metropolis(AER::RngEngine &rng) {
   accept_ = false;
-  //Random initial x_string from RngEngine
-  uint_t max = (1ULL<<n_qubits_) - 1;
+  // Random initial x_string from RngEngine
+  uint_t max = (1ULL << n_qubits_) - 1;
   x_string_ = rng.rand_int(ZERO, max);
-  last_proposal_=0;
-  double local_real=0., local_imag=0.;
+  last_proposal_ = 0;
+  double local_real = 0., local_imag = 0.;
   const int_t END = num_states_;
-  #pragma omp parallel for if(num_states_ > omp_threshold_ && num_threads_ > 1) num_threads(num_threads_) reduction(+:local_real) reduction(+:local_imag)
-  for (int_t i=0; i<END; i++)
-  {
+#pragma omp parallel for if(num_states_ > omp_threshold_ && num_threads_ > 1) num_threads(num_threads_) reduction(+:local_real) reduction(+:local_imag)
+  for (int_t i = 0; i < END; i++) {
     scalar_t amp = states_[i].Amplitude(x_string_);
-    if(amp.eps == 1)
-    {
+    if (amp.eps == 1) {
       complex_t local = (amp.to_complex() * coefficients_[i]);
       local_real += local.real();
       local_imag += local.imag();
@@ -623,39 +557,30 @@ void Runner::init_metropolis(AER::RngEngine &rng)
   old_ampsum_ = complex_t(local_real, local_imag);
 }
 
-void Runner::metropolis_step(AER::RngEngine &rng)
-{
+void Runner::metropolis_step(AER::RngEngine &rng) {
   uint_t proposal = rng.rand(0ULL, n_qubits_);
-  if(accept_)
-  {
+  if (accept_) {
     x_string_ ^= (one << last_proposal_);
   }
-  double real_part = 0.,imag_part =0.;
-  if (accept_ == 0)
-  {
+  double real_part = 0., imag_part = 0.;
+  if (accept_ == 0) {
     const int_t END = num_states_;
-    #pragma omp parallel for if(num_states_ > omp_threshold_ && num_threads_ > 1) num_threads(num_threads_) reduction(+:real_part) reduction(+:imag_part)
-    for (int_t i=0; i<END; i++)
-    {
+#pragma omp parallel for if(num_states_ > omp_threshold_ && num_threads_ > 1) num_threads(num_threads_) reduction(+:real_part) reduction(+:imag_part)
+    for (int_t i = 0; i < END; i++) {
       scalar_t amp = states_[i].ProposeFlip(proposal);
-      if(amp.eps == 1)
-      {
+      if (amp.eps == 1) {
         complex_t local = (amp.to_complex() * coefficients_[i]);
         real_part += local.real();
         imag_part += local.imag();
       }
     }
-  }
-  else
-  {
+  } else {
     const int_t END = num_states_;
-    #pragma omp parallel for if(num_states_ > omp_threshold_ && num_threads_ > 1) num_threads(num_threads_) reduction(+:real_part) reduction(+:imag_part)
-    for (int_t i=0; i<END; i++)
-    {
+#pragma omp parallel for if(num_states_ > omp_threshold_ && num_threads_ > 1) num_threads(num_threads_) reduction(+:real_part) reduction(+:imag_part)
+    for (int_t i = 0; i < END; i++) {
       states_[i].AcceptFlip();
       scalar_t amp = states_[i].ProposeFlip(proposal);
-      if(amp.eps == 1)
-      {
+      if (amp.eps == 1) {
         complex_t local = (amp.to_complex() * coefficients_[i]);
         real_part += local.real();
         imag_part += local.imag();
@@ -663,58 +588,50 @@ void Runner::metropolis_step(AER::RngEngine &rng)
     }
   }
   complex_t ampsum(real_part, imag_part);
-  double p_threshold = std::norm(ampsum)/std::norm(old_ampsum_);
-  if(std::isinf(p_threshold) || std::isnan(p_threshold))
-  {
+  double p_threshold = std::norm(ampsum) / std::norm(old_ampsum_);
+  if (std::isinf(p_threshold) || std::isnan(p_threshold)) {
     accept_ = true;
     old_ampsum_ = ampsum;
-    last_proposal_ = proposal; //We try to move away from node with 0 probability.
-  }
-  else
-  {
+    last_proposal_ =
+        proposal; // We try to move away from node with 0 probability.
+  } else {
     double rand = rng.rand();
-    if (rand < p_threshold)
-    {
+    if (rand < p_threshold) {
       accept_ = true;
       old_ampsum_ = ampsum;
       last_proposal_ = proposal;
-    }
-    else
-    {
+    } else {
       accept_ = false;
     }
   }
 }
 
-uint_t Runner::stabilizer_sampler(AER::RngEngine &rng)
-{
-  uint_t max = (1ULL << n_qubits_) -1;
+uint_t Runner::stabilizer_sampler(AER::RngEngine &rng) {
+  uint_t max = (1ULL << n_qubits_) - 1;
   return states_[0].Sample(rng.rand_int(ZERO, max));
 }
 
-std::vector<uint_t> Runner::stabilizer_sampler(uint_t n_shots, AER::RngEngine &rng)
-{
-  if(num_states_ > 1)
-  {
-    throw std::invalid_argument("CH::Runner::stabilizer_sampler: This method can only be used for a single Stabilizer state.\n");
+std::vector<uint_t> Runner::stabilizer_sampler(uint_t n_shots,
+                                               AER::RngEngine &rng) {
+  if (num_states_ > 1) {
+    throw std::invalid_argument(
+        "CH::Runner::stabilizer_sampler: This method can only be used for a "
+        "single Stabilizer state.\n");
   }
   std::vector<uint_t> shots;
   shots.reserve(n_shots);
-  for(uint_t i=0; i<n_shots; i++)
-  {
+  for (uint_t i = 0; i < n_shots; i++) {
     shots.push_back(stabilizer_sampler(rng));
   }
   return shots;
 }
 
-complex_t Runner::amplitude(uint_t x_measure)
-{
-  double real_part=0., imag_part=0.;
-  //Splitting the reduction guarantees support on more OMP versions.
+complex_t Runner::amplitude(uint_t x_measure) {
+  double real_part = 0., imag_part = 0.;
+  // Splitting the reduction guarantees support on more OMP versions.
   const int_t END = num_states_;
-  #pragma omp parallel for if(num_states_ > omp_threshold_ && num_threads_ > 1) num_threads(num_threads_) reduction(+:real_part) reduction(+:imag_part)
-  for(int_t i=0; i<END; i++)
-  {
+#pragma omp parallel for if(num_states_ > omp_threshold_ && num_threads_ > 1) num_threads(num_threads_) reduction(+:real_part) reduction(+:imag_part)
+  for (int_t i = 0; i < END; i++) {
     complex_t amplitude = states_[i].Amplitude(x_measure).to_complex();
     amplitude *= coefficients_[i];
     real_part += amplitude.real();
@@ -723,24 +640,22 @@ complex_t Runner::amplitude(uint_t x_measure)
   return {real_part, imag_part};
 }
 
-AER::Vector<complex_t> Runner::statevector()
-{
+AER::Vector<complex_t> Runner::statevector() {
   uint_t ceil = 1ULL << n_qubits_;
   AER::Vector<complex_t> svector(ceil, false);
 
   double norm_squared = 0;
 
-  for(uint_t i=0; i<ceil; i++)
-  {
+  for (uint_t i = 0; i < ceil; i++) {
     svector[i] = amplitude(i);
-    norm_squared += svector[i].real()*svector[i].real() + svector[i].imag()*svector[i].imag();
+    norm_squared += svector[i].real() * svector[i].real() +
+                    svector[i].imag() * svector[i].imag();
   }
   double norm = std::sqrt(norm_squared);
-  for(uint_t i=0; i<ceil; i++)
-  {
+  for (uint_t i = 0; i < ceil; i++) {
     svector[i] /= norm;
   }
-  
+
   return svector;
 }
 
@@ -748,27 +663,24 @@ AER::Vector<complex_t> Runner::statevector()
 // Utility
 //=========================================================================
 
-inline void to_json(json_t &js, const Runner &rn)
-{
+inline void to_json(json_t &js, const Runner &rn) {
   js["num_qubits"] = rn.get_n_qubits();
   js["num_states"] = rn.get_num_states();
   js["decomposition"] = rn.serialize_decomposition();
 }
 
-std::vector<std::string> Runner::serialize_decomposition() const
-{
+std::vector<std::string> Runner::serialize_decomposition() const {
   std::vector<std::string> serialized_states(num_states_);
   const int_t END = num_states_;
-  #pragma omp parallel for if(num_threads_ > 1 && num_states_ > omp_threshold_) num_threads(num_threads_)
-  for(int_t i=0; i<END; i++)
-  {
+#pragma omp parallel for if (num_threads_ > 1 && num_states_ > omp_threshold_) \
+    num_threads(num_threads_)
+  for (int_t i = 0; i < END; i++) {
     serialized_states[i] = serialize_state(i).dump();
   }
   return serialized_states;
 }
 
-json_t Runner::serialize_state(uint_t rank) const
-{
+json_t Runner::serialize_state(uint_t rank) const {
   json_t js = json_t::object();
   std::vector<unsigned> gamma;
   std::vector<uint_t> M;
@@ -780,9 +692,8 @@ json_t Runner::serialize_state(uint_t rank) const
   G = states_[rank].GMatrix();
   uint_t gamma1 = states_[rank].Gamma1();
   uint_t gamma2 = states_[rank].Gamma2();
-  for(uint_t i=0; i<n_qubits_; i++)
-  {
-    gamma.push_back(((gamma1 >> i) & 1ULL) + 2*((gamma2 >> i) & 1ULL));
+  for (uint_t i = 0; i < n_qubits_; i++) {
+    gamma.push_back(((gamma1 >> i) & 1ULL) + 2 * ((gamma2 >> i) & 1ULL));
   }
   js["gamma"] = gamma;
   js["M"] = M;
@@ -793,5 +704,5 @@ json_t Runner::serialize_state(uint_t rank) const
   return js;
 }
 
-} // Close namespace CHSimulator
+} // namespace CHSimulator
 #endif
diff --git a/src/simulators/extended_stabilizer/chlib/chstabilizer.hpp b/src/simulators/extended_stabilizer/chlib/chstabilizer.hpp
index e55c3988da..21f15e2c27 100644
--- a/src/simulators/extended_stabilizer/chlib/chstabilizer.hpp
+++ b/src/simulators/extended_stabilizer/chlib/chstabilizer.hpp
@@ -26,110 +26,85 @@
 #include "core.hpp"
 #include "framework/utils.hpp"
 
-namespace CHSimulator
-{
-// Clifford simulator based on the CH-form 
-class StabilizerState
-{
+namespace CHSimulator {
+// Clifford simulator based on the CH-form
+class StabilizerState {
 public:
-  // constructor creates basis state |phi>=|00...0> 
+  // constructor creates basis state |phi>=|00...0>
   StabilizerState(const unsigned n_qubits);
-  //Copy constructor
-  StabilizerState(const StabilizerState& rhs);
+  // Copy constructor
+  StabilizerState(const StabilizerState &rhs);
   // n = number of qubits
   // qubits are numbered as q=0,1,...,n-1
 
-
-  uint_fast64_t NQubits() const
-  {
-    return n;
-  }
-  scalar_t Omega() const
-  {
-    return omega;
-  }
-  uint_fast64_t Gamma1() const
-  {
-    return gamma1;
-  }
-  uint_fast64_t Gamma2() const
-  {
-    return gamma2;
-  }
-  std::vector<uint_fast64_t> GMatrix() const
-  {
-    return G;
-  }
-  std::vector<uint_fast64_t> FMatrix() const
-  {
-    return F;
-  }
-  std::vector<uint_fast64_t> MMatrix() const
-  {
-    return M;
-  }
-
+  uint_fast64_t NQubits() const { return n; }
+  scalar_t Omega() const { return omega; }
+  uint_fast64_t Gamma1() const { return gamma1; }
+  uint_fast64_t Gamma2() const { return gamma2; }
+  std::vector<uint_fast64_t> GMatrix() const { return G; }
+  std::vector<uint_fast64_t> FMatrix() const { return F; }
+  std::vector<uint_fast64_t> MMatrix() const { return M; }
 
   // Clifford gates
   void CX(unsigned q, unsigned r); // q=control, r=target
   void CZ(unsigned q, unsigned r);
-  void H(unsigned q); 
-  void S(unsigned q); 
-  void Z(unsigned q); 
+  void H(unsigned q);
+  void S(unsigned q);
+  void Z(unsigned q);
   void X(unsigned q);
   void Y(unsigned q);
   void Sdag(unsigned q); // S inverse
- 
 
   // state preps
-  void CompBasisVector(uint_fast64_t x); // prepares |x> 
+  void CompBasisVector(uint_fast64_t x);     // prepares |x>
   void HadamardBasisVector(uint_fast64_t x); // prepares H(x)|00...0>
 
-
   // measurements
   scalar_t Amplitude(uint_fast64_t x); // computes the  amplitude <x|phi>
   uint_fast64_t Sample(); // returns a sample from the distribution |<x|phi>|^2
   uint_fast64_t Sample(uint_fast64_t v_mask);
-  void MeasurePauli(const pauli_t P); // applies a gate (I+P)/2 
-                                // where P is an arbitrary Pauli operator
-  void MeasurePauliProjector(const std::vector<pauli_t>& generators);
+  void MeasurePauli(const pauli_t P); // applies a gate (I+P)/2
+                                      // where P is an arbitrary Pauli operator
+  void MeasurePauliProjector(const std::vector<pauli_t> &generators);
+
+  inline scalar_t ScalarPart() { return omega; }
 
-  inline scalar_t ScalarPart() {return omega;} 
+  // InnerProduct & Norm Estimation
+  scalar_t InnerProduct(const uint_fast64_t &A_diag1,
+                        const uint_fast64_t &A_diag2,
+                        const std::vector<uint_fast64_t> &A);
 
-  
-  //InnerProduct & Norm Estimation
-  scalar_t InnerProduct(const uint_fast64_t& A_diag1, const uint_fast64_t& A_diag2, const std::vector<uint_fast64_t>& A);
-  
   // Metropolis updates:
   // To initialize Metropolis by a state x call Amplitude(x)
-  scalar_t ProposeFlip(unsigned flip_pos); // returns the amplitude <x'|phi> 
+  scalar_t ProposeFlip(unsigned flip_pos); // returns the amplitude <x'|phi>
                                            // where x'=bitflip(x,q)
                                            // x = current Metropolis state
-  inline void AcceptFlip() {P=Q;} // accept the proposed bit flip
-    
-  friend double NormEstimate(std::vector<StabilizerState>& states,
-              const std::vector< std::complex<double> >& phases, 
-              const std::vector<uint_fast64_t>& Samples_d1,
-              const std::vector<uint_fast64_t> &Samples_d2, 
-              const std::vector< std::vector<uint_fast64_t> >& Samples);
-  #ifdef _OPENMP
-  friend double ParallelNormEstimate(std::vector<StabilizerState>& states,
-                        const std::vector< std::complex<double> >& phases, 
-                        const std::vector<uint_fast64_t>& Samples_d1,
-                        const std::vector<uint_fast64_t> &Samples_d2, 
-                        const std::vector< std::vector<uint_fast64_t> >& Samples,
-                        int n_threads);
-  #endif
+  inline void AcceptFlip() { P = Q; }      // accept the proposed bit flip
+
+  friend double
+  NormEstimate(std::vector<StabilizerState> &states,
+               const std::vector<std::complex<double>> &phases,
+               const std::vector<uint_fast64_t> &Samples_d1,
+               const std::vector<uint_fast64_t> &Samples_d2,
+               const std::vector<std::vector<uint_fast64_t>> &Samples);
+#ifdef _OPENMP
+  friend double
+  ParallelNormEstimate(std::vector<StabilizerState> &states,
+                       const std::vector<std::complex<double>> &phases,
+                       const std::vector<uint_fast64_t> &Samples_d1,
+                       const std::vector<uint_fast64_t> &Samples_d2,
+                       const std::vector<std::vector<uint_fast64_t>> &Samples,
+                       int n_threads);
+#endif
 
 private:
-
-  unsigned n; 
+  unsigned n;
 
   // define CH-data (F,G,M,gamma,v,s,omega)  see Section IIIA for notations
 
   // stabilizer tableaux of the C-layer
-  uint_fast64_t gamma1; //phase vector gamma = gamma1 + 2*gamma2 (mod 4)
-  uint_fast64_t gamma2; 
+  uint_fast64_t gamma1; // phase vector gamma = gamma1 + 2*gamma2 (mod 4)
+  uint_fast64_t gamma2;
   // each column of F,G,M is represented by uint_fast64_t integer
   std::vector<uint_fast64_t> F; // F[i] = i-th column of F
   std::vector<uint_fast64_t> G; // G[i] = i-th column of G
@@ -137,7 +112,7 @@ class StabilizerState
 
   uint_fast64_t v; // H-layer U_H=H(v)
   uint_fast64_t s; // initial state |s>
-  scalar_t omega; // scalar factor such that |phi>=omega*U_C*U_H|s>
+  scalar_t omega;  // scalar factor such that |phi>=omega*U_C*U_H|s>
 
   // multiplies the C-layer on the right by a C-type gate
   void RightCX(unsigned q, unsigned r); // q=control, r=target
@@ -145,16 +120,15 @@ class StabilizerState
   void RightS(unsigned q);
   void RightZ(unsigned q);
   void RightSdag(unsigned q);
-  
-  // computes a Pauli operator U_C^{-1}X(x)U_C 
+
+  // computes a Pauli operator U_C^{-1}X(x)U_C
   pauli_t GetPauliX(uint_fast64_t x);
 
   // replace the initial state |s> in the CH-form by a superposition
   // (|t> + i^b |u>)*sqrt(1/2) as described in Proposition 3
-  // update the CH-form 
+  // update the CH-form
   void UpdateSvector(uint_fast64_t t, uint_fast64_t u, unsigned b);
 
-
   // F-transposed and M-transposed. Need this to compute amplitudes
   std::vector<uint_fast64_t> FT; // FT[i] = i-th row of F
   std::vector<uint_fast64_t> MT; // MT[i] = i-th row of M
@@ -164,14 +138,12 @@ class StabilizerState
   bool isReadyFT; // true if F-transposed is available
   bool isReadyMT; // true if M-transposed is available
 
-
   // auxiliary Pauli operators
   pauli_t P;
   pauli_t Q;
-  
 };
 
-using cdouble =  std::complex<double>;
+using cdouble = std::complex<double>;
 
 //-------------------------------//
 // Implementation                //
@@ -179,328 +151,271 @@ using cdouble =  std::complex<double>;
 
 // Clifford simulator based on the CH-form for for n<=64 qubits
 
-StabilizerState::StabilizerState(const unsigned n_qubits):
-n(n_qubits), // number of qubits
-gamma1(zer),
-gamma2(zer),
-F(n,zer),
-G(n,zer),
-M(n,zer),
-v(zer),
-s(zer),
-omega(),
-FT(n,zer),
-MT(n,zer),
-isReadyFT(false),
-isReadyMT(false)
-{
+StabilizerState::StabilizerState(const unsigned n_qubits)
+    : n(n_qubits), // number of qubits
+      gamma1(zer), gamma2(zer), F(n, zer), G(n, zer), M(n, zer), v(zer), s(zer),
+      omega(), FT(n, zer), MT(n, zer), isReadyFT(false), isReadyMT(false) {
   // initialize  by the basis vector 00...0
-  if(n>63)
-  {
-    throw std::invalid_argument("The CH simulator only supports up to 63 qubits.\n");
+  if (n > 63) {
+    throw std::invalid_argument(
+        "The CH simulator only supports up to 63 qubits.\n");
   }
 
   // G and F are identity matrices
-  for (unsigned q=0; q<n; q++)
-  {
-    G[q]=(one<<q);
-    F[q]=(one<<q);
+  for (unsigned q = 0; q < n; q++) {
+    G[q] = (one << q);
+    F[q] = (one << q);
   }
   omega.makeOne();
 }
 
-StabilizerState::StabilizerState(const StabilizerState& rhs):
-n(rhs.n), // number of qubits
-gamma1(rhs.gamma1),
-gamma2(rhs.gamma2),
-F(rhs.F),
-G(rhs.G),
-M(rhs.M),
-v(rhs.v),
-s(rhs.s),
-omega(rhs.omega),
-FT(rhs.FT),
-MT(rhs.MT),
-isReadyFT(rhs.isReadyFT),
-isReadyMT(rhs.isReadyMT)
-{
-}
-
-void StabilizerState::CompBasisVector(uint_fast64_t x)
-{
-  s=x;
-  v=zer;
-  gamma1=zer;
-  gamma2=zer;
+StabilizerState::StabilizerState(const StabilizerState &rhs)
+    : n(rhs.n), // number of qubits
+      gamma1(rhs.gamma1), gamma2(rhs.gamma2), F(rhs.F), G(rhs.G), M(rhs.M),
+      v(rhs.v), s(rhs.s), omega(rhs.omega), FT(rhs.FT), MT(rhs.MT),
+      isReadyFT(rhs.isReadyFT), isReadyMT(rhs.isReadyMT) {}
+
+void StabilizerState::CompBasisVector(uint_fast64_t x) {
+  s = x;
+  v = zer;
+  gamma1 = zer;
+  gamma2 = zer;
   omega.makeOne();
   // G and F are identity matrices, M is zero matrix
-  for (unsigned q=0; q<n; q++)
-  {
-    M[q]=zer;
-    G[q]=(one<<q);
-    F[q]=(one<<q);
+  for (unsigned q = 0; q < n; q++) {
+    M[q] = zer;
+    G[q] = (one << q);
+    F[q] = (one << q);
   }
-  isReadyFT=false;
-  isReadyMT=false;
+  isReadyFT = false;
+  isReadyMT = false;
 }
 
-void StabilizerState::HadamardBasisVector(uint_fast64_t x)
-{
-  s=zer;
-  v=x;
-  gamma1=zer;
-  gamma2=zer;
+void StabilizerState::HadamardBasisVector(uint_fast64_t x) {
+  s = zer;
+  v = x;
+  gamma1 = zer;
+  gamma2 = zer;
   omega.makeOne();
   // G and F are identity matrices, M is zero matrix
-  for (unsigned q=0; q<n; q++)
-  {
-    M[q]=zer;
-    G[q]=(one<<q);
-    F[q]=(one<<q);
+  for (unsigned q = 0; q < n; q++) {
+    M[q] = zer;
+    G[q] = (one << q);
+    F[q] = (one << q);
   }
-  isReadyFT=false;
-  isReadyMT=false;
+  isReadyFT = false;
+  isReadyMT = false;
 }
 
-void StabilizerState::RightS(unsigned q)
-{
-  isReadyMT=false;// we are going to change M
-  M[q]^=F[q];
+void StabilizerState::RightS(unsigned q) {
+  isReadyMT = false; // we are going to change M
+  M[q] ^= F[q];
   // update phase vector: gamma[p] gets gamma[p] - F_{p,q} (mod 4)   for all p
-  gamma2^=F[q]^(gamma1 & F[q]);
-  gamma1^=F[q];
+  gamma2 ^= F[q] ^ (gamma1 & F[q]);
+  gamma1 ^= F[q];
 }
 
-void StabilizerState::RightSdag(unsigned q)
-{
-  isReadyMT=false;// we are going to change M
-  M[q]^=F[q];
+void StabilizerState::RightSdag(unsigned q) {
+  isReadyMT = false; // we are going to change M
+  M[q] ^= F[q];
   // update phase vector: gamma[p] gets gamma[p] + F_{p,q} (mod 4)   for all p
-  gamma1^=F[q];
-  gamma2^=F[q]^(gamma1 & F[q]);
+  gamma1 ^= F[q];
+  gamma2 ^= F[q] ^ (gamma1 & F[q]);
 }
 
-void StabilizerState::RightZ(unsigned q)
-{
+void StabilizerState::RightZ(unsigned q) {
   // update phase vector: gamma[p] gets gamma[p] + 2F_{p,q} (mod 4)   for all p
-  gamma2^=F[q];
+  gamma2 ^= F[q];
 }
 
-void StabilizerState::S(unsigned q)
-{
-  isReadyMT=false;// we are going to change M
-  uint_fast64_t C=(one<<q);
-  for (unsigned p=0; p<n;  p++)
-  {
-    M[p]^=((G[p]>>q) & one)*C;
+void StabilizerState::S(unsigned q) {
+  isReadyMT = false; // we are going to change M
+  uint_fast64_t C = (one << q);
+  for (unsigned p = 0; p < n; p++) {
+    M[p] ^= ((G[p] >> q) & one) * C;
   }
   // update phase vector:  gamma[q] gets gamma[q] - 1
-  gamma1^=C;
-  gamma2^=((gamma1 >> q) & one )*C;
+  gamma1 ^= C;
+  gamma2 ^= ((gamma1 >> q) & one) * C;
 }
 
-void StabilizerState::Sdag(unsigned q)
-{
-  isReadyMT=false;// we are going to change M
-  uint_fast64_t C=(one<<q);
-  for (unsigned p=0; p<n;  p++)
-  {
-    M[p]^=((G[p]>>q) & one)*C;
+void StabilizerState::Sdag(unsigned q) {
+  isReadyMT = false; // we are going to change M
+  uint_fast64_t C = (one << q);
+  for (unsigned p = 0; p < n; p++) {
+    M[p] ^= ((G[p] >> q) & one) * C;
   }
   // update phase vector:  gamma[q] gets gamma[q] + 1
-  gamma2^=((gamma1 >> q) & one )*C;
-  gamma1^=C;
+  gamma2 ^= ((gamma1 >> q) & one) * C;
+  gamma1 ^= C;
 }
 
-void StabilizerState::Z(unsigned q)
-{
+void StabilizerState::Z(unsigned q) {
   // update phase vector:  gamma[q] gets gamma[q] + 2
-  gamma2^=(one<<q);
+  gamma2 ^= (one << q);
 }
 
-void StabilizerState::X(unsigned q)
-{
-  //Commute the Pauli through UC
-  if (!isReadyMT)
-  {
+void StabilizerState::X(unsigned q) {
+  // Commute the Pauli through UC
+  if (!isReadyMT) {
     TransposeM();
   }
-  if (!isReadyFT)
-  {
+  if (!isReadyFT) {
     TransposeF();
   }
   uint_fast64_t x_string = FT[q];
   uint_fast64_t z_string = MT[q];
-  //Initial phase correction
-  int phase = 2*((gamma1 >> q)&one) + 4*((gamma2>>q) & one);
-  //Commute the z_string through the hadamard layer
-  // Each z that hits a hadamard becomes a Pauli X
+  // Initial phase correction
+  int phase = 2 * ((gamma1 >> q) & one) + 4 * ((gamma2 >> q) & one);
+  // Commute the z_string through the hadamard layer
+  //  Each z that hits a hadamard becomes a Pauli X
   s ^= (z_string & v);
-  //Remaining Z gates add a global phase from their action on the s string
-  phase += 4*(AER::Utils::hamming_parity((z_string & ~(v)) & s));
-  //Commute the x_string through the hadamard layer
-  // Any remaining X gates update s
+  // Remaining Z gates add a global phase from their action on the s string
+  phase += 4 * (AER::Utils::hamming_parity((z_string & ~(v)) & s));
+  // Commute the x_string through the hadamard layer
+  //  Any remaining X gates update s
   s ^= (x_string & ~(v));
-  //New z gates add a global phase from their action on the s string
-  phase += 4*(AER::Utils::hamming_parity((x_string & v) & s));
-  //Update the global phase
-  omega.e = (omega.e + phase)%8;
+  // New z gates add a global phase from their action on the s string
+  phase += 4 * (AER::Utils::hamming_parity((x_string & v) & s));
+  // Update the global phase
+  omega.e = (omega.e + phase) % 8;
 }
 
-void StabilizerState::Y(unsigned q)
-{
+void StabilizerState::Y(unsigned q) {
   Z(q);
   X(q);
-  //Add a global phase of -i
-  omega.e = (omega.e + 2)%8;
+  // Add a global phase of -i
+  omega.e = (omega.e + 2) % 8;
 }
 
-void StabilizerState::RightCX(unsigned q, unsigned r)
-{
-  G[q]^=G[r];
-  F[r]^=F[q];
-  M[q]^=M[r];
+void StabilizerState::RightCX(unsigned q, unsigned r) {
+  G[q] ^= G[r];
+  F[r] ^= F[q];
+  M[q] ^= M[r];
 }
 
-void StabilizerState::CX(unsigned q, unsigned r)
-{
-  isReadyMT=false;// we are going to change M and F
-  isReadyFT=false;
-  uint_fast64_t C=(one<<q);
-  uint_fast64_t T=(one<<r);
-  bool b=false;
-  for (unsigned p=0; p<n;  p++)
-  {
-    b=( b != ( ( M[p] & C ) && ( F[p] & T ) )  );
-    G[p]^=((G[p]>>q) & one)*T;
-    F[p]^=((F[p]>>r) & one)*C;
-    M[p]^=((M[p]>>r) & one)*C;
+void StabilizerState::CX(unsigned q, unsigned r) {
+  isReadyMT = false; // we are going to change M and F
+  isReadyFT = false;
+  uint_fast64_t C = (one << q);
+  uint_fast64_t T = (one << r);
+  bool b = false;
+  for (unsigned p = 0; p < n; p++) {
+    b = (b != ((M[p] & C) && (F[p] & T)));
+    G[p] ^= ((G[p] >> q) & one) * T;
+    F[p] ^= ((F[p] >> r) & one) * C;
+    M[p] ^= ((M[p] >> r) & one) * C;
   }
   // update phase vector as
   // gamma[q] gets gamma[q] + gamma[r] + 2*b (mod 4)
-  if (b) gamma2^=C;
-  b= ( (gamma1 & C) && (gamma1 & T));
-  gamma1^=((gamma1 >> r) & one)*C;
-  gamma2^=((gamma2 >> r) & one)*C;
-  if (b) gamma2^=C;
+  if (b)
+    gamma2 ^= C;
+  b = ((gamma1 & C) && (gamma1 & T));
+  gamma1 ^= ((gamma1 >> r) & one) * C;
+  gamma2 ^= ((gamma2 >> r) & one) * C;
+  if (b)
+    gamma2 ^= C;
 }
 
-void StabilizerState::RightCZ(unsigned q, unsigned r)
-{
-  isReadyMT=false;// we are going to change M
-  M[q]^=F[r];
-  M[r]^=F[q];
-  gamma2^=(F[q] & F[r]);
+void StabilizerState::RightCZ(unsigned q, unsigned r) {
+  isReadyMT = false; // we are going to change M
+  M[q] ^= F[r];
+  M[r] ^= F[q];
+  gamma2 ^= (F[q] & F[r]);
 }
 
-void StabilizerState::CZ(unsigned q, unsigned r)
-{
-  isReadyMT=false;// we are going to change M
-  uint_fast64_t C=(one<<q);
-  uint_fast64_t T=(one<<r);
-  for (unsigned p=0; p<n;  p++)
-  {
-    M[p]^=((G[p]>>r) & one)*C;
-    M[p]^=((G[p]>>q) & one)*T;
+void StabilizerState::CZ(unsigned q, unsigned r) {
+  isReadyMT = false; // we are going to change M
+  uint_fast64_t C = (one << q);
+  uint_fast64_t T = (one << r);
+  for (unsigned p = 0; p < n; p++) {
+    M[p] ^= ((G[p] >> r) & one) * C;
+    M[p] ^= ((G[p] >> q) & one) * T;
   }
 }
 
-pauli_t StabilizerState::GetPauliX(uint_fast64_t x)
-{
+pauli_t StabilizerState::GetPauliX(uint_fast64_t x) {
   // make sure that M-transposed and F-transposed have been already computed
-  if (!isReadyMT)
-  {
+  if (!isReadyMT) {
     TransposeM();
   }
-  if (!isReadyFT)
-  {
+  if (!isReadyFT) {
     TransposeF();
   }
   pauli_t R;
 
-  for (unsigned pos=0; pos<n; pos++)
-  {
-    if (x & (one<<pos))
-    {
+  for (unsigned pos = 0; pos < n; pos++) {
+    if (x & (one << pos)) {
       pauli_t P1; // make P1=U_C^{-1} X_{pos} U_C
-      P1.e=1*((gamma1>>pos) & one);
-      P1.e+=2*((gamma2>>pos) & one);
-      P1.X=FT[pos];
-      P1.Z=MT[pos];
-      R*=P1;
+      P1.e = 1 * ((gamma1 >> pos) & one);
+      P1.e += 2 * ((gamma2 >> pos) & one);
+      P1.X = FT[pos];
+      P1.Z = MT[pos];
+      R *= P1;
     }
   }
- return R;
+  return R;
 }
 
-scalar_t StabilizerState::Amplitude(uint_fast64_t x)
-{
+scalar_t StabilizerState::Amplitude(uint_fast64_t x) {
   // compute transposed matrices if needed
-  if (!isReadyMT)
-  {
+  if (!isReadyMT) {
     TransposeM();
   }
-  if (!isReadyFT)
-  {
+  if (!isReadyFT) {
     TransposeF();
   }
   // compute Pauli U_C^{-1} X(x) U_C
-  P=GetPauliX(x);
+  P = GetPauliX(x);
 
-  if (!omega.eps) return omega; // the state is zero
+  if (!omega.eps)
+    return omega; // the state is zero
 
   // now the amplitude = complex conjugate of <s|U_H P |0^n>
   // Z-part of P is absorbed into 0^n
 
   scalar_t amp;
-  amp.e=2*P.e;
-  int p = (int) AER::Utils::popcount(v);
-  amp.p= -1 * p;// each Hadamard gate contributes 1/sqrt(2)
-  bool isNonZero=true;
-
-
-  for (unsigned q=0; q<n; q++)
-  {
-    uint_fast64_t pos=(one<<q);
-    if (v & pos)
-    {
-      amp.e += 4*( (s & pos) && (P.X & pos) ); // minus sign that comes from <1|H|1>
+  amp.e = 2 * P.e;
+  int p = (int)AER::Utils::popcount(v);
+  amp.p = -1 * p; // each Hadamard gate contributes 1/sqrt(2)
+  bool isNonZero = true;
+
+  for (unsigned q = 0; q < n; q++) {
+    uint_fast64_t pos = (one << q);
+    if (v & pos) {
+      amp.e +=
+          4 * ((s & pos) && (P.X & pos)); // minus sign that comes from <1|H|1>
+    } else {
+      isNonZero = (((P.X & pos) == (s & pos)));
     }
-    else
-    {
-      isNonZero=( ((P.X & pos)==(s & pos)) );
-    }
-    if (!isNonZero) break;
+    if (!isNonZero)
+      break;
   }
 
-
-  amp.e%=8;
-  if (isNonZero)
-  {
+  amp.e %= 8;
+  if (isNonZero) {
     amp.conjugate();
-  }
-  else
-  {
-    amp.eps=0;
+  } else {
+    amp.eps = 0;
     return amp;
   }
 
   // multiply amp by omega
-  amp.p+=omega.p;
-  amp.e=(amp.e + omega.e) % 8;
+  amp.p += omega.p;
+  amp.e = (amp.e + omega.e) % 8;
   return amp;
 }
 
-scalar_t StabilizerState::ProposeFlip(unsigned flip_pos)
-{
+scalar_t StabilizerState::ProposeFlip(unsigned flip_pos) {
   // Q gets Pauli operator U_C^{-1} X_{flip_pos} U_C
-  Q.e=1*((gamma1>>flip_pos) & one);
-  Q.e+=2*((gamma2>>flip_pos) & one);
-  Q.X=FT[flip_pos];
-  Q.Z=MT[flip_pos];
-  Q*=P;
+  Q.e = 1 * ((gamma1 >> flip_pos) & one);
+  Q.e += 2 * ((gamma2 >> flip_pos) & one);
+  Q.X = FT[flip_pos];
+  Q.Z = MT[flip_pos];
+  Q *= P;
 
-  if (!omega.eps) return omega; // the state is zero
+  if (!omega.eps)
+    return omega; // the state is zero
 
   // the rest is the same as Amplitude() except that P becomes Q
 
@@ -510,561 +425,517 @@ scalar_t StabilizerState::ProposeFlip(unsigned flip_pos)
   // the rest is the same as Amplitude() except that P is replaced by Q
 
   scalar_t amp;
-  amp.e=2*Q.e;
-  amp.p=-1*(AER::Utils::popcount(v));// each Hadamard gate contributes 1/sqrt(2)
-  bool isNonZero=true;
-
-  for (unsigned q=0; q<n; q++)
-  {
-    uint_fast64_t pos=(one<<q);
-    if (v & pos)
-    {
-      amp.e+=4*( (s & pos) && (Q.X & pos) ); // minus sign that comes from <1|H|1>
+  amp.e = 2 * Q.e;
+  amp.p = -1 *
+          (AER::Utils::popcount(v)); // each Hadamard gate contributes 1/sqrt(2)
+  bool isNonZero = true;
+
+  for (unsigned q = 0; q < n; q++) {
+    uint_fast64_t pos = (one << q);
+    if (v & pos) {
+      amp.e +=
+          4 * ((s & pos) && (Q.X & pos)); // minus sign that comes from <1|H|1>
+    } else {
+      isNonZero = (((Q.X & pos) == (s & pos)));
     }
-    else
-    {
-      isNonZero=( ((Q.X & pos)==(s & pos)) );
-    }
-    if (!isNonZero) break;
+    if (!isNonZero)
+      break;
   }
 
-  amp.e%=8;
-  if (isNonZero)
-  {
+  amp.e %= 8;
+  if (isNonZero) {
     amp.conjugate();
-  }
-  else
-  {
-    amp.eps=0;
+  } else {
+    amp.eps = 0;
     return amp;
   }
 
   // multiply amp by omega
-  amp.p+=omega.p;
-  amp.e=(amp.e + omega.e) % 8;
+  amp.p += omega.p;
+  amp.e = (amp.e + omega.e) % 8;
   return amp;
 }
 
-uint_fast64_t StabilizerState::Sample()
-{
-  uint_fast64_t x=zer;
-  for (unsigned q=0; q<n; q++)
-  {
-    bool w = !!(s & (one<<q));
-    w^=( (v & (one<<q)) && (rand() % 2) );
-    if (w) x^=G[q];
+uint_fast64_t StabilizerState::Sample() {
+  uint_fast64_t x = zer;
+  for (unsigned q = 0; q < n; q++) {
+    bool w = !!(s & (one << q));
+    w ^= ((v & (one << q)) && (rand() % 2));
+    if (w)
+      x ^= G[q];
   }
   return x;
 }
 
-uint_fast64_t StabilizerState::Sample(uint_fast64_t v_mask)
-{
-  //v_mask is a uniform random binary string we use to sample the bits
-  //of v in a single step.
-  uint_fast64_t x=zer;
-  uint_fast64_t masked_v = v&v_mask;
-  for (unsigned q=0; q<n; q++)
-  {
-    bool w = !!(s & (one<<q));
-    w^= !!(masked_v & (one<<q));
-    if (w) x^=G[q];
+uint_fast64_t StabilizerState::Sample(uint_fast64_t v_mask) {
+  // v_mask is a uniform random binary string we use to sample the bits
+  // of v in a single step.
+  uint_fast64_t x = zer;
+  uint_fast64_t masked_v = v & v_mask;
+  for (unsigned q = 0; q < n; q++) {
+    bool w = !!(s & (one << q));
+    w ^= !!(masked_v & (one << q));
+    if (w)
+      x ^= G[q];
   }
   return x;
 }
 
-
-void StabilizerState::TransposeF()
-{
-  for (unsigned p=0; p<n; p++) // look at p-th row of F
+void StabilizerState::TransposeF() {
+  for (unsigned p = 0; p < n; p++) // look at p-th row of F
   {
-    uint_fast64_t row=zer;
-    uint_fast64_t mask=(one<<p);
-    for (unsigned q=0; q<n; q++) // look at q-th column of F
-        if (F[q] & mask) row^=(one<<q);
-    FT[p]=row;
+    uint_fast64_t row = zer;
+    uint_fast64_t mask = (one << p);
+    for (unsigned q = 0; q < n; q++) // look at q-th column of F
+      if (F[q] & mask)
+        row ^= (one << q);
+    FT[p] = row;
   }
   isReadyFT = true;
 }
 
-void StabilizerState::TransposeM()
-{
-  for (unsigned p=0; p<n; p++) // look at p-th row of M
+void StabilizerState::TransposeM() {
+  for (unsigned p = 0; p < n; p++) // look at p-th row of M
   {
-    uint_fast64_t row=zer;
-    uint_fast64_t mask=(one<<p);
-    for (unsigned q=0; q<n; q++) // look at q-th column of M
-        if (M[q] & mask) row^=(one<<q);
-    MT[p]=row;
+    uint_fast64_t row = zer;
+    uint_fast64_t mask = (one << p);
+    for (unsigned q = 0; q < n; q++) // look at q-th column of M
+      if (M[q] & mask)
+        row ^= (one << q);
+    MT[p] = row;
   }
   isReadyMT = true;
 }
 
-void StabilizerState::UpdateSvector(uint_fast64_t t, uint_fast64_t u, unsigned b)
-{
-// take care of the trivial case: t=u
-    if (t==u)  // multiply omega by (1+i^b)/sqrt(2)
-        switch(b)
-        {
-             case 0 :
-                omega.p+=1;
-                s=t;
-                return;
-             case 1 :
-                s=t;
-                omega.e=(omega.e + 1) % 8;
-                return;
-             case 2 :
-                s=t;
-                omega.eps=0;
-                return;
-             case 3 :
-                s=t;
-                omega.e=(omega.e + 7) % 8;
-                return;
-             default :
-                // we should not get here
-                throw std::logic_error("Invalid phase factor found b:" + std::to_string(b) + ".\n");
-         }
-
-    // now t and u are distinct
-    isReadyFT=false; // below we are going to change F and M
-    isReadyMT=false;
-    // naming of variables roughly follows Section IIIA
-    uint_fast64_t ut=u^t;
-    uint_fast64_t nu0 = (~v) & ut;
-    uint_fast64_t nu1 = v & ut;
-    //
-    b%=4;
-    unsigned q=0;
-    uint_fast64_t qpos=zer;
-    if (nu0)
-    {
-
-        // the subset nu0 is non-empty
-        // find the first element of nu0
-        q=0;
-        while (!(nu0 & (one<<q))) q++;
-
-        qpos=(one<<q);
-        if(!(nu0 & qpos))
-        {
-          throw std::logic_error("Failed to find first bit of nu despite being non-empty.");
-        }
-
-        // if nu0 has size >1 then multiply U_C on the right by the first half of the circuit VC
-        nu0^=qpos; // set q-th bit to zero
-        if (nu0)
-            for (unsigned q1=q+1; q1<n; q1++)
-                if (nu0 & (one<<q1))
-                    RightCX(q,q1);
-
-        // if nu1 has size >0 then apply the second half of the circuit VC
-        if (nu1)
-            for (unsigned q1=0; q1<n; q1++)
-                if (nu1 & (one<<q1))
-                    RightCZ(q,q1);
-
-    }// if (nu0)
-    else
-    {
-        // if we got here when nu0 is empty
-        // find the first element of nu1
-        q=0;
-        while (!(nu1 & (one<<q)))  q++;
-
-        qpos=(one<<q);
-        if(!(nu1 & qpos))
-        {
-          throw std::logic_error("Expect at least one non-zero element in nu1.\n");
-        }
-
-        // if nu1 has size >1 then apply the circuit VC
-        nu1^=qpos;
-        if (nu1)
-            for (unsigned q1=q+1; q1<n; q1++)
-                if (nu1 & (one<<q1))
-                    RightCX(q1,q);
-
-    }// if (nu0) else
-
-    // update the initial state
-    // if t_q=1 then switch t_q and u_q
-    // uint_fast64_t y,z;
-    if (t & qpos)
-    {
-        s=u;
-        omega.e=(omega.e + 2*b) % 8;
-        b=(4-b) % 4;
-        if(!!(u & qpos))
-        {
-
-        }
+void StabilizerState::UpdateSvector(uint_fast64_t t, uint_fast64_t u,
+                                    unsigned b) {
+  // take care of the trivial case: t=u
+  if (t == u) // multiply omega by (1+i^b)/sqrt(2)
+    switch (b) {
+    case 0:
+      omega.p += 1;
+      s = t;
+      return;
+    case 1:
+      s = t;
+      omega.e = (omega.e + 1) % 8;
+      return;
+    case 2:
+      s = t;
+      omega.eps = 0;
+      return;
+    case 3:
+      s = t;
+      omega.e = (omega.e + 7) % 8;
+      return;
+    default:
+      // we should not get here
+      throw std::logic_error(
+          "Invalid phase factor found b:" + std::to_string(b) + ".\n");
     }
-    else
-        s=t;
-
-    // change the order of H and S gates
-    // H^{a} S^{b} |+> = eta^{e1} S^{e2} H^{e3} |e4>
-    // here eta=exp( i (pi/4) )
-    // a=0,1
-    // b=0,1,2,3
-    //
-    // H^0 S^0 |+> = eta^0 S^0 H^1 |0>
-    // H^0 S^1 |+> = eta^0 S^1 H^1 |0>
-    // H^0 S^2 |+> = eta^0 S^0 H^1 |1>
-    // H^0 S^3 |+> = eta^0 S^1 H^1 |1>
-    //
-    // H^1 S^0 |+> = eta^0 S^0 H^0 |0>
-    // H^1 S^1 |+> = eta^1 S^1 H^1 |1>
-    // H^1 S^2 |+> = eta^0 S^0 H^0 |1>
-    // H^1 S^3 |+> = eta^{7} S^1 H^1 |0>
-    //
-    // "analytic" formula:
-    // e1 = a * (b mod 2) * ( 3*b -2 )
-    // e2 = b mod 2
-    // e3 = not(a) + a * (b mod 2)
-    // e4 = not(a)*(b>=2) + a*( (b==1) || (b==2) )
-
-    bool a=((v & qpos)>0);
-    unsigned e1=a*(b % 2)*( 3*b -2);
-    unsigned e2 = b % 2;
-    bool e3 = ( (!a) != (a && ((b % 2)>0) ) );
-    bool e4 = ( ( (!a) && (b>=2) ) != (a && ((b==1) || (b==2)))  );
-
-    // update CH-form
-    // set q-th bit of s to e4
-    s&=~qpos;
-    s^=e4*qpos;
-
-    // set q-th bit of v to e3
-    v&=~qpos;
-    v^=e3*qpos;
-
-    // update the scalar factor omega
-    omega.e=(omega.e  + e1) % 8;
-
-    // multiply the C-layer on the right by S^{e2} on the q-th qubit
-    if (e2) RightS(q);
-}
-
-
 
-void StabilizerState::H(unsigned q)
-{
-    isReadyMT=false;// we are going to change M and F
-    isReadyFT=false;
-    // extract the q-th row of F,G,M
-    uint_fast64_t rowF=zer;
-    uint_fast64_t rowG=zer;
-    uint_fast64_t rowM=zer;
-    for (unsigned j=0; j<n; j++)
-    {
-        uint_fast64_t pos=(one<<j);
-        rowF^=pos*( (F[j]>>q) & one );
-        rowG^=pos*( (G[j]>>q) & one );
-        rowM^=pos*( (M[j]>>q) & one );
+  // now t and u are distinct
+  isReadyFT = false; // below we are going to change F and M
+  isReadyMT = false;
+  // naming of variables roughly follows Section IIIA
+  uint_fast64_t ut = u ^ t;
+  uint_fast64_t nu0 = (~v) & ut;
+  uint_fast64_t nu1 = v & ut;
+  //
+  b %= 4;
+  unsigned q = 0;
+  uint_fast64_t qpos = zer;
+  if (nu0) {
+
+    // the subset nu0 is non-empty
+    // find the first element of nu0
+    q = 0;
+    while (!(nu0 & (one << q)))
+      q++;
+
+    qpos = (one << q);
+    if (!(nu0 & qpos)) {
+      throw std::logic_error(
+          "Failed to find first bit of nu despite being non-empty.");
     }
 
-    // after commuting H through the C and H laters it maps |s> to a state
-    // sqrt(0.5)*[  (-1)^alpha |t> + i^{gamma[p]} (-1)^beta |u>  ]
-    //
-    // compute t,s,alpha,beta
-    uint_fast64_t t = s ^ (rowG & v);
-    uint_fast64_t u = s ^ (rowF & (~v)) ^ (rowM & v);
-
-    unsigned alpha =  AER::Utils::popcount( rowG & (~v) & s );
-    unsigned beta =  AER::Utils::popcount( (rowM & (~v) & s) ^ (rowF & v & (rowM ^ s)) );
-
-    if (alpha % 2) omega.e=(omega.e+4) % 8;
-    // get the phase gamma[q]
-    unsigned phase = ((gamma1>>q) & one) + 2*((gamma2>>q) & one);
-    unsigned b=(phase + 2*alpha + 2*beta) % 4;
-
+    // if nu0 has size >1 then multiply U_C on the right by the first half of
+    // the circuit VC
+    nu0 ^= qpos; // set q-th bit to zero
+    if (nu0)
+      for (unsigned q1 = q + 1; q1 < n; q1++)
+        if (nu0 & (one << q1))
+          RightCX(q, q1);
+
+    // if nu1 has size >0 then apply the second half of the circuit VC
+    if (nu1)
+      for (unsigned q1 = 0; q1 < n; q1++)
+        if (nu1 & (one << q1))
+          RightCZ(q, q1);
+
+  } // if (nu0)
+  else {
+    // if we got here when nu0 is empty
+    // find the first element of nu1
+    q = 0;
+    while (!(nu1 & (one << q)))
+      q++;
+
+    qpos = (one << q);
+    if (!(nu1 & qpos)) {
+      throw std::logic_error("Expect at least one non-zero element in nu1.\n");
+    }
 
-    // now the initial state is sqrt(0.5)*(|t> + i^b |u>)
+    // if nu1 has size >1 then apply the circuit VC
+    nu1 ^= qpos;
+    if (nu1)
+      for (unsigned q1 = q + 1; q1 < n; q1++)
+        if (nu1 & (one << q1))
+          RightCX(q1, q);
+
+  } // if (nu0) else
+
+  // update the initial state
+  // if t_q=1 then switch t_q and u_q
+  // uint_fast64_t y,z;
+  if (t & qpos) {
+    s = u;
+    omega.e = (omega.e + 2 * b) % 8;
+    b = (4 - b) % 4;
+    if (!!(u & qpos)) {
+    }
+  } else
+    s = t;
+
+  // change the order of H and S gates
+  // H^{a} S^{b} |+> = eta^{e1} S^{e2} H^{e3} |e4>
+  // here eta=exp( i (pi/4) )
+  // a=0,1
+  // b=0,1,2,3
+  //
+  // H^0 S^0 |+> = eta^0 S^0 H^1 |0>
+  // H^0 S^1 |+> = eta^0 S^1 H^1 |0>
+  // H^0 S^2 |+> = eta^0 S^0 H^1 |1>
+  // H^0 S^3 |+> = eta^0 S^1 H^1 |1>
+  //
+  // H^1 S^0 |+> = eta^0 S^0 H^0 |0>
+  // H^1 S^1 |+> = eta^1 S^1 H^1 |1>
+  // H^1 S^2 |+> = eta^0 S^0 H^0 |1>
+  // H^1 S^3 |+> = eta^{7} S^1 H^1 |0>
+  //
+  // "analytic" formula:
+  // e1 = a * (b mod 2) * ( 3*b -2 )
+  // e2 = b mod 2
+  // e3 = not(a) + a * (b mod 2)
+  // e4 = not(a)*(b>=2) + a*( (b==1) || (b==2) )
+
+  bool a = ((v & qpos) > 0);
+  unsigned e1 = a * (b % 2) * (3 * b - 2);
+  unsigned e2 = b % 2;
+  bool e3 = ((!a) != (a && ((b % 2) > 0)));
+  bool e4 = (((!a) && (b >= 2)) != (a && ((b == 1) || (b == 2))));
+
+  // update CH-form
+  // set q-th bit of s to e4
+  s &= ~qpos;
+  s ^= e4 * qpos;
+
+  // set q-th bit of v to e3
+  v &= ~qpos;
+  v ^= e3 * qpos;
+
+  // update the scalar factor omega
+  omega.e = (omega.e + e1) % 8;
+
+  // multiply the C-layer on the right by S^{e2} on the q-th qubit
+  if (e2)
+    RightS(q);
+}
 
-    // take care of the trivial case
-    if (t==u)
+void StabilizerState::H(unsigned q) {
+  isReadyMT = false; // we are going to change M and F
+  isReadyFT = false;
+  // extract the q-th row of F,G,M
+  uint_fast64_t rowF = zer;
+  uint_fast64_t rowG = zer;
+  uint_fast64_t rowM = zer;
+  for (unsigned j = 0; j < n; j++) {
+    uint_fast64_t pos = (one << j);
+    rowF ^= pos * ((F[j] >> q) & one);
+    rowG ^= pos * ((G[j] >> q) & one);
+    rowM ^= pos * ((M[j] >> q) & one);
+  }
+
+  // after commuting H through the C and H laters it maps |s> to a state
+  // sqrt(0.5)*[  (-1)^alpha |t> + i^{gamma[p]} (-1)^beta |u>  ]
+  //
+  // compute t,s,alpha,beta
+  uint_fast64_t t = s ^ (rowG & v);
+  uint_fast64_t u = s ^ (rowF & (~v)) ^ (rowM & v);
+
+  unsigned alpha = AER::Utils::popcount(rowG & (~v) & s);
+  unsigned beta =
+      AER::Utils::popcount((rowM & (~v) & s) ^ (rowF & v & (rowM ^ s)));
+
+  if (alpha % 2)
+    omega.e = (omega.e + 4) % 8;
+  // get the phase gamma[q]
+  unsigned phase = ((gamma1 >> q) & one) + 2 * ((gamma2 >> q) & one);
+  unsigned b = (phase + 2 * alpha + 2 * beta) % 4;
+
+  // now the initial state is sqrt(0.5)*(|t> + i^b |u>)
+
+  // take care of the trivial case
+  if (t == u) {
+    s = t;
+    if (!((b == 1) || (b == 3))) // otherwise the state is not normalized
     {
-        s=t;
-        if(!((b==1) || (b==3))) // otherwise the state is not normalized
-        {
-          throw std::logic_error("State is not properly normalised, b should be 1 or 3.\n");
-        }
-        if (b==1)
-            omega.e=(omega.e + 1) % 8;
-        else
-            omega.e=(omega.e + 7) % 8;
+      throw std::logic_error(
+          "State is not properly normalised, b should be 1 or 3.\n");
     }
+    if (b == 1)
+      omega.e = (omega.e + 1) % 8;
     else
-        UpdateSvector(t,u,b);
-
+      omega.e = (omega.e + 7) % 8;
+  } else
+    UpdateSvector(t, u, b);
 }
 
-void StabilizerState::MeasurePauli(pauli_t PP)
-{
-    // compute Pauli R = U_C^{-1} P U_C
-    pauli_t R;
-    R.e = PP.e;
-
-    for (unsigned j=0; j<n; j++)
-        if ((PP.X>>j) & one)
-        {
-            // multiply R by U_C^{-1} X_j U_C
-            // extract the j-th rows of F and M
-            uint_fast64_t rowF=zer;
-            uint_fast64_t rowM=zer;
-            for (unsigned i=0; i<n; i++)
-            {
-                rowF^=(one<<i)*( (F[i]>>j) & one);
-                rowM^=(one<<i)*( (M[i]>>j) & one);
-            }
-            R.e+= 2*AER::Utils::popcount(R.Z & rowF); // extra sign from Pauli commutation
-            R.Z^=rowM;
-            R.X^=rowF;
-            R.e+= ((gamma1>>j) & one) + 2*((gamma2>>j) & one);
-        }
-    for (unsigned q=0; q<n; q++)
-          R.Z^=(one<<q)*(AER::Utils::popcount( PP.Z & G[q]) % 2);
-
-    // now R=U_C^{-1} PP U_C
-    // next conjugate R by U_H
-    uint_fast64_t tempX = ( (~v) & R.X ) ^ (v & R.Z);
-    uint_fast64_t tempZ = ( (~v) & R.Z ) ^ (v & R.X);
-    // the sign flips each time a Hadamard hits Y on some qubit
-    R.e=(R.e + 2*AER::Utils::popcount(v & R.X & R.Z)) % 4;
-    R.X=tempX;
-    R.Z=tempZ;
-
-    // now the initial state |s> becomes 0.5*(|s> + R |s>) = 0.5*(|s> + i^b |s ^ R.X>)
-    unsigned b = (R.e + 2*AER::Utils::popcount(R.Z & s) ) % 4;
-    UpdateSvector(s, s ^ R.X, b);
-    // account for the extra factor sqrt(1/2)
-    omega.p-=1;
-
-    isReadyMT=false;// we have changed change M and F
-    isReadyFT=false;
+void StabilizerState::MeasurePauli(pauli_t PP) {
+  // compute Pauli R = U_C^{-1} P U_C
+  pauli_t R;
+  R.e = PP.e;
+
+  for (unsigned j = 0; j < n; j++)
+    if ((PP.X >> j) & one) {
+      // multiply R by U_C^{-1} X_j U_C
+      // extract the j-th rows of F and M
+      uint_fast64_t rowF = zer;
+      uint_fast64_t rowM = zer;
+      for (unsigned i = 0; i < n; i++) {
+        rowF ^= (one << i) * ((F[i] >> j) & one);
+        rowM ^= (one << i) * ((M[i] >> j) & one);
+      }
+      R.e += 2 * AER::Utils::popcount(
+                     R.Z & rowF); // extra sign from Pauli commutation
+      R.Z ^= rowM;
+      R.X ^= rowF;
+      R.e += ((gamma1 >> j) & one) + 2 * ((gamma2 >> j) & one);
+    }
+  for (unsigned q = 0; q < n; q++)
+    R.Z ^= (one << q) * (AER::Utils::popcount(PP.Z & G[q]) % 2);
+
+  // now R=U_C^{-1} PP U_C
+  // next conjugate R by U_H
+  uint_fast64_t tempX = ((~v) & R.X) ^ (v & R.Z);
+  uint_fast64_t tempZ = ((~v) & R.Z) ^ (v & R.X);
+  // the sign flips each time a Hadamard hits Y on some qubit
+  R.e = (R.e + 2 * AER::Utils::popcount(v & R.X & R.Z)) % 4;
+  R.X = tempX;
+  R.Z = tempZ;
+
+  // now the initial state |s> becomes 0.5*(|s> + R |s>) = 0.5*(|s> + i^b |s ^
+  // R.X>)
+  unsigned b = (R.e + 2 * AER::Utils::popcount(R.Z & s)) % 4;
+  UpdateSvector(s, s ^ R.X, b);
+  // account for the extra factor sqrt(1/2)
+  omega.p -= 1;
+
+  isReadyMT = false; // we have changed change M and F
+  isReadyFT = false;
 }
 
-void StabilizerState::MeasurePauliProjector(const std::vector<pauli_t>& generators)
-//Measure generators of a projector.
+void StabilizerState::MeasurePauliProjector(
+    const std::vector<pauli_t> &generators)
+// Measure generators of a projector.
 {
-    for (uint_fast64_t i=0; i<generators.size(); i++)
-    {
-        this->MeasurePauli(generators[i]);
-        if (omega.eps == 0)
-        {
-            break;
-        }
+  for (uint_fast64_t i = 0; i < generators.size(); i++) {
+    this->MeasurePauli(generators[i]);
+    if (omega.eps == 0) {
+      break;
     }
+  }
 }
 
-scalar_t StabilizerState::InnerProduct(const uint_fast64_t& A_diag1,
-                                       const uint_fast64_t& A_diag2,
-                                       const std::vector<uint_fast64_t>& A)
-{
-    uint_fast64_t K_diag1 = zer, K_diag2=zer, J_diag1=gamma1, J_diag2=gamma2;
-    std::vector<uint_fast64_t> J(n, zer);
-    std::vector<uint_fast64_t> K(n, zer);
-    std::vector<uint_fast64_t> placeholder(n, zer);
-    if(!isReadyMT)
-    {
-        TransposeM();
-    }
-    if (!isReadyFT)
-    {
-        TransposeF();
-    }
-    //Setup the J matrix
-    for (size_t i=0; i<n; i++)
-    {
-        for (size_t j=i; j<n; j++)
-        {
-            if (AER::Utils::hamming_parity(MT[i] & FT[j]))
-            {
-                J[i] |= (one << j);
-                J[j] |= (one << i);
-            }
-        }
+scalar_t StabilizerState::InnerProduct(const uint_fast64_t &A_diag1,
+                                       const uint_fast64_t &A_diag2,
+                                       const std::vector<uint_fast64_t> &A) {
+  uint_fast64_t K_diag1 = zer, K_diag2 = zer, J_diag1 = gamma1,
+                J_diag2 = gamma2;
+  std::vector<uint_fast64_t> J(n, zer);
+  std::vector<uint_fast64_t> K(n, zer);
+  std::vector<uint_fast64_t> placeholder(n, zer);
+  if (!isReadyMT) {
+    TransposeM();
+  }
+  if (!isReadyFT) {
+    TransposeF();
+  }
+  // Setup the J matrix
+  for (size_t i = 0; i < n; i++) {
+    for (size_t j = i; j < n; j++) {
+      if (AER::Utils::hamming_parity(MT[i] & FT[j])) {
+        J[i] |= (one << j);
+        J[j] |= (one << i);
+      }
     }
-    //Calculate the matrix J =  A+J
-    J_diag2 = (A_diag2 ^ J_diag2 ^ (A_diag1&J_diag1));
-    J_diag1 = (A_diag1 ^ J_diag1);
-    for (size_t i=0; i<n; i++)
-    {
-        J[i] ^= A[i];
+  }
+  // Calculate the matrix J =  A+J
+  J_diag2 = (A_diag2 ^ J_diag2 ^ (A_diag1 & J_diag1));
+  J_diag1 = (A_diag1 ^ J_diag1);
+  for (size_t i = 0; i < n; i++) {
+    J[i] ^= A[i];
+  }
+  // placeholder = J*G)
+  for (size_t i = 0; i < n; i++) {
+    // Grab column i of J, it's symmetric
+    uint_fast64_t col_i = J[i];
+    for (size_t j = 0; j < n; j++) {
+      if (AER::Utils::hamming_parity(col_i & G[j])) {
+        placeholder[j] |= (one << i);
+      }
     }
-    //placeholder = J*G)
-    for (size_t i=0; i<n; i++)
-    {
-        //Grab column i of J, it's symmetric
-        uint_fast64_t col_i = J[i];
-        for (size_t j=0; j<n; j++)
-        {
-            if (AER::Utils::hamming_parity(col_i & G[j]))
-            {
-                placeholder[j] |= (one<<i);
-            }
-        }
+  }
+  // K = GT*placeholder
+  for (size_t i = 0; i < n; i++) {
+    uint_fast64_t col_i = G[i];
+    uint_fast64_t shift = (one << i);
+    for (size_t j = i; j < n; j++) {
+      if (AER::Utils::hamming_parity(col_i & placeholder[j])) {
+        K[j] |= shift;
+        K[i] |= (one << j);
+      }
     }
-    //K = GT*placeholder
-    for (size_t i=0; i<n; i++)
-    {
-        uint_fast64_t col_i = G[i];
-        uint_fast64_t shift = (one << i);
-        for (size_t j=i; j<n; j++)
-        {
-            if(AER::Utils::hamming_parity(col_i & placeholder[j]))
-            {
-                K[j] |= shift;
-                K[i] |= (one << j);
-            }
+    for (size_t r = 0; r < n; r++) {
+      if ((col_i >> r) & one) {
+        uint_fast64_t one_bit = (J_diag1 >> r) & one;
+        if ((K_diag1 >> i) & one_bit) {
+          K_diag2 ^= shift;
         }
-        for (size_t r =0; r<n; r++)
-        {
-            if ((col_i >> r) & one)
-            {
-                uint_fast64_t one_bit = (J_diag1 >> r) & one;
-                if ((K_diag1 >> i) & one_bit)
-                {
-                    K_diag2 ^= shift;
-                }
-                K_diag1 ^= one_bit*shift;
-                K_diag2 ^= ((J_diag2 >> r)&one) * shift;
-            }
-            for (size_t k=r+1; k<n; k++)
-            {
-                if ((J[k] >> r) & (col_i >> r) & (col_i >> k) & one)
-                {
-                    K_diag2 ^= shift;
-                }
-            }
+        K_diag1 ^= one_bit * shift;
+        K_diag2 ^= ((J_diag2 >> r) & one) * shift;
+      }
+      for (size_t k = r + 1; k < n; k++) {
+        if ((J[k] >> r) & (col_i >> r) & (col_i >> k) & one) {
+          K_diag2 ^= shift;
         }
+      }
     }
-    unsigned col=0;
-    QuadraticForm q(AER::Utils::popcount(v));
-    //We need to setup a quadratic form to evaluate the Exponential Sum
-    for (size_t i=0; i<n; i++)
-    {
-        if ((v>>i) & one)
-        {
-            uint_fast64_t shift = (one << col);
-            //D = Diag(K(1,1)) + 2*[s + s*K](1)
-            // J = K(1,1);
-            q.D1 ^= ((K_diag1 >> i) & one) * shift;
-            q.D2 ^= (( ((K_diag2 >> i) ^ (s >> i)) & one)
-                     ^ AER::Utils::hamming_parity(K[i] & s)) * shift;
-            // q.D2 ^= ((s >> i) & one) * shift;
-            // q.D2 ^= AER::Utils::hamming_parity(K[i] & s) * shift;
-            unsigned row=0;
-            for (size_t j=0; j<n; j++)
-            {
-                if((v>>j) & one)
-                {
-                    q.J[col] |= (((K[i] >> j) & one) << row);
-                    row++;
-                }
-            }
-            col++;
+  }
+  unsigned col = 0;
+  QuadraticForm q(AER::Utils::popcount(v));
+  // We need to setup a quadratic form to evaluate the Exponential Sum
+  for (size_t i = 0; i < n; i++) {
+    if ((v >> i) & one) {
+      uint_fast64_t shift = (one << col);
+      // D = Diag(K(1,1)) + 2*[s + s*K](1)
+      //  J = K(1,1);
+      q.D1 ^= ((K_diag1 >> i) & one) * shift;
+      q.D2 ^= ((((K_diag2 >> i) ^ (s >> i)) & one) ^
+               AER::Utils::hamming_parity(K[i] & s)) *
+              shift;
+      // q.D2 ^= ((s >> i) & one) * shift;
+      // q.D2 ^= AER::Utils::hamming_parity(K[i] & s) * shift;
+      unsigned row = 0;
+      for (size_t j = 0; j < n; j++) {
+        if ((v >> j) & one) {
+          q.J[col] |= (((K[i] >> j) & one) << row);
+          row++;
         }
+      }
+      col++;
     }
-    // Q = 4* (s.v) + sKs
-    q.Q = AER::Utils::hamming_parity(s&v)*4;
-    for (size_t i=0; i<n; i++)
-    {
-        if ((s>>i) & one)
-        {
-            q.Q = (q.Q + 4*((K_diag2 >> i) & one) + 2*((K_diag1 >> i) & one))%8;// + 2*((K_diag1 >> i) & one))%8;
-            for (size_t j=i+1; j<n; j++)
-            {
-                if ((s>>j) & (K[j] >> i) & one)
-                {
-                    q.Q ^= 4;
-                }
-            }
+  }
+  // Q = 4* (s.v) + sKs
+  q.Q = AER::Utils::hamming_parity(s & v) * 4;
+  for (size_t i = 0; i < n; i++) {
+    if ((s >> i) & one) {
+      q.Q = (q.Q + 4 * ((K_diag2 >> i) & one) + 2 * ((K_diag1 >> i) & one)) %
+            8; // + 2*((K_diag1 >> i) & one))%8;
+      for (size_t j = i + 1; j < n; j++) {
+        if ((s >> j) & (K[j] >> i) & one) {
+          q.Q ^= 4;
         }
+      }
     }
-    scalar_t amp = q.ExponentialSum();
-    // Reweight by 2^{-(n+|v|)}/2
-    amp.p -= (n+AER::Utils::popcount(v));
-    // We need to further multiply by omega*
-    scalar_t psi_amp(omega);
-    psi_amp.conjugate();
-    amp *= psi_amp;
-    return amp;
+  }
+  scalar_t amp = q.ExponentialSum();
+  // Reweight by 2^{-(n+|v|)}/2
+  amp.p -= (n + AER::Utils::popcount(v));
+  // We need to further multiply by omega*
+  scalar_t psi_amp(omega);
+  psi_amp.conjugate();
+  amp *= psi_amp;
+  return amp;
 }
 
-double NormEstimate(std::vector<StabilizerState>& states, const std::vector< std::complex<double> >& phases, 
-                    const std::vector<uint_fast64_t>& Samples_d1, const std::vector<uint_fast64_t> &Samples_d2, 
-                    const std::vector< std::vector<uint_fast64_t> >& Samples)
-{
-    // Norm estimate for a state |psi> = \sum_{i} c_{i}|phi_{i}>
-    double xi=0;
-    unsigned L = Samples_d1.size();
-    // std::vector<double> data = (L,0.);
-    for (size_t i=0; i<L; i++)
-    {
-      double re_eta =0., im_eta = 0.;
-      const int_t END = states.size();
-      #pragma omp parallel for reduction(+:re_eta) reduction(+:im_eta)
-      for (int_t j=0; j<END; j++)
-      {
-          if(states[j].ScalarPart().eps != 0)
-          {
-              scalar_t amp = states[j].InnerProduct(Samples_d1[i], Samples_d2[i], Samples[i]);
-              if (amp.eps != 0)
-              {
-                  if (amp.e % 2)
-                  {
-                    amp.p--;
-                  }
-                  double mag = pow(2, amp.p/(double) 2);
-                  cdouble phase(RE_PHASE[amp.e], IM_PHASE[amp.e]);
-                  phase *= conj(phases[j]);
-                  re_eta += (mag * real(phase));
-                  im_eta += (mag * imag(phase));
-              }
+double NormEstimate(std::vector<StabilizerState> &states,
+                    const std::vector<std::complex<double>> &phases,
+                    const std::vector<uint_fast64_t> &Samples_d1,
+                    const std::vector<uint_fast64_t> &Samples_d2,
+                    const std::vector<std::vector<uint_fast64_t>> &Samples) {
+  // Norm estimate for a state |psi> = \sum_{i} c_{i}|phi_{i}>
+  double xi = 0;
+  unsigned L = Samples_d1.size();
+  // std::vector<double> data = (L,0.);
+  for (size_t i = 0; i < L; i++) {
+    double re_eta = 0., im_eta = 0.;
+    const int_t END = states.size();
+#pragma omp parallel for reduction(+ : re_eta) reduction(+ : im_eta)
+    for (int_t j = 0; j < END; j++) {
+      if (states[j].ScalarPart().eps != 0) {
+        scalar_t amp =
+            states[j].InnerProduct(Samples_d1[i], Samples_d2[i], Samples[i]);
+        if (amp.eps != 0) {
+          if (amp.e % 2) {
+            amp.p--;
           }
+          double mag = pow(2, amp.p / (double)2);
+          cdouble phase(RE_PHASE[amp.e], IM_PHASE[amp.e]);
+          phase *= conj(phases[j]);
+          re_eta += (mag * real(phase));
+          im_eta += (mag * imag(phase));
+        }
       }
-      xi += (pow(re_eta,2) + pow(im_eta, 2));
     }
-    return std::pow(2, states[0].NQubits()) * (xi/L);
+    xi += (pow(re_eta, 2) + pow(im_eta, 2));
+  }
+  return std::pow(2, states[0].NQubits()) * (xi / L);
 }
 
-double ParallelNormEstimate(std::vector<StabilizerState>& states, const std::vector< std::complex<double> >& phases, 
-                    const std::vector<uint_fast64_t>& Samples_d1, const std::vector<uint_fast64_t>& Samples_d2, 
-                    const std::vector< std::vector<uint_fast64_t> >& Samples, int n_threads)
-{
-    double xi=0;
-    unsigned L = Samples_d1.size();
-    unsigned chi = states.size();
-    for (uint_fast64_t i=0; i<L; i++)
-    {
-        double re_eta =0., im_eta = 0.;
-        #pragma omp parallel for reduction(+:re_eta) reduction(+:im_eta) num_threads(n_threads)
-        for (int_t j=0; j<chi; j++)
-        {
-            if(states[j].ScalarPart().eps != 0)
-            {
-                scalar_t amp = states[j].InnerProduct(Samples_d1[i], Samples_d2[i], Samples[i]);
-                if (amp.eps != 0)
-                {
-                    if (amp.e % 2)
-                    {
-                      amp.p--;
-                    }
-                    double mag = pow(2, amp.p/(double) 2);
-                    cdouble phase(RE_PHASE[amp.e], IM_PHASE[amp.e]);
-                    phase *= conj(phases[j]);
-                    re_eta += (mag * real(phase));
-                    im_eta += (mag * imag(phase));
-                }
-            }
+double
+ParallelNormEstimate(std::vector<StabilizerState> &states,
+                     const std::vector<std::complex<double>> &phases,
+                     const std::vector<uint_fast64_t> &Samples_d1,
+                     const std::vector<uint_fast64_t> &Samples_d2,
+                     const std::vector<std::vector<uint_fast64_t>> &Samples,
+                     int n_threads) {
+  double xi = 0;
+  unsigned L = Samples_d1.size();
+  unsigned chi = states.size();
+  for (uint_fast64_t i = 0; i < L; i++) {
+    double re_eta = 0., im_eta = 0.;
+#pragma omp parallel for reduction(+:re_eta) reduction(+:im_eta) num_threads(n_threads)
+    for (int_t j = 0; j < chi; j++) {
+      if (states[j].ScalarPart().eps != 0) {
+        scalar_t amp =
+            states[j].InnerProduct(Samples_d1[i], Samples_d2[i], Samples[i]);
+        if (amp.eps != 0) {
+          if (amp.e % 2) {
+            amp.p--;
+          }
+          double mag = pow(2, amp.p / (double)2);
+          cdouble phase(RE_PHASE[amp.e], IM_PHASE[amp.e]);
+          phase *= conj(phases[j]);
+          re_eta += (mag * real(phase));
+          im_eta += (mag * imag(phase));
         }
-        xi += (pow(re_eta,2) + pow(im_eta, 2));
+      }
     }
-    return pow(2., states[0].NQubits())*(xi/L);
+    xi += (pow(re_eta, 2) + pow(im_eta, 2));
+  }
+  return pow(2., states[0].NQubits()) * (xi / L);
 }
 
-}
+} // namespace CHSimulator
 #endif
diff --git a/src/simulators/extended_stabilizer/chlib/core.hpp b/src/simulators/extended_stabilizer/chlib/core.hpp
index 1fac013e18..e4e18dba7a 100644
--- a/src/simulators/extended_stabilizer/chlib/core.hpp
+++ b/src/simulators/extended_stabilizer/chlib/core.hpp
@@ -17,15 +17,14 @@
 
 #include <array>
 #include <climits>
-#include <cstdint>
 #include <complex>
+#include <cstdint>
 #include <iostream>
 #include <vector>
 
 #include "framework/utils.hpp"
 
-namespace CHSimulator 
-{
+namespace CHSimulator {
 
 static const std::array<int, 8> RE_PHASE = {1, 1, 0, -1, -1, -1, 0, 1};
 static const std::array<int, 8> IM_PHASE = {0, 1, 1, 1, 0, -1, -1, -1};
@@ -46,91 +45,81 @@ struct scalar_t {
   int e = 0;
   // constructor makes number 1
   scalar_t() = default;
-  scalar_t(const scalar_t& rhs) = default;
-  scalar_t(const std::complex<double> coeff)
-  {
+  scalar_t(const scalar_t &rhs) = default;
+  scalar_t(const std::complex<double> coeff) {
     double abs_val = std::abs(coeff);
-    if(std::abs(abs_val-0.)<1e-8)
-    {
+    if (std::abs(abs_val - 0.) < 1e-8) {
       eps = 0;
-    }
-    else
-    {
-      p = (int) std::log2(std::pow(abs_val, 2));
-      bool is_real_zero = (std::abs(coeff.real()-0)<1e-8);
-      bool is_imag_zero = (std::abs(coeff.imag()-0)<1e-8);
+    } else {
+      p = (int)std::log2(std::pow(abs_val, 2));
+      bool is_real_zero = (std::abs(coeff.real() - 0) < 1e-8);
+      bool is_imag_zero = (std::abs(coeff.imag() - 0) < 1e-8);
       bool is_real_posi = (coeff.real() > 0) && !(is_real_zero);
       bool is_imag_posi = (coeff.imag() > 0) && !(is_imag_zero);
-      char switch_var = (is_real_zero * 1) + (is_imag_zero*2) + (is_real_posi * 4) + (is_imag_posi * 8);
-      switch(switch_var)
-      {
-        case 0:
-          e = 5;
-          break;
-        case 1:
-          e = 6;
-          break;
-        case 2:
-          e = 4;
-          break;
-        case 4:
-          e=7;
-          break;
-        case 6:
-          e=0;
-          break;
-        case 8:
-          e=3;
-          break;
-        case 9:
-          e=2;
-          break;
-        case 12:
-          e=1;
-          break;
-        default:
-          throw std::runtime_error("Unsure what to do here chief.");
-          break;
+      char switch_var = (is_real_zero * 1) + (is_imag_zero * 2) +
+                        (is_real_posi * 4) + (is_imag_posi * 8);
+      switch (switch_var) {
+      case 0:
+        e = 5;
+        break;
+      case 1:
+        e = 6;
+        break;
+      case 2:
+        e = 4;
+        break;
+      case 4:
+        e = 7;
+        break;
+      case 6:
+        e = 0;
+        break;
+      case 8:
+        e = 3;
+        break;
+      case 9:
+        e = 2;
+        break;
+      case 12:
+        e = 1;
+        break;
+      default:
+        throw std::runtime_error("Unsure what to do here chief.");
+        break;
       }
     }
   }
 
   // complex conjugation
-  inline void conjugate()
-  {
-   e%=8;
-   e=(8-e) % 8; 
+  inline void conjugate() {
+    e %= 8;
+    e = (8 - e) % 8;
   }
 
-  inline void makeOne() 
-  {
-    eps=1;
-    p=0;
-    e=0;
+  inline void makeOne() {
+    eps = 1;
+    p = 0;
+    e = 0;
   }
 
-  scalar_t& operator*=(const scalar_t& rhs);
-  scalar_t operator*(const scalar_t& rhs) const;
+  scalar_t &operator*=(const scalar_t &rhs);
+  scalar_t operator*(const scalar_t &rhs) const;
 
-  std::complex<double> to_complex() const 
-  {
-    if (eps==0)
-    {
+  std::complex<double> to_complex() const {
+    if (eps == 0) {
       return {0., 0.};
     }
-    std::complex<double> mag(std::pow(2, p/(double)2), 0.);
+    std::complex<double> mag(std::pow(2, p / (double)2), 0.);
     std::complex<double> phase(RE_PHASE[e], IM_PHASE[e]);
-    if(e % 2){
+    if (e % 2) {
       phase /= std::sqrt(2);
     }
-    return mag*phase;
+    return mag * phase;
   }
 
-  void Print()
-  {
-    std::cout<<"eps="<<eps<<", p="<<p<<", e="<<e<<std::endl;
+  void Print() {
+    std::cout << "eps=" << eps << ", p=" << p << ", e=" << e << std::endl;
   }
-
 };
 
 // Below we represent n-bit strings by uint64_t integers
@@ -138,15 +127,14 @@ struct pauli_t {
   // n-qubit Pauli operators: i^e * X(x) * Z(z)
   uint_fast64_t X; // n-bit string
   uint_fast64_t Z; // n-bit string
-  unsigned e = 0; // takes values 0,1,2,3
-  
-  // constructor makes the identity Pauli operator 
+  unsigned e = 0;  // takes values 0,1,2,3
+
+  // constructor makes the identity Pauli operator
   pauli_t();
-  pauli_t(const pauli_t& p) = default;
+  pauli_t(const pauli_t &p) = default;
 
   // multiplication of Pauli operators
-  pauli_t& operator*=( const pauli_t& rhs );
-
+  pauli_t &operator*=(const pauli_t &rhs);
 };
 
 struct QuadraticForm {
@@ -157,132 +145,113 @@ struct QuadraticForm {
   std::vector<uint_fast64_t> J;
   scalar_t ExponentialSum();
   QuadraticForm(unsigned n_qubits);
-  QuadraticForm(const QuadraticForm& rhs);
-  QuadraticForm& operator -=(const QuadraticForm& rhs);
+  QuadraticForm(const QuadraticForm &rhs);
+  QuadraticForm &operator-=(const QuadraticForm &rhs);
   // ~QuadraticForm();
 };
 
-bool operator==(const QuadraticForm& lhs, const QuadraticForm& rhs);
+bool operator==(const QuadraticForm &lhs, const QuadraticForm &rhs);
 
-std::ostream& operator<<(std::ostream& os, const QuadraticForm& q);
+std::ostream &operator<<(std::ostream &os, const QuadraticForm &q);
 
-void Print(uint_fast64_t x, unsigned n);// print a bit string 
-void Print(std::vector<uint_fast64_t> A, unsigned n);// print a binary matrix
+void Print(uint_fast64_t x, unsigned n);              // print a bit string
+void Print(std::vector<uint_fast64_t> A, unsigned n); // print a binary matrix
 // A[i] represents i-th column of the matrix
 
 //---------------------------------------//
 // Implementations                       //
 //---------------------------------------//
 
-scalar_t& scalar_t::operator*=(const scalar_t& rhs)
-{
+scalar_t &scalar_t::operator*=(const scalar_t &rhs) {
   p += (rhs.p);
   e += (rhs.e);
-  e%=8;
+  e %= 8;
   eps *= rhs.eps;
   return *this;
 }
 
-scalar_t scalar_t::operator*(const scalar_t& rhs) const
-{
+scalar_t scalar_t::operator*(const scalar_t &rhs) const {
   scalar_t out;
-  out.p = (p+rhs.p);
-  out.e = (e+rhs.e);
-  out.e = (out.e%8);
-  out.eps = (eps*rhs.eps);
+  out.p = (p + rhs.p);
+  out.e = (e + rhs.e);
+  out.e = (out.e % 8);
+  out.eps = (eps * rhs.eps);
   return out;
 }
 
-pauli_t::pauli_t(): X(zer), Z(zer) {}
+pauli_t::pauli_t() : X(zer), Z(zer) {}
 
-pauli_t& pauli_t::operator*=( const pauli_t& rhs )
-{
-    unsigned overlap=AER::Utils::popcount(Z & rhs.X);// commute rhs.X to the left
-    X^=rhs.X;
-    Z^=rhs.Z;
-    e=(e + rhs.e + 2*overlap) % 4;
-    return (*this);
+pauli_t &pauli_t::operator*=(const pauli_t &rhs) {
+  unsigned overlap =
+      AER::Utils::popcount(Z & rhs.X); // commute rhs.X to the left
+  X ^= rhs.X;
+  Z ^= rhs.Z;
+  e = (e + rhs.e + 2 * overlap) % 4;
+  return (*this);
 }
 
-class QubitException: public std::exception
-{
-  virtual const char* what() const throw()
-  {
-    return "Length error: We cannot compute a quadratic form with more that 63 dimensions.";
+class QubitException : public std::exception {
+  virtual const char *what() const throw() {
+    return "Length error: We cannot compute a quadratic form with more that 63 "
+           "dimensions.";
   }
 } qubex;
 
-QuadraticForm::QuadraticForm(unsigned int n_qubits):
-n(n_qubits), Q(0), D1(zer), D2(zer), J(n_qubits,zer)
-{
-  if (n>63)
-  {
+QuadraticForm::QuadraticForm(unsigned int n_qubits)
+    : n(n_qubits), Q(0), D1(zer), D2(zer), J(n_qubits, zer) {
+  if (n > 63) {
     throw qubex;
   }
 }
 
-QuadraticForm::QuadraticForm(const QuadraticForm &rhs) : J(rhs.n, zer)
-{
-  n=rhs.n;
-  Q=rhs.Q;
-  D1=rhs.D1;
-  D2=rhs.D2;
-  for (size_t i=0; i<n; i++)
-  {
+QuadraticForm::QuadraticForm(const QuadraticForm &rhs) : J(rhs.n, zer) {
+  n = rhs.n;
+  Q = rhs.Q;
+  D1 = rhs.D1;
+  D2 = rhs.D2;
+  for (size_t i = 0; i < n; i++) {
     J[i] = rhs.J[i];
   }
 }
 
-QuadraticForm& QuadraticForm::operator-=(const QuadraticForm& rhs)
-{
-  Q = (Q-rhs.Q)%8;
-  if (Q<0)
-  {
-    Q +=8;
+QuadraticForm &QuadraticForm::operator-=(const QuadraticForm &rhs) {
+  Q = (Q - rhs.Q) % 8;
+  if (Q < 0) {
+    Q += 8;
   }
-  //TODO: D Update
-  for (size_t j=0; j<n; j++)
-  {
+  // TODO: D Update
+  for (size_t j = 0; j < n; j++) {
     J[j] ^= rhs.J[j];
   }
   return *this;
 }
 
-bool operator==(const QuadraticForm& lhs, const QuadraticForm& rhs)
-{
-  if (lhs.Q != rhs.Q)
-  {
+bool operator==(const QuadraticForm &lhs, const QuadraticForm &rhs) {
+  if (lhs.Q != rhs.Q) {
     return false;
   }
-  if (lhs.D1 != rhs.D1)
-  {
+  if (lhs.D1 != rhs.D1) {
     return false;
   }
-  if (lhs.D2 != rhs.D2)
-  {
+  if (lhs.D2 != rhs.D2) {
     return false;
   }
-  if (lhs.J != rhs.J)
-  {
+  if (lhs.J != rhs.J) {
     return false;
   }
   return true;
 }
 
-std::ostream& operator<<(std::ostream& os, const QuadraticForm& q)
-{
+std::ostream &operator<<(std::ostream &os, const QuadraticForm &q) {
   os << "Q: " << q.Q << std::endl;
   os << "D:";
-  for (size_t i=0; i<q.n; i++)
-  {
-    os << " " << (2*(2*((q.D2 >> i) & one) + ((q.D1 >> i) & one)));
+  for (size_t i = 0; i < q.n; i++) {
+    os << " " << (2 * (2 * ((q.D2 >> i) & one) + ((q.D1 >> i) & one)));
   }
   os << std::endl;
-  os <<"J:\n";
-  for (size_t i=0; i<q.n; i++)
-  {
-    for (size_t j=0; j<q.n; j++)
-    {
+  os << "J:\n";
+  for (size_t i = 0; i < q.n; i++) {
+    for (size_t j = 0; j < q.n; j++) {
       os << ((q.J[i] >> j) & one) << " ";
     }
     os << "\n";
@@ -311,96 +280,84 @@ std::ostream& operator<<(std::ostream& os, const QuadraticForm& q)
 // Output: integers p>=0, m=0,1,2,..,7, and eps=0,1  such that
 // Z = sum_x exp(j*(pi/4)*q(x)) = eps*2^(p/2)*exp(j*pi*m/4)
 // if eps=0 then p and m can be ignored
-scalar_t QuadraticForm::ExponentialSum()
-{
-  
+scalar_t QuadraticForm::ExponentialSum() {
+
   // Variables for Z2-valued exponential sums
   // Z=(2^pow2)*sigma
   // where pow2 is integer
   // sigma=0,1
   // if Z=0 then pow2,sigma contain junk and isZero=1
-  int pow2_real=0;
-  bool sigma_real=false;
-  bool isZero_real=false;
+  int pow2_real = 0;
+  bool sigma_real = false;
+  bool isZero_real = false;
 
-  int pow2_imag=0;
-  bool sigma_imag=false;
-  bool isZero_imag=false;
+  int pow2_imag = 0;
+  bool sigma_imag = false;
+  bool isZero_imag = false;
   scalar_t amp;
   amp.makeOne();
 
-  int m = n+1;
+  int m = n + 1;
 
   // Lreal, Limag define the linear part of the Z2-valued forms
   // M defines the quadratic part of the Z2-valued forms
   // each column of M is represented by long integer
-  uint_fast64_t Lreal, c=zer;
-  std::vector<uint_fast64_t> M(n+1,zer);
+  uint_fast64_t Lreal, c = zer;
+  std::vector<uint_fast64_t> M(n + 1, zer);
   Lreal = D2;
-  for (size_t i=0; i<n; i++)
-  {
-    if ( (D1 >> i) & one )
-    {
+  for (size_t i = 0; i < n; i++) {
+    if ((D1 >> i) & one) {
       c |= (one << i);
       M[n] |= (one << i);
     }
   }
   uint_fast64_t Limag = Lreal;
   Limag ^= (one << n);
-  for (size_t i=0; i<n; i++)
-  {
-    for (size_t j=(i+1); j<n; j++)
-    {
-        bool x = !!((J[i] >> j) & one);
-        bool c1 = !!((c>>i) & one);
-        bool c2 = !!((c>>j) & one);
-        if (x ^ (c1 & c2))
-        {
-            M[j] ^= (one << i);
-        }
+  for (size_t i = 0; i < n; i++) {
+    for (size_t j = (i + 1); j < n; j++) {
+      bool x = !!((J[i] >> j) & one);
+      bool c1 = !!((c >> i) & one);
+      bool c2 = !!((c >> j) & one);
+      if (x ^ (c1 & c2)) {
+        M[j] ^= (one << i);
+      }
     }
   }
   uint_fast64_t active = zer;
   active = ~(active);
-  int nActive=m;
-  int firstActive=0;
-  while (nActive>=1)
-  {
+  int nActive = m;
+  int firstActive = 0;
+  while (nActive >= 1) {
     // find the first active variable
     int i1;
-    for (i1=firstActive; i1<m; i1++)
-    {
-      if ((active >> i1) & one)
-      {
+    for (i1 = firstActive; i1 < m; i1++) {
+      if ((active >> i1) & one) {
         break;
       }
     }
-    firstActive=i1;
+    firstActive = i1;
     // find i2 such that M(i1,i2)!=M(i2,i1)
     int i2;
-    bool isFound=false;
-    for (i2=0; i2<m; i2++)
-    {
-        isFound = ( ((M[i1]>>i2) & one) != ((M[i2]>>i1) & one) );
-        if (isFound)
-        {
-          break;
-        }
+    bool isFound = false;
+    for (i2 = 0; i2 < m; i2++) {
+      isFound = (((M[i1] >> i2) & one) != ((M[i2] >> i1) & one));
+      if (isFound) {
+        break;
+      }
     }
-    bool L1real = !!(((Lreal >> i1) & one) ^ ((M[i1]>>i1) & one));
-    bool L1imag = !!(((Limag >> i1) & one) ^ ((M[i1]>>i1) & one));
+    bool L1real = !!(((Lreal >> i1) & one) ^ ((M[i1] >> i1) & one));
+    bool L1imag = !!(((Limag >> i1) & one) ^ ((M[i1] >> i1) & one));
     // take care of the trivial cases
-    if (!isFound)
-    {
+    if (!isFound) {
       // the form is linear in the variable i1
       if (L1real)
-          isZero_real=true;
-       
+        isZero_real = true;
+
       pow2_real++;
-       
+
       if (L1imag)
-          isZero_imag=true;
-       
+        isZero_imag = true;
+
       pow2_imag++;
 
       nActive--;
@@ -410,33 +367,30 @@ scalar_t QuadraticForm::ExponentialSum()
       // set column i1 to zero
       M[i1] = zer;
       // set row i1 to zero
-      for (int j=0; j<m; j++)
-      {
+      for (int j = 0; j < m; j++) {
         M[j] &= not_shift;
       }
       Lreal &= not_shift;
       Limag &= not_shift;
 
-      if (isZero_real && isZero_imag)
-      {
-         amp.eps=0;
-         break;
+      if (isZero_real && isZero_imag) {
+        amp.eps = 0;
+        break;
       }
       continue;
-    }// trivial cases
-    bool L2real = !!(((Lreal>>i2) & one) ^ ((M[i2]>>i2) & one));
-    bool L2imag = !!(((Limag>>i2) & one) ^ ((M[i2]>>i2) & one));
-    Lreal&=~(one<<i1);
-    Lreal&=~(one<<i2);
-    Limag&=~(one<<i1);
-    Limag&=~(one<<i2);
+    } // trivial cases
+    bool L2real = !!(((Lreal >> i2) & one) ^ ((M[i2] >> i2) & one));
+    bool L2imag = !!(((Limag >> i2) & one) ^ ((M[i2] >> i2) & one));
+    Lreal &= ~(one << i1);
+    Lreal &= ~(one << i2);
+    Limag &= ~(one << i1);
+    Limag &= ~(one << i2);
     // Extract rows i1 and i2 of M
-    uint_fast64_t m1=zer;
-    uint_fast64_t m2=zer;
-    for (int j=0; j<m; j++)
-    {
-      m1^=((M[j]>>i1) & one)<<j;
-      m2^=((M[j]>>i2) & one)<<j;
+    uint_fast64_t m1 = zer;
+    uint_fast64_t m2 = zer;
+    for (int j = 0; j < m; j++) {
+      m1 ^= ((M[j] >> i1) & one) << j;
+      m2 ^= ((M[j] >> i2) & one) << j;
     }
     m1 ^= M[i1];
     m2 ^= M[i2];
@@ -448,82 +402,68 @@ scalar_t QuadraticForm::ExponentialSum()
     M[i1] = zer;
     M[i2] = zer;
     // set rows i1,i2 to zero
-    for (int j=0; j<m; j++)
-    {
-       M[j] &= ~(one<<i1);
-       M[j] &= ~(one<<i2);
+    for (int j = 0; j < m; j++) {
+      M[j] &= ~(one << i1);
+      M[j] &= ~(one << i2);
     }
 
     // update the std::vectors Lreal, Limag
-    if (!isZero_real)
-    {
+    if (!isZero_real) {
       pow2_real++;
       sigma_real ^= (L1real && L2real);
-      if (L1real)
-      {
+      if (L1real) {
         Lreal ^= m2;
       }
-      if (L2real)
-      {
+      if (L2real) {
         Lreal ^= m1;
       }
     }
-    if (!isZero_imag)
-    {
+    if (!isZero_imag) {
       pow2_imag++;
       sigma_imag ^= (L1imag && L2imag);
-      if(L1imag)
-      {
+      if (L1imag) {
         Limag ^= m2;
       }
-      if(L2imag)
-      {
+      if (L2imag) {
         Limag ^= m1;
       }
     }
     // update matrix M
-    for (int j=0; j<m; j++)
-    {
-      if((m2 >> j) & one)
-      {
-        M[j]^=m1;
+    for (int j = 0; j < m; j++) {
+      if ((m2 >> j) & one) {
+        M[j] ^= m1;
       }
     }
     active &= ~(one << i1);
     active &= ~(one << i2);
-    nActive-=2;
+    nActive -= 2;
   }
   // int J0 = Q;
   // int J0 = inJ0[0];
-  Q%=8;
+  Q %= 8;
 
   // Combine the real and the imaginary parts
-  if (isZero_imag)
-  {
-    amp.p = 2*pow2_real - 2;
-    amp.e = (4*sigma_real + Q) % 8;
-  } else if (isZero_real)
-  {
-    amp.p = 2*pow2_imag - 2;
-    amp.e = (2 + 4*sigma_imag + Q) % 8;
+  if (isZero_imag) {
+    amp.p = 2 * pow2_real - 2;
+    amp.e = (4 * sigma_real + Q) % 8;
+  } else if (isZero_real) {
+    amp.p = 2 * pow2_imag - 2;
+    amp.e = (2 + 4 * sigma_imag + Q) % 8;
   } else {
     // now both parts are nonzero
-    amp.p = 2*pow2_real - 1;
+    amp.p = 2 * pow2_real - 1;
     amp.eps = 1;
-    if (sigma_real == 0)
-    {
-      if (sigma_imag == 0)
-      {
-        amp.e=(1 + Q) % 8;
+    if (sigma_real == 0) {
+      if (sigma_imag == 0) {
+        amp.e = (1 + Q) % 8;
       } else {
-        amp.e=(7 + Q) % 8;
+        amp.e = (7 + Q) % 8;
       }
     } else {
-      if (sigma_imag == 0)
-      {
-        amp.e=(3 + Q) % 8;
+      if (sigma_imag == 0) {
+        amp.e = (3 + Q) % 8;
       } else {
-        amp.e=(5 + Q) % 8;
+        amp.e = (5 + Q) % 8;
       }
     }
   }
@@ -531,28 +471,23 @@ scalar_t QuadraticForm::ExponentialSum()
 }
 
 // prints a binary form of x
-void Print(uint_fast64_t x, unsigned n)
-{
-  for (unsigned i=0; i<n; i++)
-  {
-    std::cout<<( (x & (1ULL << i) ) >0);
+void Print(uint_fast64_t x, unsigned n) {
+  for (unsigned i = 0; i < n; i++) {
+    std::cout << ((x & (1ULL << i)) > 0);
   }
-  std::cout<<std::endl;
+  std::cout << std::endl;
 }
 
-// prints a binary form of each element of A 
+// prints a binary form of each element of A
 // each element of A represents column of a binary matrix
-void Print(std::vector<uint_fast64_t> A, unsigned n)
-{
-  for (unsigned row=0; row<n; row++)
-  {
-    for (unsigned col=0; col<n; col++)
-    {
-      std::cout<<( ( A[col] & (one<<row) ) >0);
+void Print(std::vector<uint_fast64_t> A, unsigned n) {
+  for (unsigned row = 0; row < n; row++) {
+    for (unsigned col = 0; col < n; col++) {
+      std::cout << ((A[col] & (one << row)) > 0);
     }
-    std::cout<<std::endl;
+    std::cout << std::endl;
   }
 }
 
-}
+} // namespace CHSimulator
 #endif
diff --git a/src/simulators/extended_stabilizer/extended_stabilizer_state.hpp b/src/simulators/extended_stabilizer/extended_stabilizer_state.hpp
index b14f2c0798..735dd2931a 100644
--- a/src/simulators/extended_stabilizer/extended_stabilizer_state.hpp
+++ b/src/simulators/extended_stabilizer/extended_stabilizer_state.hpp
@@ -18,33 +18,38 @@
 #include <complex>
 #include <vector>
 
-#include "simulators/state.hpp"
 #include "framework/json.hpp"
 #include "framework/types.hpp"
+#include "simulators/state.hpp"
 
-#include "chlib/core.hpp"
-#include "chlib/chstabilizer.hpp"
 #include "ch_runner.hpp"
+#include "chlib/chstabilizer.hpp"
+#include "chlib/core.hpp"
 #include "gates.hpp"
 
-namespace AER{
+namespace AER {
 namespace ExtendedStabilizer {
 
 // OpSet of supported instructions
 const Operations::OpSet StateOpSet(
-  // Op types
-  {Operations::OpType::gate, Operations::OpType::measure,
-    Operations::OpType::reset, Operations::OpType::barrier,
-    Operations::OpType::roerror, Operations::OpType::bfunc,
-    Operations::OpType::qerror_loc,
-    Operations::OpType::snapshot, Operations::OpType::save_statevec,
-    }, //Operations::OpType::save_expval, Operations::OpType::save_expval_var},
-  // Gates
-  {"CX", "u0", "u1", "p", "cx", "cz", "swap", "id", "x", "y", "z", "h",
-    "s", "sdg", "sx", "sxdg", "t", "tdg", "ccx", "ccz", "delay", "pauli"},
-  // Snapshots
-  {"statevector", "probabilities", "memory", "register"}
-);
+    // Op types
+    {
+        Operations::OpType::gate,
+        Operations::OpType::measure,
+        Operations::OpType::reset,
+        Operations::OpType::barrier,
+        Operations::OpType::roerror,
+        Operations::OpType::bfunc,
+        Operations::OpType::qerror_loc,
+        Operations::OpType::snapshot,
+        Operations::OpType::save_statevec,
+    }, // Operations::OpType::save_expval, Operations::OpType::save_expval_var},
+    // Gates
+    {"CX", "u0",  "u1",  "p",   "cx",    "cz",   "swap", "id",
+     "x",  "y",   "z",   "h",   "s",     "sdg",  "sx",   "sxdg",
+     "t",  "tdg", "ccx", "ccz", "delay", "pauli"},
+    // Snapshots
+    {"statevector", "probabilities", "memory", "register"});
 
 using chpauli_t = CHSimulator::pauli_t;
 using chstate_t = CHSimulator::Runner;
@@ -53,102 +58,86 @@ using Gates = CHSimulator::Gates;
 uint_t zero = 0ULL;
 uint_t toff_branch_max = 7ULL;
 
-enum class SamplingMethod {
-  metropolis,
-  resampled_metropolis,
-  norm_estimation
-};
+enum class SamplingMethod { metropolis, resampled_metropolis, norm_estimation };
 
-enum class Snapshots {
-  statevector,
-  cmemory,
-  cregister,
-  probs
-};
+enum class Snapshots { statevector, cmemory, cregister, probs };
 
-class State: public QuantumState::State<chstate_t>
-{
+class State : public QuantumState::State<chstate_t> {
 public:
   using BaseState = QuantumState::State<chstate_t>;
-  
+
   State() : BaseState(StateOpSet) {}
   virtual ~State() = default;
 
-  std::string name() const override {return "extended_stabilizer";}
+  std::string name() const override { return "extended_stabilizer"; }
 
-  //Apply a sequence of operations to the cicuit. For each operation,
-  //we loop over the terms in the decomposition in parallel
+  // Apply a sequence of operations to the cicuit. For each operation,
+  // we loop over the terms in the decomposition in parallel
   template <typename InputIterator>
   void apply_ops(InputIterator first, InputIterator last,
-                  ExperimentResult &result,
-                  RngEngine &rng,
-                  bool final_ops = false);
+                 ExperimentResult &result, RngEngine &rng,
+                 bool final_ops = false);
 
   // Apply a single operation
   // If the op is not in allowed_ops an exeption will be raised.
-  virtual void apply_op(const Operations::Op &op,
-                        ExperimentResult &result,
-                        RngEngine &rng,
-                        bool final_op = false) override;
+  virtual void apply_op(const Operations::Op &op, ExperimentResult &result,
+                        RngEngine &rng, bool final_op = false) override;
 
   void initialize_qreg(uint_t num_qubits) override;
 
-  size_t required_memory_mb(uint_t num_qubits,
-                                    const std::vector<Operations::Op> &ops)
-                                    const override;
+  size_t
+  required_memory_mb(uint_t num_qubits,
+                     const std::vector<Operations::Op> &ops) const override;
 
   void set_config(const json_t &config) override;
 
-  std::vector<reg_t> sample_measure(const reg_t& qubits,
-                                    uint_t shots,
+  std::vector<reg_t> sample_measure(const reg_t &qubits, uint_t shots,
                                     RngEngine &rng) override;
 
 protected:
-
-  //Alongside the sample measure optimisaiton, we can parallelise
-  //circuit applicaiton over the states. This reduces the threading overhead
-  //as we only have to fork once per circuit.
+  // Alongside the sample measure optimisaiton, we can parallelise
+  // circuit applicaiton over the states. This reduces the threading overhead
+  // as we only have to fork once per circuit.
   template <typename InputIterator>
   void apply_ops_parallel(InputIterator first, InputIterator last,
-                          ExperimentResult &result,
-                          RngEngine &rng);
+                          ExperimentResult &result, RngEngine &rng);
 
-  //Small routine that eschews any parallelisation/decomposition and applies a stabilizer
-  //circuit to a single state. This is used to optimize a circuit with a large
-  //initial clifford fraction, or for running stabilizer circuits.
+  // Small routine that eschews any parallelisation/decomposition and applies a
+  // stabilizer circuit to a single state. This is used to optimize a circuit
+  // with a large initial clifford fraction, or for running stabilizer circuits.
   template <typename InputIterator>
   void apply_stabilizer_circuit(InputIterator first, InputIterator last,
-                                ExperimentResult &result,
-                                RngEngine &rng);
+                                ExperimentResult &result, RngEngine &rng);
 
   // Applies a sypported Gate operation to the state class.
   // If the input is not in allowed_gates an exeption will be raised.
-  // TODO: Investigate OMP synchronisation over stattes to remove these different versions
-  // One option would be tasks, but the memory overhead isn't clear
+  // TODO: Investigate OMP synchronisation over stattes to remove these
+  // different versions One option would be tasks, but the memory overhead isn't
+  // clear
   void apply_gate(const Operations::Op &op, RngEngine &rng);
   void apply_gate(const Operations::Op &op, RngEngine &rng, uint_t rank);
 
   // Apply a multi-qubit Pauli gate
-  void apply_pauli(const reg_t &qubits, const std::string& pauli, uint_t rank);
+  void apply_pauli(const reg_t &qubits, const std::string &pauli, uint_t rank);
 
   // Measure qubits and return a list of outcomes [q0, q1, ...]
-  // If a state subclass supports this function then "measure" 
+  // If a state subclass supports this function then "measure"
   // should be contained in the set returned by the 'allowed_ops'
   // method.
-  void apply_measure(const reg_t &qubits,
-                     const reg_t &cmemory,
-                     const reg_t &cregister,
-                     RngEngine &rng);
+  void apply_measure(const reg_t &qubits, const reg_t &cmemory,
+                     const reg_t &cregister, RngEngine &rng);
 
   // Reset the specified qubits to the |0> state by measuring the
   // projectors Id+Z_{i} for each qubit i
   void apply_reset(const reg_t &qubits, AER::RngEngine &rng);
 
-  void apply_snapshot(const Operations::Op &op, ExperimentResult &result, RngEngine &rng);
-  //Convert a decomposition to a state-vector
+  void apply_snapshot(const Operations::Op &op, ExperimentResult &result,
+                      RngEngine &rng);
+  // Convert a decomposition to a state-vector
   void statevector_snapshot(const Operations::Op &op, ExperimentResult &result);
   // //Compute probabilities from a stabilizer rank decomposition
-  void probabilities_snapshot(const Operations::Op &op, ExperimentResult &result, RngEngine &rng);
+  void probabilities_snapshot(const Operations::Op &op,
+                              ExperimentResult &result, RngEngine &rng);
   const static stringmap_t<Gates> gateset_;
   const static stringmap_t<Snapshots> snapshotset_;
 
@@ -161,26 +150,24 @@ class State: public QuantumState::State<chstate_t>
                               ExperimentResult &result);
 
   // Compute and save the expval for the current simulator state
-  void apply_save_expval(const Operations::Op &op,
-                              ExperimentResult &result,
-                              RngEngine &rng);
+  void apply_save_expval(const Operations::Op &op, ExperimentResult &result,
+                         RngEngine &rng);
 
-   // Helper function for computing expectation value
-   double expval_pauli(const reg_t &qubits,
-                       const std::string& pauli,
-                       RngEngine &rng);
+  // Helper function for computing expectation value
+  double expval_pauli(const reg_t &qubits, const std::string &pauli,
+                      RngEngine &rng);
 
   // Helper function for computing expectation value
   virtual double expval_pauli(const reg_t &qubits,
-                              const std::string& pauli) override;
+                              const std::string &pauli) override;
 
   //-----------------------------------------------------------------------
-  //Parameters and methods specific to the Stabilizer Rank Decomposition
+  // Parameters and methods specific to the Stabilizer Rank Decomposition
   //-----------------------------------------------------------------------
 
-  //Allowed error in the stabilizer rank decomposition.
-  //The required number of states scales as \delta^{-2}
-  //for allowed error \delta
+  // Allowed error in the stabilizer rank decomposition.
+  // The required number of states scales as \delta^{-2}
+  // for allowed error \delta
   double approximation_error_ = 0.05;
 
   uint_t norm_estimation_samples_ = 100;
@@ -192,7 +179,7 @@ class State: public QuantumState::State<chstate_t>
   // output distribution
   uint_t metropolis_mixing_steps_ = 5000;
 
-  //Minimum number of states before we try to parallelise
+  // Minimum number of states before we try to parallelise
   uint_t omp_threshold_rank_ = 100;
 
   double snapshot_chop_threshold_ = 1e-10;
@@ -208,14 +195,15 @@ class State: public QuantumState::State<chstate_t>
   void compute_extent(const Operations::Op &op, double &xi) const;
 
   template <typename InputIterator>
-  std::pair<uint_t, uint_t> decomposition_parameters(InputIterator first, InputIterator last);
-  
+  std::pair<uint_t, uint_t> decomposition_parameters(InputIterator first,
+                                                     InputIterator last);
+
   template <typename InputIterator>
-  std::pair<bool, size_t> check_stabilizer_opt(InputIterator first, InputIterator last) const;
+  std::pair<bool, size_t> check_stabilizer_opt(InputIterator first,
+                                               InputIterator last) const;
 
   template <typename InputIterator>
   bool check_measurement_opt(InputIterator first, InputIterator last) const;
-
 };
 
 //=========================================================================
@@ -223,135 +211,131 @@ class State: public QuantumState::State<chstate_t>
 //=========================================================================
 
 const stringmap_t<Gates> State::gateset_({
-  // Single qubit gates
-  {"delay", Gates::id},  // Delay gate
-  {"id", Gates::id},     // Pauli-Identity gate
-  {"x", Gates::x},       // Pauli-X gate
-  {"y", Gates::y},       // Pauli-Y gate
-  {"z", Gates::z},       // Pauli-Z gate
-  {"s", Gates::s},       // Phase gate (aka sqrt(Z) gate)
-  {"sdg", Gates::sdg},   // Conjugate-transpose of Phase gate
-  {"h", Gates::h},       // Hadamard gate (X + Z / sqrt(2))
-  {"sx", Gates::sx},     // sqrt(X) gate
-  {"sxdg", Gates::sxdg}, // Inverse sqrt(X) gate
-  {"t", Gates::t},       // T-gate (sqrt(S))
-  {"tdg", Gates::tdg},   // Conjguate-transpose of T gate
-  // Waltz Gates
-  {"u0", Gates::u0},     // idle gate in multiples of X90
-  {"u1", Gates::u1},     // zero-X90 pulse waltz gate
-  {"p", Gates::u1},      // zero-X90 pulse waltz gate
-  // Two-qubit gates
-  {"CX", Gates::cx},     // Controlled-X gate (CNOT)
-  {"cx", Gates::cx},     // Controlled-X gate (CNOT)
-  {"cz", Gates::cz},     // Controlled-Z gate
-  {"swap", Gates::swap}, // SWAP gate
-  // Three-qubit gates
-  {"ccx", Gates::ccx},    // Controlled-CX gate (Toffoli)
-  {"ccz", Gates::ccz},    // Constrolled-CZ gate (H3 Toff H3)
-  // Multi-qubit Pauli
-  {"pauli", Gates::pauli} // Multi-qubit Pauli gate
+    // Single qubit gates
+    {"delay", Gates::id},  // Delay gate
+    {"id", Gates::id},     // Pauli-Identity gate
+    {"x", Gates::x},       // Pauli-X gate
+    {"y", Gates::y},       // Pauli-Y gate
+    {"z", Gates::z},       // Pauli-Z gate
+    {"s", Gates::s},       // Phase gate (aka sqrt(Z) gate)
+    {"sdg", Gates::sdg},   // Conjugate-transpose of Phase gate
+    {"h", Gates::h},       // Hadamard gate (X + Z / sqrt(2))
+    {"sx", Gates::sx},     // sqrt(X) gate
+    {"sxdg", Gates::sxdg}, // Inverse sqrt(X) gate
+    {"t", Gates::t},       // T-gate (sqrt(S))
+    {"tdg", Gates::tdg},   // Conjguate-transpose of T gate
+    // Waltz Gates
+    {"u0", Gates::u0}, // idle gate in multiples of X90
+    {"u1", Gates::u1}, // zero-X90 pulse waltz gate
+    {"p", Gates::u1},  // zero-X90 pulse waltz gate
+    // Two-qubit gates
+    {"CX", Gates::cx},     // Controlled-X gate (CNOT)
+    {"cx", Gates::cx},     // Controlled-X gate (CNOT)
+    {"cz", Gates::cz},     // Controlled-Z gate
+    {"swap", Gates::swap}, // SWAP gate
+    // Three-qubit gates
+    {"ccx", Gates::ccx}, // Controlled-CX gate (Toffoli)
+    {"ccz", Gates::ccz}, // Constrolled-CZ gate (H3 Toff H3)
+    // Multi-qubit Pauli
+    {"pauli", Gates::pauli} // Multi-qubit Pauli gate
 });
 
-const stringmap_t<Snapshots> State::snapshotset_({
-  {"statevector", Snapshots::statevector},
-  {"probabilities", Snapshots::probs},
-  {"memory", Snapshots::cmemory},
-  {"register", Snapshots::cregister}
-});
+const stringmap_t<Snapshots>
+    State::snapshotset_({{"statevector", Snapshots::statevector},
+                         {"probabilities", Snapshots::probs},
+                         {"memory", Snapshots::cmemory},
+                         {"register", Snapshots::cregister}});
 
 //-------------------------------------------------------------------------
 // Implementation: Initialisation and Config
 //-------------------------------------------------------------------------
 
-void State::initialize_qreg(uint_t num_qubits)
-{
+void State::initialize_qreg(uint_t num_qubits) {
   BaseState::qreg_.initialize(num_qubits);
   BaseState::qreg_.initialize_omp(BaseState::threads_, omp_threshold_rank_);
 }
 
-void State::set_config(const json_t &config)
-{
+void State::set_config(const json_t &config) {
   // Set the error upper bound in the stabilizer rank approximation
-  JSON::get_value(approximation_error_, "extended_stabilizer_approximation_error", config);
+  JSON::get_value(approximation_error_,
+                  "extended_stabilizer_approximation_error", config);
   // Set the number of samples used in the norm estimation routine
-  JSON::get_value(norm_estimation_samples_, "extended_stabilizer_norm_estimation_default_samples", config);
-  // Set the desired number of repetitions of the norm estimation step. If not explicitly set, we
-  // compute a default basd on the approximation error
-  norm_estimation_repetitions_ = std::llrint(std::log2(1. / approximation_error_));
-  JSON::get_value(norm_estimation_repetitions_, "extended_stabilizer_norm_estimation_repetitions", config);
+  JSON::get_value(norm_estimation_samples_,
+                  "extended_stabilizer_norm_estimation_default_samples",
+                  config);
+  // Set the desired number of repetitions of the norm estimation step. If not
+  // explicitly set, we compute a default basd on the approximation error
+  norm_estimation_repetitions_ =
+      std::llrint(std::log2(1. / approximation_error_));
+  JSON::get_value(norm_estimation_repetitions_,
+                  "extended_stabilizer_norm_estimation_repetitions", config);
   // Set the number of steps used in the metropolis sampler before we
   // consider the distribution as approximating the output
-  JSON::get_value(metropolis_mixing_steps_, "extended_stabilizer_metropolis_mixing_time", config);
-  //Set the threshold of the decomposition before we use omp
-  JSON::get_value(omp_threshold_rank_, "extended_stabilizer_parallel_threshold", config);
-  //Set the truncation threshold for the probabilities snapshot.
+  JSON::get_value(metropolis_mixing_steps_,
+                  "extended_stabilizer_metropolis_mixing_time", config);
+  // Set the threshold of the decomposition before we use omp
+  JSON::get_value(omp_threshold_rank_, "extended_stabilizer_parallel_threshold",
+                  config);
+  // Set the truncation threshold for the probabilities snapshot.
   JSON::get_value(snapshot_chop_threshold_, "zero_threshold", config);
-  //Set the number of samples for the probabilities snapshot
-  JSON::get_value(probabilities_snapshot_samples_, "extended_stabilizer_probabilities_snapshot_samples", config);
-  //Set the measurement strategy
+  // Set the number of samples for the probabilities snapshot
+  JSON::get_value(probabilities_snapshot_samples_,
+                  "extended_stabilizer_probabilities_snapshot_samples", config);
+  // Set the measurement strategy
   std::string sampling_method_str = "resampled_metropolis";
-  JSON::get_value(sampling_method_str, "extended_stabilizer_sampling_method", config);
+  JSON::get_value(sampling_method_str, "extended_stabilizer_sampling_method",
+                  config);
   if (sampling_method_str == "metropolis") {
     sampling_method_ = SamplingMethod::metropolis;
-  }
-  else if (sampling_method_str == "resampled_metropolis")
-  {
+  } else if (sampling_method_str == "resampled_metropolis") {
     sampling_method_ = SamplingMethod::resampled_metropolis;
-  }
-  else if (sampling_method_str == "norm_estimation") {
+  } else if (sampling_method_str == "norm_estimation") {
     sampling_method_ = SamplingMethod::norm_estimation;
-  }
-  else {
+  } else {
     throw std::runtime_error(
-      std::string("Unrecognised sampling method ") + sampling_method_str +
-      std::string("for the extended stabilizer simulator.")
-    );
+        std::string("Unrecognised sampling method ") + sampling_method_str +
+        std::string("for the extended stabilizer simulator."));
   }
 }
 
 template <typename InputIterator>
-std::pair<uint_t, uint_t> State::decomposition_parameters(InputIterator first, InputIterator last)
-{
-  double xi=1.;
+std::pair<uint_t, uint_t> State::decomposition_parameters(InputIterator first,
+                                                          InputIterator last) {
+  double xi = 1.;
   unsigned three_qubit_gate_count = 0;
-  for (auto op = first; op != last; op++)
-  {
-    if (op->type == Operations::OpType::gate)
-    {
+  for (auto op = first; op != last; op++) {
+    if (op->type == Operations::OpType::gate) {
       compute_extent(op, xi);
       auto it = CHSimulator::gate_types_.find(op->name);
-      if (it->second == CHSimulator::Gatetypes::non_clifford && op->qubits.size() == 3)
-      { //We count the number of 3 qubit gates for normalisation purposes
+      if (it->second == CHSimulator::Gatetypes::non_clifford &&
+          op->qubits.size() == 3) { // We count the number of 3 qubit gates for
+                                    // normalisation purposes
         three_qubit_gate_count++;
       }
     }
   }
-  uint_t chi=1;
-  if (xi >1)
-  {
+  uint_t chi = 1;
+  if (xi > 1) {
     double err_scaling = std::pow(approximation_error_, -2);
-    chi = std::llrint(std::ceil(xi*err_scaling));
+    chi = std::llrint(std::ceil(xi * err_scaling));
   }
   return std::pair<uint_t, uint_t>({chi, three_qubit_gate_count});
 }
 
 template <typename InputIterator>
-std::pair<bool, size_t> State::check_stabilizer_opt(InputIterator first, InputIterator last) const
-{
-  for(auto op = first; op != last; op++)
-  {
-    if (op->type != Operations::OpType::gate)
-    {
+std::pair<bool, size_t> State::check_stabilizer_opt(InputIterator first,
+                                                    InputIterator last) const {
+  for (auto op = first; op != last; op++) {
+    if (op->type != Operations::OpType::gate) {
       continue;
     }
     auto it = CHSimulator::gate_types_.find(op->name);
-    if(it == CHSimulator::gate_types_.end())
-    {
-      throw std::invalid_argument("CHState::check_measurement_opt doesn't recognise a the operation \'"+
-                                   op->name + "\'.");
+    if (it == CHSimulator::gate_types_.end()) {
+      throw std::invalid_argument("CHState::check_measurement_opt doesn't "
+                                  "recognise a the operation \'" +
+                                  op->name + "\'.");
     }
-    if(it->second == CHSimulator::Gatetypes::non_clifford)
-    {
+    if (it->second == CHSimulator::Gatetypes::non_clifford) {
       return std::pair<bool, size_t>({false, op - first});
     }
   }
@@ -359,20 +343,17 @@ std::pair<bool, size_t> State::check_stabilizer_opt(InputIterator first, InputIt
 }
 
 template <typename InputIterator>
-bool State::check_measurement_opt(InputIterator first, InputIterator last) const
-{
-  for (auto op = first; op != last; op++)
-  {
-    if (op->conditional)
-    {
+bool State::check_measurement_opt(InputIterator first,
+                                  InputIterator last) const {
+  for (auto op = first; op != last; op++) {
+    if (op->conditional) {
       return false;
     }
     if (op->type == Operations::OpType::measure ||
         op->type == Operations::OpType::bfunc ||
         op->type == Operations::OpType::snapshot ||
         op->type == Operations::OpType::save_statevec ||
-        op->type == Operations::OpType::save_expval)
-    {
+        op->type == Operations::OpType::save_expval) {
       return false;
     }
   }
@@ -384,82 +365,76 @@ bool State::check_measurement_opt(InputIterator first, InputIterator last) const
 //-------------------------------------------------------------------------
 void State::apply_op(const Operations::Op &op, ExperimentResult &result,
                      RngEngine &rng, bool final_op) {
-  apply_ops(&op, &op+1, result, rng, final_op);
+  apply_ops(&op, &op + 1, result, rng, final_op);
 }
 
 template <typename InputIterator>
-void State::apply_ops(InputIterator first, InputIterator last, ExperimentResult &result,
-                      RngEngine &rng, bool final_ops)
-{
+void State::apply_ops(InputIterator first, InputIterator last,
+                      ExperimentResult &result, RngEngine &rng,
+                      bool final_ops) {
   std::pair<bool, size_t> stabilizer_opts = check_stabilizer_opt(first, last);
   bool is_stabilizer = stabilizer_opts.first;
-  if(is_stabilizer)
-  {
+  if (is_stabilizer) {
     apply_stabilizer_circuit(first, last, result, rng);
-  }
-  else
-  {
-    //Split the circuit into stabilizer and non-stabilizer fractions
+  } else {
+    // Split the circuit into stabilizer and non-stabilizer fractions
     size_t first_non_clifford = stabilizer_opts.second;
-    if (first_non_clifford > 0)
-    {
-      //Apply the stabilizer circuit first. This optimisaiton avoids duplicating the application
-      //of the initial stabilizer circuit chi times.
-      apply_stabilizer_circuit(first, first+first_non_clifford, result, rng);
+    if (first_non_clifford > 0) {
+      // Apply the stabilizer circuit first. This optimisaiton avoids
+      // duplicating the application of the initial stabilizer circuit chi
+      // times.
+      apply_stabilizer_circuit(first, first + first_non_clifford, result, rng);
     }
 
-    auto it_nonstab_begin = first+first_non_clifford;
+    auto it_nonstab_begin = first + first_non_clifford;
 
     uint_t chi = compute_chi(it_nonstab_begin, last);
     double delta = std::pow(approximation_error_, -2);
     BaseState::qreg_.initialize_decomposition(chi, delta);
-    //Check for measurement optimisaitons
+    // Check for measurement optimisaitons
     bool measurement_opt = check_measurement_opt(first, last);
 
-    if(measurement_opt)
-    {
+    if (measurement_opt) {
       apply_ops_parallel(it_nonstab_begin, last, result, rng);
-    }
-    else
-    {
-      for (auto it = it_nonstab_begin; it != last; it++)
-      {
+    } else {
+      for (auto it = it_nonstab_begin; it != last; it++) {
         const auto op = *it;
-        if(BaseState::creg().check_conditional(op)) {
+        if (BaseState::creg().check_conditional(op)) {
           switch (op.type) {
-            case Operations::OpType::gate:
-              apply_gate(op, rng);
-              break;
-            case Operations::OpType::reset:
-              apply_reset(op.qubits, rng);
-              break;
-            case Operations::OpType::barrier:
-            case Operations::OpType::qerror_loc:
-              break;
-            case Operations::OpType::measure:
-              apply_measure(op.qubits, op.memory, op.registers, rng);
-              break;
-            case Operations::OpType::roerror:
-              BaseState::creg().apply_roerror(op, rng);
-              break;
-            case Operations::OpType::bfunc:
-              BaseState::creg().apply_bfunc(op);
-              break;
-            case Operations::OpType::snapshot:
-              apply_snapshot(op, result, rng);
-              break;
-            case Operations::OpType::save_statevec:
-              apply_save_statevector(op, result);
-              break;
-            // Disabled until can fix bug in expval
-            // case Operations::OpType::save_expval:
-            // case Operations::OpType::save_expval_var:
-            //   apply_save_expval(op, result, rng);
-            //   break;
-            default:
-              throw std::invalid_argument("CH::State::apply_ops does not support operations of the type \'" + 
-                                          op.name + "\'.");
-              break;
+          case Operations::OpType::gate:
+            apply_gate(op, rng);
+            break;
+          case Operations::OpType::reset:
+            apply_reset(op.qubits, rng);
+            break;
+          case Operations::OpType::barrier:
+          case Operations::OpType::qerror_loc:
+            break;
+          case Operations::OpType::measure:
+            apply_measure(op.qubits, op.memory, op.registers, rng);
+            break;
+          case Operations::OpType::roerror:
+            BaseState::creg().apply_roerror(op, rng);
+            break;
+          case Operations::OpType::bfunc:
+            BaseState::creg().apply_bfunc(op);
+            break;
+          case Operations::OpType::snapshot:
+            apply_snapshot(op, result, rng);
+            break;
+          case Operations::OpType::save_statevec:
+            apply_save_statevector(op, result);
+            break;
+          // Disabled until can fix bug in expval
+          // case Operations::OpType::save_expval:
+          // case Operations::OpType::save_expval_var:
+          //   apply_save_expval(op, result, rng);
+          //   break;
+          default:
+            throw std::invalid_argument("CH::State::apply_ops does not support "
+                                        "operations of the type \'" +
+                                        op.name + "\'.");
+            break;
           }
         }
       }
@@ -467,51 +442,36 @@ void State::apply_ops(InputIterator first, InputIterator last, ExperimentResult
   }
 }
 
-std::vector<reg_t> State::sample_measure(const reg_t& qubits,
-                           uint_t shots,
-                           RngEngine &rng)
-{
+std::vector<reg_t> State::sample_measure(const reg_t &qubits, uint_t shots,
+                                         RngEngine &rng) {
   std::vector<uint_t> output_samples;
-  if(BaseState::qreg_.get_num_states() == 1)
-  {
+  if (BaseState::qreg_.get_num_states() == 1) {
     output_samples = BaseState::qreg_.stabilizer_sampler(shots, rng);
-  }
-  else
-  {
-    if (sampling_method_ == SamplingMethod::metropolis)
-    {
-        output_samples = BaseState::qreg_.metropolis_estimation(metropolis_mixing_steps_, shots, rng);
-    }
-    else if (sampling_method_ == SamplingMethod::resampled_metropolis)
-    {
+  } else {
+    if (sampling_method_ == SamplingMethod::metropolis) {
+      output_samples = BaseState::qreg_.metropolis_estimation(
+          metropolis_mixing_steps_, shots, rng);
+    } else if (sampling_method_ == SamplingMethod::resampled_metropolis) {
       output_samples.reserve(shots);
-      for (uint_t i=0; i<shots; i++)
-      {
-        output_samples.push_back(
-          BaseState::qreg_.metropolis_estimation(metropolis_mixing_steps_, rng)
-        );
+      for (uint_t i = 0; i < shots; i++) {
+        output_samples.push_back(BaseState::qreg_.metropolis_estimation(
+            metropolis_mixing_steps_, rng));
       }
-    }
-    else
-    {
+    } else {
       output_samples.reserve(shots);
-      for(uint_t i=0; i<shots; i++)
-      {
-        output_samples.push_back(
-          BaseState::qreg_.ne_single_sample(norm_estimation_samples_, norm_estimation_repetitions_, true, qubits, rng)
-        );
+      for (uint_t i = 0; i < shots; i++) {
+        output_samples.push_back(BaseState::qreg_.ne_single_sample(
+            norm_estimation_samples_, norm_estimation_repetitions_, true,
+            qubits, rng));
       }
     }
   }
   std::vector<reg_t> all_samples;
   all_samples.reserve(shots);
-  for(uint_t sample: output_samples)
-  {
+  for (uint_t sample : output_samples) {
     reg_t sample_bits(qubits.size(), 0ULL);
-    for(size_t i=0; i<qubits.size(); i++)
-    {
-      if((sample >> qubits[i]) & 1ULL)
-      {
+    for (size_t i = 0; i < qubits.size(); i++) {
+      if ((sample >> qubits[i]) & 1ULL) {
         sample_bits[i] = 1ULL;
       }
     }
@@ -520,37 +480,36 @@ std::vector<reg_t> State::sample_measure(const reg_t& qubits,
   return all_samples;
 }
 
-
 //-------------------------------------------------------------------------
 // Implemenation: Protected Methods
 //-------------------------------------------------------------------------
 
-//Method with slighty optimized parallelisation for the case of a sample_measure circuit
+// Method with slighty optimized parallelisation for the case of a
+// sample_measure circuit
 template <typename InputIterator>
-void State::apply_ops_parallel(InputIterator first, InputIterator last, ExperimentResult &result, RngEngine &rng)
-{
+void State::apply_ops_parallel(InputIterator first, InputIterator last,
+                               ExperimentResult &result, RngEngine &rng) {
   const int_t NUM_STATES = BaseState::qreg_.get_num_states();
-  #pragma omp parallel for if(BaseState::qreg_.check_omp_threshold() && BaseState::threads_>1) num_threads(BaseState::threads_)
-  for(int_t i=0; i < NUM_STATES; i++)
-  {
-    if(!BaseState::qreg_.check_eps(i))
-    {
+#pragma omp parallel for if (BaseState::qreg_.check_omp_threshold() &&         \
+                             BaseState::threads_ > 1)                          \
+    num_threads(BaseState::threads_)
+  for (int_t i = 0; i < NUM_STATES; i++) {
+    if (!BaseState::qreg_.check_eps(i)) {
       continue;
     }
-    for(auto it = first; it != last; it++)
-    {
-      switch (it->type)
-      {
-        case Operations::OpType::gate:
-          apply_gate(*it, rng, i);
-          break;
-        case Operations::OpType::barrier:
-        case Operations::OpType::qerror_loc:
-          break;
-        default:
-          throw std::invalid_argument("CH::State::apply_ops_parallel does not support operations of the type \'" + 
-                                       it->name + "\'.");
-          break;
+    for (auto it = first; it != last; it++) {
+      switch (it->type) {
+      case Operations::OpType::gate:
+        apply_gate(*it, rng, i);
+        break;
+      case Operations::OpType::barrier:
+      case Operations::OpType::qerror_loc:
+        break;
+      default:
+        throw std::invalid_argument("CH::State::apply_ops_parallel does not "
+                                    "support operations of the type \'" +
+                                    it->name + "\'.");
+        break;
       }
     }
   }
@@ -558,103 +517,93 @@ void State::apply_ops_parallel(InputIterator first, InputIterator last, Experime
 
 template <typename InputIterator>
 void State::apply_stabilizer_circuit(InputIterator first, InputIterator last,
-                                     ExperimentResult &result, RngEngine &rng)
-{
-  for (auto it = first; it != last; ++it)
-  {
+                                     ExperimentResult &result, RngEngine &rng) {
+  for (auto it = first; it != last; ++it) {
     const Operations::Op op = *it;
-    if(BaseState::creg().check_conditional(op)) {
-      switch (op.type)
-      {
-        case Operations::OpType::gate:
-          apply_gate(op, rng, 0);
-          break;
-        case Operations::OpType::reset:
-          apply_reset(op.qubits, rng);
-          break;
-        case Operations::OpType::barrier:
-        case Operations::OpType::qerror_loc:
-          break;
-        case Operations::OpType::measure:
-          apply_measure(op.qubits, op.memory, op.registers, rng);
-          break;
-        case Operations::OpType::roerror:
-          BaseState::creg().apply_roerror(op, rng);
-          break;
-        case Operations::OpType::bfunc:
-          BaseState::creg().apply_bfunc(op);
-          break;
-        case Operations::OpType::snapshot:
-          apply_snapshot(op, result, rng);
-          break;
-        case Operations::OpType::save_statevec:
-          apply_save_statevector(op, result);
-          break;
-        case Operations::OpType::save_expval:
-        case Operations::OpType::save_expval_var:
-          apply_save_expval(op, result, rng);
-          break;
-        default:
-          throw std::invalid_argument("CH::State::apply_stabilizer_circuit does not support operations of the type \'" + 
-                                      op.name + "\'.");
-          break;
+    if (BaseState::creg().check_conditional(op)) {
+      switch (op.type) {
+      case Operations::OpType::gate:
+        apply_gate(op, rng, 0);
+        break;
+      case Operations::OpType::reset:
+        apply_reset(op.qubits, rng);
+        break;
+      case Operations::OpType::barrier:
+      case Operations::OpType::qerror_loc:
+        break;
+      case Operations::OpType::measure:
+        apply_measure(op.qubits, op.memory, op.registers, rng);
+        break;
+      case Operations::OpType::roerror:
+        BaseState::creg().apply_roerror(op, rng);
+        break;
+      case Operations::OpType::bfunc:
+        BaseState::creg().apply_bfunc(op);
+        break;
+      case Operations::OpType::snapshot:
+        apply_snapshot(op, result, rng);
+        break;
+      case Operations::OpType::save_statevec:
+        apply_save_statevector(op, result);
+        break;
+      case Operations::OpType::save_expval:
+      case Operations::OpType::save_expval_var:
+        apply_save_expval(op, result, rng);
+        break;
+      default:
+        throw std::invalid_argument("CH::State::apply_stabilizer_circuit does "
+                                    "not support operations of the type \'" +
+                                    op.name + "\'.");
+        break;
       }
     }
   }
 }
 
-void State::apply_measure(const reg_t &qubits, const reg_t &cmemory, const reg_t &cregister, RngEngine &rng)
-{
+void State::apply_measure(const reg_t &qubits, const reg_t &cmemory,
+                          const reg_t &cregister, RngEngine &rng) {
   uint_t out_string;
   // Flag if the Pauli projector is applied already as part of the sampling
   bool do_projector_correction = true;
   // Prepare an output register for the qubits we are measurig
   reg_t outcome(qubits.size(), 0ULL);
-  if(BaseState::qreg_.get_num_states() == 1)
-  {
-    //For a single state, we use the efficient sampler defined in Sec IV.A ofarxiv:1808.00128
+  if (BaseState::qreg_.get_num_states() == 1) {
+    // For a single state, we use the efficient sampler defined in Sec IV.A
+    // ofarxiv:1808.00128
     out_string = BaseState::qreg_.stabilizer_sampler(rng);
-  }
-  else
-  {
-    if (sampling_method_ == SamplingMethod::norm_estimation)
-    {
+  } else {
+    if (sampling_method_ == SamplingMethod::norm_estimation) {
       do_projector_correction = false;
-      //Run the norm estimation routine
+      // Run the norm estimation routine
       out_string = BaseState::qreg_.ne_single_sample(
-        norm_estimation_samples_, norm_estimation_repetitions_, false, qubits, rng
-      );
-    }
-    else
-    {
-      // We use the metropolis algorithm to sample an output string non-destructively
-      // This is a single measure step so we do the same for metropolis or resampled_metropolis
-      out_string = BaseState::qreg_.metropolis_estimation(metropolis_mixing_steps_, rng);
+          norm_estimation_samples_, norm_estimation_repetitions_, false, qubits,
+          rng);
+    } else {
+      // We use the metropolis algorithm to sample an output string
+      // non-destructively This is a single measure step so we do the same for
+      // metropolis or resampled_metropolis
+      out_string =
+          BaseState::qreg_.metropolis_estimation(metropolis_mixing_steps_, rng);
     }
   }
-  if (do_projector_correction)
-  {
-    //We prepare the Pauli projector corresponding to the measurement result
-    std::vector<chpauli_t>paulis(qubits.size(), chpauli_t());
-    for (uint_t i=0; i<qubits.size(); i++)
-    {
-      //Create a Pauli projector onto 1+-Z_{i} on qubit i
+  if (do_projector_correction) {
+    // We prepare the Pauli projector corresponding to the measurement result
+    std::vector<chpauli_t> paulis(qubits.size(), chpauli_t());
+    for (uint_t i = 0; i < qubits.size(); i++) {
+      // Create a Pauli projector onto 1+-Z_{i} on qubit i
       paulis[i].Z = (1ULL << qubits[i]);
-      if ((out_string >> qubits[i]) & 1ULL)
-      {
-        //Additionally, store the output bit for this qubit
+      if ((out_string >> qubits[i]) & 1ULL) {
+        // Additionally, store the output bit for this qubit
         paulis[i].e = 2;
       }
     }
-    //Project the decomposition onto the measurement outcome
+    // Project the decomposition onto the measurement outcome
     BaseState::qreg_.apply_pauli_projector(paulis);
   }
-  for (uint_t i=0; i<qubits.size(); i++)
-  {
-    //Create a Pauli projector onto 1+-Z_{i} on qubit i
-    if ((out_string >> qubits[i]) & 1ULL)
-    {
-      //Additionally, store the output bit for this qubit
+  for (uint_t i = 0; i < qubits.size(); i++) {
+    // Create a Pauli projector onto 1+-Z_{i} on qubit i
+    if ((out_string >> qubits[i]) & 1ULL) {
+      // Additionally, store the output bit for this qubit
       outcome[i] = 1ULL;
     }
   }
@@ -662,143 +611,137 @@ void State::apply_measure(const reg_t &qubits, const reg_t &cmemory, const reg_t
   BaseState::creg().store_measure(outcome, cmemory, cregister);
 }
 
-void State::apply_reset(const reg_t &qubits, AER::RngEngine &rng)
-{
+void State::apply_reset(const reg_t &qubits, AER::RngEngine &rng) {
   uint_t measure_string;
   const int_t NUM_STATES = BaseState::qreg_.get_num_states();
-  if(BaseState::qreg_.get_num_states() == 1)
-  {
+  if (BaseState::qreg_.get_num_states() == 1) {
     measure_string = BaseState::qreg_.stabilizer_sampler(rng);
-  }
-  else
-  {
-    measure_string = BaseState::qreg_.metropolis_estimation(metropolis_mixing_steps_, rng);
+  } else {
+    measure_string =
+        BaseState::qreg_.metropolis_estimation(metropolis_mixing_steps_, rng);
   }
 
   std::vector<chpauli_t> paulis(qubits.size(), chpauli_t());
-  for(size_t i=0; i<qubits.size(); i++)
-  {
+  for (size_t i = 0; i < qubits.size(); i++) {
     uint_t qubit = qubits[i];
     uint_t shift = 1ULL << qubit;
     paulis[i].Z = shift;
-    if(!!(measure_string & shift))
-    {
+    if (!!(measure_string & shift)) {
       paulis[i].e = 2;
     }
   }
   BaseState::qreg_.apply_pauli_projector(paulis);
-  #pragma omp parallel for if(BaseState::threads_ > 1 && BaseState::qreg_.check_omp_threshold()) num_threads(BaseState::threads_)
-  for(int_t i=0; i< NUM_STATES; i++)
-  {
-    for (auto qubit: qubits)
-    {
-      if ((measure_string>>qubit) & 1ULL)
-      {
+#pragma omp parallel for if (BaseState::threads_ > 1 &&                        \
+                             BaseState::qreg_.check_omp_threshold())           \
+    num_threads(BaseState::threads_)
+  for (int_t i = 0; i < NUM_STATES; i++) {
+    for (auto qubit : qubits) {
+      if ((measure_string >> qubit) & 1ULL) {
         BaseState::qreg_.apply_x(qubit, i);
       }
     }
   }
 }
 
-void State::apply_gate(const Operations::Op &op, RngEngine &rng)
-{
+void State::apply_gate(const Operations::Op &op, RngEngine &rng) {
   const int_t NUM_STATES = BaseState::qreg_.get_num_states();
-  #pragma omp parallel for if (BaseState::threads_ > 1 && BaseState::qreg_.check_omp_threshold()) num_threads(BaseState::threads_)
-  for(int_t i=0; i < NUM_STATES; i++)
-  {
-    if(BaseState::qreg_.check_eps(i))
-    {
+#pragma omp parallel for if (BaseState::threads_ > 1 &&                        \
+                             BaseState::qreg_.check_omp_threshold())           \
+    num_threads(BaseState::threads_)
+  for (int_t i = 0; i < NUM_STATES; i++) {
+    if (BaseState::qreg_.check_eps(i)) {
       apply_gate(op, rng, i);
     }
   }
 }
 
-void State::apply_gate(const Operations::Op &op, RngEngine &rng, uint_t rank)
-{
+void State::apply_gate(const Operations::Op &op, RngEngine &rng, uint_t rank) {
   auto it = gateset_.find(op.name);
-  if (it == gateset_.end())
-  {
-    throw std::invalid_argument("CH::State: Invalid gate operation \'"
-                                +op.name + "\'.");
+  if (it == gateset_.end()) {
+    throw std::invalid_argument("CH::State: Invalid gate operation \'" +
+                                op.name + "\'.");
   }
-  switch(it->second)
-  {
-    case Gates::x:
-      BaseState::qreg_.apply_x(op.qubits[0], rank);
-      break;
-    case Gates::y:
-      BaseState::qreg_.apply_y(op.qubits[0], rank);
-      break;
-    case Gates::z:
-      BaseState::qreg_.apply_z(op.qubits[0], rank);
-      break;
-    case Gates::s:
-      BaseState::qreg_.apply_s(op.qubits[0], rank);
-      break;
-    case Gates::sdg:
-      BaseState::qreg_.apply_sdag(op.qubits[0], rank);
-      break;
-    case Gates::h:
-      BaseState::qreg_.apply_h(op.qubits[0], rank);
-      break;
-    case Gates::sx:
-      BaseState::add_global_phase(M_PI / 4.);
-      BaseState::qreg_.apply_sx(op.qubits[0], rank);
-      break;
-    case Gates::sxdg:
-      BaseState::add_global_phase(-M_PI / 4.);
-      BaseState::qreg_.apply_sxdg(op.qubits[0], rank);
-      break;
-    case Gates::cx:
-      BaseState::qreg_.apply_cx(op.qubits[0], op.qubits[1], rank);
-      break;
-    case Gates::cz:
-      BaseState::qreg_.apply_cz(op.qubits[0], op.qubits[1], rank);
-      break;
-    case Gates::swap:
-      BaseState::qreg_.apply_swap(op.qubits[0], op.qubits[1], rank);
-      break;
-    case Gates::t:
-      BaseState::qreg_.apply_t(op.qubits[0], rng.rand(), rank);
-      break;
-    case Gates::tdg:
-      BaseState::qreg_.apply_tdag(op.qubits[0], rng.rand(), rank);
-      break;
-    case Gates::ccx:
-      BaseState::qreg_.apply_ccx(op.qubits[0], op.qubits[1], op.qubits[2], rng.rand_int(zero, toff_branch_max), rank);
-      break;
-    case Gates::ccz:
-      BaseState::qreg_.apply_ccz(op.qubits[0], op.qubits[1], op.qubits[2], rng.rand_int(zero, toff_branch_max), rank);
-      break;
-    case Gates::u1:
-      BaseState::qreg_.apply_u1(op.qubits[0], op.params[0], rng.rand(), rank);
-      break;
-    case Gates::pauli:
-      apply_pauli(op.qubits, op.string_params[0], rank);
-      break;
-    default: //u0 or Identity
-      break;
+  switch (it->second) {
+  case Gates::x:
+    BaseState::qreg_.apply_x(op.qubits[0], rank);
+    break;
+  case Gates::y:
+    BaseState::qreg_.apply_y(op.qubits[0], rank);
+    break;
+  case Gates::z:
+    BaseState::qreg_.apply_z(op.qubits[0], rank);
+    break;
+  case Gates::s:
+    BaseState::qreg_.apply_s(op.qubits[0], rank);
+    break;
+  case Gates::sdg:
+    BaseState::qreg_.apply_sdag(op.qubits[0], rank);
+    break;
+  case Gates::h:
+    BaseState::qreg_.apply_h(op.qubits[0], rank);
+    break;
+  case Gates::sx:
+    BaseState::add_global_phase(M_PI / 4.);
+    BaseState::qreg_.apply_sx(op.qubits[0], rank);
+    break;
+  case Gates::sxdg:
+    BaseState::add_global_phase(-M_PI / 4.);
+    BaseState::qreg_.apply_sxdg(op.qubits[0], rank);
+    break;
+  case Gates::cx:
+    BaseState::qreg_.apply_cx(op.qubits[0], op.qubits[1], rank);
+    break;
+  case Gates::cz:
+    BaseState::qreg_.apply_cz(op.qubits[0], op.qubits[1], rank);
+    break;
+  case Gates::swap:
+    BaseState::qreg_.apply_swap(op.qubits[0], op.qubits[1], rank);
+    break;
+  case Gates::t:
+    BaseState::qreg_.apply_t(op.qubits[0], rng.rand(), rank);
+    break;
+  case Gates::tdg:
+    BaseState::qreg_.apply_tdag(op.qubits[0], rng.rand(), rank);
+    break;
+  case Gates::ccx:
+    BaseState::qreg_.apply_ccx(op.qubits[0], op.qubits[1], op.qubits[2],
+                               rng.rand_int(zero, toff_branch_max), rank);
+    break;
+  case Gates::ccz:
+    BaseState::qreg_.apply_ccz(op.qubits[0], op.qubits[1], op.qubits[2],
+                               rng.rand_int(zero, toff_branch_max), rank);
+    break;
+  case Gates::u1:
+    BaseState::qreg_.apply_u1(op.qubits[0], op.params[0], rng.rand(), rank);
+    break;
+  case Gates::pauli:
+    apply_pauli(op.qubits, op.string_params[0], rank);
+    break;
+  default: // u0 or Identity
+    break;
   }
 }
 
-void State::apply_pauli(const reg_t &qubits, const std::string& pauli, uint_t rank) {
+void State::apply_pauli(const reg_t &qubits, const std::string &pauli,
+                        uint_t rank) {
   const auto size = qubits.size();
   for (size_t i = 0; i < qubits.size(); ++i) {
     const auto qubit = qubits[size - 1 - i];
     switch (pauli[i]) {
-      case 'I':
-        break;
-      case 'X':
-        BaseState::qreg_.apply_x(qubit, rank);
-        break;
-      case 'Y':
-        BaseState::qreg_.apply_y(qubit, rank);
-        break;
-      case 'Z':
-        BaseState::qreg_.apply_z(qubit, rank);
-        break;
-      default:
-        throw std::invalid_argument("invalid Pauli \'" + std::to_string(pauli[i]) + "\'.");
+    case 'I':
+      break;
+    case 'X':
+      BaseState::qreg_.apply_x(qubit, rank);
+      break;
+    case 'Y':
+      BaseState::qreg_.apply_y(qubit, rank);
+      break;
+    case 'Z':
+      BaseState::qreg_.apply_z(qubit, rank);
+      break;
+    default:
+      throw std::invalid_argument("invalid Pauli \'" +
+                                  std::to_string(pauli[i]) + "\'.");
     }
   }
 }
@@ -814,15 +757,12 @@ void State::apply_save_statevector(const Operations::Op &op,
   if (BaseState::has_global_phase_) {
     statevec *= BaseState::global_phase_;
   }
-  result.save_data_pershot(
-    creg(), op.string_params[0],
-    std::move(statevec),
-    op.type, op.save_type);
+  result.save_data_pershot(creg(), op.string_params[0], std::move(statevec),
+                           op.type, op.save_type);
 }
 
 void State::apply_save_expval(const Operations::Op &op,
-                                ExperimentResult &result,
-                                RngEngine& rng) {
+                              ExperimentResult &result, RngEngine &rng) {
   // Check empty edge case
   if (op.expval_params.empty()) {
     throw std::invalid_argument(
@@ -844,236 +784,215 @@ void State::apply_save_expval(const Operations::Op &op,
   }
   if (variance) {
     std::vector<double> expval_var(2);
-    expval_var[0] = expval;  // mean
-    expval_var[1] = sq_expval - expval * expval;  // variance
-    result.save_data_average(creg(), op.string_params[0], expval_var, op.type, op.save_type);
+    expval_var[0] = expval;                      // mean
+    expval_var[1] = sq_expval - expval * expval; // variance
+    result.save_data_average(creg(), op.string_params[0], expval_var, op.type,
+                             op.save_type);
   } else {
-    result.save_data_average(creg(), op.string_params[0], expval, op.type, op.save_type);
+    result.save_data_average(creg(), op.string_params[0], expval, op.type,
+                             op.save_type);
   }
 }
 
-void State::apply_snapshot(const Operations::Op &op, ExperimentResult &result, RngEngine &rng)
-{
+void State::apply_snapshot(const Operations::Op &op, ExperimentResult &result,
+                           RngEngine &rng) {
   auto it = snapshotset_.find(op.name);
-  if (it == snapshotset_.end())
-  {
-    throw std::invalid_argument("CH::State::invlaid snapshot instruction \'"+
+  if (it == snapshotset_.end()) {
+    throw std::invalid_argument("CH::State::invlaid snapshot instruction \'" +
                                 op.name + "\'.");
   }
-  switch(it->second)
-  {
-    case Snapshots::cmemory:
-      BaseState::snapshot_creg_memory(op, result);
-      break;
-    case Snapshots::cregister:
-      BaseState::snapshot_creg_register(op, result);
-      break;
-    case Snapshots::statevector:
-      statevector_snapshot(op, result);
-      break;
-    case Snapshots::probs:
-      probabilities_snapshot(op, result, rng);
-      break;
-    default:
-      throw std::invalid_argument("CH::State::invlaid snapshot instruction \'"+
-                              op.name + "\'.");
-      break;
+  switch (it->second) {
+  case Snapshots::cmemory:
+    BaseState::snapshot_creg_memory(op, result);
+    break;
+  case Snapshots::cregister:
+    BaseState::snapshot_creg_register(op, result);
+    break;
+  case Snapshots::statevector:
+    statevector_snapshot(op, result);
+    break;
+  case Snapshots::probs:
+    probabilities_snapshot(op, result, rng);
+    break;
+  default:
+    throw std::invalid_argument("CH::State::invlaid snapshot instruction \'" +
+                                op.name + "\'.");
+    break;
   }
 }
 
-void State::statevector_snapshot(const Operations::Op &op, ExperimentResult &result)
-{
+void State::statevector_snapshot(const Operations::Op &op,
+                                 ExperimentResult &result) {
   result.legacy_data.add_pershot_snapshot("statevector", op.string_params[0],
-		      BaseState::qreg_.statevector());
+                                          BaseState::qreg_.statevector());
 }
 
-double State::expval_pauli(const reg_t &qubits,
-                           const std::string& pauli,
+double State::expval_pauli(const reg_t &qubits, const std::string &pauli,
                            RngEngine &rng) {
-    // Compute expval components
-    auto state_cpy = BaseState::qreg_;
-    auto phi_norm = state_cpy.norm_estimation(norm_estimation_samples_, norm_estimation_repetitions_, rng);
-    std::vector<chpauli_t>paulis(1, chpauli_t());
-    for (uint_t pos = 0; pos < qubits.size(); ++pos) {
-      switch (pauli[pauli.size() - 1 - pos]) {
-        case 'I':
-          break;
-        case 'X':
-          paulis[0].X += (1ULL << qubits[pos]);
-          break;
-        case 'Y':
-          paulis[0].X += (1ULL << qubits[pos]);
-          paulis[0].Z += (1ULL << qubits[pos]);
-          break;
-        case 'Z':
-          paulis[0].Z += (1ULL << qubits[pos]);
-          break;
-        default: {
-          std::stringstream msg;
-          msg << "QubitVectorState::invalid Pauli string \'" << pauli[pos]
-              << "\'.";
-          throw std::invalid_argument(msg.str());
-        }
-      }
+  // Compute expval components
+  auto state_cpy = BaseState::qreg_;
+  auto phi_norm = state_cpy.norm_estimation(norm_estimation_samples_,
+                                            norm_estimation_repetitions_, rng);
+  std::vector<chpauli_t> paulis(1, chpauli_t());
+  for (uint_t pos = 0; pos < qubits.size(); ++pos) {
+    switch (pauli[pauli.size() - 1 - pos]) {
+    case 'I':
+      break;
+    case 'X':
+      paulis[0].X += (1ULL << qubits[pos]);
+      break;
+    case 'Y':
+      paulis[0].X += (1ULL << qubits[pos]);
+      paulis[0].Z += (1ULL << qubits[pos]);
+      break;
+    case 'Z':
+      paulis[0].Z += (1ULL << qubits[pos]);
+      break;
+    default: {
+      std::stringstream msg;
+      msg << "QubitVectorState::invalid Pauli string \'" << pauli[pos] << "\'.";
+      throw std::invalid_argument(msg.str());
+    }
     }
-    auto g_norm = state_cpy.norm_estimation(norm_estimation_samples_, norm_estimation_repetitions_, paulis, rng);
-    return (2*g_norm - phi_norm);
+  }
+  auto g_norm = state_cpy.norm_estimation(
+      norm_estimation_samples_, norm_estimation_repetitions_, paulis, rng);
+  return (2 * g_norm - phi_norm);
 }
 
-double State::expval_pauli(const reg_t &qubits,
-                           const std::string& pauli) {
-    // empty implementation of base class virtual method
-    // since in the extended stabilizer, expval relies on RNG
-    return 0;
+double State::expval_pauli(const reg_t &qubits, const std::string &pauli) {
+  // empty implementation of base class virtual method
+  // since in the extended stabilizer, expval relies on RNG
+  return 0;
 }
 
-void State::probabilities_snapshot(const Operations::Op &op, ExperimentResult &result, RngEngine &rng)
-{
+void State::probabilities_snapshot(const Operations::Op &op,
+                                   ExperimentResult &result, RngEngine &rng) {
   rvector_t probs;
-  if (op.qubits.size() == 0)
-  {
-    probs.push_back(BaseState::qreg_.norm_estimation(norm_estimation_samples_, norm_estimation_repetitions_, rng));
-  }
-  else
-  {
-    probs = rvector_t(1ULL<<op.qubits.size(), 0.);
+  if (op.qubits.size() == 0) {
+    probs.push_back(BaseState::qreg_.norm_estimation(
+        norm_estimation_samples_, norm_estimation_repetitions_, rng));
+  } else {
+    probs = rvector_t(1ULL << op.qubits.size(), 0.);
     int_t dim = probs.size();
     uint_t mask = 0ULL;
-    for(auto qubit: op.qubits)
-    {
+    for (auto qubit : op.qubits) {
       mask ^= (1ULL << qubit);
     }
-    if (BaseState::qreg_.get_num_states() == 1 || sampling_method_ != SamplingMethod::norm_estimation)
-    {
+    if (BaseState::qreg_.get_num_states() == 1 ||
+        sampling_method_ != SamplingMethod::norm_estimation) {
       std::vector<uint_t> samples;
       samples.reserve(probabilities_snapshot_samples_);
-      if(BaseState::qreg_.get_num_states() == 1)
-      {
-        samples = BaseState::qreg_.stabilizer_sampler(probabilities_snapshot_samples_, rng);
-      }
-      else
-      {
-        if (sampling_method_ == SamplingMethod::metropolis)
-        {
-          samples = BaseState::qreg_.metropolis_estimation(metropolis_mixing_steps_, probabilities_snapshot_samples_,
-                                                          rng);
-        }
-        else{
-          for (uint_t s=0; s<probabilities_snapshot_samples_; s++)
-          {
-            uint_t sample = BaseState::qreg_.metropolis_estimation(metropolis_mixing_steps_, rng);
+      if (BaseState::qreg_.get_num_states() == 1) {
+        samples = BaseState::qreg_.stabilizer_sampler(
+            probabilities_snapshot_samples_, rng);
+      } else {
+        if (sampling_method_ == SamplingMethod::metropolis) {
+          samples = BaseState::qreg_.metropolis_estimation(
+              metropolis_mixing_steps_, probabilities_snapshot_samples_, rng);
+        } else {
+          for (uint_t s = 0; s < probabilities_snapshot_samples_; s++) {
+            uint_t sample = BaseState::qreg_.metropolis_estimation(
+                metropolis_mixing_steps_, rng);
             samples.push_back(sample);
           }
         }
       }
-      #pragma omp parallel for if(BaseState::qreg_.check_omp_threshold() && BaseState::threads_>1) num_threads(BaseState::threads_)
-      for(int_t i=0; i < dim; i++)
-      {
+#pragma omp parallel for if (BaseState::qreg_.check_omp_threshold() &&         \
+                             BaseState::threads_ > 1)                          \
+    num_threads(BaseState::threads_)
+      for (int_t i = 0; i < dim; i++) {
         uint_t target = 0ULL;
-        for(uint_t j=0; j<op.qubits.size(); j++)
-        {
-          if((i >> j) & 1ULL)
-          {
+        for (uint_t j = 0; j < op.qubits.size(); j++) {
+          if ((i >> j) & 1ULL) {
             target ^= (1ULL << op.qubits[j]);
           }
         }
-        for(uint_t j=0; j<probabilities_snapshot_samples_; j++)
-        {
-          if((samples[j] & mask) == target)
-          {
+        for (uint_t j = 0; j < probabilities_snapshot_samples_; j++) {
+          if ((samples[j] & mask) == target) {
             probs[i] += 1;
           }
         }
         probs[i] /= probabilities_snapshot_samples_;
       }
-    }
-    else
-    {
-      probs = BaseState::qreg_.ne_probabilities(norm_estimation_samples_, norm_estimation_repetitions_, op.qubits, rng);
+    } else {
+      probs = BaseState::qreg_.ne_probabilities(norm_estimation_samples_,
+                                                norm_estimation_repetitions_,
+                                                op.qubits, rng);
     }
   }
-  result.legacy_data.add_average_snapshot("probabilities", op.string_params[0],
-                            BaseState::creg().memory_hex(),
-                            Utils::vec2ket(probs, snapshot_chop_threshold_, 16),
-                            false);
+  result.legacy_data.add_average_snapshot(
+      "probabilities", op.string_params[0], BaseState::creg().memory_hex(),
+      Utils::vec2ket(probs, snapshot_chop_threshold_, 16), false);
 }
 
 //-------------------------------------------------------------------------
 // Implementation: Utility
 //-------------------------------------------------------------------------
 
-inline void to_json(json_t &js, cvector_t vec)
-{
+inline void to_json(json_t &js, cvector_t vec) {
   js = json_t();
-  for (uint_t j=0; j < vec.size(); j++) {
+  for (uint_t j = 0; j < vec.size(); j++) {
     js.push_back(vec[j]);
   }
 }
 
 template <typename InputIterator>
-uint_t State::compute_chi(InputIterator first, InputIterator last) const
-{
+uint_t State::compute_chi(InputIterator first, InputIterator last) const {
   double xi = 1;
-  for (auto op = first; op != last; op++)
-  {
+  for (auto op = first; op != last; op++) {
     compute_extent(*op, xi);
   }
   double err_scaling = std::pow(approximation_error_, -2);
-  return std::llrint(std::ceil(xi*err_scaling));
+  return std::llrint(std::ceil(xi * err_scaling));
 }
 
-void State::compute_extent(const Operations::Op &op, double &xi) const
-{
-  if(op.type == Operations::OpType::gate)
-  {
+void State::compute_extent(const Operations::Op &op, double &xi) const {
+  if (op.type == Operations::OpType::gate) {
     auto it = gateset_.find(op.name);
-    if (it == gateset_.end())
-    {
-      throw std::invalid_argument("CH::State: Invalid gate operation \'"
-                                  +op.name + "\'.");
+    if (it == gateset_.end()) {
+      throw std::invalid_argument("CH::State: Invalid gate operation \'" +
+                                  op.name + "\'.");
     }
-    switch (it->second)
-    {
-      case Gates::t:
-        xi *= CHSimulator::t_extent;
-        break;
-      case Gates::tdg:
-        xi *= CHSimulator::t_extent;
-        break;
-      case Gates::ccx:
-        xi *= CHSimulator::ccx_extent;
-        break;
-      case Gates::ccz:
-        xi *= CHSimulator::ccx_extent;
-        break;
-      case Gates::u1:
-        xi *= CHSimulator::u1_extent(std::real(op.params[0]));
-        break;
-      default:
-        break;
+    switch (it->second) {
+    case Gates::t:
+      xi *= CHSimulator::t_extent;
+      break;
+    case Gates::tdg:
+      xi *= CHSimulator::t_extent;
+      break;
+    case Gates::ccx:
+      xi *= CHSimulator::ccx_extent;
+      break;
+    case Gates::ccz:
+      xi *= CHSimulator::ccx_extent;
+      break;
+    case Gates::u1:
+      xi *= CHSimulator::u1_extent(std::real(op.params[0]));
+      break;
+    default:
+      break;
     }
   }
 }
 
 size_t State::required_memory_mb(uint_t num_qubits,
-                                 const std::vector<Operations::Op> &ops) const
-{
+                                 const std::vector<Operations::Op> &ops) const {
   size_t required_chi = compute_chi(ops.cbegin(), ops.cend());
   // 5 vectors of num_qubits*8byte words
   // Plus 2*CHSimulator::scalar_t which has 3 4 byte words
   // Plus 2*CHSimulator::pauli_t which has 2 8 byte words and one 4 byte word;
-  double mb_per_state = 5e-5*num_qubits;//
-  size_t required_mb = std::llrint(std::ceil(mb_per_state*required_chi));
+  double mb_per_state = 5e-5 * num_qubits; //
+  size_t required_mb = std::llrint(std::ceil(mb_per_state * required_chi));
 
-  if (sampling_method_ == SamplingMethod::norm_estimation)
-  {
+  if (sampling_method_ == SamplingMethod::norm_estimation) {
     required_mb *= 2;
   }
   return required_mb;
-  //Todo: Update this function to account for snapshots
+  // Todo: Update this function to account for snapshots
 }
 
-}
-}
+} // namespace ExtendedStabilizer
+} // namespace AER
 
 #endif
diff --git a/src/simulators/extended_stabilizer/gates.hpp b/src/simulators/extended_stabilizer/gates.hpp
index 29004f2621..c08ee91dea 100644
--- a/src/simulators/extended_stabilizer/gates.hpp
+++ b/src/simulators/extended_stabilizer/gates.hpp
@@ -24,24 +24,35 @@
 #include "framework/operations.hpp"
 #include "framework/types.hpp"
 
-namespace CHSimulator
-{
-  using uint_t = uint_fast64_t;
-  using complex_t = std::complex<double>;
-
-  enum class Gates {
-    u0, u1, id, x, y, z, h, s, sdg, sx, sxdg, t, tdg,
-    cx, cz, swap,
-    ccx, ccz, pauli
-  };
-
-  enum class Gatetypes {
-    pauli,
-    clifford,
-    non_clifford
-  };
-
-  const AER::stringmap_t<Gatetypes> gate_types_ = {
+namespace CHSimulator {
+using uint_t = uint_fast64_t;
+using complex_t = std::complex<double>;
+
+enum class Gates {
+  u0,
+  u1,
+  id,
+  x,
+  y,
+  z,
+  h,
+  s,
+  sdg,
+  sx,
+  sxdg,
+  t,
+  tdg,
+  cx,
+  cz,
+  swap,
+  ccx,
+  ccz,
+  pauli
+};
+
+enum class Gatetypes { pauli, clifford, non_clifford };
+
+const AER::stringmap_t<Gatetypes> gate_types_ = {
     // One-qubit gates
     {"u0", Gatetypes::pauli},         // Pauli-Identity gate
     {"delay", Gatetypes::pauli},      // Pauli-Identity gate
@@ -59,51 +70,50 @@ namespace CHSimulator
     {"u1", Gatetypes::non_clifford},  // zero-X90 pulse waltz gate
     {"p", Gatetypes::non_clifford},   // zero-X90 pulse waltz gate
     // Two-qubit gates
-    {"CX", Gatetypes::clifford},      // Controlled-X gate (CNOT)
-    {"cx", Gatetypes::clifford},      // Controlled-X gate (CNOT)
-    {"cz", Gatetypes::clifford},      // Controlled-Z gate
-    {"swap", Gatetypes::clifford},    // SWAP gate
+    {"CX", Gatetypes::clifford},   // Controlled-X gate (CNOT)
+    {"cx", Gatetypes::clifford},   // Controlled-X gate (CNOT)
+    {"cz", Gatetypes::clifford},   // Controlled-Z gate
+    {"swap", Gatetypes::clifford}, // SWAP gate
     // Three-qubit gates
     {"ccx", Gatetypes::non_clifford}, // Controlled-CX gate (Toffoli)
     {"ccz", Gatetypes::non_clifford}, // Controlled-CZ gate (H3 Toff H3)
     // N-qubit gates
-    {"pauli", Gatetypes::pauli},      // N-qubit Pauli gate
-  };
-
-  using sample_branch_t = std::pair<complex_t, Gates>;
-
-  const double root2 = std::sqrt(2);
-  const double root1_2 = 1./root2;
-  const complex_t pi_over_8_phase(0., M_PI/8);
-  const complex_t omega(root1_2, root1_2);
-  const complex_t omega_star(root1_2, -1*root1_2);
-  const complex_t root_omega = std::exp(pi_over_8_phase);
-  const complex_t root_omega_star = std::conj(root_omega);
-
-  const double tan_pi_over_8 = std::tan(M_PI/8.);
-
-  //Base class for sampling over non-Clifford gates in the Sum Over Cliffords routine. 
-  struct Sample {
-  public:
-    Sample() = default;
-    virtual ~Sample() = default;
-    Sample(const Sample& other) : branches(other.branches) {};
-    std::vector<sample_branch_t> branches;
-
-    virtual sample_branch_t sample(double r) const = 0;
-  };
-
-  //Functor class that defines how to sample branches over a U1 operation
-  //Used for caching each U1 gate angle we encounter in the circuit
-struct U1Sample : public Sample
-{
+    {"pauli", Gatetypes::pauli}, // N-qubit Pauli gate
+};
+
+using sample_branch_t = std::pair<complex_t, Gates>;
+
+const double root2 = std::sqrt(2);
+const double root1_2 = 1. / root2;
+const complex_t pi_over_8_phase(0., M_PI / 8);
+const complex_t omega(root1_2, root1_2);
+const complex_t omega_star(root1_2, -1 * root1_2);
+const complex_t root_omega = std::exp(pi_over_8_phase);
+const complex_t root_omega_star = std::conj(root_omega);
+
+const double tan_pi_over_8 = std::tan(M_PI / 8.);
+
+// Base class for sampling over non-Clifford gates in the Sum Over Cliffords
+// routine.
+struct Sample {
+public:
+  Sample() = default;
+  virtual ~Sample() = default;
+  Sample(const Sample &other) : branches(other.branches){};
+  std::vector<sample_branch_t> branches;
+
+  virtual sample_branch_t sample(double r) const = 0;
+};
+
+// Functor class that defines how to sample branches over a U1 operation
+// Used for caching each U1 gate angle we encounter in the circuit
+struct U1Sample : public Sample {
   double p_threshold;
 
   U1Sample() = default;
   U1Sample(double lambda);
 
-  U1Sample(const U1Sample &other) : Sample(other)
-  {
+  U1Sample(const U1Sample &other) : Sample(other) {
     p_threshold = other.p_threshold;
   }
 
@@ -112,135 +122,101 @@ struct U1Sample : public Sample
   sample_branch_t sample(double r) const override;
 };
 
-U1Sample::U1Sample(double lambda)
-{
+U1Sample::U1Sample(double lambda) {
   // Shift parameter into +- 2 Pi
-  uint_t shift_factor = std::floor(std::abs(lambda)/(2*M_PI));
-  if (shift_factor != 0)
-  {
-    if(lambda < 0)
-    {
-      lambda += shift_factor*(2*M_PI);
-    } 
-    else
-    {
-      lambda -= shift_factor*(2*M_PI);
+  uint_t shift_factor = std::floor(std::abs(lambda) / (2 * M_PI));
+  if (shift_factor != 0) {
+    if (lambda < 0) {
+      lambda += shift_factor * (2 * M_PI);
+    } else {
+      lambda -= shift_factor * (2 * M_PI);
     }
   }
   // Shift parameter into +- Pi
-  if (lambda > M_PI)
-  {
-    lambda -= 2*M_PI;
-  }
-  else if (lambda < -1*M_PI)
-  {
-    lambda += 2*M_PI;
+  if (lambda > M_PI) {
+    lambda -= 2 * M_PI;
+  } else if (lambda < -1 * M_PI) {
+    lambda += 2 * M_PI;
   }
   // Compute the coefficients
   double angle = std::abs(lambda);
-  bool s_z_quadrant = (angle > M_PI/2);
-  if(s_z_quadrant)
-  {
-    angle = angle - M_PI/2;
+  bool s_z_quadrant = (angle > M_PI / 2);
+  if (s_z_quadrant) {
+    angle = angle - M_PI / 2;
   }
   angle /= 2;
-  complex_t coeff_0 = std::cos(angle)-std::sin(angle);
-  complex_t coeff_1 = root2*std::sin(angle);
+  complex_t coeff_0 = std::cos(angle) - std::sin(angle);
+  complex_t coeff_1 = root2 * std::sin(angle);
   complex_t phase_0, phase_1;
   std::array<Gates, 2> gates;
-  if(lambda < 0)
-  {
+  if (lambda < 0) {
     coeff_0 *= root_omega_star;
     coeff_1 = coeff_1 * root_omega;
-    if(s_z_quadrant)
-    {
+    if (s_z_quadrant) {
       gates[0] = Gates::sdg;
       gates[1] = Gates::z;
-    }
-    else
-    {
+    } else {
       gates[0] = Gates::id;
       gates[1] = Gates::sdg;
     }
-  }
-  else
-  {
+  } else {
     coeff_0 *= root_omega;
     coeff_1 = coeff_1 * root_omega_star;
-    if(s_z_quadrant)
-    {
+    if (s_z_quadrant) {
       gates[0] = Gates::s;
       gates[1] = Gates::z;
-    }
-    else
-    {
+    } else {
       gates[0] = Gates::id;
       gates[1] = Gates::s;
     }
   }
   phase_0 = std::polar(1.0, std::arg(coeff_0));
   phase_1 = std::polar(1.0, std::arg(coeff_1));
-  branches =
-  {
-    sample_branch_t(phase_0, gates[0]),
-    sample_branch_t(phase_1, gates[1])
-  };
-  p_threshold = std::abs(coeff_0) / (std::abs(coeff_0)+std::abs(coeff_1));
+  branches = {sample_branch_t(phase_0, gates[0]),
+              sample_branch_t(phase_1, gates[1])};
+  p_threshold = std::abs(coeff_0) / (std::abs(coeff_0) + std::abs(coeff_1));
 }
 
-sample_branch_t U1Sample::sample(double r) const
-{
-  if (r<p_threshold)
-  {
+sample_branch_t U1Sample::sample(double r) const {
+  if (r < p_threshold) {
     return branches[0];
-  }
-  else
-  {
+  } else {
     return branches[1];
   }
 }
 
-  // Stabilizer extent for different non-Clifford unitaries
-  // Special case of Eq. 28 in arXiv:1808.00128
-  const double t_extent = std::pow(1./(std::cos(M_PI/8.)), 2);
-  // Equation 32 in arXiv: 1808.00128
-  const double ccx_extent = 16./9.;
-  const double ccx_coeff = 1./6.;
-  //General result for z rotations, Eq. 28 in arXiv 1809.00128
-  inline double u1_extent(double lambda)
-  {
-    // Shift parameter into +- 2 Pi
-    uint_t shift_factor = std::floor(std::abs(lambda)/(2*M_PI));
-    if (shift_factor != 0)
-    {
-      if(lambda < 0)
-      {
-        lambda += shift_factor*(2*M_PI);
-      } 
-      else
-      {
-        lambda -= shift_factor*(2*M_PI);
-      }
-    }
-    // Shift parameter into +- Pi
-    if (lambda > M_PI)
-    {
-      lambda -= 2*M_PI;
-    }
-    else if (lambda < -1*M_PI)
-    {
-      lambda += 2*M_PI;
-    }
-    double angle = std::abs(lambda);
-    bool s_z_quadrant = (angle > M_PI/2);
-    if(s_z_quadrant)
-    {
-      angle = angle - M_PI/2;
+// Stabilizer extent for different non-Clifford unitaries
+// Special case of Eq. 28 in arXiv:1808.00128
+const double t_extent = std::pow(1. / (std::cos(M_PI / 8.)), 2);
+// Equation 32 in arXiv: 1808.00128
+const double ccx_extent = 16. / 9.;
+const double ccx_coeff = 1. / 6.;
+// General result for z rotations, Eq. 28 in arXiv 1809.00128
+inline double u1_extent(double lambda) {
+  // Shift parameter into +- 2 Pi
+  uint_t shift_factor = std::floor(std::abs(lambda) / (2 * M_PI));
+  if (shift_factor != 0) {
+    if (lambda < 0) {
+      lambda += shift_factor * (2 * M_PI);
+    } else {
+      lambda -= shift_factor * (2 * M_PI);
     }
-    angle /= 2;
-    return std::pow(std::cos(angle) + tan_pi_over_8*std::sin(angle), 2.);
   }
-
+  // Shift parameter into +- Pi
+  if (lambda > M_PI) {
+    lambda -= 2 * M_PI;
+  } else if (lambda < -1 * M_PI) {
+    lambda += 2 * M_PI;
+  }
+  double angle = std::abs(lambda);
+  bool s_z_quadrant = (angle > M_PI / 2);
+  if (s_z_quadrant) {
+    angle = angle - M_PI / 2;
+  }
+  angle /= 2;
+  return std::pow(std::cos(angle) + tan_pi_over_8 * std::sin(angle), 2.);
 }
 
+} // namespace CHSimulator
+
 #endif
diff --git a/src/simulators/matrix_product_state/matrix_product_state.hpp b/src/simulators/matrix_product_state/matrix_product_state.hpp
index 23e14f6637..6ea484c62c 100644
--- a/src/simulators/matrix_product_state/matrix_product_state.hpp
+++ b/src/simulators/matrix_product_state/matrix_product_state.hpp
@@ -12,14 +12,13 @@
  * that they have been altered from the originals.
  */
 
-
 //=========================================================================
 // Tensor Network State - simulation method
 //=========================================================================
-// For this simulation method, we represent the state of the circuit using a tensor
-// network structure, the specifically matrix product state. The idea is based on
-// the following paper (there exist other sources as well):
-// The density-matrix renormalization group in the age of matrix product states by
+// For this simulation method, we represent the state of the circuit using a
+// tensor network structure, the specifically matrix product state. The idea is
+// based on the following paper (there exist other sources as well): The
+// density-matrix renormalization group in the age of matrix product states by
 // Ulrich Schollwock.
 //
 //--------------------------------------------------------------------------
@@ -33,12 +32,11 @@
 #include <math.h>
 
 #include "framework/json.hpp"
+#include "framework/linalg/almost_equal.hpp"
 #include "framework/utils.hpp"
-#include "simulators/state.hpp"
-#include "matrix_product_state_internal.hpp"
 #include "matrix_product_state_internal.cpp"
-#include "framework/linalg/almost_equal.hpp"
-
+#include "matrix_product_state_internal.hpp"
+#include "simulators/state.hpp"
 
 namespace AER {
 namespace MatrixProductState {
@@ -49,44 +47,65 @@ using OpType = Operations::OpType;
 
 // OpSet of supported instructions
 const Operations::OpSet StateOpSet(
-  {OpType::gate, OpType::measure,
-   OpType::reset, OpType::initialize,
-   OpType::snapshot, OpType::barrier,
-   OpType::bfunc, OpType::roerror, OpType::qerror_loc,
-   OpType::matrix, OpType::diagonal_matrix,
-   OpType::kraus, OpType::save_expval,
-   OpType::save_expval_var, OpType::save_densmat,
-   OpType::save_statevec, OpType::save_probs,
-   OpType::save_probs_ket, OpType::save_amps,
-   OpType::save_amps_sq, OpType::save_mps, OpType::save_state,
-   OpType::set_mps, OpType::set_statevec,
-   OpType::jump, OpType::mark
-  },
-  // Gates
-  {"id", "x",  "y", "z", "s",  "sdg", "h",  "t",   "tdg",  "p", "u1",
-   "u2", "u3", "u", "U", "CX", "cx",  "cy", "cz", "cp", "cu1", "swap", "ccx",
-   "sx", "sxdg", "r", "rx", "ry", "rz", "rxx", "ryy", "rzz", "rzx", "csx", "delay",
-   "cswap", "pauli"},
-  // Snapshots
-  {"statevector", "amplitudes", "memory", "register", "probabilities",
-    "expectation_value_pauli", "expectation_value_pauli_with_variance",
-    "expectation_value_pauli_single_shot", "expectation_value_matrix",
-    "expectation_value_matrix_with_variance",
-      "expectation_value_matrix_single_shot",
-      "density_matrix", "density_matrix_with_variance"}
-);
+    {OpType::gate,
+     OpType::measure,
+     OpType::reset,
+     OpType::initialize,
+     OpType::snapshot,
+     OpType::barrier,
+     OpType::bfunc,
+     OpType::roerror,
+     OpType::qerror_loc,
+     OpType::matrix,
+     OpType::diagonal_matrix,
+     OpType::kraus,
+     OpType::save_expval,
+     OpType::save_expval_var,
+     OpType::save_densmat,
+     OpType::save_statevec,
+     OpType::save_probs,
+     OpType::save_probs_ket,
+     OpType::save_amps,
+     OpType::save_amps_sq,
+     OpType::save_mps,
+     OpType::save_state,
+     OpType::set_mps,
+     OpType::set_statevec,
+     OpType::jump,
+     OpType::mark},
+    // Gates
+    {"id",  "x",    "y",   "z",   "s",     "sdg",   "h",    "t",  "tdg", "p",
+     "u1",  "u2",   "u3",  "u",   "U",     "CX",    "cx",   "cy", "cz",  "cp",
+     "cu1", "swap", "ccx", "sx",  "sxdg",  "r",     "rx",   "ry", "rz",  "rxx",
+     "ryy", "rzz",  "rzx", "csx", "delay", "cswap", "pauli"},
+    // Snapshots
+    {"statevector", "amplitudes", "memory", "register", "probabilities",
+     "expectation_value_pauli", "expectation_value_pauli_with_variance",
+     "expectation_value_pauli_single_shot", "expectation_value_matrix",
+     "expectation_value_matrix_with_variance",
+     "expectation_value_matrix_single_shot", "density_matrix",
+     "density_matrix_with_variance"});
 
 // Allowed snapshots enum class
 enum class Snapshots {
-  statevector, amplitudes, cmemory, cregister,
-    probs, probs_var, densmat, densmat_var,
-    expval_pauli, expval_pauli_var, expval_pauli_shot,
-    expval_matrix, expval_matrix_var, expval_matrix_shot
+  statevector,
+  amplitudes,
+  cmemory,
+  cregister,
+  probs,
+  probs_var,
+  densmat,
+  densmat_var,
+  expval_pauli,
+  expval_pauli_var,
+  expval_pauli_shot,
+  expval_matrix,
+  expval_matrix_var,
+  expval_matrix_shot
 };
 
 // Enum class for different types of expectation values
-enum class SnapshotDataType {average, average_var, pershot};
-
+enum class SnapshotDataType { average, average_var, pershot };
 
 //=========================================================================
 // Matrix Product State subclass
@@ -99,29 +118,22 @@ class State : public QuantumState::State<matrixproductstate_t> {
   using BaseState = QuantumState::State<matrixproductstate_t>;
 
   State() : BaseState(StateOpSet) {}
-  State(uint_t num_qubits) : State() {qreg_.initialize((uint_t)num_qubits);}
+  State(uint_t num_qubits) : State() { qreg_.initialize((uint_t)num_qubits); }
   virtual ~State() = default;
 
-
   //-----------------------------------------------------------------------
   // Base class overrides
   //-----------------------------------------------------------------------
 
   // Return the string name of the State class
-  virtual std::string name() const override {
-	  return "matrix_product_state";
-  }
+  virtual std::string name() const override { return "matrix_product_state"; }
 
-  bool empty() const {
-    return qreg_.empty();
-  }
+  bool empty() const { return qreg_.empty(); }
 
   // Apply an operation
   // If the op is not in allowed_ops an exeption will be raised.
-  virtual void apply_op(const Operations::Op &op,
-                        ExperimentResult &result,
-                        RngEngine &rng,
-                        bool final_op = false) override;
+  virtual void apply_op(const Operations::Op &op, ExperimentResult &result,
+                        RngEngine &rng, bool final_op = false) override;
 
   // Initializes an n-qubit state to the all |0> state
   virtual void initialize_qreg(uint_t num_qubits) override;
@@ -129,13 +141,14 @@ class State : public QuantumState::State<matrixproductstate_t> {
   // Returns the required memory for storing an n-qubit state in megabytes.
   // For this state the memory is indepdentent of the number of ops
   // and is approximately 16 * 1 << num_qubits bytes
-  virtual size_t required_memory_mb(uint_t num_qubits,
-                                  const std::vector<Operations::Op> &ops)
-                                  const override;
+  virtual size_t
+  required_memory_mb(uint_t num_qubits,
+                     const std::vector<Operations::Op> &ops) const override;
 
   // Load the threshold for applying OpenMP parallelization
   // if the controller/engine allows threads for it
-  // We currently set the threshold to 1 in qasm_controller.hpp, i.e., no parallelization
+  // We currently set the threshold to 1 in qasm_controller.hpp, i.e., no
+  // parallelization
   virtual void set_config(const json_t &config) override;
 
   virtual void add_metadata(ExperimentResult &result) const override;
@@ -145,19 +158,16 @@ class State : public QuantumState::State<matrixproductstate_t> {
 
   // Sample n-measurement outcomes without applying the measure operation
   // to the system state
-  virtual std::vector<reg_t> sample_measure(const reg_t& qubits,
-                                            uint_t shots,
+  virtual std::vector<reg_t> sample_measure(const reg_t &qubits, uint_t shots,
                                             RngEngine &rng) override;
 
   // Computes sample_measure by copying the MPS to a temporary structure, and
   // applying a measurement on the temporary MPS. This is done for every shot,
   // so is not efficient for a large number of shots
-  std::vector<reg_t> 
-  sample_measure_using_apply_measure(const reg_t &qubits,
-				     uint_t shots,
-				     RngEngine &rng);
-std::vector<reg_t> sample_measure_all(uint_t shots, 
-				      RngEngine &rng);
+  std::vector<reg_t> sample_measure_using_apply_measure(const reg_t &qubits,
+                                                        uint_t shots,
+                                                        RngEngine &rng);
+  std::vector<reg_t> sample_measure_all(uint_t shots, RngEngine &rng);
   //-----------------------------------------------------------------------
   // Additional methods
   //-----------------------------------------------------------------------
@@ -165,7 +175,6 @@ std::vector<reg_t> sample_measure_all(uint_t shots,
   void initialize_omp();
 
 protected:
-
   //-----------------------------------------------------------------------
   // Apply instructions
   //-----------------------------------------------------------------------
@@ -178,17 +187,14 @@ std::vector<reg_t> sample_measure_all(uint_t shots,
   // by creating the MPS state with the new state |psi>.
   // |psi> is given in params
   // Currently only supports intialization of all qubits
-  void apply_initialize(const reg_t &qubits,
-			const cvector_t &params,
-			RngEngine &rng);
+  void apply_initialize(const reg_t &qubits, const cvector_t &params,
+                        RngEngine &rng);
 
   // Measure qubits and return a list of outcomes [q0, q1, ...]
   // If a state subclass supports this function, then "measure"
   // should be contained in the set defined by 'allowed_ops'
-  virtual void apply_measure(const reg_t &qubits,
-                             const reg_t &cmemory,
-                             const reg_t &cregister,
-                             RngEngine &rng);
+  virtual void apply_measure(const reg_t &qubits, const reg_t &cmemory,
+                             const reg_t &cregister, RngEngine &rng);
 
   // Reset the specified qubits to the |0> state by simulating
   // a measurement, applying a conditional x-gate if the outcome is 1, and
@@ -197,32 +203,31 @@ std::vector<reg_t> sample_measure_all(uint_t shots,
 
   // Apply a supported snapshot instruction
   // If the input is not in allowed_snapshots an exception will be raised.
-  virtual void apply_snapshot(const Operations::Op &op, ExperimentResult &result);
+  virtual void apply_snapshot(const Operations::Op &op,
+                              ExperimentResult &result);
 
   // Apply a matrix to given qubits (identity on all other qubits)
   // We assume matrix to be 2x2
-  void apply_matrix(const reg_t &qubits, const cmatrix_t & mat);
+  void apply_matrix(const reg_t &qubits, const cmatrix_t &mat);
 
   // Apply a vectorized matrix to given qubits (identity on all other qubits)
-  void apply_matrix(const reg_t &qubits, const cvector_t & vmat);
+  void apply_matrix(const reg_t &qubits, const cvector_t &vmat);
 
   // Apply a Kraus error operation
-  void apply_kraus(const reg_t &qubits,
-                   const std::vector<cmatrix_t> &kmats,
+  void apply_kraus(const reg_t &qubits, const std::vector<cmatrix_t> &kmats,
                    RngEngine &rng);
 
   // Apply multi-qubit Pauli
-  void apply_pauli(const reg_t &qubits, const std::string& pauli);
+  void apply_pauli(const reg_t &qubits, const std::string &pauli);
 
   //-----------------------------------------------------------------------
   // Save data instructions
   //-----------------------------------------------------------------------
 
   // Save the current state of the simulator
-  void apply_save_mps(const Operations::Op &op,
-                      ExperimentResult &result,
+  void apply_save_mps(const Operations::Op &op, ExperimentResult &result,
                       bool last_op);
-                            
+
   // Compute and save the statevector for the current simulator state
   void apply_save_statevector(const Operations::Op &op,
                               ExperimentResult &result);
@@ -232,8 +237,7 @@ std::vector<reg_t> sample_measure_all(uint_t shots,
                                  ExperimentResult &result);
 
   // Helper function for computing expectation value
-  void apply_save_probs(const Operations::Op &op,
-                        ExperimentResult &result);
+  void apply_save_probs(const Operations::Op &op, ExperimentResult &result);
 
   // Helper function for saving amplitudes and amplitudes squared
   void apply_save_amplitudes(const Operations::Op &op,
@@ -241,7 +245,7 @@ std::vector<reg_t> sample_measure_all(uint_t shots,
 
   // Helper function for computing expectation value
   virtual double expval_pauli(const reg_t &qubits,
-                              const std::string& pauli) override;
+                              const std::string &pauli) override;
 
   //-----------------------------------------------------------------------
   // Measurement Helpers
@@ -260,8 +264,8 @@ std::vector<reg_t> sample_measure_all(uint_t shots,
   // 1 -> |q1 = 0, q0 = 1> state
   // 2 -> |q1 = 1, q0 = 0> state
   // 3 -> |q1 = 1, q0 = 1> state
-  std::pair<uint_t, double>
-  sample_measure_with_prob(const reg_t &qubits, RngEngine &rng);
+  std::pair<uint_t, double> sample_measure_with_prob(const reg_t &qubits,
+                                                     RngEngine &rng);
 
   //-----------------------------------------------------------------------
   // Special snapshot types
@@ -273,27 +277,22 @@ std::vector<reg_t> sample_measure_all(uint_t shots,
 
   // Snapshot current qubit probabilities for a measurement (average)
   void snapshot_probabilities(const Operations::Op &op,
-                              ExperimentResult &result,
-                              SnapshotDataType type);
+                              ExperimentResult &result, SnapshotDataType type);
 
- void snapshot_density_matrix(const Operations::Op &op,
-			     ExperimentResult &result,
-	     		     SnapshotDataType type);
+  void snapshot_density_matrix(const Operations::Op &op,
+                               ExperimentResult &result, SnapshotDataType type);
 
   // Snapshot the expectation value of a Pauli operator
-  void snapshot_pauli_expval(const Operations::Op &op,
-                             ExperimentResult &result,
+  void snapshot_pauli_expval(const Operations::Op &op, ExperimentResult &result,
                              SnapshotDataType type);
 
   // Snapshot the expectation value of a matrix operator
   void snapshot_matrix_expval(const Operations::Op &op,
-                              ExperimentResult &result,
-                              SnapshotDataType type);
+                              ExperimentResult &result, SnapshotDataType type);
 
   // Snapshot the state vector
-  void snapshot_state(const Operations::Op &op,
-		      ExperimentResult &result,
-		      std::string name = "");
+  void snapshot_state(const Operations::Op &op, ExperimentResult &result,
+                      std::string name = "");
 
   //-----------------------------------------------------------------------
   // Single-qubit gate helpers
@@ -317,73 +316,69 @@ std::vector<reg_t> sample_measure_all(uint_t shots,
   const static stringmap_t<Snapshots> snapshotset_;
 };
 
-
 //=========================================================================
 // Implementation: Allowed ops and gateset
 //=========================================================================
 
-const stringmap_t<Gates> State::gateset_({
-  // Single qubit gates
-  {"id", Gates::id},     // Pauli-Identity gate
-  {"delay", Gates::id},
-  {"x", Gates::x},       // Pauli-X gate
-  {"y", Gates::y},       // Pauli-Y gate
-  {"z", Gates::z},       // Pauli-Z gate
-  {"s", Gates::s},       // Phase gate (aka sqrt(Z) gate)
-  {"sdg", Gates::sdg},   // Conjugate-transpose of Phase gate
-  {"h", Gates::h},       // Hadamard gate (X + Z / sqrt(2))
-  {"sx", Gates::sx},     // Sqrt(X) gate
-  {"sxdg", Gates::sxdg}, // Inverse Sqrt(X) gate
-  {"t", Gates::t},       // T-gate (sqrt(S))
-  {"tdg", Gates::tdg},   // Conjguate-transpose of T gate
-  {"r", Gates::r},       // R rotation gate
-  {"rx", Gates::rx},     // Pauli-X rotation gate
-  {"ry", Gates::ry},     // Pauli-Y rotation gate
-  {"rz", Gates::rz},     // Pauli-Z rotation gate
-  // Waltz Gates
-  {"p", Gates::u1},      // zero-X90 pulse waltz gate
-  {"u1", Gates::u1},     // zero-X90 pulse waltz gate
-  {"u2", Gates::u2},     // single-X90 pulse waltz gate
-  {"u3", Gates::u3},     // two X90 pulse waltz gate
-  {"u", Gates::u3},      // two X90 pulse waltz gate
-  {"U", Gates::u3},      // two X90 pulse waltz gate
-  // Two-qubit gates
-  {"CX", Gates::cx},     // Controlled-X gate (CNOT)
-  {"cx", Gates::cx},     // Controlled-X gate (CNOT)
-  {"cy", Gates::cy},     // Controlled-Y gate
-  {"cz", Gates::cz},     // Controlled-Z gate
-  {"cu1", Gates::cu1},   // Controlled-U1 gate
-  {"cp", Gates::cu1},    // Controlled-U1 gate
-  {"csx", Gates::csx},
-  {"swap", Gates::swap}, // SWAP gate
-  {"rxx", Gates::rxx},   // Pauli-XX rotation gate
-  {"ryy", Gates::ryy},   // Pauli-YY rotation gate
-  {"rzz", Gates::rzz},   // Pauli-ZZ rotation gate
-  {"rzx", Gates::rzx},   // Pauli-ZX rotation gate
-  // Three-qubit gates
-  {"ccx", Gates::ccx},   // Controlled-CX gate (Toffoli)
-  {"cswap", Gates::cswap},
-  // Pauli
-  {"pauli", Gates::pauli}
-});
-
-const stringmap_t<Snapshots> State::snapshotset_({
-  {"statevector", Snapshots::statevector},
-  {"amplitudes", Snapshots::amplitudes},
-  {"probabilities", Snapshots::probs},
-  {"expectation_value_pauli", Snapshots::expval_pauli},
-  {"expectation_value_matrix", Snapshots::expval_matrix},
-  {"probabilities_with_variance", Snapshots::probs_var},
-  {"density_matrix", Snapshots::densmat},
-  {"density_matrix_with_variance", Snapshots::densmat_var},
-  {"expectation_value_pauli_with_variance", Snapshots::expval_pauli_var},
-  {"expectation_value_matrix_with_variance", Snapshots::expval_matrix_var},
-  {"expectation_value_pauli_single_shot", Snapshots::expval_pauli_shot},
-  {"expectation_value_matrix_single_shot", Snapshots::expval_matrix_shot},
-  {"memory", Snapshots::cmemory},
-  {"register", Snapshots::cregister}
-});
-
+const stringmap_t<Gates>
+    State::gateset_({                   // Single qubit gates
+                     {"id", Gates::id}, // Pauli-Identity gate
+                     {"delay", Gates::id},
+                     {"x", Gates::x},       // Pauli-X gate
+                     {"y", Gates::y},       // Pauli-Y gate
+                     {"z", Gates::z},       // Pauli-Z gate
+                     {"s", Gates::s},       // Phase gate (aka sqrt(Z) gate)
+                     {"sdg", Gates::sdg},   // Conjugate-transpose of Phase gate
+                     {"h", Gates::h},       // Hadamard gate (X + Z / sqrt(2))
+                     {"sx", Gates::sx},     // Sqrt(X) gate
+                     {"sxdg", Gates::sxdg}, // Inverse Sqrt(X) gate
+                     {"t", Gates::t},       // T-gate (sqrt(S))
+                     {"tdg", Gates::tdg},   // Conjguate-transpose of T gate
+                     {"r", Gates::r},       // R rotation gate
+                     {"rx", Gates::rx},     // Pauli-X rotation gate
+                     {"ry", Gates::ry},     // Pauli-Y rotation gate
+                     {"rz", Gates::rz},     // Pauli-Z rotation gate
+                                            // Waltz Gates
+                     {"p", Gates::u1},      // zero-X90 pulse waltz gate
+                     {"u1", Gates::u1},     // zero-X90 pulse waltz gate
+                     {"u2", Gates::u2},     // single-X90 pulse waltz gate
+                     {"u3", Gates::u3},     // two X90 pulse waltz gate
+                     {"u", Gates::u3},      // two X90 pulse waltz gate
+                     {"U", Gates::u3},      // two X90 pulse waltz gate
+                                            // Two-qubit gates
+                     {"CX", Gates::cx},     // Controlled-X gate (CNOT)
+                     {"cx", Gates::cx},     // Controlled-X gate (CNOT)
+                     {"cy", Gates::cy},     // Controlled-Y gate
+                     {"cz", Gates::cz},     // Controlled-Z gate
+                     {"cu1", Gates::cu1},   // Controlled-U1 gate
+                     {"cp", Gates::cu1},    // Controlled-U1 gate
+                     {"csx", Gates::csx},
+                     {"swap", Gates::swap}, // SWAP gate
+                     {"rxx", Gates::rxx},   // Pauli-XX rotation gate
+                     {"ryy", Gates::ryy},   // Pauli-YY rotation gate
+                     {"rzz", Gates::rzz},   // Pauli-ZZ rotation gate
+                     {"rzx", Gates::rzx},   // Pauli-ZX rotation gate
+                                            // Three-qubit gates
+                     {"ccx", Gates::ccx},   // Controlled-CX gate (Toffoli)
+                     {"cswap", Gates::cswap},
+                     // Pauli
+                     {"pauli", Gates::pauli}});
+
+const stringmap_t<Snapshots> State::snapshotset_(
+    {{"statevector", Snapshots::statevector},
+     {"amplitudes", Snapshots::amplitudes},
+     {"probabilities", Snapshots::probs},
+     {"expectation_value_pauli", Snapshots::expval_pauli},
+     {"expectation_value_matrix", Snapshots::expval_matrix},
+     {"probabilities_with_variance", Snapshots::probs_var},
+     {"density_matrix", Snapshots::densmat},
+     {"density_matrix_with_variance", Snapshots::densmat_var},
+     {"expectation_value_pauli_with_variance", Snapshots::expval_pauli_var},
+     {"expectation_value_matrix_with_variance", Snapshots::expval_matrix_var},
+     {"expectation_value_pauli_single_shot", Snapshots::expval_pauli_shot},
+     {"expectation_value_matrix_single_shot", Snapshots::expval_matrix_shot},
+     {"memory", Snapshots::cmemory},
+     {"register", Snapshots::cregister}});
 
 //=========================================================================
 // Implementation: Base class method overrides
@@ -393,38 +388,40 @@ const stringmap_t<Snapshots> State::snapshotset_({
 // Initialization
 //-------------------------------------------------------------------------
 
-void State::initialize_qreg(uint_t num_qubits=0) {
+void State::initialize_qreg(uint_t num_qubits = 0) {
   qreg_.initialize(num_qubits);
 }
 
 void State::initialize_omp() {
   if (BaseState::threads_ > 0)
-    qreg_.set_omp_threads(BaseState::threads_); // set allowed OMP threads in MPS
+    qreg_.set_omp_threads(
+        BaseState::threads_); // set allowed OMP threads in MPS
 }
 
-
 size_t State::required_memory_mb(uint_t num_qubits,
-			      const std::vector<Operations::Op> &ops) const {
-    // for each qubit we have a tensor structure.
-    // Initially, each tensor contains 2 matrices with a single complex double
-    // Depending on the number of 2-qubit gates,
-    // these matrices may double their size
-    // for now - compute only initial size
-    // later - FIXME
-    size_t mem_mb = 16 * 2 * num_qubits;
-    return mem_mb;
+                                 const std::vector<Operations::Op> &ops) const {
+  // for each qubit we have a tensor structure.
+  // Initially, each tensor contains 2 matrices with a single complex double
+  // Depending on the number of 2-qubit gates,
+  // these matrices may double their size
+  // for now - compute only initial size
+  // later - FIXME
+  size_t mem_mb = 16 * 2 * num_qubits;
+  return mem_mb;
 }
 
 void State::set_config(const json_t &config) {
   // Set threshold for truncating Schmidt coefficients
   double threshold;
-  if (JSON::get_value(threshold, "matrix_product_state_truncation_threshold", config))
+  if (JSON::get_value(threshold, "matrix_product_state_truncation_threshold",
+                      config))
     MPS_Tensor::set_truncation_threshold(threshold);
   else
     MPS_Tensor::set_truncation_threshold(1e-16);
 
   uint_t max_bond_dimension;
-  if (JSON::get_value(max_bond_dimension, "matrix_product_state_max_bond_dimension", config)) 
+  if (JSON::get_value(max_bond_dimension,
+                      "matrix_product_state_max_bond_dimension", config))
     MPS_Tensor::set_max_bond_dimension(max_bond_dimension);
   else
     MPS_Tensor::set_max_bond_dimension(UINT64_MAX);
@@ -441,7 +438,7 @@ void State::set_config(const json_t &config) {
   if (JSON::get_value(omp_qubit_threshold, "mps_parallel_threshold", config))
     MPS::set_omp_threshold(omp_qubit_threshold);
   else
-     MPS::set_omp_threshold(14);
+    MPS::set_omp_threshold(14);
 
   // Set OMP threads
   uint_t omp_threads;
@@ -450,7 +447,7 @@ void State::set_config(const json_t &config) {
   else
     MPS::set_omp_threads(1);
 
-// Set the algorithm for sample measure
+  // Set the algorithm for sample measure
   std::string alg;
   if (JSON::get_value(alg, "mps_sample_measure_algorithm", config)) {
     if (alg.compare("mps_probabilities") == 0) {
@@ -464,7 +461,7 @@ void State::set_config(const json_t &config) {
   if (JSON::get_value(mps_log_data, "mps_log_data", config))
     MPS::set_mps_log_data(mps_log_data);
 
-// Set the direction for the internal swaps
+  // Set the direction for the internal swaps
   std::string direction;
   if (JSON::get_value(direction, "mps_swap_direction", config)) {
     if (direction.compare("mps_swap_right") == 0)
@@ -475,113 +472,111 @@ void State::set_config(const json_t &config) {
 }
 
 void State::add_metadata(ExperimentResult &result) const {
-  result.metadata.add(
-    MPS_Tensor::get_truncation_threshold(),
-    "matrix_product_state_truncation_threshold");
-  result.metadata.add(
-    MPS_Tensor::get_max_bond_dimension(),
-    "matrix_product_state_max_bond_dimension");
-  result.metadata.add(
-    MPS::get_sample_measure_alg(),
-    "matrix_product_state_sample_measure_algorithm");
+  result.metadata.add(MPS_Tensor::get_truncation_threshold(),
+                      "matrix_product_state_truncation_threshold");
+  result.metadata.add(MPS_Tensor::get_max_bond_dimension(),
+                      "matrix_product_state_max_bond_dimension");
+  result.metadata.add(MPS::get_sample_measure_alg(),
+                      "matrix_product_state_sample_measure_algorithm");
   if (MPS::get_mps_log_data())
     result.metadata.add("{" + MPS::output_log() + "}", "MPS_log_data");
-} 
+}
 
 void State::output_bond_dimensions(const Operations::Op &op) const {
-  MPS::print_to_log("I", instruction_number, ":", op.name, " on qubits ", op.qubits[0]);
-  for (uint_t index=1; index<op.qubits.size(); index++) {
+  MPS::print_to_log("I", instruction_number, ":", op.name, " on qubits ",
+                    op.qubits[0]);
+  for (uint_t index = 1; index < op.qubits.size(); index++) {
     MPS::print_to_log(",", op.qubits[index]);
   }
   qreg_.print_bond_dimensions();
   instruction_number++;
 }
 
-
 //=========================================================================
 // Implementation: apply operations
 //=========================================================================
 
-void State::apply_op(const Operations::Op &op,
-                      ExperimentResult &result,
-                      RngEngine &rng, bool final_op) {
+void State::apply_op(const Operations::Op &op, ExperimentResult &result,
+                     RngEngine &rng, bool final_op) {
   if (BaseState::creg().check_conditional(op)) {
     switch (op.type) {
-      case OpType::barrier:
-      case OpType::qerror_loc:
-        break;
-      case OpType::reset:
-        apply_reset(op.qubits, rng);
-        break;
-      case OpType::initialize:
-        apply_initialize(op.qubits, op.params, rng);
-        break;
-      case OpType::measure:
-        apply_measure(op.qubits, op.memory, op.registers, rng);
-        break;
-      case OpType::bfunc:
-        BaseState::creg().apply_bfunc(op);
-        break;
-      case OpType::roerror:
-        BaseState::creg().apply_roerror(op, rng);
-        break;
-      case OpType::gate:
-        apply_gate(op);
-        break;
-      case OpType::snapshot:
-        apply_snapshot(op, result);
-        break;
-      case OpType::matrix:
-        apply_matrix(op.qubits, op.mats[0]);
-        break;
-      case OpType::diagonal_matrix:
-        BaseState::qreg_.apply_diagonal_matrix(op.qubits, op.params);
-        break;
-      case OpType::kraus:
-        apply_kraus(op.qubits, op.mats, rng);
-        break;
-      case OpType::set_statevec: {
-          reg_t all_qubits(qreg_.num_qubits());
-          std::iota(all_qubits.begin(), all_qubits.end(), 0);
-          qreg_.apply_initialize(all_qubits, op.params, rng);
-          break;
-        }
-      case OpType::set_mps:
-        qreg_.initialize_from_mps(op.mps);
-        break;
-      case OpType::save_expval:
-      case OpType::save_expval_var:
-        BaseState::apply_save_expval(op, result);
-        break;
-      case OpType::save_densmat:
-        apply_save_density_matrix(op, result);
-        break;
-      case OpType::save_statevec:
-        apply_save_statevector(op, result);
-        break;
-      case OpType::save_state:
-      case OpType::save_mps:
-        apply_save_mps(op, result, final_op);
-        break;
-      case OpType::save_probs:
-      case OpType::save_probs_ket:
-        apply_save_probs(op, result);
-        break;
-      case OpType::save_amps:
-      case OpType::save_amps_sq:
-        apply_save_amplitudes(op, result);
-        break;
-      default:
-        throw std::invalid_argument("MatrixProductState::State::invalid instruction \'" +
-                                    op.name + "\'.");
+    case OpType::barrier:
+    case OpType::qerror_loc:
+      break;
+    case OpType::reset:
+      apply_reset(op.qubits, rng);
+      break;
+    case OpType::initialize:
+      apply_initialize(op.qubits, op.params, rng);
+      break;
+    case OpType::measure:
+      apply_measure(op.qubits, op.memory, op.registers, rng);
+      break;
+    case OpType::bfunc:
+      BaseState::creg().apply_bfunc(op);
+      break;
+    case OpType::roerror:
+      BaseState::creg().apply_roerror(op, rng);
+      break;
+    case OpType::gate:
+      apply_gate(op);
+      break;
+    case OpType::snapshot:
+      apply_snapshot(op, result);
+      break;
+    case OpType::matrix:
+      apply_matrix(op.qubits, op.mats[0]);
+      break;
+    case OpType::diagonal_matrix:
+      BaseState::qreg_.apply_diagonal_matrix(op.qubits, op.params);
+      break;
+    case OpType::kraus:
+      apply_kraus(op.qubits, op.mats, rng);
+      break;
+    case OpType::set_statevec: {
+      reg_t all_qubits(qreg_.num_qubits());
+      std::iota(all_qubits.begin(), all_qubits.end(), 0);
+      qreg_.apply_initialize(all_qubits, op.params, rng);
+      break;
+    }
+    case OpType::set_mps:
+      qreg_.initialize_from_mps(op.mps);
+      break;
+    case OpType::save_expval:
+    case OpType::save_expval_var:
+      BaseState::apply_save_expval(op, result);
+      break;
+    case OpType::save_densmat:
+      apply_save_density_matrix(op, result);
+      break;
+    case OpType::save_statevec:
+      apply_save_statevector(op, result);
+      break;
+    case OpType::save_state:
+    case OpType::save_mps:
+      apply_save_mps(op, result, final_op);
+      break;
+    case OpType::save_probs:
+    case OpType::save_probs_ket:
+      apply_save_probs(op, result);
+      break;
+    case OpType::save_amps:
+    case OpType::save_amps_sq:
+      apply_save_amplitudes(op, result);
+      break;
+    default:
+      throw std::invalid_argument(
+          "MatrixProductState::State::invalid instruction \'" + op.name +
+          "\'.");
     }
-    //qreg_.print(std::cout);
-    // print out bond dimensions only if they may have changed since previous print
-    if (MPS::get_mps_log_data()
-        && (op.type == OpType::gate ||op.type == OpType::measure || 
-            op.type == OpType::initialize || op.type == OpType::reset || 
-            op.type == OpType::matrix) && 
-            op.qubits.size() > 1) {
+    // qreg_.print(std::cout);
+    //  print out bond dimensions only if they may have changed since previous
+    //  print
+    if (MPS::get_mps_log_data() &&
+        (op.type == OpType::gate || op.type == OpType::measure ||
+         op.type == OpType::initialize || op.type == OpType::reset ||
+         op.type == OpType::matrix) &&
+        op.qubits.size() > 1) {
       output_bond_dimensions(op);
     }
   }
@@ -591,20 +586,18 @@ void State::apply_op(const Operations::Op &op,
 // Implementation: Save data
 //=========================================================================
 
-void State::apply_save_mps(const Operations::Op &op,
-                           ExperimentResult &result,
+void State::apply_save_mps(const Operations::Op &op, ExperimentResult &result,
                            bool last_op) {
   if (op.qubits.size() != qreg_.num_qubits()) {
     throw std::invalid_argument(
         "Save MPS was not applied to all qubits."
         " Only the full matrix product state can be saved.");
   }
-  std::string key = (op.string_params[0] == "_method_")
-                      ? "matrix_product_state"
-                      : op.string_params[0];
+  std::string key = (op.string_params[0] == "_method_") ? "matrix_product_state"
+                                                        : op.string_params[0];
   if (last_op) {
     result.save_data_pershot(creg(), key, qreg_.move_to_mps_container(),
-		                         OpType::save_mps, op.save_type);
+                             OpType::save_mps, op.save_type);
   } else {
     result.save_data_pershot(creg(), key, qreg_.copy_to_mps_container(),
                              OpType::save_mps, op.save_type);
@@ -616,36 +609,37 @@ void State::apply_save_probs(const Operations::Op &op,
   rvector_t probs;
   qreg_.get_probabilities_vector(probs, op.qubits);
   if (op.type == OpType::save_probs_ket) {
-    result.save_data_average(creg(), op.string_params[0],
-                             Utils::vec2ket(probs, MPS::get_json_chop_threshold(), 16),
-                             op.type, op.save_type);
+    result.save_data_average(
+        creg(), op.string_params[0],
+        Utils::vec2ket(probs, MPS::get_json_chop_threshold(), 16), op.type,
+        op.save_type);
   } else {
-    result.save_data_average(creg(), op.string_params[0],
-                             std::move(probs), op.type, op.save_type);
+    result.save_data_average(creg(), op.string_params[0], std::move(probs),
+                             op.type, op.save_type);
   }
 }
 
 void State::apply_save_amplitudes(const Operations::Op &op,
-                             ExperimentResult &result) {
+                                  ExperimentResult &result) {
   if (op.int_params.empty()) {
-    throw std::invalid_argument("Invalid save amplitudes instructions (empty params).");
+    throw std::invalid_argument(
+        "Invalid save amplitudes instructions (empty params).");
   }
   Vector<complex_t> amps = qreg_.get_amplitude_vector(op.int_params);
   if (op.type == OpType::save_amps_sq) {
     // Square amplitudes
     std::vector<double> amps_sq(op.int_params.size());
     std::transform(amps.data(), amps.data() + amps.size(), amps_sq.begin(),
-      [](complex_t val) -> double { return pow(abs(val), 2); });
-    result.save_data_average(creg(), op.string_params[0],
-                             std::move(amps_sq), op.type, op.save_type);
+                   [](complex_t val) -> double { return pow(abs(val), 2); });
+    result.save_data_average(creg(), op.string_params[0], std::move(amps_sq),
+                             op.type, op.save_type);
   } else {
-    result.save_data_pershot(creg(), op.string_params[0],
-                             std::move(amps), op.type, op.save_type);
+    result.save_data_pershot(creg(), op.string_params[0], std::move(amps),
+                             op.type, op.save_type);
   }
 }
 
-double State::expval_pauli(const reg_t &qubits,
-                           const std::string& pauli) {
+double State::expval_pauli(const reg_t &qubits, const std::string &pauli) {
   return BaseState::qreg_.expectation_value_pauli(qubits, pauli).real();
 }
 
@@ -660,7 +654,6 @@ void State::apply_save_statevector(const Operations::Op &op,
                            qreg_.full_statevector(), op.type, op.save_type);
 }
 
-
 void State::apply_save_density_matrix(const Operations::Op &op,
                                       ExperimentResult &result) {
   cmatrix_t reduced_state;
@@ -680,13 +673,14 @@ void State::apply_save_density_matrix(const Operations::Op &op,
 //=========================================================================
 
 void State::snapshot_pauli_expval(const Operations::Op &op,
-				  ExperimentResult &result,
-				  SnapshotDataType type){
+                                  ExperimentResult &result,
+                                  SnapshotDataType type) {
   if (op.params_expval_pauli.empty()) {
-    throw std::invalid_argument("Invalid expval snapshot (Pauli components are empty).");
+    throw std::invalid_argument(
+        "Invalid expval snapshot (Pauli components are empty).");
   }
 
-  //Compute expval components
+  // Compute expval components
   complex_t expval(0., 0.);
 
   for (const auto &param : op.params_expval_pauli) {
@@ -698,32 +692,36 @@ void State::snapshot_pauli_expval(const Operations::Op &op,
   // add to snapshot
   Utils::chop_inplace(expval, MPS::get_json_chop_threshold());
   switch (type) {
-    case SnapshotDataType::average:
-      result.legacy_data.add_average_snapshot("expectation_value", op.string_params[0],
-                                              BaseState::creg().memory_hex(), expval, false);
-      break;
-    case SnapshotDataType::average_var:
-      result.legacy_data.add_average_snapshot("expectation_value", op.string_params[0],
-                                              BaseState::creg().memory_hex(), expval, true);
-      break;
-    case SnapshotDataType::pershot:
-      result.legacy_data.add_pershot_snapshot("expectation_values", op.string_params[0], expval);
-      break;
+  case SnapshotDataType::average:
+    result.legacy_data.add_average_snapshot(
+        "expectation_value", op.string_params[0],
+        BaseState::creg().memory_hex(), expval, false);
+    break;
+  case SnapshotDataType::average_var:
+    result.legacy_data.add_average_snapshot(
+        "expectation_value", op.string_params[0],
+        BaseState::creg().memory_hex(), expval, true);
+    break;
+  case SnapshotDataType::pershot:
+    result.legacy_data.add_pershot_snapshot("expectation_values",
+                                            op.string_params[0], expval);
+    break;
   }
 }
 
 void State::snapshot_matrix_expval(const Operations::Op &op,
-				   ExperimentResult &result,
-				   SnapshotDataType type){
+                                   ExperimentResult &result,
+                                   SnapshotDataType type) {
   if (op.params_expval_matrix.empty()) {
-    throw std::invalid_argument("Invalid matrix snapshot (components are empty).");
+    throw std::invalid_argument(
+        "Invalid matrix snapshot (components are empty).");
   }
   complex_t expval(0., 0.);
   double one_expval = 0;
   for (const auto &param : op.params_expval_matrix) {
     complex_t coeff = param.first;
 
-    for (const auto &pair: param.second) {
+    for (const auto &pair : param.second) {
       reg_t sub_qubits;
       for (const auto pos : pair.first) {
         sub_qubits.push_back(op.qubits[pos]);
@@ -736,42 +734,45 @@ void State::snapshot_matrix_expval(const Operations::Op &op,
   // add to snapshot
   Utils::chop_inplace(expval, MPS::get_json_chop_threshold());
   switch (type) {
-    case SnapshotDataType::average:
-      result.legacy_data.add_average_snapshot("expectation_value", op.string_params[0],
-                                              BaseState::creg().memory_hex(), expval, false);
-      break;
-    case SnapshotDataType::average_var:
-      result.legacy_data.add_average_snapshot("expectation_value", op.string_params[0],
-                                              BaseState::creg().memory_hex(), expval, true);
-      break;
-    case SnapshotDataType::pershot:
-      result.legacy_data.add_pershot_snapshot("expectation_values", op.string_params[0], expval);
-      break;
+  case SnapshotDataType::average:
+    result.legacy_data.add_average_snapshot(
+        "expectation_value", op.string_params[0],
+        BaseState::creg().memory_hex(), expval, false);
+    break;
+  case SnapshotDataType::average_var:
+    result.legacy_data.add_average_snapshot(
+        "expectation_value", op.string_params[0],
+        BaseState::creg().memory_hex(), expval, true);
+    break;
+  case SnapshotDataType::pershot:
+    result.legacy_data.add_pershot_snapshot("expectation_values",
+                                            op.string_params[0], expval);
+    break;
   }
 }
 
-void State::snapshot_state(const Operations::Op &op,
-			   ExperimentResult &result,
-			   std::string name) {
-  result.legacy_data.add_pershot_snapshot("statevector", op.string_params[0], qreg_.full_statevector());
+void State::snapshot_state(const Operations::Op &op, ExperimentResult &result,
+                           std::string name) {
+  result.legacy_data.add_pershot_snapshot("statevector", op.string_params[0],
+                                          qreg_.full_statevector());
 }
 
 void State::snapshot_probabilities(const Operations::Op &op,
-				   ExperimentResult &result,
-				   SnapshotDataType type) {
+                                   ExperimentResult &result,
+                                   SnapshotDataType type) {
   rvector_t prob_vector;
   qreg_.get_probabilities_vector(prob_vector, op.qubits);
   auto probs = Utils::vec2ket(prob_vector, MPS::get_json_chop_threshold(), 16);
 
   bool variance = type == SnapshotDataType::average_var;
-  result.legacy_data.add_average_snapshot("probabilities", op.string_params[0], 
-  			                                  BaseState::creg().memory_hex(), probs, variance);
-
+  result.legacy_data.add_average_snapshot("probabilities", op.string_params[0],
+                                          BaseState::creg().memory_hex(), probs,
+                                          variance);
 }
 
 void State::snapshot_density_matrix(const Operations::Op &op,
-			     ExperimentResult &result,
-			     SnapshotDataType type) {
+                                    ExperimentResult &result,
+                                    SnapshotDataType type) {
   cmatrix_t reduced_state;
   if (op.qubits.empty()) {
     reduced_state = cmatrix_t(1, 1);
@@ -782,17 +783,20 @@ void State::snapshot_density_matrix(const Operations::Op &op,
 
   // Add density matrix to result data
   switch (type) {
-    case SnapshotDataType::average:
-      result.legacy_data.add_average_snapshot("density_matrix", op.string_params[0],
-                                              BaseState::creg().memory_hex(), std::move(reduced_state), false);
-      break;
-    case SnapshotDataType::average_var:
-      result.legacy_data.add_average_snapshot("density_matrix", op.string_params[0],
-                                              BaseState::creg().memory_hex(), std::move(reduced_state), true);
-      break;
-    case SnapshotDataType::pershot:
-      result.legacy_data.add_pershot_snapshot("density_matrix", op.string_params[0], std::move(reduced_state));
-      break;
+  case SnapshotDataType::average:
+    result.legacy_data.add_average_snapshot(
+        "density_matrix", op.string_params[0], BaseState::creg().memory_hex(),
+        std::move(reduced_state), false);
+    break;
+  case SnapshotDataType::average_var:
+    result.legacy_data.add_average_snapshot(
+        "density_matrix", op.string_params[0], BaseState::creg().memory_hex(),
+        std::move(reduced_state), true);
+    break;
+  case SnapshotDataType::pershot:
+    result.legacy_data.add_pershot_snapshot(
+        "density_matrix", op.string_params[0], std::move(reduced_state));
+    break;
   }
 }
 
@@ -801,143 +805,132 @@ void State::apply_gate(const Operations::Op &op) {
   auto it = gateset_.find(op.name);
   if (it == gateset_.end())
     throw std::invalid_argument(
-      "MatrixProductState::State::invalid gate instruction \'" + op.name + "\'.");
-  switch (it -> second) {
-    case Gates::ccx:
-      qreg_.apply_ccx(op.qubits);
-      break;
-    case Gates::cswap:
-      qreg_.apply_cswap(op.qubits);
-      break;
-    case Gates::u3:
-      qreg_.apply_u3(op.qubits[0],
-                    std::real(op.params[0]),
-                    std::real(op.params[1]),
-                    std::real(op.params[2]));
-      break;
-    case Gates::u2:
-      qreg_.apply_u2(op.qubits[0],
-                    std::real(op.params[0]),
-                    std::real(op.params[1]));
-      break;
-    case Gates::u1:
-      qreg_.apply_u1(op.qubits[0],
-		     std::real(op.params[0]));
-      break;
-    case Gates::cx:
-      qreg_.apply_cnot(op.qubits[0], op.qubits[1]);
-      break;
-    case Gates::id:
-    {
-        break;
-    }
-    case Gates::x:
-      qreg_.apply_x(op.qubits[0]);
-      break;
-    case Gates::y:
-      qreg_.apply_y(op.qubits[0]);
-      break;
-    case Gates::z:
-      qreg_.apply_z(op.qubits[0]);
-      break;
-    case Gates::h:
-      qreg_.apply_h(op.qubits[0]);
-      break;
-    case Gates::s:
-      qreg_.apply_s(op.qubits[0]);
-      break;
-    case Gates::sdg:
-      qreg_.apply_sdg(op.qubits[0]);
-      break;
-    case Gates::sx:
-      qreg_.apply_sx(op.qubits[0]);
-      break;
-    case Gates::sxdg:
-      qreg_.apply_sxdg(op.qubits[0]);
-      break;
-    case Gates::t:
-      qreg_.apply_t(op.qubits[0]);
-      break;
-    case Gates::tdg:
-      qreg_.apply_tdg(op.qubits[0]);
-      break;
-    case Gates::r:
-      qreg_.apply_r(op.qubits[0], 
-		    std::real(op.params[0]),
-		    std::real(op.params[1]));
-      break;
-    case Gates::rx:
-      qreg_.apply_rx(op.qubits[0], 
-		     std::real(op.params[0]));
-      break;
-    case Gates::ry:
-      qreg_.apply_ry(op.qubits[0], 
-		     std::real(op.params[0]));
-      break;
-    case Gates::rz:
-      qreg_.apply_rz(op.qubits[0], 
-		     std::real(op.params[0]));
-      break;
-    case Gates::swap:
-      qreg_.apply_swap(op.qubits[0], op.qubits[1], true);
-      break;
-    case Gates::cy:
-      qreg_.apply_cy(op.qubits[0], op.qubits[1]);
-      break;
-    case Gates::cz:
-      qreg_.apply_cz(op.qubits[0], op.qubits[1]);
-      break;
-    case Gates::csx:
-      qreg_.apply_csx(op.qubits[0], op.qubits[1]);
-      break;
-    case Gates::cu1:
-      qreg_.apply_cu1(op.qubits[0], op.qubits[1],
-    		      std::real(op.params[0]));
-      break;
-    case Gates::rxx:
-      qreg_.apply_rxx(op.qubits[0], op.qubits[1],
-    		      std::real(op.params[0]));
-      break;
-    case Gates::ryy:
-      qreg_.apply_ryy(op.qubits[0], op.qubits[1],
-    		      std::real(op.params[0]));
-      break;
-    case Gates::rzz:
-      qreg_.apply_rzz(op.qubits[0], op.qubits[1],
-    		      std::real(op.params[0]));
-      break;
-    case Gates::rzx:
-      qreg_.apply_rzx(op.qubits[0], op.qubits[1],
-    		      std::real(op.params[0]));
-      break;
-    case Gates::pauli:
-      apply_pauli(op.qubits, op.string_params[0]);
-      break;
-    default:
-      // We shouldn't reach here unless there is a bug in gateset
-      throw std::invalid_argument(
-        "MatrixProductState::State::invalid gate instruction \'" + op.name + "\'.");
+        "MatrixProductState::State::invalid gate instruction \'" + op.name +
+        "\'.");
+  switch (it->second) {
+  case Gates::ccx:
+    qreg_.apply_ccx(op.qubits);
+    break;
+  case Gates::cswap:
+    qreg_.apply_cswap(op.qubits);
+    break;
+  case Gates::u3:
+    qreg_.apply_u3(op.qubits[0], std::real(op.params[0]),
+                   std::real(op.params[1]), std::real(op.params[2]));
+    break;
+  case Gates::u2:
+    qreg_.apply_u2(op.qubits[0], std::real(op.params[0]),
+                   std::real(op.params[1]));
+    break;
+  case Gates::u1:
+    qreg_.apply_u1(op.qubits[0], std::real(op.params[0]));
+    break;
+  case Gates::cx:
+    qreg_.apply_cnot(op.qubits[0], op.qubits[1]);
+    break;
+  case Gates::id: {
+    break;
+  }
+  case Gates::x:
+    qreg_.apply_x(op.qubits[0]);
+    break;
+  case Gates::y:
+    qreg_.apply_y(op.qubits[0]);
+    break;
+  case Gates::z:
+    qreg_.apply_z(op.qubits[0]);
+    break;
+  case Gates::h:
+    qreg_.apply_h(op.qubits[0]);
+    break;
+  case Gates::s:
+    qreg_.apply_s(op.qubits[0]);
+    break;
+  case Gates::sdg:
+    qreg_.apply_sdg(op.qubits[0]);
+    break;
+  case Gates::sx:
+    qreg_.apply_sx(op.qubits[0]);
+    break;
+  case Gates::sxdg:
+    qreg_.apply_sxdg(op.qubits[0]);
+    break;
+  case Gates::t:
+    qreg_.apply_t(op.qubits[0]);
+    break;
+  case Gates::tdg:
+    qreg_.apply_tdg(op.qubits[0]);
+    break;
+  case Gates::r:
+    qreg_.apply_r(op.qubits[0], std::real(op.params[0]),
+                  std::real(op.params[1]));
+    break;
+  case Gates::rx:
+    qreg_.apply_rx(op.qubits[0], std::real(op.params[0]));
+    break;
+  case Gates::ry:
+    qreg_.apply_ry(op.qubits[0], std::real(op.params[0]));
+    break;
+  case Gates::rz:
+    qreg_.apply_rz(op.qubits[0], std::real(op.params[0]));
+    break;
+  case Gates::swap:
+    qreg_.apply_swap(op.qubits[0], op.qubits[1], true);
+    break;
+  case Gates::cy:
+    qreg_.apply_cy(op.qubits[0], op.qubits[1]);
+    break;
+  case Gates::cz:
+    qreg_.apply_cz(op.qubits[0], op.qubits[1]);
+    break;
+  case Gates::csx:
+    qreg_.apply_csx(op.qubits[0], op.qubits[1]);
+    break;
+  case Gates::cu1:
+    qreg_.apply_cu1(op.qubits[0], op.qubits[1], std::real(op.params[0]));
+    break;
+  case Gates::rxx:
+    qreg_.apply_rxx(op.qubits[0], op.qubits[1], std::real(op.params[0]));
+    break;
+  case Gates::ryy:
+    qreg_.apply_ryy(op.qubits[0], op.qubits[1], std::real(op.params[0]));
+    break;
+  case Gates::rzz:
+    qreg_.apply_rzz(op.qubits[0], op.qubits[1], std::real(op.params[0]));
+    break;
+  case Gates::rzx:
+    qreg_.apply_rzx(op.qubits[0], op.qubits[1], std::real(op.params[0]));
+    break;
+  case Gates::pauli:
+    apply_pauli(op.qubits, op.string_params[0]);
+    break;
+  default:
+    // We shouldn't reach here unless there is a bug in gateset
+    throw std::invalid_argument(
+        "MatrixProductState::State::invalid gate instruction \'" + op.name +
+        "\'.");
   }
 }
 
-void State::apply_pauli(const reg_t &qubits, const std::string& pauli) {
+void State::apply_pauli(const reg_t &qubits, const std::string &pauli) {
   const auto size = qubits.size();
   for (size_t i = 0; i < qubits.size(); ++i) {
     const auto qubit = qubits[size - 1 - i];
     switch (pauli[i]) {
-      case 'I':
-        break;
-      case 'X':
-        BaseState::qreg_.apply_x(qubit);
-        break;
-      case 'Y':
-        BaseState::qreg_.apply_y(qubit);
-        break;
-      case 'Z':
-        BaseState::qreg_.apply_z(qubit);
-        break;
-      default:
-        throw std::invalid_argument("invalid Pauli \'" + std::to_string(pauli[i]) + "\'.");
+    case 'I':
+      break;
+    case 'X':
+      BaseState::qreg_.apply_x(qubit);
+      break;
+    case 'Y':
+      BaseState::qreg_.apply_y(qubit);
+      break;
+    case 'Z':
+      BaseState::qreg_.apply_z(qubit);
+      break;
+    default:
+      throw std::invalid_argument("invalid Pauli \'" +
+                                  std::to_string(pauli[i]) + "\'.");
     }
   }
 }
@@ -957,26 +950,21 @@ void State::apply_matrix(const reg_t &qubits, const cvector_t &vmat) {
 }
 
 void State::apply_kraus(const reg_t &qubits,
-                   const std::vector<cmatrix_t> &kmats,
-                   RngEngine &rng) {
+                        const std::vector<cmatrix_t> &kmats, RngEngine &rng) {
   qreg_.apply_kraus(qubits, kmats, rng);
 }
 
-
 //=========================================================================
 // Implementation: Reset and Measurement Sampling
 //=========================================================================
 
-void State::apply_initialize(const reg_t &qubits,
-			     const cvector_t &params,
-			     RngEngine &rng) {
+void State::apply_initialize(const reg_t &qubits, const cvector_t &params,
+                             RngEngine &rng) {
   qreg_.apply_initialize(qubits, params, rng);
 }
 
-void State::apply_measure(const reg_t &qubits,
-                          const reg_t &cmemory,
-                          const reg_t &cregister,
-                          RngEngine &rng) {
+void State::apply_measure(const reg_t &qubits, const reg_t &cmemory,
+                          const reg_t &cregister, RngEngine &rng) {
   rvector_t rands;
   rands.reserve(qubits.size());
   for (int_t i = 0; i < qubits.size(); ++i)
@@ -991,29 +979,28 @@ rvector_t State::measure_probs(const reg_t &qubits) const {
   return probvector;
 }
 
-std::vector<reg_t> State::sample_measure(const reg_t& qubits,
-					 uint_t shots,
+std::vector<reg_t> State::sample_measure(const reg_t &qubits, uint_t shots,
                                          RngEngine &rng) {
   // There are two alternative algorithms for sample measure
-  // We choose the one that is optimal relative to the total number 
+  // We choose the one that is optimal relative to the total number
   // of qubits,and the number of shots.
   // The parameters used below are based on experimentation.
-  // The user can override this by setting the parameter "mps_sample_measure_algorithm"
-  if (MPS::get_sample_measure_alg() == Sample_measure_alg::PROB && 
-      qubits.size() == qreg_.num_qubits()){
+  // The user can override this by setting the parameter
+  // "mps_sample_measure_algorithm"
+  if (MPS::get_sample_measure_alg() == Sample_measure_alg::PROB &&
+      qubits.size() == qreg_.num_qubits()) {
     return sample_measure_all(shots, rng);
   }
   return sample_measure_using_apply_measure(qubits, shots, rng);
 }
-	     
-std::vector<reg_t> State::
-  sample_measure_using_apply_measure(const reg_t &qubits, 
-				     uint_t shots, 
-				     RngEngine &rng) {
+
+std::vector<reg_t>
+State::sample_measure_using_apply_measure(const reg_t &qubits, uint_t shots,
+                                          RngEngine &rng) {
   std::vector<reg_t> all_samples;
   all_samples.resize(shots);
-  // input is always sorted in qasm_controller, therefore, we must return the qubits 
-  // to their original location (sorted)
+  // input is always sorted in qasm_controller, therefore, we must return the
+  // qubits to their original location (sorted)
   qreg_.move_all_qubits_to_sorted_ordering();
   reg_t sorted_qubits = qubits;
   std::sort(sorted_qubits.begin(), sorted_qubits.end());
@@ -1028,13 +1015,15 @@ std::vector<reg_t> State::
     rnds_list.push_back(rands);
   }
 
-  #pragma omp parallel if (BaseState::threads_ > 1) num_threads(BaseState::threads_)
+#pragma omp parallel if (BaseState::threads_ > 1)                              \
+    num_threads(BaseState::threads_)
   {
     MPS temp;
-    #pragma omp for
-    for (int_t i=0; i<static_cast<int_t>(shots);  i++) {
+#pragma omp for
+    for (int_t i = 0; i < static_cast<int_t>(shots); i++) {
       temp.initialize(qreg_);
-      auto single_result = temp.apply_measure_internal(sorted_qubits, rnds_list[i]);
+      auto single_result =
+          temp.apply_measure_internal(sorted_qubits, rnds_list[i]);
       all_samples[i] = single_result;
     }
   }
@@ -1042,12 +1031,11 @@ std::vector<reg_t> State::
   return all_samples;
 }
 
-std::vector<reg_t> State::sample_measure_all(uint_t shots, 
-					     RngEngine &rng) {
+std::vector<reg_t> State::sample_measure_all(uint_t shots, RngEngine &rng) {
   std::vector<reg_t> all_samples;
   all_samples.resize(shots);
 
-  for (uint_t i=0; i<shots;  i++) {
+  for (uint_t i = 0; i < shots; i++) {
     auto single_result = qreg_.sample_measure(shots, rng);
     all_samples[i] = single_result;
   }
@@ -1058,12 +1046,13 @@ void State::apply_snapshot(const Operations::Op &op, ExperimentResult &result) {
   // Look for snapshot type in snapshotset
   auto it = snapshotset_.find(op.name);
   if (it == snapshotset_.end())
-    throw std::invalid_argument("MatrixProductState::invalid snapshot instruction \'" +
-                                op.name + "\'.");
-  switch (it -> second) {
+    throw std::invalid_argument(
+        "MatrixProductState::invalid snapshot instruction \'" + op.name +
+        "\'.");
+  switch (it->second) {
   case Snapshots::statevector: {
-      snapshot_state(op, result, "statevector");
-      break;
+    snapshot_state(op, result, "statevector");
+    break;
   }
   case Snapshots::cmemory:
     BaseState::snapshot_creg_memory(op, result);
@@ -1072,53 +1061,52 @@ void State::apply_snapshot(const Operations::Op &op, ExperimentResult &result) {
     BaseState::snapshot_creg_register(op, result);
     break;
   case Snapshots::probs: {
-      // get probs as hexadecimal
-      snapshot_probabilities(op, result, SnapshotDataType::average);
-      break;
+    // get probs as hexadecimal
+    snapshot_probabilities(op, result, SnapshotDataType::average);
+    break;
   }
   case Snapshots::densmat: {
-      snapshot_density_matrix(op, result, SnapshotDataType::average);
+    snapshot_density_matrix(op, result, SnapshotDataType::average);
   } break;
   case Snapshots::expval_pauli: {
     snapshot_pauli_expval(op, result, SnapshotDataType::average);
   } break;
   case Snapshots::expval_matrix: {
     snapshot_matrix_expval(op, result, SnapshotDataType::average);
-  }  break;
+  } break;
   case Snapshots::probs_var: {
     // get probs as hexadecimal
     snapshot_probabilities(op, result, SnapshotDataType::average_var);
   } break;
   case Snapshots::densmat_var: {
-      snapshot_density_matrix(op, result, SnapshotDataType::average_var);
+    snapshot_density_matrix(op, result, SnapshotDataType::average_var);
   } break;
   case Snapshots::expval_pauli_var: {
     snapshot_pauli_expval(op, result, SnapshotDataType::average_var);
   } break;
   case Snapshots::expval_matrix_var: {
     snapshot_matrix_expval(op, result, SnapshotDataType::average_var);
-  }  break;
+  } break;
   case Snapshots::expval_pauli_shot: {
     snapshot_pauli_expval(op, result, SnapshotDataType::pershot);
   } break;
   case Snapshots::expval_matrix_shot: {
     snapshot_matrix_expval(op, result, SnapshotDataType::pershot);
-  }  break;
+  } break;
   default:
     // We shouldn't get here unless there is a bug in the snapshotset
-    throw std::invalid_argument("MatrixProductState::State::invalid snapshot instruction \'" +
-				op.name + "\'.");
+    throw std::invalid_argument(
+        "MatrixProductState::State::invalid snapshot instruction \'" + op.name +
+        "\'.");
   }
 }
 
-void State::apply_reset(const reg_t &qubits,
-                        RngEngine &rng) {
+void State::apply_reset(const reg_t &qubits, RngEngine &rng) {
   qreg_.reset(qubits, rng);
 }
 
-std::pair<uint_t, double>
-State::sample_measure_with_prob(const reg_t &qubits,
-                                RngEngine &rng) {
+std::pair<uint_t, double> State::sample_measure_with_prob(const reg_t &qubits,
+                                                          RngEngine &rng) {
   rvector_t probs = measure_probs(qubits);
 
   // Randomly pick outcome and return pair
@@ -1126,7 +1114,6 @@ State::sample_measure_with_prob(const reg_t &qubits,
   return std::make_pair(outcome, probs[outcome]);
 }
 
-
 //-------------------------------------------------------------------------
 } // end namespace MatrixProductState
 //-------------------------------------------------------------------------
diff --git a/src/simulators/matrix_product_state/matrix_product_state_internal.cpp b/src/simulators/matrix_product_state/matrix_product_state_internal.cpp
index ae8b265edb..9668dbf1ff 100644
--- a/src/simulators/matrix_product_state/matrix_product_state_internal.cpp
+++ b/src/simulators/matrix_product_state/matrix_product_state_internal.cpp
@@ -12,19 +12,18 @@
  * that they have been altered from the originals.
  */
 
-
 #include <bitset>
 #include <math.h>
 
-#include "stdlib.h"
 #include "stdio.h"
+#include "stdlib.h"
 #include "string.h"
-#include <utility>
 #include <iostream>
+#include <utility>
 
-#include "framework/utils.hpp"
-#include "framework/matrix.hpp"
 #include "framework/linalg/almost_equal.hpp"
+#include "framework/matrix.hpp"
+#include "framework/utils.hpp"
 
 #include "matrix_product_state_internal.hpp"
 #include "matrix_product_state_tensor.hpp"
@@ -32,19 +31,19 @@
 namespace AER {
 namespace MatrixProductState {
 
-static const cmatrix_t zero_measure = 
-      AER::Utils::make_matrix<complex_t>({{{1, 0}, {0, 0}},
-	                                 {{0, 0}, {0, 0}}});
-static const cmatrix_t one_measure = 
-      AER::Utils::make_matrix<complex_t>({{{0, 0}, {0, 0}},
-			                 {{0, 0}, {1, 0}}});
-  uint_t MPS::omp_threads_ = 1;     
-  uint_t MPS::omp_threshold_ = 14;  
-  enum Sample_measure_alg MPS::sample_measure_alg_ = Sample_measure_alg::HEURISTIC; 
-  enum MPS_swap_direction MPS::mps_swap_direction_ = MPS_swap_direction::SWAP_LEFT;
-  double MPS::json_chop_threshold_ = 1E-8;
-  std::stringstream MPS::logging_str_;
-  bool MPS::mps_log_data_ = 0;
+static const cmatrix_t zero_measure =
+    AER::Utils::make_matrix<complex_t>({{{1, 0}, {0, 0}}, {{0, 0}, {0, 0}}});
+static const cmatrix_t one_measure =
+    AER::Utils::make_matrix<complex_t>({{{0, 0}, {0, 0}}, {{0, 0}, {1, 0}}});
+uint_t MPS::omp_threads_ = 1;
+uint_t MPS::omp_threshold_ = 14;
+enum Sample_measure_alg MPS::sample_measure_alg_ =
+    Sample_measure_alg::HEURISTIC;
+enum MPS_swap_direction MPS::mps_swap_direction_ =
+    MPS_swap_direction::SWAP_LEFT;
+double MPS::json_chop_threshold_ = 1E-8;
+std::stringstream MPS::logging_str_;
+bool MPS::mps_log_data_ = 0;
 
 //------------------------------------------------------------------------
 // local function declarations
@@ -52,24 +51,26 @@ static const cmatrix_t one_measure =
 
 //------------------------------------------------------------------------
 // Function name: squeeze_qubits
-// Description: Takes a list of qubits, and squeezes them into a list of the same size,
-//     that begins at 0, and where all qubits are consecutive. Note that relative 
-//     order between qubits is preserved.
-//     Example: [8, 4, 6, 0, 9] -> [3, 1, 2, 0, 4]
-// Input: original_qubits 
+// Description: Takes a list of qubits, and squeezes them into a list of the
+// same size,
+//     that begins at 0, and where all qubits are consecutive. Note that
+//     relative order between qubits is preserved. Example: [8, 4, 6, 0, 9] ->
+//     [3, 1, 2, 0, 4]
+// Input: original_qubits
 // Returns: squeezed_qubits
 //
 //------------------------------------------------------------------------
-  void squeeze_qubits(const reg_t &original_qubits, reg_t &squeezed_qubits);
+void squeeze_qubits(const reg_t &original_qubits, reg_t &squeezed_qubits);
 
 //------------------------------------------------------------------------
 // Function name: reorder_all_qubits
-// Description: The ordering of the amplitudes in the statevector in this module is 
+// Description: The ordering of the amplitudes in the statevector in this module
+// is
 //    [n, (n-1),.., 2, 1, 0], i.e., msb is leftmost and lsb is rightmost.
-//    Sometimes, we need to provide a different ordering of the amplitudes, such as 
-//    in snapshot_probabilities. For example, instead of [2, 1, 0] the user requests 
-//    the probabilities of [1, 0, 2].
-//    Note that the qubits are numbered from left to right, e.g., 210
+//    Sometimes, we need to provide a different ordering of the amplitudes, such
+//    as in snapshot_probabilities. For example, instead of [2, 1, 0] the user
+//    requests the probabilities of [1, 0, 2]. Note that the qubits are numbered
+//    from left to right, e.g., 210
 // Input: orig_probvector - the ordered vector of probabilities/amplitudes
 //        qubits - a list containing the new ordering
 // Returns: new_probvector - the vector in the new ordering
@@ -77,15 +78,14 @@ static const cmatrix_t one_measure =
 //
 //------------------------------------------------------------------------
 template <class vec_t>
-void reorder_all_qubits(const vec_t& orig_probvector, 
-			const reg_t &qubits, 
-			vec_t& new_probvector);
+void reorder_all_qubits(const vec_t &orig_probvector, const reg_t &qubits,
+                        vec_t &new_probvector);
 uint_t reorder_qubits(const reg_t &qubits, uint_t index);
 
 //------------------------------------------------------------------------
 // Function name: permute_all_qubits
-// Description: Given an input ordering of the qubits, an output ordering of the 
-//    qubits and a statevector, create the statevector that represents the same 
+// Description: Given an input ordering of the qubits, an output ordering of the
+//    qubits and a statevector, create the statevector that represents the same
 //    state in the output ordering of the qubits.
 // Input: orig_statevector - the ordered vector of probabilities/amplitudes
 //        input_qubits - a list containing the original ordering of the qubits
@@ -95,39 +95,40 @@ uint_t reorder_qubits(const reg_t &qubits, uint_t index);
 //
 //------------------------------------------------------------------------
 template <class vec_t>
-void permute_all_qubits(const vec_t& orig_statevector, 
-			const reg_t &input_qubits, 
-			const reg_t &output_qubits,
-			vec_t& new_statevector);
+void permute_all_qubits(const vec_t &orig_statevector,
+                        const reg_t &input_qubits, const reg_t &output_qubits,
+                        vec_t &new_statevector);
 
 //------------------------------------------------------------------------
 // Function name: permute_qubits
 // Description: Helper function for permute_all_qubits
-//    Given a single index in the amplitude vector, returns the index in the new 
+//    Given a single index in the amplitude vector, returns the index in the new
 //    statevector that will be assigned the value of this index.
 // Input: index - the original index
 //        input_qubits - the original ordering of the qubits
-//        output_qubits - a list containing the new ordering 
+//        output_qubits - a list containing the new ordering
 // Returns: new index
 // Note that the qubits are numbered from left to right, i.e., the msb is 0
-// For example, if input_qubits=[0,1,2], and output_qubits=[1,0,2], for index=[0x100],
-// output index =[0x010]
+// For example, if input_qubits=[0,1,2], and output_qubits=[1,0,2], for
+// index=[0x100], output index =[0x010]
 //------------------------------------------------------------------------
-  uint_t permute_qubits(const reg_t &input_qubits, uint_t index, const reg_t &output_qubits);
+uint_t permute_qubits(const reg_t &input_qubits, uint_t index,
+                      const reg_t &output_qubits);
 
 //--------------------------------------------------------------------------
 // Function name: reverse_all_bits
-// Description: The ordering of the amplitudes in the statevector in this module is 
+// Description: The ordering of the amplitudes in the statevector in this module
+// is
 //    000, 001, 010, 011, 100, 101, 110, 111.
-//    The ordering of the amplitudes in the statevector in Qasm in general is 
+//    The ordering of the amplitudes in the statevector in Qasm in general is
 //    000, 100, 010, 110, 001, 101, 011, 111.
-//    This function converts the statevector from one representation to the other.
-//    This is a special case of reorder_qubits
+//    This function converts the statevector from one representation to the
+//    other. This is a special case of reorder_qubits
 // Input: the input statevector and the number of qubits
 // Output: the statevector in reverse order
-//----------------------------------------------------------------	
+//----------------------------------------------------------------
 template <class vec_t>
-vec_t reverse_all_bits(const vec_t& statevector, uint_t num_qubits);
+vec_t reverse_all_bits(const vec_t &statevector, uint_t num_qubits);
 
 // with 5 qubits, the number 2 in binary is 00010,
 // when reversed it is 01000, which is the number 8
@@ -135,20 +136,18 @@ uint_t reverse_bits(uint_t num, uint_t len);
 
 std::vector<uint_t> calc_new_indices(const reg_t &indices);
 
-// The following two functions are helper functions used by 
+// The following two functions are helper functions used by
 // initialize_from_statevector
 cmatrix_t reshape_matrix(cmatrix_t input_matrix);
-cmatrix_t mul_matrix_by_lambda(const cmatrix_t &mat,
-		               const rvector_t &lambda);
+cmatrix_t mul_matrix_by_lambda(const cmatrix_t &mat, const rvector_t &lambda);
 
-std::string sort_paulis_by_qubits(const std::string &paulis, 
-				  const reg_t &qubits);
+std::string sort_paulis_by_qubits(const std::string &paulis,
+                                  const reg_t &qubits);
 
 bool is_ordered(const reg_t &qubits);
 
-uint_t binary_search(const rvector_t &acc_probvector, 
-		     uint_t start, uint_t end, 
-		     double rnd);
+uint_t binary_search(const rvector_t &acc_probvector, uint_t start, uint_t end,
+                     double rnd);
 //------------------------------------------------------------------------
 // local function implementations
 //------------------------------------------------------------------------
@@ -158,88 +157,87 @@ void squeeze_qubits(const reg_t &original_qubits, reg_t &squeezed_qubits) {
     sorted_qubits.push_back(index);
   }
   sort(sorted_qubits.begin(), sorted_qubits.end());
-  for (uint_t i=0; i<original_qubits.size(); i++) {
-    for (uint_t j=0; j<sorted_qubits.size(); j++) {
+  for (uint_t i = 0; i < original_qubits.size(); i++) {
+    for (uint_t j = 0; j < sorted_qubits.size(); j++) {
       if (original_qubits[i] == sorted_qubits[j]) {
-	squeezed_qubits[i] = j;
-	break;
-      } 
-    }    
+        squeezed_qubits[i] = j;
+        break;
+      }
+    }
   }
 }
 
 template <class vec_t>
-void reorder_all_qubits(const vec_t& orig_probvector, 
-			const reg_t &qubits,
-			vec_t& new_probvector) {
+void reorder_all_qubits(const vec_t &orig_probvector, const reg_t &qubits,
+                        vec_t &new_probvector) {
   uint_t new_index;
-  uint_t length = 1ULL << qubits.size();   // length = pow(2, num_qubits)
-  // if qubits are [k0, k1,...,kn], move them to [0, 1, .. , n], but preserve relative
-  // ordering
+  uint_t length = 1ULL << qubits.size(); // length = pow(2, num_qubits)
+  // if qubits are [k0, k1,...,kn], move them to [0, 1, .. , n], but preserve
+  // relative ordering
   reg_t squeezed_qubits(qubits.size());
   squeeze_qubits(qubits, squeezed_qubits);
 
-  for (uint_t i=0; i < length; i++) {
+  for (uint_t i = 0; i < length; i++) {
     new_index = reorder_qubits(squeezed_qubits, i);
     new_probvector[new_index] = orig_probvector[i];
-  } 
+  }
 }
 
 uint_t reorder_qubits(const reg_t &qubits, uint_t index) {
   uint_t new_index = 0;
 
-  int_t current_pos = 0, current_val = 0, new_pos = 0, shift =0;
+  int_t current_pos = 0, current_val = 0, new_pos = 0, shift = 0;
   uint_t num_qubits = qubits.size();
-  for (uint_t i=0; i<num_qubits; i++) {
-    current_pos = num_qubits-1-qubits[i];
+  for (uint_t i = 0; i < num_qubits; i++) {
+    current_pos = num_qubits - 1 - qubits[i];
     current_val = 1ULL << current_pos;
-    new_pos = num_qubits-1-i;
+    new_pos = num_qubits - 1 - i;
     shift = new_pos - current_pos;
     if (index & current_val) {
       if (shift > 0) {
-	new_index += current_val << shift;
+        new_index += current_val << shift;
       } else if (shift < 0) {
-	new_index += current_val >> -shift; 
+        new_index += current_val >> -shift;
       } else {
-	new_index += current_val;
+        new_index += current_val;
       }
-      
     }
   }
   return new_index;
 }
 
 template <class vec_t>
-void permute_all_qubits(const vec_t& orig_statevector, 
-			const reg_t &input_qubits,
-			const reg_t &output_qubits,
-			vec_t& new_statevector) {
+void permute_all_qubits(const vec_t &orig_statevector,
+                        const reg_t &input_qubits, const reg_t &output_qubits,
+                        vec_t &new_statevector) {
   uint_t new_index;
-  uint_t length = 1ULL << input_qubits.size();   // length = pow(2, num_qubits)
-  // if qubits are [k0, k1,...,kn], move them to [0, 1, .. , n], but preserve relative
-  // ordering
+  uint_t length = 1ULL << input_qubits.size(); // length = pow(2, num_qubits)
+  // if qubits are [k0, k1,...,kn], move them to [0, 1, .. , n], but preserve
+  // relative ordering
   reg_t squeezed_qubits(input_qubits.size());
   squeeze_qubits(input_qubits, squeezed_qubits);
 
-  for (uint_t i=0; i < length; i++) {
+  for (uint_t i = 0; i < length; i++) {
     new_index = permute_qubits(squeezed_qubits, i, output_qubits);
     new_statevector[new_index] = orig_statevector[i];
-  } 
+  }
 }
 
-uint_t permute_qubits(const reg_t &input_qubits, uint_t index, const reg_t &output_qubits) {
+uint_t permute_qubits(const reg_t &input_qubits, uint_t index,
+                      const reg_t &output_qubits) {
   uint_t new_index = 0;
-  // pos is from right to left, i.e., msb has pos 0, and lsb has pos num_qubits-1
-  // This is in line with the ordering of the qubits in the MPS structure
-  int_t current_pos = 0, current_val = 0, new_pos = 0, shift =0;
+  // pos is from right to left, i.e., msb has pos 0, and lsb has pos
+  // num_qubits-1 This is in line with the ordering of the qubits in the MPS
+  // structure
+  int_t current_pos = 0, current_val = 0, new_pos = 0, shift = 0;
   uint_t num_qubits = input_qubits.size();
 
-  for (uint_t in=0; in<num_qubits; in++) {
+  for (uint_t in = 0; in < num_qubits; in++) {
     current_pos = in;
-    for (uint_t out=0; out<num_qubits; out++) {
+    for (uint_t out = 0; out < num_qubits; out++) {
       if (input_qubits[in] == output_qubits[out]) {
-	new_pos = out;
-	break;
+        new_pos = out;
+        break;
       }
     }
     shift = new_pos - current_pos;
@@ -247,12 +245,12 @@ uint_t permute_qubits(const reg_t &input_qubits, uint_t index, const reg_t &outp
 
     if (index & current_val) {
       if (shift > 0) {
-	new_index += current_val << shift;
+        new_index += current_val << shift;
       } else if (shift < 0) {
-	new_index += current_val >> -shift; 
+        new_index += current_val >> -shift;
       } else {
-	new_index += current_val;
-      }      
+        new_index += current_val;
+      }
     }
   }
   return new_index;
@@ -262,11 +260,11 @@ uint_t permute_qubits(const reg_t &input_qubits, uint_t index, const reg_t &outp
 // when reversed it is 01000, which is the number 8
 uint_t reverse_bits(uint_t num, uint_t len) {
   uint_t sum = 0;
-  for (uint_t i=0; i<len; ++i) {
+  for (uint_t i = 0; i < len; ++i) {
     if ((num & 0x1) == 1) {
-      sum += 1ULL << (len-1-i);   // adding pow(2, len-1-i)
+      sum += 1ULL << (len - 1 - i); // adding pow(2, len-1-i)
     }
-    num = num>>1;
+    num = num >> 1;
     if (num == 0) {
       break;
     }
@@ -275,13 +273,14 @@ uint_t reverse_bits(uint_t num, uint_t len) {
 }
 
 template <class vec_t>
-vec_t reverse_all_bits(const vec_t& statevector, uint_t num_qubits)
-{
-  uint_t length = statevector.size();   // length = pow(2, num_qubits_)
+vec_t reverse_all_bits(const vec_t &statevector, uint_t num_qubits) {
+  uint_t length = statevector.size(); // length = pow(2, num_qubits_)
   vec_t output_vector;
   output_vector.resize(length);
 
-#pragma omp parallel for if (length > MPS::get_omp_threshold() && MPS::get_omp_threads() > 1) num_threads(MPS::get_omp_threads()) 
+#pragma omp parallel for if (length > MPS::get_omp_threshold() &&              \
+                             MPS::get_omp_threads() > 1)                       \
+    num_threads(MPS::get_omp_threads())
   for (int_t i = 0; i < static_cast<int_t>(length); i++) {
     output_vector[i] = statevector[reverse_bits(i, num_qubits)];
   }
@@ -289,32 +288,36 @@ vec_t reverse_all_bits(const vec_t& statevector, uint_t num_qubits)
   return output_vector;
 }
 
-
 std::vector<uint_t> calc_new_indices(const reg_t &indices) {
   // assumes indices vector is sorted
   uint_t n = indices.size();
-  uint_t mid_index = indices[(n-1)/2];
-  uint_t first = mid_index - (n-1)/2;
+  uint_t mid_index = indices[(n - 1) / 2];
+  uint_t first = mid_index - (n - 1) / 2;
   std::vector<uint_t> new_indices(n);
-  std::iota( std::begin( new_indices ), std::end( new_indices ), first);
+  std::iota(std::begin(new_indices), std::end(new_indices), first);
   return new_indices;
 }
 
-cmatrix_t mul_matrix_by_lambda(const cmatrix_t &mat,
-			       const rvector_t &lambda) {
-  if (lambda == rvector_t {1.0}) return mat;
+cmatrix_t mul_matrix_by_lambda(const cmatrix_t &mat, const rvector_t &lambda) {
+  if (lambda == rvector_t{1.0})
+    return mat;
   cmatrix_t res_mat(mat);
   uint_t num_rows = mat.GetRows(), num_cols = mat.GetColumns();
 
 #ifdef _WIN32
-#pragma omp parallel for if (num_rows*num_cols > MPS_Tensor::MATRIX_OMP_THRESHOLD && MPS::get_omp_threads() > 1) num_threads(MPS::get_omp_threads()) 
+#pragma omp parallel for if (num_rows * num_cols >                             \
+                                 MPS_Tensor::MATRIX_OMP_THRESHOLD &&           \
+                             MPS::get_omp_threads() > 1)                       \
+    num_threads(MPS::get_omp_threads())
 #else
-#pragma omp parallel for collapse(2) if (num_rows*num_cols > MPS_Tensor::MATRIX_OMP_THRESHOLD && MPS::get_omp_threads() > 1) num_threads(MPS::get_omp_threads()) 
+#pragma omp parallel for collapse(                                             \
+    2) if (num_rows * num_cols > MPS_Tensor::MATRIX_OMP_THRESHOLD &&           \
+           MPS::get_omp_threads() > 1) num_threads(MPS::get_omp_threads())
 #endif
-  for(int_t row = 0; row < static_cast<int_t>(num_rows); row++) {
-    for(int_t col = 0; col < static_cast<int_t>(num_cols); col++) {
-	res_mat(row, col) = mat(row, col) * lambda[col];
-      }
+  for (int_t row = 0; row < static_cast<int_t>(num_rows); row++) {
+    for (int_t col = 0; col < static_cast<int_t>(num_cols); col++) {
+      res_mat(row, col) = mat(row, col) * lambda[col];
+    }
   }
   return res_mat;
 }
@@ -326,22 +329,22 @@ cmatrix_t reshape_matrix(cmatrix_t input_matrix) {
   return reshaped_matrix;
 }
 
-std::string sort_paulis_by_qubits(const std::string &paulis, 
-				  const reg_t &qubits) {
+std::string sort_paulis_by_qubits(const std::string &paulis,
+                                  const reg_t &qubits) {
   uint_t min = UINT_MAX;
   uint_t min_index = 0;
 
   std::string new_paulis;
   std::vector<uint_t> temp_qubits = qubits;
   // find min_index, the next smallest index in qubits
-  for (uint_t i=0; i<paulis.size(); i++) {
+  for (uint_t i = 0; i < paulis.size(); i++) {
     min = temp_qubits[0];
-    for (uint_t qubit=0; qubit<qubits.size(); qubit++)
+    for (uint_t qubit = 0; qubit < qubits.size(); qubit++)
       if (temp_qubits[qubit] <= min) {
-	min = temp_qubits[qubit];
-	min_index = qubit;
+        min = temp_qubits[qubit];
+        min_index = qubit;
       }
-    // select the corresponding pauli, and put it next in 
+    // select the corresponding pauli, and put it next in
     // the sorted vector
     new_paulis.push_back(paulis[min_index]);
     // make sure we don't select this index again by setting it to UINT_MAX
@@ -352,8 +355,8 @@ std::string sort_paulis_by_qubits(const std::string &paulis,
 
 bool is_ordered(const reg_t &qubits) {
   bool ordered = true;
-  for (uint_t index=0; index < qubits.size()-1; index++) {
-    if (qubits[index]+1 != qubits[index+1]){
+  for (uint_t index = 0; index < qubits.size() - 1; index++) {
+    if (qubits[index] + 1 != qubits[index + 1]) {
       ordered = false;
       break;
     }
@@ -364,19 +367,18 @@ bool is_ordered(const reg_t &qubits) {
 // implementation of MPS methods
 //------------------------------------------------------------------------
 
-void MPS::initialize(uint_t num_qubits)
-{
+void MPS::initialize(uint_t num_qubits) {
   num_qubits_ = num_qubits;
   q_reg_.clear();
   lambda_reg_.clear();
   complex_t alpha = 1.0f;
   complex_t beta = 0.0f;
 
-  for(uint_t i = 0; i < num_qubits_; i++) {
+  for (uint_t i = 0; i < num_qubits_; i++) {
     q_reg_.push_back(MPS_Tensor(alpha, beta));
   }
   for (uint_t i = 1; i < num_qubits_; i++) {
-    lambda_reg_.push_back(rvector_t {1.0});
+    lambda_reg_.push_back(rvector_t{1.0});
   }
 
   qubit_ordering_.order_.clear();
@@ -385,178 +387,164 @@ void MPS::initialize(uint_t num_qubits)
 
   qubit_ordering_.location_.clear();
   qubit_ordering_.location_.resize(num_qubits);
-  std::iota(qubit_ordering_.location_.begin(), qubit_ordering_.location_.end(), 0);
+  std::iota(qubit_ordering_.location_.begin(), qubit_ordering_.location_.end(),
+            0);
 }
 
-void MPS::initialize(const MPS &other){
-    if (this != &other) {
-      num_qubits_ = other.num_qubits_;
-      q_reg_ = other.q_reg_;
-      lambda_reg_ = other.lambda_reg_;
-      qubit_ordering_.order_ = other.qubit_ordering_.order_;
-      qubit_ordering_.location_ = other.qubit_ordering_.location_;
-    }     
+void MPS::initialize(const MPS &other) {
+  if (this != &other) {
+    num_qubits_ = other.num_qubits_;
+    q_reg_ = other.q_reg_;
+    lambda_reg_ = other.lambda_reg_;
+    qubit_ordering_.order_ = other.qubit_ordering_.order_;
+    qubit_ordering_.location_ = other.qubit_ordering_.location_;
+  }
 }
 
 reg_t MPS::get_internal_qubits(const reg_t &qubits) const {
   reg_t internal_qubits(qubits.size());
-  for (uint_t i=0; i<qubits.size(); i++) {
+  for (uint_t i = 0; i < qubits.size(); i++) {
     internal_qubits[i] = get_qubit_index(qubits[i]);
   }
   return internal_qubits;
 }
- 
-void MPS::apply_h(uint_t index) 
-{
+
+void MPS::apply_h(uint_t index) {
   get_qubit(index).apply_matrix(AER::Linalg::Matrix::H);
 }
 
-void MPS::apply_sx(uint_t index)
-{
+void MPS::apply_sx(uint_t index) {
   get_qubit(index).apply_matrix(AER::Linalg::Matrix::SX);
 }
 
-void MPS::apply_sxdg(uint_t index)
-{
+void MPS::apply_sxdg(uint_t index) {
   get_qubit(index).apply_matrix(AER::Linalg::Matrix::SXDG);
 }
 
-void MPS::apply_r(uint_t index, double phi, double lam)
-{
+void MPS::apply_r(uint_t index, double phi, double lam) {
   get_qubit(index).apply_matrix(AER::Linalg::Matrix::r(phi, lam));
 }
 
-void MPS::apply_rx(uint_t index, double theta)
-{
+void MPS::apply_rx(uint_t index, double theta) {
   get_qubit(index).apply_matrix(AER::Linalg::Matrix::rx(theta));
 }
 
-void MPS::apply_ry(uint_t index, double theta)
-{
+void MPS::apply_ry(uint_t index, double theta) {
   get_qubit(index).apply_matrix(AER::Linalg::Matrix::ry(theta));
 }
 
-void MPS::apply_rz(uint_t index, double theta)
-{
+void MPS::apply_rz(uint_t index, double theta) {
   get_qubit(index).apply_matrix(AER::Linalg::Matrix::rz(theta));
 }
 
-void MPS::apply_u2(uint_t index, double phi, double lambda)
-{
+void MPS::apply_u2(uint_t index, double phi, double lambda) {
   get_qubit(index).apply_matrix(AER::Linalg::Matrix::u2(phi, lambda));
 }
 
-void MPS::apply_u3(uint_t index, double theta, double phi, double lambda)
-{
+void MPS::apply_u3(uint_t index, double theta, double phi, double lambda) {
   get_qubit(index).apply_matrix(AER::Linalg::Matrix::u3(theta, phi, lambda));
 }
 
-
-
-void MPS::apply_cnot(uint_t index_A, uint_t index_B)
-{
-  apply_2_qubit_gate(get_qubit_index(index_A), 
-		     get_qubit_index(index_B), cx, cmatrix_t(1, 1));
+void MPS::apply_cnot(uint_t index_A, uint_t index_B) {
+  apply_2_qubit_gate(get_qubit_index(index_A), get_qubit_index(index_B), cx,
+                     cmatrix_t(1, 1));
 }
 
-void MPS::apply_cy(uint_t index_A, uint_t index_B)
-{
-  apply_2_qubit_gate(get_qubit_index(index_A), 
-		     get_qubit_index(index_B), cy, cmatrix_t(1, 1));
+void MPS::apply_cy(uint_t index_A, uint_t index_B) {
+  apply_2_qubit_gate(get_qubit_index(index_A), get_qubit_index(index_B), cy,
+                     cmatrix_t(1, 1));
 }
 
-void MPS::apply_cz(uint_t index_A, uint_t index_B)
-{
-  apply_2_qubit_gate(get_qubit_index(index_A), 
-		     get_qubit_index(index_B), cz, cmatrix_t(1, 1));
+void MPS::apply_cz(uint_t index_A, uint_t index_B) {
+  apply_2_qubit_gate(get_qubit_index(index_A), get_qubit_index(index_B), cz,
+                     cmatrix_t(1, 1));
 }
 
-void MPS::apply_cu1(uint_t index_A, uint_t index_B, double lambda)
-{
+void MPS::apply_cu1(uint_t index_A, uint_t index_B, double lambda) {
   cmatrix_t lambda_in_mat(1, 1);
   lambda_in_mat(0, 0) = lambda;
-  apply_2_qubit_gate(get_qubit_index(index_A), 
-		     get_qubit_index(index_B), cu1, lambda_in_mat);
+  apply_2_qubit_gate(get_qubit_index(index_A), get_qubit_index(index_B), cu1,
+                     lambda_in_mat);
 }
 
-void MPS::apply_csx(uint_t index_A, uint_t index_B)
-{
+void MPS::apply_csx(uint_t index_A, uint_t index_B) {
   cmatrix_t sx_matrix = AER::Linalg::Matrix::SX;
-  apply_2_qubit_gate(get_qubit_index(index_A), 
-		     get_qubit_index(index_B), csx, sx_matrix);
+  apply_2_qubit_gate(get_qubit_index(index_A), get_qubit_index(index_B), csx,
+                     sx_matrix);
 }
 
-void MPS::apply_rxx(uint_t index_A, uint_t index_B, double theta)
-{
+void MPS::apply_rxx(uint_t index_A, uint_t index_B, double theta) {
   cmatrix_t rxx_matrix = AER::Linalg::Matrix::rxx(theta);
-  apply_2_qubit_gate(get_qubit_index(index_A), get_qubit_index(index_B), su4, rxx_matrix);
+  apply_2_qubit_gate(get_qubit_index(index_A), get_qubit_index(index_B), su4,
+                     rxx_matrix);
 }
 
-void MPS::apply_ryy(uint_t index_A, uint_t index_B, double theta)
-{
+void MPS::apply_ryy(uint_t index_A, uint_t index_B, double theta) {
   cmatrix_t ryy_matrix = AER::Linalg::Matrix::ryy(theta);
-  apply_2_qubit_gate(get_qubit_index(index_A), get_qubit_index(index_B), su4, ryy_matrix);
+  apply_2_qubit_gate(get_qubit_index(index_A), get_qubit_index(index_B), su4,
+                     ryy_matrix);
 }
 
-void MPS::apply_rzz(uint_t index_A, uint_t index_B, double theta)
-{
+void MPS::apply_rzz(uint_t index_A, uint_t index_B, double theta) {
   cmatrix_t rzz_matrix = AER::Linalg::Matrix::rzz(theta);
-  apply_2_qubit_gate(get_qubit_index(index_A), get_qubit_index(index_B), su4, rzz_matrix);
+  apply_2_qubit_gate(get_qubit_index(index_A), get_qubit_index(index_B), su4,
+                     rzz_matrix);
 }
 
-void MPS::apply_rzx(uint_t index_A, uint_t index_B, double theta)
-{
+void MPS::apply_rzx(uint_t index_A, uint_t index_B, double theta) {
   cmatrix_t rzx_matrix = AER::Linalg::Matrix::rzx(theta);
-  apply_2_qubit_gate(get_qubit_index(index_A), get_qubit_index(index_B), su4, rzx_matrix);
+  apply_2_qubit_gate(get_qubit_index(index_A), get_qubit_index(index_B), su4,
+                     rzx_matrix);
 }
 
-void MPS::apply_ccx(const reg_t &qubits)
-{
+void MPS::apply_ccx(const reg_t &qubits) {
   reg_t internal_qubits = get_internal_qubits(qubits);
   apply_3_qubit_gate(internal_qubits, ccx, cmatrix_t(1, 1));
 }
 
-void MPS::apply_cswap(const reg_t &qubits)
-{
+void MPS::apply_cswap(const reg_t &qubits) {
   reg_t internal_qubits = get_internal_qubits(qubits);
   apply_3_qubit_gate(internal_qubits, cswap, cmatrix_t(1, 1));
 }
 
 void MPS::apply_swap(uint_t index_A, uint_t index_B, bool swap_gate) {
-  apply_swap_internal(get_qubit_index(index_A), get_qubit_index(index_B), swap_gate);
+  apply_swap_internal(get_qubit_index(index_A), get_qubit_index(index_B),
+                      swap_gate);
 }
 
 void MPS::apply_swap_internal(uint_t index_A, uint_t index_B, bool swap_gate) {
   uint_t actual_A = index_A;
   uint_t actual_B = index_B;
-  if(actual_A > actual_B) {
+  if (actual_A > actual_B) {
     std::swap(actual_A, actual_B);
   }
 
-  if(actual_A + 1 < actual_B) {
+  if (actual_A + 1 < actual_B) {
     uint_t i;
-    for(i = actual_A; i < actual_B; i++) {
-      apply_swap_internal(i, i+1, swap_gate);
+    for (i = actual_A; i < actual_B; i++) {
+      apply_swap_internal(i, i + 1, swap_gate);
     }
-    for(i = actual_B-1; i > actual_A; i--) {
-      apply_swap_internal(i, i-1, swap_gate);
+    for (i = actual_B - 1; i > actual_A; i--) {
+      apply_swap_internal(i, i - 1, swap_gate);
     }
     return;
   }
-  // when actual_A+1 == actual_B then we can really do the swap between A and A+1
-  common_apply_2_qubit_gate(actual_A, Gates::swap, 
-			    cmatrix_t(1, 1) /*dummy matrix*/, false /*swapped*/);
- 
+  // when actual_A+1 == actual_B then we can really do the swap between A and
+  // A+1
+  common_apply_2_qubit_gate(actual_A, Gates::swap,
+                            cmatrix_t(1, 1) /*dummy matrix*/,
+                            false /*swapped*/);
+
   if (!swap_gate) {
     // we move the qubit at index_A one position to the right
-    // and the qubit at index_B (or index_A+1) is moved one position 
-    //to the left
-    std::swap(qubit_ordering_.order_[index_A], qubit_ordering_.order_[index_B]);    
+    // and the qubit at index_B (or index_A+1) is moved one position
+    // to the left
+    std::swap(qubit_ordering_.order_[index_A], qubit_ordering_.order_[index_B]);
     // For logging purposes:
     print_to_log_internal_swap(index_A, index_B);
 
     // update qubit locations after all the swaps
-    for (uint_t i=0; i<num_qubits_; i++)
+    for (uint_t i = 0; i < num_qubits_; i++)
       qubit_ordering_.location_[qubit_ordering_.order_[i]] = i;
   }
 }
@@ -571,37 +559,40 @@ void MPS::print_to_log_internal_swap(uint_t qubit0, uint_t qubit1) const {
 void MPS::print_bond_dimensions() const {
   print_to_log(", BD=[");
   reg_t bd = get_bond_dimensions();
-  for (uint_t index=0; index<bd.size(); index++) {
+  for (uint_t index = 0; index < bd.size(); index++) {
     print_to_log(bd[index]);
-      if (index < bd.size()-1)
-	print_to_log(" ");
+    if (index < bd.size() - 1)
+      print_to_log(" ");
   }
   print_to_log("],  ");
 }
 //-------------------------------------------------------------------------
 // MPS::apply_2_qubit_gate - outline of the algorithm
 // 1. Swap qubits A and B until they are consecutive
-// 2. Contract MPS_Tensor[A] and MPS_Tensor[B], yielding a temporary four-matrix MPS_Tensor 
+// 2. Contract MPS_Tensor[A] and MPS_Tensor[B], yielding a temporary four-matrix
+// MPS_Tensor
 //    that represents the entangled states of A and B.
 // 3. Apply the gate
-// 4. Decompose the temporary MPS_Tensor (using SVD) into U*S*V, where U and V are matrices
+// 4. Decompose the temporary MPS_Tensor (using SVD) into U*S*V, where U and V
+// are matrices
 //    and S is a diagonal matrix
-// 5. U is split by rows to yield two MPS_Tensors representing qubit A (in reshape_U_after_SVD), 
-//    V is split by columns to yield two MPS_Tensors representing qubit B (in reshape_V_after_SVD),
-//    the diagonal of S becomes the Lambda-vector in between A and B.
+// 5. U is split by rows to yield two MPS_Tensors representing qubit A (in
+// reshape_U_after_SVD),
+//    V is split by columns to yield two MPS_Tensors representing qubit B (in
+//    reshape_V_after_SVD), the diagonal of S becomes the Lambda-vector in
+//    between A and B.
 //-------------------------------------------------------------------------
-void MPS::apply_2_qubit_gate(uint_t index_A, uint_t index_B, 
-			     Gates gate_type, const cmatrix_t &mat, 
-			     bool is_diagonal)
-{
+void MPS::apply_2_qubit_gate(uint_t index_A, uint_t index_B, Gates gate_type,
+                             const cmatrix_t &mat, bool is_diagonal) {
   // We first move the two qubits to be in consecutive positions
   // By default, the right qubit is moved to the position after the left qubit.
-  // However, the user can choose to move the left qubit to be in the position 
+  // However, the user can choose to move the left qubit to be in the position
   // before the right qubit by changing the MPS_swap_direction to SWAP_RIGHT.
-  // The direction of the swaps may affect performance, depending on the circuit.
+  // The direction of the swaps may affect performance, depending on the
+  // circuit.
 
   bool swapped = false;
-  uint_t low_qubit=0, high_qubit=0;
+  uint_t low_qubit = 0, high_qubit = 0;
 
   if (index_B > index_A) {
     low_qubit = index_A;
@@ -613,30 +604,30 @@ void MPS::apply_2_qubit_gate(uint_t index_A, uint_t index_B,
   }
   if (mps_swap_direction_ == MPS_swap_direction::SWAP_LEFT) {
     // Move high_qubit to be right after low_qubit
-      change_position(high_qubit, low_qubit+1);  
-  } else {  //mps_swap_right
+    change_position(high_qubit, low_qubit + 1);
+  } else { // mps_swap_right
     // Move low_qubit to be right before high_qubit
-      change_position(low_qubit, high_qubit-1);  
-      low_qubit = high_qubit-1;
-    }
+    change_position(low_qubit, high_qubit - 1);
+    low_qubit = high_qubit - 1;
+  }
   common_apply_2_qubit_gate(low_qubit, gate_type, mat, swapped, is_diagonal);
 }
 
-void MPS::common_apply_2_qubit_gate(uint_t A,  // the gate is applied to A and A+1
-				    Gates gate_type, const cmatrix_t &mat,
-				    bool swapped,
-				    bool is_diagonal) {
-  // After we moved the qubits as necessary, 
+void MPS::common_apply_2_qubit_gate(
+    uint_t A, // the gate is applied to A and A+1
+    Gates gate_type, const cmatrix_t &mat, bool swapped, bool is_diagonal) {
+  // After we moved the qubits as necessary,
   // the operation is always between qubits A and A+1
 
-  //There is no lambda on the edges of the MPS
+  // There is no lambda on the edges of the MPS
   if (A != 0)
-    q_reg_[A].mul_Gamma_by_left_Lambda(lambda_reg_[A-1]);
-  if (A+1 != num_qubits_-1)
-    q_reg_[A+1].mul_Gamma_by_right_Lambda(lambda_reg_[A+1]);
+    q_reg_[A].mul_Gamma_by_left_Lambda(lambda_reg_[A - 1]);
+  if (A + 1 != num_qubits_ - 1)
+    q_reg_[A + 1].mul_Gamma_by_right_Lambda(lambda_reg_[A + 1]);
+
+  MPS_Tensor temp =
+      MPS_Tensor::contract(q_reg_[A], lambda_reg_[A], q_reg_[A + 1]);
 
-  MPS_Tensor temp = MPS_Tensor::contract(q_reg_[A], lambda_reg_[A], q_reg_[A+1]);
-  
   switch (gate_type) {
   case cx:
     temp.apply_cnot(swapped);
@@ -663,31 +654,30 @@ void MPS::common_apply_2_qubit_gate(uint_t A,  // the gate is applied to A and A
     // Effectively, this reverses swap for 2-qubit gates
     temp.apply_matrix_2_qubits(mat, !swapped, is_diagonal);
     break;
-    
+
   default:
-    throw std::invalid_argument("illegal gate for apply_2_qubit_gate"); 
+    throw std::invalid_argument("illegal gate for apply_2_qubit_gate");
   }
 
   MPS_Tensor left_gamma, right_gamma;
   rvector_t lambda;
-  double discarded_value = MPS_Tensor::Decompose(temp, left_gamma, lambda, right_gamma);
+  double discarded_value =
+      MPS_Tensor::Decompose(temp, left_gamma, lambda, right_gamma);
   if (discarded_value > json_chop_threshold_)
     MPS::print_to_log("discarded_value=", discarded_value, ", ");
 
   if (A != 0)
-    left_gamma.div_Gamma_by_left_Lambda(lambda_reg_[A-1]);
-  if (A+1 != num_qubits_-1)
-    right_gamma.div_Gamma_by_right_Lambda(lambda_reg_[A+1]);
+    left_gamma.div_Gamma_by_left_Lambda(lambda_reg_[A - 1]);
+  if (A + 1 != num_qubits_ - 1)
+    right_gamma.div_Gamma_by_right_Lambda(lambda_reg_[A + 1]);
 
   q_reg_[A] = left_gamma;
   lambda_reg_[A] = lambda;
-  q_reg_[A+1] = right_gamma;
+  q_reg_[A + 1] = right_gamma;
 }
 
-void MPS::apply_3_qubit_gate(const reg_t &qubits,
-			     Gates gate_type, const cmatrix_t &mat,
-			     bool is_diagonal)
-{
+void MPS::apply_3_qubit_gate(const reg_t &qubits, Gates gate_type,
+                             const cmatrix_t &mat, bool is_diagonal) {
   if (qubits.size() != 3) {
     std::stringstream ss;
     ss << "error: apply_3_qubit gate must receive 3 qubits";
@@ -699,14 +689,14 @@ void MPS::apply_3_qubit_gate(const reg_t &qubits,
 
   // extract the tensor containing only the 3 qubits on which we apply the gate
   uint_t first = new_qubits.front();
-  MPS_Tensor sub_tensor(state_vec_as_MPS(first, first+2));
+  MPS_Tensor sub_tensor(state_vec_as_MPS(first, first + 2));
 
   // apply the gate to sub_tensor
   switch (gate_type) {
   case ccx:
-    // The controlled (or target) qubit, is qubit[2]. Since in new_qubits the qubits are sorted,
-    // the relative position of the controlled qubit will be 0, 1, or 2 depending on
-    // where qubit[2] was moved to in new_qubits
+    // The controlled (or target) qubit, is qubit[2]. Since in new_qubits the
+    // qubits are sorted, the relative position of the controlled qubit will be
+    // 0, 1, or 2 depending on where qubit[2] was moved to in new_qubits
     uint_t target;
     if (qubits[2] > qubits[0] && qubits[2] > qubits[1])
       target = 2;
@@ -728,43 +718,44 @@ void MPS::apply_3_qubit_gate(const reg_t &qubits,
     break;
 
   default:
-    throw std::invalid_argument("illegal gate for apply_3_qubit_gate"); 
+    throw std::invalid_argument("illegal gate for apply_3_qubit_gate");
   }
 
-  // state_mat is a matrix containing the flattened representation of the sub-tensor 
-  // into a single matrix. Note that sub_tensor will contain 8 matrices for 3-qubit
-  // gates. state_mat will be the concatenation of them all.
+  // state_mat is a matrix containing the flattened representation of the
+  // sub-tensor into a single matrix. Note that sub_tensor will contain 8
+  // matrices for 3-qubit gates. state_mat will be the concatenation of them
+  // all.
   cmatrix_t state_mat = sub_tensor.get_data(0);
-  for (uint_t i=1; i<sub_tensor.get_data().size(); i++)
-    state_mat = AER::Utils::concatenate(state_mat, sub_tensor.get_data(i), 1) ;
+  for (uint_t i = 1; i < sub_tensor.get_data().size(); i++)
+    state_mat = AER::Utils::concatenate(state_mat, sub_tensor.get_data(i), 1);
 
   // We convert the matrix back into a 3-qubit MPS structure
   MPS sub_MPS;
   sub_MPS.initialize_from_matrix(qubits.size(), state_mat);
 
-  // copy the 3-qubit MPS back to the corresponding positions in the original MPS
-  for (uint_t i=0; i<sub_MPS.num_qubits(); i++) {
-    q_reg_[first+i] = sub_MPS.q_reg_[i];
+  // copy the 3-qubit MPS back to the corresponding positions in the original
+  // MPS
+  for (uint_t i = 0; i < sub_MPS.num_qubits(); i++) {
+    q_reg_[first + i] = sub_MPS.q_reg_[i];
   }
   lambda_reg_[first] = sub_MPS.lambda_reg_[0];
-  lambda_reg_[first+1] = sub_MPS.lambda_reg_[1];
+  lambda_reg_[first + 1] = sub_MPS.lambda_reg_[1];
   if (first > 0)
-    q_reg_[first].div_Gamma_by_left_Lambda(lambda_reg_[first-1]);
-  if (first+2 < num_qubits_-1)
-    q_reg_[first+2].div_Gamma_by_right_Lambda(lambda_reg_[first+2]);
+    q_reg_[first].div_Gamma_by_left_Lambda(lambda_reg_[first - 1]);
+  if (first + 2 < num_qubits_ - 1)
+    q_reg_[first + 2].div_Gamma_by_right_Lambda(lambda_reg_[first + 2]);
 }
 
-void MPS::apply_matrix(const reg_t & qubits, const cmatrix_t &mat, 
-		       bool is_diagonal) {
+void MPS::apply_matrix(const reg_t &qubits, const cmatrix_t &mat,
+                       bool is_diagonal) {
   reg_t internal_qubits = get_internal_qubits(qubits);
   apply_matrix_internal(internal_qubits, mat, is_diagonal);
 }
 
-void MPS::apply_matrix_internal(const reg_t & qubits, const cmatrix_t &mat,
-				bool is_diagonal) 
-{
+void MPS::apply_matrix_internal(const reg_t &qubits, const cmatrix_t &mat,
+                                bool is_diagonal) {
   switch (qubits.size()) {
-  case 1: 
+  case 1:
     q_reg_[qubits[0]].apply_matrix(mat, is_diagonal);
     break;
   case 2:
@@ -775,12 +766,11 @@ void MPS::apply_matrix_internal(const reg_t & qubits, const cmatrix_t &mat,
   }
 }
 
-void MPS::apply_multi_qubit_gate(const reg_t &qubits,
-				 const cmatrix_t &mat,
-				 bool is_diagonal) {
+void MPS::apply_multi_qubit_gate(const reg_t &qubits, const cmatrix_t &mat,
+                                 bool is_diagonal) {
   // bring the qubits to consecutive positions
   uint_t num_qubits = qubits.size();
-  uint_t length  = 1ULL << num_qubits;
+  uint_t length = 1ULL << num_qubits;
   reg_t squeezed_qubits(num_qubits);
   squeeze_qubits(qubits, squeezed_qubits);
 
@@ -789,7 +779,7 @@ void MPS::apply_multi_qubit_gate(const reg_t &qubits,
 
   // reorder on a dummy vector to get the new ordering
   reg_t ordered_vec(length);
-  std::iota( std::begin(ordered_vec), std::end(ordered_vec), 0);
+  std::iota(std::begin(ordered_vec), std::end(ordered_vec), 0);
   reg_t new_vec(length);
   reorder_all_qubits(ordered_vec, squeezed_qubits, new_vec);
 
@@ -797,12 +787,12 @@ void MPS::apply_multi_qubit_gate(const reg_t &qubits,
   uint_t nqubits = qubits.size();
   uint_t sidelen = 1 << nqubits;
   cmatrix_t new_mat(sidelen, sidelen);
-  for (uint_t col=0; col<sidelen; ++col) {
-    for (uint_t row=0; row<sidelen; ++row) {
+  for (uint_t col = 0; col < sidelen; ++col) {
+    for (uint_t row = 0; row < sidelen; ++row) {
       if (row == col)
-	new_mat(new_vec[row], new_vec[row]) = mat(row, row);
+        new_mat(new_vec[row], new_vec[row]) = mat(row, row);
       else
-	new_mat(new_vec[row], new_vec[col]) = mat(row, col);
+        new_mat(new_vec[row], new_vec[col]) = mat(row, col);
     }
   }
 
@@ -813,27 +803,27 @@ void MPS::apply_multi_qubit_gate(const reg_t &qubits,
 }
 
 void MPS::apply_unordered_multi_qubit_gate(const reg_t &qubits,
-					   const cmatrix_t &mat,
-					   bool is_diagonal){
+                                           const cmatrix_t &mat,
+                                           bool is_diagonal) {
   reg_t new_qubits(qubits.size());
   centralize_qubits(qubits, new_qubits);
   apply_matrix_to_target_qubits(new_qubits, mat, is_diagonal);
 }
 
 void MPS::apply_matrix_to_target_qubits(const reg_t &target_qubits,
-					const cmatrix_t &mat,
-					bool is_diagonal) {
+                                        const cmatrix_t &mat,
+                                        bool is_diagonal) {
   uint_t num_qubits = target_qubits.size();
   uint_t first = target_qubits.front();
-  MPS_Tensor sub_tensor(state_vec_as_MPS(first, first+num_qubits-1));
+  MPS_Tensor sub_tensor(state_vec_as_MPS(first, first + num_qubits - 1));
   sub_tensor.apply_matrix(mat, is_diagonal);
 
-  // state_mat is a matrix containing the flattened representation of the sub-tensor 
-  // into a single matrix. E.g., sub_tensor will contain 8 matrices for 3-qubit
-  // gates. state_mat will be the concatenation of them all.
+  // state_mat is a matrix containing the flattened representation of the
+  // sub-tensor into a single matrix. E.g., sub_tensor will contain 8 matrices
+  // for 3-qubit gates. state_mat will be the concatenation of them all.
   cmatrix_t state_mat = sub_tensor.get_data(0);
-  for (uint_t i=1; i<sub_tensor.get_data().size(); i++)
-    state_mat = AER::Utils::concatenate(state_mat, sub_tensor.get_data(i), 1) ;
+  for (uint_t i = 1; i < sub_tensor.get_data().size(); i++)
+    state_mat = AER::Utils::concatenate(state_mat, sub_tensor.get_data(i), 1);
 
   // We convert the matrix back into an MPS structure
   MPS sub_MPS;
@@ -845,39 +835,39 @@ void MPS::apply_matrix_to_target_qubits(const reg_t &target_qubits,
     lambda_reg_ = sub_MPS.lambda_reg_;
   } else {
     // copy the sub_MPS back to the corresponding positions in the original MPS
-    for (uint_t i=0; i<sub_MPS.num_qubits(); i++) {
-      q_reg_[first+i] = sub_MPS.q_reg_[i];
+    for (uint_t i = 0; i < sub_MPS.num_qubits(); i++) {
+      q_reg_[first + i] = sub_MPS.q_reg_[i];
     }
-    for (uint_t i=0; i<num_qubits-1; i++) {
-      lambda_reg_[first+i] = sub_MPS.lambda_reg_[i];       
+    for (uint_t i = 0; i < num_qubits - 1; i++) {
+      lambda_reg_[first + i] = sub_MPS.lambda_reg_[i];
     }
     if (first > 0)
-      q_reg_[first].div_Gamma_by_left_Lambda(lambda_reg_[first-1]);
-    if (first+num_qubits-1 < num_qubits_-1)
-	q_reg_[first+num_qubits-1].div_Gamma_by_right_Lambda(lambda_reg_[first+num_qubits-1]);
+      q_reg_[first].div_Gamma_by_left_Lambda(lambda_reg_[first - 1]);
+    if (first + num_qubits - 1 < num_qubits_ - 1)
+      q_reg_[first + num_qubits - 1].div_Gamma_by_right_Lambda(
+          lambda_reg_[first + num_qubits - 1]);
   }
 }
 
-void MPS::apply_diagonal_matrix(const AER::reg_t &qubits, const cvector_t &vmat) {
+void MPS::apply_diagonal_matrix(const AER::reg_t &qubits,
+                                const cvector_t &vmat) {
   // converting the vector to a 1xn matrix whose first (and single) row is vmat
   uint_t dim = vmat.size();
   cmatrix_t diag_mat(1, dim);
-  for (uint_t i=0; i<dim; i++) {
-      diag_mat(0, i) = vmat[i];
+  for (uint_t i = 0; i < dim; i++) {
+    diag_mat(0, i) = vmat[i];
   }
   apply_matrix(qubits, diag_mat, true /*is_diagonal*/);
 }
 
-void MPS::apply_kraus(const reg_t &qubits,
-                   const std::vector<cmatrix_t> &kmats,
-                   RngEngine &rng) {
+void MPS::apply_kraus(const reg_t &qubits, const std::vector<cmatrix_t> &kmats,
+                      RngEngine &rng) {
   reg_t internal_qubits = get_internal_qubits(qubits);
   apply_kraus_internal(internal_qubits, kmats, rng);
-
 }
 void MPS::apply_kraus_internal(const reg_t &qubits,
-                   const std::vector<cmatrix_t> &kmats,
-                   RngEngine &rng) {
+                               const std::vector<cmatrix_t> &kmats,
+                               RngEngine &rng) {
   // Check edge case for empty Kraus set (this shouldn't happen)
   if (kmats.empty())
     return; // end function early
@@ -890,14 +880,14 @@ void MPS::apply_kraus_internal(const reg_t &qubits,
   double r = rng.rand(0., 1.);
   double accum = 0.;
   bool complete = false;
-  
+
   cmatrix_t rho = density_matrix_internal(qubits);
-  
+
   cmatrix_t sq_kmat;
   double p = 0;
 
   // Loop through N-1 kraus operators
-  for (size_t j=0; j < kmats.size() - 1; j++) {
+  for (size_t j = 0; j < kmats.size() - 1; j++) {
     sq_kmat = AER::Utils::dagger(kmats[j]) * kmats[j];
     // Calculate probability
     p = real(AER::Utils::trace(rho * sq_kmat));
@@ -906,7 +896,7 @@ void MPS::apply_kraus_internal(const reg_t &qubits,
     // check if we need to apply this operator
     if (accum > r) {
       // rescale mat so projection is normalized
-      cmatrix_t temp_mat =  kmats[j] * (1 / std::sqrt(p));
+      cmatrix_t temp_mat = kmats[j] * (1 / std::sqrt(p));
       apply_matrix_internal(qubits, temp_mat);
       complete = true;
       break;
@@ -916,29 +906,27 @@ void MPS::apply_kraus_internal(const reg_t &qubits,
   if (!complete) {
     // Compute probability from accumulated
     double renorm = 1 / std::sqrt(1. - accum);
-    cmatrix_t temp_mat = kmats.back()* renorm;
+    cmatrix_t temp_mat = kmats.back() * renorm;
     apply_matrix_internal(qubits, temp_mat);
   }
-  
+
   uint_t min_qubit = qubits[0];
   uint_t max_qubit = qubits[0];
-  for (uint_t i=qubits[0]; i<qubits.size(); i++) {
+  for (uint_t i = qubits[0]; i < qubits.size(); i++) {
     min_qubit = std::min(min_qubit, qubits[i]);
     max_qubit = std::max(max_qubit, qubits[i]);
   }
-  propagate_to_neighbors_internal(min_qubit, max_qubit, num_qubits_-1);
+  propagate_to_neighbors_internal(min_qubit, max_qubit, num_qubits_ - 1);
 }
 
-void MPS::centralize_qubits(const reg_t &qubits, 
-			    reg_t &centralized_qubits) {
+void MPS::centralize_qubits(const reg_t &qubits, reg_t &centralized_qubits) {
   reg_t sorted_indices;
   find_centralized_indices(qubits, sorted_indices, centralized_qubits);
   move_qubits_to_centralized_indices(sorted_indices, centralized_qubits);
 }
 
-void MPS::find_centralized_indices(const reg_t &qubits, 
-				   reg_t &sorted_indices,
-				   reg_t &centralized_qubits) const {
+void MPS::find_centralized_indices(const reg_t &qubits, reg_t &sorted_indices,
+                                   reg_t &centralized_qubits) const {
   sorted_indices = qubits;
   uint_t num_qubits = qubits.size();
 
@@ -948,61 +936,61 @@ void MPS::find_centralized_indices(const reg_t &qubits,
   }
 
   bool ordered = true;
-  for (uint_t index=0; index < num_qubits-1; index++) {
-    if (qubits[index] > qubits[index+1]){
+  for (uint_t index = 0; index < num_qubits - 1; index++) {
+    if (qubits[index] > qubits[index + 1]) {
       ordered = false;
       break;
     }
   }
   if (!ordered)
-      sort(sorted_indices.begin(), sorted_indices.end());
+    sort(sorted_indices.begin(), sorted_indices.end());
 
   centralized_qubits = calc_new_indices(sorted_indices);
 }
 
 void MPS::move_qubits_to_centralized_indices(const reg_t &sorted_indices,
-					     const reg_t &centralized_qubits) {
-  // We wish to minimize the number of swaps. Therefore we center the 
+                                             const reg_t &centralized_qubits) {
+  // We wish to minimize the number of swaps. Therefore we center the
   // new indices around the median
-  uint_t mid_index = (centralized_qubits.size()-1)/2;
-  for(uint_t i = mid_index; i < sorted_indices.size(); i++) {
+  uint_t mid_index = (centralized_qubits.size() - 1) / 2;
+  for (uint_t i = mid_index; i < sorted_indices.size(); i++) {
     change_position(sorted_indices[i], centralized_qubits[i]);
   }
-  for(int i = mid_index-1; i >= 0; i--) {
+  for (int i = mid_index - 1; i >= 0; i--) {
     change_position(sorted_indices[i], centralized_qubits[i]);
   }
 }
 
 void MPS::move_all_qubits_to_sorted_ordering() {
   // qubit_ordering_.order_ can simply be initialized
-  for (uint_t left_index=0;  left_index<num_qubits_; left_index++) {
+  for (uint_t left_index = 0; left_index < num_qubits_; left_index++) {
     // find the qubit with the smallest index
     uint_t min_index = left_index;
-    for (uint_t i = left_index+1; i<num_qubits_ ; i++) {
+    for (uint_t i = left_index + 1; i < num_qubits_; i++) {
       if (qubit_ordering_.order_[i] == min_index) {
-	  min_index = i;
-	  break;
+        min_index = i;
+        break;
       }
     }
     // Move this qubit back to its original position
-    for (uint_t j=min_index; j>left_index; j--) {
-      //swap the qubits until smallest reaches its original position
-      apply_swap_internal(j, j-1);
+    for (uint_t j = min_index; j > left_index; j--) {
+      // swap the qubits until smallest reaches its original position
+      apply_swap_internal(j, j - 1);
     }
   }
-}  
+}
 
 void MPS::change_position(uint_t src, uint_t dst) {
-   if(src == dst)
-     return;
-   if(src < dst)
-     for(uint_t i = src; i < dst; i++) {
-       apply_swap_internal(i, i+1, false);
-     }
-   else
-     for(uint_t i = src; i > dst; i--) {
-       apply_swap_internal(i, i-1, false);
-     }
+  if (src == dst)
+    return;
+  if (src < dst)
+    for (uint_t i = src; i < dst; i++) {
+      apply_swap_internal(i, i + 1, false);
+    }
+  else
+    for (uint_t i = src; i > dst; i--) {
+      apply_swap_internal(i, i - 1, false);
+    }
 }
 
 cmatrix_t MPS::density_matrix(const reg_t &qubits) const {
@@ -1015,66 +1003,70 @@ cmatrix_t MPS::density_matrix_internal(const reg_t &qubits) const {
   temp_MPS.initialize(*this);
   MPS_Tensor psi = temp_MPS.state_vec_as_MPS(qubits);
   uint_t size = psi.get_dim();
-  cmatrix_t rho(size,size);
- 
-  // We do the reordering of qubits on a dummy vector in order to not do the reordering on psi, 
-  // since psi is a vector of matrices and this would be more costly in performance
-  reg_t ordered_vector(size), temp_vector(size), actual_vec(size); 
-  std::iota( std::begin(ordered_vector), std::end(ordered_vector), 0);
+  cmatrix_t rho(size, size);
+
+  // We do the reordering of qubits on a dummy vector in order to not do the
+  // reordering on psi, since psi is a vector of matrices and this would be more
+  // costly in performance
+  reg_t ordered_vector(size), temp_vector(size), actual_vec(size);
+  std::iota(std::begin(ordered_vector), std::end(ordered_vector), 0);
   reorder_all_qubits(ordered_vector, qubits, temp_vector);
   actual_vec = reverse_all_bits(temp_vector, qubits.size());
 
 #ifdef _WIN32
-    #pragma omp parallel for if (size > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+#pragma omp parallel for if (size > omp_threshold_ && omp_threads_ > 1)        \
+    num_threads(omp_threads_)
 #else
-    #pragma omp parallel for collapse(2) if (size > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+#pragma omp parallel for collapse(2) if (size > omp_threshold_ &&              \
+                                         omp_threads_ > 1)                     \
+    num_threads(omp_threads_)
 #endif
-  
-  for(int_t i = 0; i < static_cast<int_t>(size); i++) {
-    for(int_t j = 0; j < static_cast<int_t>(size); j++) {
-      rho(i,j) = AER::Utils::sum( AER::Utils::elementwise_multiplication(
-					psi.get_data(actual_vec[i]), 
-					AER::Utils::conjugate(psi.get_data(actual_vec[j]))) );
+
+  for (int_t i = 0; i < static_cast<int_t>(size); i++) {
+    for (int_t j = 0; j < static_cast<int_t>(size); j++) {
+      rho(i, j) = AER::Utils::sum(AER::Utils::elementwise_multiplication(
+          psi.get_data(actual_vec[i]),
+          AER::Utils::conjugate(psi.get_data(actual_vec[j]))));
     }
   }
 
   return rho;
 }
 
-rvector_t MPS::diagonal_of_density_matrix(const reg_t &qubits) const
-{
+rvector_t MPS::diagonal_of_density_matrix(const reg_t &qubits) const {
   reg_t new_qubits;
   MPS temp_MPS;
   temp_MPS.initialize(*this);
   temp_MPS.centralize_qubits(qubits, new_qubits);
 
-  MPS_Tensor psi = temp_MPS.state_vec_as_MPS(new_qubits.front(), new_qubits.back());
+  MPS_Tensor psi =
+      temp_MPS.state_vec_as_MPS(new_qubits.front(), new_qubits.back());
 
   uint_t size = psi.get_dim();
   rvector_t diagonal_rho(size);
 
-  for(int_t i = 0; i < static_cast<int_t>(size); i++) {
-    diagonal_rho[i] = real(AER::Utils::sum( AER::Utils::elementwise_multiplication(psi.get_data(i), AER::Utils::conjugate(psi.get_data(i))) ));
+  for (int_t i = 0; i < static_cast<int_t>(size); i++) {
+    diagonal_rho[i] =
+        real(AER::Utils::sum(AER::Utils::elementwise_multiplication(
+            psi.get_data(i), AER::Utils::conjugate(psi.get_data(i)))));
   }
   return diagonal_rho;
 }
 
-void MPS::MPS_with_new_indices(const reg_t &qubits, 
-			       reg_t &centralized_qubits,
-			       MPS& temp_MPS) const {
+void MPS::MPS_with_new_indices(const reg_t &qubits, reg_t &centralized_qubits,
+                               MPS &temp_MPS) const {
   temp_MPS.initialize(*this);
   temp_MPS.centralize_qubits(qubits, centralized_qubits);
 }
 
-double MPS::expectation_value(const reg_t &qubits, 
-			      const cmatrix_t &M) const {
-   reg_t internal_qubits = get_internal_qubits(qubits);
-   double expval = expectation_value_internal(internal_qubits, M);
-   return expval;
+double MPS::expectation_value(const reg_t &qubits, const cmatrix_t &M) const {
+  reg_t internal_qubits = get_internal_qubits(qubits);
+  double expval = expectation_value_internal(internal_qubits, M);
+  return expval;
 }
 
-double MPS::expectation_value_internal(const reg_t &qubits, 
-				       const cmatrix_t &M) const {
+double MPS::expectation_value_internal(const reg_t &qubits,
+                                       const cmatrix_t &M) const {
   cmatrix_t rho;
   rho = density_matrix_internal(qubits);
 
@@ -1082,95 +1074,102 @@ double MPS::expectation_value_internal(const reg_t &qubits,
   complex_t res = 0;
   for (uint_t i = 0; i < M.GetRows(); i++)
     for (uint_t j = 0; j < M.GetRows(); j++)
-      res += M(i,j)*rho(j,i);
+      res += M(i, j) * rho(j, i);
   // Trace(rho*M). not using methods for efficiency
   return real(res);
 }
 
 //---------------------------------------------------------------
 // Function: expectation_value_pauli
-// Algorithm: For more details, see "The density-matrix renormalization group in the age of matrix 
+// Algorithm: For more details, see "The density-matrix renormalization group in
+// the age of matrix
 //            product states" by Ulrich Schollwock.
-// For the illustration, assume computing the expectation 
+// For the illustration, assume computing the expectation
 // value on qubits numbered q0, q1, q2, q3. There may be additional qubits
-// before q0 or after q3 
-// Initial state: 
-//      q0     q1     q2     q3                               
-//   -a0-o--a1--o--a2--o--a3--o---  
-//       |      |      |      |  
-//   -a0-o--a1--o--a2--o--a3--o---                                     
-//                       
-//                                 
+// before q0 or after q3
+// Initial state:
+//      q0     q1     q2     q3
+//   -a0-o--a1--o--a2--o--a3--o---
+//       |      |      |      |
+//   -a0-o--a1--o--a2--o--a3--o---
+//
+//
 // We can actually think of this as       q0  q1  q2  q3
 //                                       --o---o---o---o--
 //                                      |  |   |   |   |  |
 //                                       --o---o---o---o--
-// because expectation value on the left and right are 1. 
+// because expectation value on the left and right are 1.
 
 // After Step 4:
 //       q1     q2     q3
 //     a1/o--a2--o--a3--o--
 //      o |      |      |  |
-//     a1\o--a2--o--a3--o-- 
+//     a1\o--a2--o--a3--o--
 //
 // After step 8:
 //       q1     q2     q3
 //        o--a2--o--a3--o--
 //     a1||i     |      |  |
-//        o--a2--o--a3--o-- 
+//        o--a2--o--a3--o--
 //
 // After step 9:
 //              q2     q3
 //            a2/o--a3--o--
 //             o |      |  |
-//            a2\o--a3--o-- 
+//            a2\o--a3--o--
 //---------------------------------------------------------------
 
-complex_t MPS::expectation_value_pauli(const reg_t &qubits, const std::string &matrices) const {
-    reg_t internal_qubits = get_internal_qubits(qubits);
-
-    // instead of computing the expectation value on the specified qubits, 
-    // we find the min and max of these qubits, and compute the expectation value
-    // on all the qubits in between, inserting I matrices for those qubits 
-    // that were not in the original vector "qubits".
-    // This enhancement was done for performance reasons
-    reg_t extended_qubits = internal_qubits;
-
-    const auto min = std::min_element(begin(internal_qubits), end(internal_qubits));
-    const auto max = std::max_element(begin(internal_qubits), end(internal_qubits));
-    uint_t min_qubit = *min;
-    uint_t max_qubit = *max;
-
-    // The number of qubits added  to extended_qubits
-    uint_t num_Is = 0;
-
-    // Add all the additional qubits at the end of the vector of extended_qubits
-    // The I matrices are added in expectation_value_pauli_internal, after they are reversed
-    for (uint_t i=min_qubit; i<=max_qubit; i++) {
-        auto itr = std::find(internal_qubits.begin(), internal_qubits.end(), i);
-        if (itr == internal_qubits.end()) {
-            extended_qubits.push_back(i);
-	    num_Is++;
-        }
-     }
-     
-     return expectation_value_pauli_internal(extended_qubits, matrices, min_qubit, max_qubit, num_Is);
-}
-
-complex_t MPS::expectation_value_pauli_internal(const reg_t &qubits, 
-						const std::string &matrices, 
-						uint_t first_index, uint_t last_index, 
-						uint_t num_Is) const {
-  // when computing the expectation value. We only have to sort the pauli matrices
-  // to be in the same ordering as the qubits
+complex_t MPS::expectation_value_pauli(const reg_t &qubits,
+                                       const std::string &matrices) const {
+  reg_t internal_qubits = get_internal_qubits(qubits);
+
+  // instead of computing the expectation value on the specified qubits,
+  // we find the min and max of these qubits, and compute the expectation value
+  // on all the qubits in between, inserting I matrices for those qubits
+  // that were not in the original vector "qubits".
+  // This enhancement was done for performance reasons
+  reg_t extended_qubits = internal_qubits;
+
+  const auto min =
+      std::min_element(begin(internal_qubits), end(internal_qubits));
+  const auto max =
+      std::max_element(begin(internal_qubits), end(internal_qubits));
+  uint_t min_qubit = *min;
+  uint_t max_qubit = *max;
+
+  // The number of qubits added  to extended_qubits
+  uint_t num_Is = 0;
+
+  // Add all the additional qubits at the end of the vector of extended_qubits
+  // The I matrices are added in expectation_value_pauli_internal, after they
+  // are reversed
+  for (uint_t i = min_qubit; i <= max_qubit; i++) {
+    auto itr = std::find(internal_qubits.begin(), internal_qubits.end(), i);
+    if (itr == internal_qubits.end()) {
+      extended_qubits.push_back(i);
+      num_Is++;
+    }
+  }
+
+  return expectation_value_pauli_internal(extended_qubits, matrices, min_qubit,
+                                          max_qubit, num_Is);
+}
+
+complex_t MPS::expectation_value_pauli_internal(const reg_t &qubits,
+                                                const std::string &matrices,
+                                                uint_t first_index,
+                                                uint_t last_index,
+                                                uint_t num_Is) const {
+  // when computing the expectation value. We only have to sort the pauli
+  // matrices to be in the same ordering as the qubits
 
   // Preliminary step - reverse the order of the matrices because
   // they are ordered in reverse to that of the qubits (in the interface)
   std::string reversed_matrices = matrices;
   reverse(reversed_matrices.begin(), reversed_matrices.end());
-  for (uint_t i=0; i<num_Is; i++)
+  for (uint_t i = 0; i < num_Is; i++)
     reversed_matrices.append("I");
-// sort the paulis according to the initial ordering of the qubits
+  // sort the paulis according to the initial ordering of the qubits
   auto sorted_matrices = sort_paulis_by_qubits(reversed_matrices, qubits);
 
   char gate = sorted_matrices[0];
@@ -1179,61 +1178,61 @@ complex_t MPS::expectation_value_pauli_internal(const reg_t &qubits,
   MPS_Tensor left_tensor = q_reg_[first_index];
 
   if (first_index > 0) {
-    left_tensor.mul_Gamma_by_left_Lambda(lambda_reg_[first_index-1]);
+    left_tensor.mul_Gamma_by_left_Lambda(lambda_reg_[first_index - 1]);
   }
 
   // The last gamma must be multiplied also by its right lambda.
   // Here we handle the special case that we are calculating exp val
   // on a single qubit
   // we need to mul every gamma by its right lambda
-  if (first_index==last_index && first_index < num_qubits_-1) {
+  if (first_index == last_index && first_index < num_qubits_ - 1) {
     left_tensor.mul_Gamma_by_right_Lambda(lambda_reg_[first_index]);
   }
 
   // Step 2 - prepare the dagger of left_tensor
   MPS_Tensor left_tensor_dagger(AER::Utils::dagger(left_tensor.get_data(0)),
-				AER::Utils::dagger(left_tensor.get_data(1)));
+                                AER::Utils::dagger(left_tensor.get_data(1)));
   // Step 3 - Apply the gate to q0
   left_tensor.apply_pauli(gate);
 
   // Step 4 - contract Gamma0' with Gamma0 over dimensions a0 and i
-  // Before contraction, Gamma0' has size a1 x a0 x i, Gamma0 has size i x a0 x a1
-  // result = left_contract is a matrix of size a1 x a1
+  // Before contraction, Gamma0' has size a1 x a0 x i, Gamma0 has size i x a0 x
+  // a1 result = left_contract is a matrix of size a1 x a1
   cmatrix_t final_contract;
-  MPS_Tensor::contract_2_dimensions(left_tensor_dagger, left_tensor, omp_threads_,
-				    final_contract);
-  for (uint_t qubit_num=first_index+1; qubit_num<=last_index; qubit_num++) {
+  MPS_Tensor::contract_2_dimensions(left_tensor_dagger, left_tensor,
+                                    omp_threads_, final_contract);
+  for (uint_t qubit_num = first_index + 1; qubit_num <= last_index;
+       qubit_num++) {
     // Step 5 - multiply next Gamma by its left lambda (same as Step 1)
     // next gamma has dimensions a0 x a1 x i
     MPS_Tensor next_gamma = q_reg_[qubit_num];
-    next_gamma.mul_Gamma_by_left_Lambda(lambda_reg_[qubit_num-1]);
+    next_gamma.mul_Gamma_by_left_Lambda(lambda_reg_[qubit_num - 1]);
 
     // Last qubit must be multiplied by rightmost lambda
-    if (qubit_num==last_index && qubit_num < num_qubits_-1)
+    if (qubit_num == last_index && qubit_num < num_qubits_ - 1)
       next_gamma.mul_Gamma_by_right_Lambda(lambda_reg_[qubit_num]);
 
     // Step 6 - prepare the dagger of the next gamma (same as Step 2)
     // next_gamma_dagger has dimensions a1' x a0' x i
     MPS_Tensor next_gamma_dagger(AER::Utils::dagger(next_gamma.get_data(0)),
-				 AER::Utils::dagger(next_gamma.get_data(1)));
+                                 AER::Utils::dagger(next_gamma.get_data(1)));
 
     // Step 7 - apply gate (same as Step 3)
     gate = sorted_matrices[qubit_num - first_index];
     next_gamma.apply_pauli(gate);
 
-    // Step 8 - contract final_contract from previous stage with next gamma over a1
-    // final_contract has dimensions a1 x a1, Gamma1 has dimensions a1 x a2 x i (where i=2)
-    // result is a tensor of size a1 x a2 x i
+    // Step 8 - contract final_contract from previous stage with next gamma over
+    // a1 final_contract has dimensions a1 x a1, Gamma1 has dimensions a1 x a2 x
+    // i (where i=2) result is a tensor of size a1 x a2 x i
     MPS_Tensor next_contract(final_contract * next_gamma.get_data(0),
-			     final_contract * next_gamma.get_data(1));
+                             final_contract * next_gamma.get_data(1));
 
     // Step 9 - contract next_contract (a1 x a2 x i)
     // with next_gamma_dagger (i x a2 x a1) (same as Step 4)
     // here we need to contract across two dimensions: a1 and i
     // result is a matrix of size a2 x a2
-    MPS_Tensor::contract_2_dimensions(next_gamma_dagger, next_contract, omp_threads_,
-				      final_contract);
-
+    MPS_Tensor::contract_2_dimensions(next_gamma_dagger, next_contract,
+                                      omp_threads_, final_contract);
   }
 
   // Step 10 - contract over final matrix of size aN x aN
@@ -1243,43 +1242,39 @@ complex_t MPS::expectation_value_pauli_internal(const reg_t &qubits,
   return result;
 }
 
-std::ostream& MPS::print(std::ostream& out) const {
-  for(uint_t i=0; i<num_qubits_; i++)
-    {
-      out << "Gamma [" << i << "] :" << std::endl;
-      q_reg_[i].print(out);
-      if(i < num_qubits_- 1)
-	{
-	  out << "Lambda [" << i << "] (size = " << lambda_reg_[i].size() << "):" << std::endl;
-	  out << lambda_reg_[i] << std::endl;
-	}
+std::ostream &MPS::print(std::ostream &out) const {
+  for (uint_t i = 0; i < num_qubits_; i++) {
+    out << "Gamma [" << i << "] :" << std::endl;
+    q_reg_[i].print(out);
+    if (i < num_qubits_ - 1) {
+      out << "Lambda [" << i << "] (size = " << lambda_reg_[i].size()
+          << "):" << std::endl;
+      out << lambda_reg_[i] << std::endl;
     }
+  }
   out << std::endl;
   return out;
 }
 
-std::vector<reg_t> MPS::get_matrices_sizes() const
-{
+std::vector<reg_t> MPS::get_matrices_sizes() const {
   std::vector<reg_t> result;
-  for(uint_t i=0; i<num_qubits_; i++)
-    {
-      result.push_back(q_reg_[i].get_size());
-    }
+  for (uint_t i = 0; i < num_qubits_; i++) {
+    result.push_back(q_reg_[i].get_size());
+  }
   return result;
 }
 
 reg_t MPS::get_bond_dimensions() const {
   reg_t result;
-  for(uint_t i=0; i<num_qubits_-1; i++)
-    {
-      result.push_back(lambda_reg_[i].size());
-    }
+  for (uint_t i = 0; i < num_qubits_ - 1; i++) {
+    result.push_back(lambda_reg_[i].size());
+  }
   return result;
 }
 
 uint_t MPS::get_max_bond_dimensions() const {
   uint_t max = 0;
-  for (uint_t i=0; i<num_qubits_-1; i++) {
+  for (uint_t i = 0; i < num_qubits_ - 1; i++) {
     if (lambda_reg_[i].size() > max)
       max = lambda_reg_[i].size();
   }
@@ -1292,31 +1287,30 @@ MPS_Tensor MPS::state_vec_as_MPS(const reg_t &qubits) {
   return state_vec_as_MPS(new_qubits.front(), new_qubits.back());
 }
 
-MPS_Tensor MPS::state_vec_as_MPS(uint_t first_index, uint_t last_index) const
-{
-	MPS_Tensor temp = q_reg_[first_index];
+MPS_Tensor MPS::state_vec_as_MPS(uint_t first_index, uint_t last_index) const {
+  MPS_Tensor temp = q_reg_[first_index];
 
-	if (first_index != 0)
-	  temp.mul_Gamma_by_left_Lambda(lambda_reg_[first_index-1]);
+  if (first_index != 0)
+    temp.mul_Gamma_by_left_Lambda(lambda_reg_[first_index - 1]);
 
-	// special case of a single qubit
-	if ((first_index == last_index) && (last_index != num_qubits_-1)) {
-	  temp.mul_Gamma_by_right_Lambda(lambda_reg_[last_index]);
-	  return temp;
-	}
-	  
-	for(uint_t i = first_index+1; i < last_index+1; i++) {
-	  temp = MPS_Tensor::contract(temp, lambda_reg_[i-1], q_reg_[i]);
-	}
-	// now temp is a tensor of 2^n matrices
-	if (last_index != num_qubits_-1)
-	  temp.mul_Gamma_by_right_Lambda(lambda_reg_[last_index]);
-	return temp;
+  // special case of a single qubit
+  if ((first_index == last_index) && (last_index != num_qubits_ - 1)) {
+    temp.mul_Gamma_by_right_Lambda(lambda_reg_[last_index]);
+    return temp;
+  }
+
+  for (uint_t i = first_index + 1; i < last_index + 1; i++) {
+    temp = MPS_Tensor::contract(temp, lambda_reg_[i - 1], q_reg_[i]);
+  }
+  // now temp is a tensor of 2^n matrices
+  if (last_index != num_qubits_ - 1)
+    temp.mul_Gamma_by_right_Lambda(lambda_reg_[last_index]);
+  return temp;
 }
 
 Vector<complex_t> MPS::full_statevector() {
   reg_t qubits(num_qubits_);
-  std::iota( std::begin(qubits), std::end(qubits), 0);
+  std::iota(std::begin(qubits), std::end(qubits), 0);
   reg_t internal_qubits = get_internal_qubits(qubits);
   return full_state_vector_internal(internal_qubits);
 }
@@ -1326,15 +1320,17 @@ Vector<complex_t> MPS::full_state_vector_internal(const reg_t &qubits) {
   MPS_Tensor mps_vec = state_vec_as_MPS(qubits);
 
   uint_t num_qubits = qubits.size();
-  uint_t length = 1ULL << num_qubits;   // length = pow(2, num_qubits)
+  uint_t length = 1ULL << num_qubits; // length = pow(2, num_qubits)
   Vector<complex_t> statevector(length, false);
   // statevector is constructed in ascending order
-#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
   for (int_t i = 0; i < static_cast<int_t>(length); i++) {
-    statevector[i] = mps_vec.get_data(i)(0,0);
+    statevector[i] = mps_vec.get_data(i)(0, 0);
   }
   Vector<complex_t> temp_statevector(length, false);
-  //temp_statevector will contain the statevector in the ordering defined in "qubits"
+  // temp_statevector will contain the statevector in the ordering defined in
+  // "qubits"
   reorder_all_qubits(statevector, qubits, temp_statevector);
   // reverse to be consistent with qasm ordering
   return reverse_all_bits(temp_statevector, num_qubits);
@@ -1345,11 +1341,13 @@ Vector<complex_t> MPS::get_amplitude_vector(const reg_t &base_values) {
   std::string base_value;
   Vector<complex_t> amplitude_vector(num_values, false);
 
-  #pragma omp parallel for if (num_values > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
-  for (int_t i=0; i<static_cast<int_t>(num_values); i++) {
+#pragma omp parallel for if (num_values > omp_threshold_ && omp_threads_ > 1)  \
+    num_threads(omp_threads_)
+  for (int_t i = 0; i < static_cast<int_t>(num_values); i++) {
     // Since the qubits may not be ordered, we determine the actual index
     // by the internal order of the qubits, to obtain the actual_base_value
-    uint_t actual_base_value = reorder_qubits(qubit_ordering_.order_, base_values[i]);
+    uint_t actual_base_value =
+        reorder_qubits(qubit_ordering_.order_, base_values[i]);
     base_value = AER::Utils::int2string(actual_base_value);
     amplitude_vector[i] = get_single_amplitude(base_value);
   }
@@ -1357,180 +1355,179 @@ Vector<complex_t> MPS::get_amplitude_vector(const reg_t &base_values) {
 }
 
 complex_t MPS::get_single_amplitude(const std::string &base_value) {
-  // We take the bits of the base value from right to left in order not to expand the 
-  // base values to the full width of 2^n
-  // We contract from left to right because the representation in Qiskit is from left 
-  // to right, i.e., 1=1000, 2=0100, ...
+  // We take the bits of the base value from right to left in order not to
+  // expand the base values to the full width of 2^n We contract from left to
+  // right because the representation in Qiskit is from left to right, i.e.,
+  // 1=1000, 2=0100, ...
 
-  int_t pos = base_value.length()-1;
-  uint_t bit = base_value[pos]=='0' ? 0 : 1;
+  int_t pos = base_value.length() - 1;
+  uint_t bit = base_value[pos] == '0' ? 0 : 1;
   pos--;
   cmatrix_t temp = q_reg_[0].get_data(bit);
 
-  for (uint_t qubit=0; qubit<num_qubits_-1; qubit++) {
-    if (pos >=0)
-      bit = base_value[pos]=='0' ? 0 : 1;
+  for (uint_t qubit = 0; qubit < num_qubits_ - 1; qubit++) {
+    if (pos >= 0)
+      bit = base_value[pos] == '0' ? 0 : 1;
     else
       bit = 0;
-    for (uint_t row=0; row<temp.GetRows(); row++){
-      for (uint_t col=0; col<temp.GetColumns(); col++){
-	temp(row, col) *= lambda_reg_[qubit][col];
+    for (uint_t row = 0; row < temp.GetRows(); row++) {
+      for (uint_t col = 0; col < temp.GetColumns(); col++) {
+        temp(row, col) *= lambda_reg_[qubit][col];
       }
     }
-    temp = temp * q_reg_[qubit+1].get_data(bit);
+    temp = temp * q_reg_[qubit + 1].get_data(bit);
     pos--;
   }
-  
+
   return temp(0, 0);
 }
 
-void MPS::get_probabilities_vector(rvector_t& probvector, const reg_t &qubits) const {
+void MPS::get_probabilities_vector(rvector_t &probvector,
+                                   const reg_t &qubits) const {
   reg_t internal_qubits = get_internal_qubits(qubits);
   get_probabilities_vector_internal(probvector, internal_qubits);
 }
 
-void MPS::get_probabilities_vector_internal(rvector_t& probvector, 
-					    const reg_t &qubits) const
-{
+void MPS::get_probabilities_vector_internal(rvector_t &probvector,
+                                            const reg_t &qubits) const {
   cvector_t state_vec;
   uint_t num_qubits = qubits.size();
-  uint_t size = 1ULL << num_qubits;   // length = pow(2, num_qubits)
+  uint_t size = 1ULL << num_qubits; // length = pow(2, num_qubits)
   probvector.resize(size);
 
   // compute the probability vector assuming the qubits are in ascending order
   rvector_t ordered_probvector = diagonal_of_density_matrix(qubits);
 
   // reorder the probabilities according to the specification in 'qubits'
-  rvector_t temp_probvector(size); 
+  rvector_t temp_probvector(size);
   reorder_all_qubits(ordered_probvector, qubits, temp_probvector);
 
   // reverse to be consistent with qasm ordering
   probvector = reverse_all_bits(temp_probvector, num_qubits);
 }
 
-double MPS::get_prob_single_qubit_internal(uint_t qubit, 
-					   uint_t outcome,
-					   cmatrix_t &mat) const {
+double MPS::get_prob_single_qubit_internal(uint_t qubit, uint_t outcome,
+                                           cmatrix_t &mat) const {
   mat = q_reg_[qubit].get_data(outcome);
   if (qubit > 0) {
     // Multiply mat by left lambda
-    for (uint_t col=0; col<mat.GetColumns(); col++)
-	for (uint_t row=0; row<mat.GetRows(); row++)
-	  mat(row, col) *= lambda_reg_[qubit-1][row];
+    for (uint_t col = 0; col < mat.GetColumns(); col++)
+      for (uint_t row = 0; row < mat.GetRows(); row++)
+        mat(row, col) *= lambda_reg_[qubit - 1][row];
   }
-  if (qubit < num_qubits_-1) {
+  if (qubit < num_qubits_ - 1) {
     // Multiply mat by right lambda
-    for (uint_t row=0; row<mat.GetRows(); row++)
-      for (uint_t col=0; col<mat.GetColumns(); col++)
-	mat(row, col) *= lambda_reg_[qubit][col];
+    for (uint_t row = 0; row < mat.GetRows(); row++)
+      for (uint_t col = 0; col < mat.GetColumns(); col++)
+        mat(row, col) *= lambda_reg_[qubit][col];
   }
-  double prob = 
-    real(AER::Utils::sum( AER::Utils::elementwise_multiplication(mat, AER::Utils::conjugate(mat)) ));
+  double prob = real(AER::Utils::sum(
+      AER::Utils::elementwise_multiplication(mat, AER::Utils::conjugate(mat))));
   return prob;
 }
 
-void MPS::get_accumulated_probabilities_vector(rvector_t& acc_probvector, 
-					       reg_t& index_vec,
-					       const reg_t &qubits) const
-{
+void MPS::get_accumulated_probabilities_vector(rvector_t &acc_probvector,
+                                               reg_t &index_vec,
+                                               const reg_t &qubits) const {
   rvector_t probvector;
   get_probabilities_vector(probvector, qubits);
   uint_t size = probvector.size();
   uint_t j = 1;
   acc_probvector.push_back(0.0);
-  for (uint_t i=0; i<size; i++) {
+  for (uint_t i = 0; i < size; i++) {
     if (!Linalg::almost_equal(probvector[i], 0.0)) {
       index_vec.push_back(i);
-      acc_probvector.push_back(acc_probvector[j-1] + probvector[i]);
+      acc_probvector.push_back(acc_probvector[j - 1] + probvector[i]);
       j++;
     }
   }
 }
 
-uint_t binary_search(const rvector_t &acc_probvector, 
-		     uint_t start, uint_t end, 
-		     double rnd) {
-  if (start >= end-1) {
+uint_t binary_search(const rvector_t &acc_probvector, uint_t start, uint_t end,
+                     double rnd) {
+  if (start >= end - 1) {
     return start;
   }
-  uint_t mid = (start+end)/2;
+  uint_t mid = (start + end) / 2;
   if (rnd <= acc_probvector[mid])
     return binary_search(acc_probvector, start, mid, rnd);
-  else 
+  else
     return binary_search(acc_probvector, mid, end, rnd);
 }
 
 double MPS::norm() const {
-    reg_t qubits(num_qubits_);
-    return norm(qubits);
+  reg_t qubits(num_qubits_);
+  return norm(qubits);
 }
 
 double MPS::norm(const reg_t &qubits) const {
   reg_t temp_qubits = qubits;
-    std::iota( std::begin(temp_qubits), std::end(temp_qubits), 0);
-    double trace = 0;
-    MPS temp_MPS;
-    temp_MPS.initialize(*this);
-    rvector_t vec = temp_MPS.diagonal_of_density_matrix(temp_qubits);
-    for (uint_t i=0; i<vec.size(); i++)
-      trace += vec[i];
-    return trace;
+  std::iota(std::begin(temp_qubits), std::end(temp_qubits), 0);
+  double trace = 0;
+  MPS temp_MPS;
+  temp_MPS.initialize(*this);
+  rvector_t vec = temp_MPS.diagonal_of_density_matrix(temp_qubits);
+  for (uint_t i = 0; i < vec.size(); i++)
+    trace += vec[i];
+  return trace;
 }
 
 double MPS::norm(const reg_t &qubits, const cvector_t &vmat) const {
-    return norm(qubits, AER::Utils::devectorize_matrix(vmat));
+  return norm(qubits, AER::Utils::devectorize_matrix(vmat));
 }
 
 double MPS::norm(const reg_t &qubits, const cmatrix_t &mat) const {
-    cmatrix_t norm_mat = AER::Utils::dagger(mat) * mat;
-    return expectation_value(qubits, norm_mat);
+  cmatrix_t norm_mat = AER::Utils::dagger(mat) * mat;
+  return expectation_value(qubits, norm_mat);
 }
 
 reg_t MPS::apply_measure(const reg_t &qubits, const rvector_t &rnds) {
-  // since input is always sorted in qasm_controller, therefore, we must return the qubits 
-  // to their original location (sorted)
+  // since input is always sorted in qasm_controller, therefore, we must return
+  // the qubits to their original location (sorted)
   move_all_qubits_to_sorted_ordering();
   return apply_measure_internal(qubits, rnds);
 }
 
-// The caller to apply_measure_internal is responsible to call 
+// The caller to apply_measure_internal is responsible to call
 // move_all_qubits_to_sorted_ordering before calling this function
-reg_t MPS::apply_measure_internal(const reg_t &sorted_qubits, const rvector_t &rands) {
+reg_t MPS::apply_measure_internal(const reg_t &sorted_qubits,
+                                  const rvector_t &rands) {
   // For every qubit, q,  that is measured, we must propagate the effect of its
-  // measurement to its neigbors, l and r, and then to their neighbors, and 
+  // measurement to its neigbors, l and r, and then to their neighbors, and
   // so on. If r (or l) is measured next, then there is no need to propagate to
-  // its next neighbor because we can propagate the effects of measuring q 
+  // its next neighbor because we can propagate the effects of measuring q
   // and r together.
-  // We sort 'qubits' at the beginning of the algorithm, so that the index of 
-  // the next measured qubit will always be r, or greater. Therefore we check 
-  // if r needs to be measured. If so, we simply measure it. If not, we 
-  // propagate the effect of measuring q all the way to the right, until 
+  // We sort 'qubits' at the beginning of the algorithm, so that the index of
+  // the next measured qubit will always be r, or greater. Therefore we check
+  // if r needs to be measured. If so, we simply measure it. If not, we
+  // propagate the effect of measuring q all the way to the right, until
   // we reach a qubit that should be measured. Then we measure that qubit
   // and continue the propagation to the right.
-  // In both cases, we propagate the effect all the way to the left, because 
+  // In both cases, we propagate the effect all the way to the left, because
   // no more qubits will be measured on the left
   reg_t qubits_to_update;
   uint_t size = sorted_qubits.size();
   reg_t outcome_vector(size);
 
-  uint_t next_measured_qubit = num_qubits_-1;
-  for (uint_t i=0; i<size; i++) {
-    if (i < size-1) {
-      next_measured_qubit = sorted_qubits[i+1];
+  uint_t next_measured_qubit = num_qubits_ - 1;
+  for (uint_t i = 0; i < size; i++) {
+    if (i < size - 1) {
+      next_measured_qubit = sorted_qubits[i + 1];
     } else {
-      next_measured_qubit = num_qubits_-1;
+      next_measured_qubit = num_qubits_ - 1;
     }
 
-    // The following line is correct because the qubits were sorted in apply_measure.
-    // If the sort is cancelled, for the case of measure_all, we must measure
-    // in the order in which the qubits are organized
-    outcome_vector[i] = apply_measure_internal_single_qubit(sorted_qubits[i], rands[i], next_measured_qubit);
+    // The following line is correct because the qubits were sorted in
+    // apply_measure. If the sort is cancelled, for the case of measure_all, we
+    // must measure in the order in which the qubits are organized
+    outcome_vector[i] = apply_measure_internal_single_qubit(
+        sorted_qubits[i], rands[i], next_measured_qubit);
   }
   return outcome_vector;
 }
 
 uint_t MPS::apply_measure_internal_single_qubit(uint_t qubit, const double rnd,
-						uint_t next_measured_qubit) {
+                                                uint_t next_measured_qubit) {
   reg_t qubits_to_update;
   qubits_to_update.push_back(qubit);
   cmatrix_t dummy_mat;
@@ -1539,7 +1536,7 @@ uint_t MPS::apply_measure_internal_single_qubit(uint_t qubit, const double rnd,
   double prob1 = 1 - prob0;
   uint_t measurement;
   cmatrix_t measurement_matrix(2, 2);
-  
+
   if (rnd < prob0) {
     measurement = 0;
     measurement_matrix = zero_measure;
@@ -1558,32 +1555,35 @@ uint_t MPS::apply_measure_internal_single_qubit(uint_t qubit, const double rnd,
 }
 
 void MPS::propagate_to_neighbors_internal(uint_t min_qubit, uint_t max_qubit,
-					  uint_t next_measured_qubit) {
+                                          uint_t next_measured_qubit) {
   // propagate the changes to all qubits to the right
-  for (uint_t i=max_qubit; i<next_measured_qubit; i++) {
-    if (lambda_reg_[i].size() == 1) 
-      break;   // no need to propagate if no entanglement
-    apply_2_qubit_gate(i, i+1, id, cmatrix_t(1, 1));
+  for (uint_t i = max_qubit; i < next_measured_qubit; i++) {
+    if (lambda_reg_[i].size() == 1)
+      break; // no need to propagate if no entanglement
+    apply_2_qubit_gate(i, i + 1, id, cmatrix_t(1, 1));
   }
- // propagate the changes to all qubits to the left
-  for (int_t i=min_qubit; i>0; i--) {
-    if (lambda_reg_[i-1].size() == 1) 
-      break;   // no need to propagate if no entanglement
-    apply_2_qubit_gate(i-1, i, id, cmatrix_t(1, 1));
+  // propagate the changes to all qubits to the left
+  for (int_t i = min_qubit; i > 0; i--) {
+    if (lambda_reg_[i - 1].size() == 1)
+      break; // no need to propagate if no entanglement
+    apply_2_qubit_gate(i - 1, i, id, cmatrix_t(1, 1));
   }
 }
 
 // The algorithm implemented here is based on https://arxiv.org/abs/1709.01662.
-// Given a particular base value, e.g., 11010, its probability is computed by contracting
-// the suitable matrices per qubit (from right to left), i.e., mat(0) for qubit 0, mat(1) 
-// for qubit 1, mat(0) for qubit 2, mat(1) for qubit 3, mat(1) for qubit 4.
-// We build the randomly selected base value for every shot as follows:
-// For the first qubit, compute its probability for 0 and then randomly select 
+// Given a particular base value, e.g., 11010, its probability is computed by
+// contracting the suitable matrices per qubit (from right to left), i.e.,
+// mat(0) for qubit 0, mat(1) for qubit 1, mat(0) for qubit 2, mat(1) for qubit
+// 3, mat(1) for qubit 4. We build the randomly selected base value for every
+// shot as follows: For the first qubit, compute its probability for 0 and then
+// randomly select
 //        the measurement. 'mat' is initialized to the suitable matrix (0 or 1).
-// For qubit i, we store in 'mat' the contraction of the matrices that were selected up to i-1.
-//        We compute the probability that qubit i is 0 by contracting with matrix 0. 
-//        We randomly select a measurement according to this probability. We then update 'mat' 
-//        by contracting it with the suitable matrix (0 or 1).
+// For qubit i, we store in 'mat' the contraction of the matrices that were
+// selected up to i-1.
+//        We compute the probability that qubit i is 0 by contracting with
+//        matrix 0. We randomly select a measurement according to this
+//        probability. We then update 'mat' by contracting it with the suitable
+//        matrix (0 or 1).
 
 reg_t MPS::sample_measure(uint_t shots, RngEngine &rng) const {
   double prob = 1;
@@ -1592,36 +1592,36 @@ reg_t MPS::sample_measure(uint_t shots, RngEngine &rng) const {
   cmatrix_t mat;
   rvector_t rnds(num_qubits_);
   for (uint_t i = 0; i < num_qubits_; ++i) {
-      rnds[i] = rng.rand(0., 1.);
+    rnds[i] = rng.rand(0., 1.);
   }
-  for (uint_t i=0; i<num_qubits_; i++) {
+  for (uint_t i = 0; i < num_qubits_; i++) {
     current_measure[i] = sample_measure_single_qubit(i, prob, rnds[i], mat);
   }
   // Rearrange internal ordering of the qubits to sorted ordering
   reg_t ordered_outcome(num_qubits_);
-  for (uint_t i=0; i<num_qubits_; i++) {
+  for (uint_t i = 0; i < num_qubits_; i++) {
     ordered_outcome[qubit_ordering_.order_[i]] = current_measure[i];
   }
   return ordered_outcome;
 }
 
-uint_t MPS::sample_measure_single_qubit(uint_t qubit,
-					double &prob, double rnd,
-					cmatrix_t &mat) const {
+uint_t MPS::sample_measure_single_qubit(uint_t qubit, double &prob, double rnd,
+                                        cmatrix_t &mat) const {
   double prob0 = 0;
   if (qubit == 0) {
     reg_t qubits_to_update;
     qubits_to_update.push_back(qubit);
     // step 1 - measure qubit in Z basis
-    double exp_val = real(expectation_value_pauli_internal(qubits_to_update, "Z", qubit, qubit, 0));
+    double exp_val = real(expectation_value_pauli_internal(
+        qubits_to_update, "Z", qubit, qubit, 0));
     // step 2 - compute probability for 0 or 1 result
-    prob0 = (1 + exp_val ) / 2;
+    prob0 = (1 + exp_val) / 2;
   } else {
     prob0 = get_single_probability0(qubit, mat);
     prob0 /= prob;
   }
   uint_t measurement = (rnd < prob0) ? 0 : 1;
-  double new_prob = (measurement == 0) ? prob0 : 1-prob0;
+  double new_prob = (measurement == 0) ? prob0 : 1 - prob0;
   prob *= new_prob;
 
   // Now update mat for the next qubit
@@ -1629,17 +1629,17 @@ uint_t MPS::sample_measure_single_qubit(uint_t qubit,
   // measurement outcome
   if (qubit == 0) {
     mat = q_reg_[qubit].get_data(measurement);
-    if (qubit != 0)  // multiply mat by left lambda
-      for (uint_t col=0; col<mat.GetColumns(); col++)
-	for (uint_t row=0; row<mat.GetRows(); row++)
-	  mat(row, col) *= lambda_reg_[qubit-1][row];
+    if (qubit != 0) // multiply mat by left lambda
+      for (uint_t col = 0; col < mat.GetColumns(); col++)
+        for (uint_t row = 0; row < mat.GetRows(); row++)
+          mat(row, col) *= lambda_reg_[qubit - 1][row];
   } else {
     mat = mat * q_reg_[qubit].get_data(measurement);
   }
-  if (qubit != num_qubits_-1) {  // multiply mat by right lambda
-    for (uint_t row=0; row<mat.GetRows(); row++)
-      for (uint_t col=0; col<mat.GetColumns(); col++)
-	mat(row, col) *= lambda_reg_[qubit][col];
+  if (qubit != num_qubits_ - 1) { // multiply mat by right lambda
+    for (uint_t row = 0; row < mat.GetRows(); row++)
+      for (uint_t col = 0; col < mat.GetColumns(); col++)
+        mat(row, col) *= lambda_reg_[qubit][col];
   }
   return measurement;
 }
@@ -1648,49 +1648,53 @@ double MPS::get_single_probability0(uint_t qubit, const cmatrix_t &mat) const {
   // multiply by the matrix for measurement of 0
   cmatrix_t temp_mat = mat * q_reg_[qubit].get_data(0);
 
-  if (qubit != num_qubits_-1) {
-    for (uint_t row=0; row<temp_mat.GetRows(); row++) {
-      for (uint_t col=0; col<temp_mat.GetColumns(); col++) {
-	temp_mat(row, col) *= lambda_reg_[qubit][col];
+  if (qubit != num_qubits_ - 1) {
+    for (uint_t row = 0; row < temp_mat.GetRows(); row++) {
+      for (uint_t col = 0; col < temp_mat.GetColumns(); col++) {
+        temp_mat(row, col) *= lambda_reg_[qubit][col];
       }
     }
   }
-  //prob0 = the probability to measure 0
-  double prob0 = real(AER::Utils::sum( AER::Utils::elementwise_multiplication(temp_mat, AER::Utils::conjugate(temp_mat))));
+  // prob0 = the probability to measure 0
+  double prob0 = real(AER::Utils::sum(AER::Utils::elementwise_multiplication(
+      temp_mat, AER::Utils::conjugate(temp_mat))));
   return prob0;
 }
 
-void MPS::apply_initialize(const reg_t &qubits, 
-			   const cvector_t &statevector,
-			   RngEngine &rng) {
+void MPS::apply_initialize(const reg_t &qubits, const cvector_t &statevector,
+                           RngEngine &rng) {
   uint_t num_qubits = qubits.size();
   reg_t internal_qubits = get_internal_qubits(qubits);
   uint_t num_amplitudes = statevector.size();
   cvector_t reordered_statevector(num_amplitudes);
   reg_t output_qubits(num_qubits);
 
- // We reorder the statevector since initialize_from_statevector_internal assumes order 3,2,1,0
-  for (uint_t i=0; i<num_qubits; i++)
-    output_qubits[i] = num_qubits-1-i;
-  permute_all_qubits(statevector, internal_qubits, output_qubits, reordered_statevector);
+  // We reorder the statevector since initialize_from_statevector_internal
+  // assumes order 3,2,1,0
+  for (uint_t i = 0; i < num_qubits; i++)
+    output_qubits[i] = num_qubits - 1 - i;
+  permute_all_qubits(statevector, internal_qubits, output_qubits,
+                     reordered_statevector);
 
   if (num_qubits == num_qubits_)
-    initialize_from_statevector_internal(internal_qubits, reordered_statevector);
+    initialize_from_statevector_internal(internal_qubits,
+                                         reordered_statevector);
   else
-    initialize_component_internal(internal_qubits, reordered_statevector, rng);  
+    initialize_component_internal(internal_qubits, reordered_statevector, rng);
 }
 
-
-void MPS::initialize_from_statevector_internal(const reg_t &qubits, 
-					       const cvector_t &statevector) {
+void MPS::initialize_from_statevector_internal(const reg_t &qubits,
+                                               const cvector_t &statevector) {
   uint_t num_qubits = qubits.size();
   cmatrix_t statevector_as_matrix(1, statevector.size());
 
-#pragma omp parallel for if (num_qubits_ > MPS::get_omp_threshold() && MPS::get_omp_threads() > 1) num_threads(MPS::get_omp_threads()) 
-  for (int_t i=0; i<static_cast<int_t>(statevector.size()); i++) {
+#pragma omp parallel for if (num_qubits_ > MPS::get_omp_threshold() &&         \
+                             MPS::get_omp_threads() > 1)                       \
+    num_threads(MPS::get_omp_threads())
+  for (int_t i = 0; i < static_cast<int_t>(statevector.size()); i++) {
     statevector_as_matrix(0, i) = statevector[i];
   }
-  if ((1ULL << num_qubits)  != statevector.size()) {
+  if ((1ULL << num_qubits) != statevector.size()) {
     std::stringstream ss;
     ss << "error: length of statevector should be 2^num_qubits";
     throw std::runtime_error(ss.str());
@@ -1708,31 +1712,32 @@ void MPS::initialize_from_matrix(uint_t num_qubits, const cmatrix_t &mat) {
   std::iota(qubit_ordering_.order_.begin(), qubit_ordering_.order_.end(), 0);
   qubit_ordering_.location_.clear();
   qubit_ordering_.location_.resize(num_qubits);
-  std::iota(qubit_ordering_.location_.begin(), qubit_ordering_.location_.end(), 0);
+  std::iota(qubit_ordering_.location_.begin(), qubit_ordering_.location_.end(),
+            0);
   num_qubits_ = 0;
 
   if (num_qubits == 1) {
     num_qubits_ = 1;
-    complex_t a = mat(0,0);
-    complex_t b = mat(0,1);
+    complex_t a = mat(0, 0);
+    complex_t b = mat(0, 1);
     q_reg_.push_back(MPS_Tensor(a, b));
     return;
   }
 
   // remaining_matrix is the matrix that remains after each iteration
   // It is initialized to the input statevector after reshaping
-  cmatrix_t remaining_matrix, reshaped_matrix; 
+  cmatrix_t remaining_matrix, reshaped_matrix;
   cmatrix_t U, V;
   rvector_t S(1.0);
   bool first_iter = true;
-  for (uint_t i=0; i<num_qubits-1; i++) {
+  for (uint_t i = 0; i < num_qubits - 1; i++) {
     // step 1 - prepare matrix for next iteration (except for first iteration):
-    //    (i) mul remaining matrix by left lambda 
+    //    (i) mul remaining matrix by left lambda
     //    (ii) dagger and reshape
     if (first_iter) {
       remaining_matrix = mat;
     } else {
-      cmatrix_t temp = mul_matrix_by_lambda(V, S); 
+      cmatrix_t temp = mul_matrix_by_lambda(V, S);
       remaining_matrix = AER::Utils::dagger(temp);
     }
     reshaped_matrix = reshape_matrix(remaining_matrix);
@@ -1740,16 +1745,15 @@ void MPS::initialize_from_matrix(uint_t num_qubits, const cmatrix_t &mat) {
     S.clear();
     S.resize(std::min(reshaped_matrix.GetRows(), reshaped_matrix.GetColumns()));
     csvd_wrapper(reshaped_matrix, U, S, V);
-    reduce_zeros(U, S, V, 
-		 MPS_Tensor::get_max_bond_dimension(), 
-		 MPS_Tensor::get_truncation_threshold() );
+    reduce_zeros(U, S, V, MPS_Tensor::get_max_bond_dimension(),
+                 MPS_Tensor::get_truncation_threshold());
 
     // step 3 - update q_reg_ with new gamma and new lambda
     //          increment number of qubits in the MPS structure
     std::vector<cmatrix_t> left_data = reshape_U_after_SVD(U);
-    MPS_Tensor left_gamma(left_data[0], left_data[1]); 
+    MPS_Tensor left_gamma(left_data[0], left_data[1]);
     if (!first_iter)
-      left_gamma.div_Gamma_by_left_Lambda(lambda_reg_.back()); 
+      left_gamma.div_Gamma_by_left_Lambda(lambda_reg_.back());
 
     q_reg_.push_back(left_gamma);
     lambda_reg_.push_back(S);
@@ -1759,12 +1763,12 @@ void MPS::initialize_from_matrix(uint_t num_qubits, const cmatrix_t &mat) {
   }
   // step 4 - create the rightmost gamma and update q_reg_
   std::vector<cmatrix_t> right_data = reshape_V_after_SVD(V);
-  
-  MPS_Tensor right_gamma(right_data[0], right_data[1]) ;
+
+  MPS_Tensor right_gamma(right_data[0], right_data[1]);
   q_reg_.push_back(right_gamma);
   num_qubits_++;
 }
- 
+
 //--------------------------------------------------
 // Algorithm for initialize_component:
 // 1. Centralize 'qubits'
@@ -1772,14 +1776,15 @@ void MPS::initialize_from_matrix(uint_t num_qubits, const cmatrix_t &mat) {
 // 3. Normalize the values in 'statevector' to the norm computed in (3)
 // 4. Create a new MPS consisting of 'qubits'
 // 5. Initialize it to 'statevector'
-// 6. Reset 'qubits' in *this (the original MPS) - note that this stage may affect 
+// 6. Reset 'qubits' in *this (the original MPS) - note that this stage may
+// affect
 //    qubits that are not in 'qubits', if they are entangled with 'qubits'.
 // 7. Cut out the old section of 'qubits' in the original MPS
 // 8. Stick the new section of 'qubits' in the original MPS
 //---------------------------------------------------
-void MPS::initialize_component_internal(const reg_t &qubits, 
-					const cvector_t &statevector,
-					 RngEngine &rng) {
+void MPS::initialize_component_internal(const reg_t &qubits,
+                                        const cvector_t &statevector,
+                                        RngEngine &rng) {
   uint_t num_qubits = qubits.size();
   uint_t num_amplitudes = statevector.size();
   reg_t new_qubits(num_qubits);
@@ -1791,17 +1796,17 @@ void MPS::initialize_component_internal(const reg_t &qubits,
   double qubits_norm = norm(new_qubits);
 
   cmatrix_t mat(1, num_amplitudes);
-  for (uint_t i=0; i<num_amplitudes; i++) {
-    complex_t normalized_i = statevector[i]/qubits_norm;
-    mat(0, i) = normalized_i;   
+  for (uint_t i = 0; i < num_amplitudes; i++) {
+    complex_t normalized_i = statevector[i] / qubits_norm;
+    mat(0, i) = normalized_i;
   }
   // Note that new_qubits are sorted by default, since they are new qubits
   // Therefore we don't need to sort before reset_internal
   reset_internal(new_qubits, rng);
   MPS qubits_mps;
   qubits_mps.initialize_from_matrix(num_qubits, mat);
-  for (uint_t i=first; i<=last; i++) {
-    q_reg_[i] = qubits_mps.q_reg_[i-first];
+  for (uint_t i = first; i <= last; i++) {
+    q_reg_[i] = qubits_mps.q_reg_[i - first];
   }
 }
 
@@ -1824,14 +1829,14 @@ void MPS::reset_internal(const reg_t &qubits, RngEngine &rng) {
 
   // note that qubits should be sorted by the caller to this method
   // Simulate unobserved measurement
-  reg_t outcome_vector =  apply_measure_internal(qubits, rands);
+  reg_t outcome_vector = apply_measure_internal(qubits, rands);
   // Apply update to reset state
   measure_reset_update_internal(qubits, outcome_vector);
 }
 
 void MPS::measure_reset_update_internal(const reg_t &qubits,
-					const reg_t &meas_state) {
-  for (uint_t i=0; i<qubits.size(); i++) {
+                                        const reg_t &meas_state) {
+  for (uint_t i = 0; i < qubits.size(); i++) {
     if (meas_state[i] != 0) {
       q_reg_[qubits[i]].apply_x();
     }
@@ -1841,11 +1846,11 @@ void MPS::measure_reset_update_internal(const reg_t &qubits,
 mps_container_t MPS::copy_to_mps_container() {
   move_all_qubits_to_sorted_ordering();
   mps_container_t ret;
-  for (uint_t i=0; i<num_qubits(); i++) {
-    ret.first.push_back(std::make_pair(q_reg_[i].get_data(0),
-                                       q_reg_[i].get_data(1)));
+  for (uint_t i = 0; i < num_qubits(); i++) {
+    ret.first.push_back(
+        std::make_pair(q_reg_[i].get_data(0), q_reg_[i].get_data(1)));
   }
-  for (uint_t i=0; i<num_qubits()-1; i++) {
+  for (uint_t i = 0; i < num_qubits() - 1; i++) {
     ret.second.push_back(lambda_reg_[i]);
   }
   return ret;
@@ -1854,12 +1859,12 @@ mps_container_t MPS::copy_to_mps_container() {
 mps_container_t MPS::move_to_mps_container() {
   move_all_qubits_to_sorted_ordering();
   mps_container_t ret;
-  for (uint_t i=0; i<num_qubits(); i++) {
+  for (uint_t i = 0; i < num_qubits(); i++) {
     ret.first.push_back(std::make_pair(std::move(q_reg_[i].get_data(0)),
                                        std::move(q_reg_[i].get_data(1))));
   }
   std::vector<std::vector<double>> lambda_vec;
-  for (uint_t i=0; i<num_qubits()-1; i++) {
+  for (uint_t i = 0; i < num_qubits() - 1; i++) {
     ret.second.push_back(std::move(lambda_reg_[i]));
   }
   initialize(MPS());
@@ -1873,27 +1878,28 @@ void MPS::initialize_from_mps(const mps_container_t &mps) {
   q_reg_.clear();
   lambda_reg_.clear();
   q_reg_.resize(num_qubits);
-  lambda_reg_.resize(num_qubits-1);
+  lambda_reg_.resize(num_qubits - 1);
   qubit_ordering_.order_.clear();
   qubit_ordering_.order_.resize(num_qubits);
   std::iota(qubit_ordering_.order_.begin(), qubit_ordering_.order_.end(), 0);
 
   qubit_ordering_.location_.clear();
   qubit_ordering_.location_.resize(num_qubits);
-  std::iota(qubit_ordering_.location_.begin(), qubit_ordering_.location_.end(), 0);
+  std::iota(qubit_ordering_.location_.begin(), qubit_ordering_.location_.end(),
+            0);
 
   // initialize values from mps_container_t
-  for (uint_t i=0; i<num_qubits; i++) {
+  for (uint_t i = 0; i < num_qubits; i++) {
     MPS_Tensor next_tensor(mps.first[i].first, mps.first[i].second);
     q_reg_[i] = std::move(next_tensor);
   }
-  for (uint_t i=0; i<num_qubits-1; i++) {
+  for (uint_t i = 0; i < num_qubits - 1; i++) {
     lambda_reg_[i] = mps.second[i];
   }
 }
 
 //-------------------------------------------------------------------------
-} // end namespace MPS
+} // namespace MatrixProductState
 //-------------------------------------------------------------------------
 } // end namespace AER
 //-------------------------------------------------------------------------
diff --git a/src/simulators/matrix_product_state/matrix_product_state_internal.hpp b/src/simulators/matrix_product_state/matrix_product_state_internal.hpp
index 468440975b..54eafba4d2 100644
--- a/src/simulators/matrix_product_state/matrix_product_state_internal.hpp
+++ b/src/simulators/matrix_product_state/matrix_product_state_internal.hpp
@@ -12,15 +12,14 @@
  * that they have been altered from the originals.
  */
 
-
 #ifndef _aer_matrix_product_state_hpp_
 #define _aer_matrix_product_state_hpp_
 
 #include <cstdarg>
 
 #include "framework/json.hpp"
-#include "framework/utils.hpp"
 #include "framework/operations.hpp"
+#include "framework/utils.hpp"
 #include "matrix_product_state_tensor.hpp"
 
 namespace AER {
@@ -28,16 +27,44 @@ namespace MatrixProductState {
 
 // Allowed gates enum class
 enum Gates {
-  id, h, x, y, z, s, sdg, sx, sxdg, t, tdg, u1, u2, u3, r, rx, ry, rz, // single qubit
-  cx, cy, cz, cu1, swap, su4, rxx, ryy, rzz, rzx, csx, // two qubit
-  ccx, cswap, // three qubit
+  id,
+  h,
+  x,
+  y,
+  z,
+  s,
+  sdg,
+  sx,
+  sxdg,
+  t,
+  tdg,
+  u1,
+  u2,
+  u3,
+  r,
+  rx,
+  ry,
+  rz, // single qubit
+  cx,
+  cy,
+  cz,
+  cu1,
+  swap,
+  su4,
+  rxx,
+  ryy,
+  rzz,
+  rzx,
+  csx, // two qubit
+  ccx,
+  cswap, // three qubit
   pauli
 };
 
-  //enum class Direction {RIGHT, LEFT};
+// enum class Direction {RIGHT, LEFT};
 
-  enum class Sample_measure_alg {APPLY_MEASURE, PROB, MEASURE_ALL, HEURISTIC};
-  enum class MPS_swap_direction {SWAP_LEFT, SWAP_RIGHT};
+enum class Sample_measure_alg { APPLY_MEASURE, PROB, MEASURE_ALL, HEURISTIC };
+enum class MPS_swap_direction { SWAP_LEFT, SWAP_RIGHT };
 
 //=========================================================================
 // MPS class
@@ -51,10 +78,9 @@ enum Gates {
 // for 0<=i<=n-1.
 // -------------------------------------------------------------------------
 
-class MPS{
+class MPS {
 public:
-  MPS(uint_t num_qubits = 0):
-    num_qubits_(num_qubits) {}
+  MPS(uint_t num_qubits = 0) : num_qubits_(num_qubits) {}
   ~MPS() {}
 
   //--------------------------------------------------------------------------
@@ -67,12 +93,12 @@ class MPS{
   //  				Initializes qubits with a statevector.
   // Returns: none.
   //----------------------------------------------------------------
-  virtual void initialize(uint_t num_qubits=0);
+  virtual void initialize(uint_t num_qubits = 0);
   void initialize(const MPS &other);
   //  void initialize(const cvector_t &statevector);
 
-  void apply_initialize(const reg_t &qubits, const cvector_t &statevector, 
-			RngEngine &rng);
+  void apply_initialize(const reg_t &qubits, const cvector_t &statevector,
+                        RngEngine &rng);
   void initialize_from_mps(const mps_container_t &mps);
 
   //----------------------------------------------------------------
@@ -81,7 +107,7 @@ class MPS{
   // Parameters: none.
   // Returns: none.
   //----------------------------------------------------------------
-  uint_t num_qubits() const{return num_qubits_;}
+  uint_t num_qubits() const { return num_qubits_; }
 
   //----------------------------------------------------------------
   // Function name: set_num_qubits
@@ -89,25 +115,19 @@ class MPS{
   // Parameters: size_t num_qubits - number of qubits to set.
   // Returns: none.
   //----------------------------------------------------------------
-  void set_num_qubits(uint_t num_qubits) {
-    num_qubits_ = num_qubits;
-  }
+  void set_num_qubits(uint_t num_qubits) { num_qubits_ = num_qubits; }
 
-  bool empty() const {
-    return(num_qubits_ == 0);
-  }
+  bool empty() const { return (num_qubits_ == 0); }
 
   // the following 3 static methods are used as a reporting mechanism
   // for MPS debug data
-  static void clear_log() {
-    logging_str_.clear();
-  }
+  static void clear_log() { logging_str_.clear(); }
 
-  static void print_to_log() {  // Base function for recursive function
+  static void print_to_log() { // Base function for recursive function
   }
 
-  template<typename T, typename... Targs>
-  static void print_to_log(const T &value, const Targs & ... Fargs) {
+  template <typename T, typename... Targs>
+  static void print_to_log(const T &value, const Targs &...Fargs) {
     if (mps_log_data_) {
       logging_str_ << value;
       MPS::print_to_log(Fargs...); // recursive call
@@ -124,7 +144,6 @@ class MPS{
   //----------------------------------------------------------------
   void move_all_qubits_to_sorted_ordering();
 
-
   /////////////////////////////////////////////////////////////////
   // API functions
   /////////////////////////////////////////////////////////////////
@@ -142,15 +161,16 @@ class MPS{
   void apply_rx(uint_t index, double theta);
   void apply_ry(uint_t index, double theta);
   void apply_rz(uint_t index, double theta);
-  void apply_x(uint_t index){ get_qubit(index).apply_x();}
-  void apply_y(uint_t index){ get_qubit(index).apply_y();}
-  void apply_z(uint_t index){ get_qubit(index).apply_z();}
-  void apply_s(uint_t index){ get_qubit(index).apply_s();}
-  void apply_sdg(uint_t index){ get_qubit(index).apply_sdg();}
-  void apply_t(uint_t index){ get_qubit(index).apply_t();}
-  void apply_tdg(uint_t index){ get_qubit(index).apply_tdg();}
-  void apply_u1(uint_t index, double lambda)
-    { get_qubit(index).apply_u1(lambda);}
+  void apply_x(uint_t index) { get_qubit(index).apply_x(); }
+  void apply_y(uint_t index) { get_qubit(index).apply_y(); }
+  void apply_z(uint_t index) { get_qubit(index).apply_z(); }
+  void apply_s(uint_t index) { get_qubit(index).apply_s(); }
+  void apply_sdg(uint_t index) { get_qubit(index).apply_sdg(); }
+  void apply_t(uint_t index) { get_qubit(index).apply_t(); }
+  void apply_tdg(uint_t index) { get_qubit(index).apply_tdg(); }
+  void apply_u1(uint_t index, double lambda) {
+    get_qubit(index).apply_u1(lambda);
+  }
   void apply_u2(uint_t index, double phi, double lambda);
   void apply_u3(uint_t index, double theta, double phi, double lambda);
   void apply_cnot(uint_t index_A, uint_t index_B);
@@ -168,11 +188,10 @@ class MPS{
   void apply_ccx(const reg_t &qubits);
   void apply_cswap(const reg_t &qubits);
 
-  void apply_matrix(const reg_t & qubits, const cmatrix_t &mat, 
-		    bool is_diagonal=false);
+  void apply_matrix(const reg_t &qubits, const cmatrix_t &mat,
+                    bool is_diagonal = false);
 
-  void apply_matrix(const AER::reg_t &qubits, const cvector_t &vmat)
-  {
+  void apply_matrix(const AER::reg_t &qubits, const cvector_t &vmat) {
     apply_diagonal_matrix(qubits, vmat);
   }
 
@@ -180,47 +199,50 @@ class MPS{
 
   cmatrix_t density_matrix(const reg_t &qubits) const;
 
-  void apply_kraus(const reg_t &qubits,
-		   const std::vector<cmatrix_t> &kmats,
-		   RngEngine &rng);
+  void apply_kraus(const reg_t &qubits, const std::vector<cmatrix_t> &kmats,
+                   RngEngine &rng);
 
   //---------------------------------------------------------------
   // Function: expectation_value
-  // Description: Computes expectation value of the given qubits on the given matrix.
-  // Parameters: The qubits for which we compute expectation value.
+  // Description: Computes expectation value of the given qubits on the given
+  // matrix. Parameters: The qubits for which we compute expectation value.
   //             M - the matrix
-  // Returns: The expectation value. 
+  // Returns: The expectation value.
   //------------------------------------------------------------------
   double expectation_value(const reg_t &qubits, const cmatrix_t &M) const;
 
   //---------------------------------------------------------------
   // Function: expectation_value_pauli
-  // Description: Computes expectation value of the given qubits on a string of Pauli matrices.
-  // Parameters: The qubits for which we compute expectation value.
-  //             A string of matrices of the set {X, Y, Z, I}. The matrices are given in 
-  //             reverse order relative to the qubits.
-  // Returns: The expectation value in the form of a complex number. The real part is the 
+  // Description: Computes expectation value of the given qubits on a string of
+  // Pauli matrices. Parameters: The qubits for which we compute expectation
+  // value.
+  //             A string of matrices of the set {X, Y, Z, I}. The matrices are
+  //             given in reverse order relative to the qubits.
+  // Returns: The expectation value in the form of a complex number. The real
+  // part is the
   //          actual expectation value.
   //------------------------------------------------------------------
-  complex_t expectation_value_pauli(const reg_t &qubits, const std::string &matrices) const;
+  complex_t expectation_value_pauli(const reg_t &qubits,
+                                    const std::string &matrices) const;
 
   //------------------------------------------------------------------
   // Function name: MPS_with_new_indices
-  // Description: Moves the indices of the selected qubits for more efficient computation
+  // Description: Moves the indices of the selected qubits for more efficient
+  // computation
   //   of the expectation value
   // Parameters: The qubits for which we compute expectation value.
   // Returns: centralized_qubits - the qubits, after sorting and centralizing
-  //          
+  //
   //----------------------------------------------------------------
-  void MPS_with_new_indices(const reg_t &qubits,
-			    reg_t &centralized_qubits,
-			    MPS& temp_MPS) const;
+  void MPS_with_new_indices(const reg_t &qubits, reg_t &centralized_qubits,
+                            MPS &temp_MPS) const;
 
   //----------------------------------------------------------------
   // Function name: print
-  // Description: prints the MPS in the current ordering of the qubits (qubit_order_)
+  // Description: prints the MPS in the current ordering of the qubits
+  // (qubit_order_)
   //----------------------------------------------------------------
-  virtual std::ostream&  print(std::ostream& out) const;
+  virtual std::ostream &print(std::ostream &out) const;
 
   Vector<complex_t> full_statevector();
 
@@ -232,9 +254,10 @@ class MPS{
   //----------------------------------------------------------------
   complex_t get_single_amplitude(const std::string &base_value);
 
-  void get_probabilities_vector(rvector_t& probvector, const reg_t &qubits) const;
+  void get_probabilities_vector(rvector_t &probvector,
+                                const reg_t &qubits) const;
 
-//----------------------------------------------------------------
+  //----------------------------------------------------------------
   // Function name: get_prob_single_qubit_internal
   // Description: Returns the probability of measuring outcome 0 (or 1)
   //   for a single qubit in the standard basis.
@@ -244,14 +267,14 @@ class MPS{
   //             outcome - probability for 0 or 1
   //             mat - the '0' (or '1')matrix for the given qubit, multiplied
   //                   by its left and right lambdas. Contracting it with
-  //                   its conjugate gives the probability for outcome '0' (or '1')
-  //                   It is returned because it may be useful for further 
+  //                   its conjugate gives the probability for outcome '0' (or
+  //                   '1') It is returned because it may be useful for further
   //                   computations.
   // Returns: the probability for the given outcome.
   //----------------------------------------------------------------
 
   double get_prob_single_qubit_internal(uint_t qubit, uint_t outcome,
-					cmatrix_t &mat) const;
+                                        cmatrix_t &mat) const;
   //----------------------------------------------------------------
   // Function name: get_accumulated_probabilities_vector
   // Description: Computes the accumulated probabilities from 0
@@ -259,14 +282,14 @@ class MPS{
   // Returns: acc_probvector - the vector of accumulated probabilities
   //          index_vec - the base values whose probabilities are not 0
   // For example:
-  // if probabilities vector is: 0.5 (00), 0.0 (01), 0.2 (10), 0.3 (11), then 
+  // if probabilities vector is: 0.5 (00), 0.0 (01), 0.2 (10), 0.3 (11), then
   // acc_probvector = 0.0,    0.5,    0.7,   1.0
   // index_vec =      0 (00), 2 (10), 3(11)
   //----------------------------------------------------------------
 
-  void get_accumulated_probabilities_vector(rvector_t& acc_probvector, 
-					    reg_t& index_vec,
-					    const reg_t &qubits) const;
+  void get_accumulated_probabilities_vector(rvector_t &acc_probvector,
+                                            reg_t &index_vec,
+                                            const reg_t &qubits) const;
 
   static void set_omp_threads(uint_t threads) {
     if (threads > 0)
@@ -296,30 +319,18 @@ class MPS{
     mps_swap_direction_ = direction;
   }
 
-  static uint_t get_omp_threads() {
-    return omp_threads_;
-  }
-  static uint_t get_omp_threshold() {
-    return omp_threshold_;
-  }
-  static double get_json_chop_threshold() {
-    return json_chop_threshold_;
-  }
+  static uint_t get_omp_threads() { return omp_threads_; }
+  static uint_t get_omp_threshold() { return omp_threshold_; }
+  static double get_json_chop_threshold() { return json_chop_threshold_; }
   static Sample_measure_alg get_sample_measure_alg() {
     return sample_measure_alg_;
   }
 
-  static bool get_enable_gate_opt() {
-    return enable_gate_opt_;
-  }
+  static bool get_enable_gate_opt() { return enable_gate_opt_; }
 
-  static bool get_mps_log_data() {
-    return mps_log_data_;
-  }
+  static bool get_mps_log_data() { return mps_log_data_; }
 
-  static MPS_swap_direction get_swap_direction() {
-    return mps_swap_direction_;
-  }
+  static MPS_swap_direction get_swap_direction() { return mps_swap_direction_; }
 
   //----------------------------------------------------------------
   // Function name: norm
@@ -331,7 +342,7 @@ class MPS{
   double norm() const;
   double norm(const reg_t &qubits) const;
   double norm(const reg_t &qubits, const cvector_t &vmat) const;
-  double norm(const reg_t &qubits, const cmatrix_t &mat) const; 
+  double norm(const reg_t &qubits, const cmatrix_t &mat) const;
 
   reg_t apply_measure(const reg_t &qubits, const rvector_t &rnds);
   reg_t apply_measure_internal(const reg_t &qubits, const rvector_t &rands);
@@ -342,12 +353,13 @@ class MPS{
   // Description: This function receives as input a state_vector and
   //      initializes the internal structures of the MPS according to its
   //      state.
-  // Parameters: qubits - with the internal ordering 
+  // Parameters: qubits - with the internal ordering
   //             statevector to initialize from
   // Returns: none.
   //----------------------------------------------------------------
 
-  void initialize_from_statevector_internal(const reg_t &qubits, const cvector_t &state_vector);
+  void initialize_from_statevector_internal(const reg_t &qubits,
+                                            const cvector_t &state_vector);
   void reset(const reg_t &qubits, RngEngine &rng);
 
   reg_t get_bond_dimensions() const;
@@ -358,11 +370,7 @@ class MPS{
   mps_container_t move_to_mps_container();
 
 private:
-
-  MPS_Tensor& get_qubit(uint_t index) {
-    
-    return q_reg_[get_qubit_index(index)];
-  }
+  MPS_Tensor &get_qubit(uint_t index) { return q_reg_[get_qubit_index(index)]; }
 
   uint_t get_qubit_index(uint_t index) const {
     return qubit_ordering_.location_[index];
@@ -377,54 +385,55 @@ class MPS{
   // if swap_gate==true, this is an actual swap_gate of the circuit
   // if swap_gate==false, this is an internal swap, necessary for
   // some internal algorithm
-  void apply_swap_internal(uint_t index_A, uint_t index_B, bool swap_gate=false);
+  void apply_swap_internal(uint_t index_A, uint_t index_B,
+                           bool swap_gate = false);
   void print_to_log_internal_swap(uint_t qubit0, uint_t qubit1) const;
 
-  void apply_2_qubit_gate(uint_t index_A, uint_t index_B, 
-			  Gates gate_type, const cmatrix_t &mat,
-			  bool is_diagonal=false);
-  void common_apply_2_qubit_gate(uint_t index_A,
-				 Gates gate_type, const cmatrix_t &mat,
-				 bool swapped,
-				 bool is_diagonal=false);
-  void apply_3_qubit_gate(const reg_t &qubits, Gates gate_type, 
-			  const cmatrix_t &mat, bool is_diagonal=false);
-  void apply_matrix_internal(const reg_t & qubits, const cmatrix_t &mat,
-			     bool is_diagonal=false);
-
-  // Certain local operations need to be propagated to the neighboring qubits. 
+  void apply_2_qubit_gate(uint_t index_A, uint_t index_B, Gates gate_type,
+                          const cmatrix_t &mat, bool is_diagonal = false);
+  void common_apply_2_qubit_gate(uint_t index_A, Gates gate_type,
+                                 const cmatrix_t &mat, bool swapped,
+                                 bool is_diagonal = false);
+  void apply_3_qubit_gate(const reg_t &qubits, Gates gate_type,
+                          const cmatrix_t &mat, bool is_diagonal = false);
+  void apply_matrix_internal(const reg_t &qubits, const cmatrix_t &mat,
+                             bool is_diagonal = false);
+
+  // Certain local operations need to be propagated to the neighboring qubits.
   // Such operations include apply_measure and apply_kraus
-  void propagate_to_neighbors_internal(uint_t min_qubit, uint_t max_qubit, 
-				       uint_t next_measured_qubit);
+  void propagate_to_neighbors_internal(uint_t min_qubit, uint_t max_qubit,
+                                       uint_t next_measured_qubit);
 
   // apply_matrix for more than 2 qubits
-  void apply_multi_qubit_gate(const reg_t &qubits,
-			      const cmatrix_t &mat,
-			      bool is_diagonal=false);
+  void apply_multi_qubit_gate(const reg_t &qubits, const cmatrix_t &mat,
+                              bool is_diagonal = false);
 
   void apply_kraus_internal(const reg_t &qubits,
-			    const std::vector<cmatrix_t> &kmats,
-			    RngEngine &rng);
+                            const std::vector<cmatrix_t> &kmats,
+                            RngEngine &rng);
 
   // The following two are helper functions for apply_multi_qubit_gate
   void apply_unordered_multi_qubit_gate(const reg_t &qubits,
-					const cmatrix_t &mat,
-					bool is_diagonal=false);
+                                        const cmatrix_t &mat,
+                                        bool is_diagonal = false);
   void apply_matrix_to_target_qubits(const reg_t &target_qubits,
-				     const cmatrix_t &mat,
-				     bool is_diagonal=false);
+                                     const cmatrix_t &mat,
+                                     bool is_diagonal = false);
   cmatrix_t density_matrix_internal(const reg_t &qubits) const;
   rvector_t diagonal_of_density_matrix(const reg_t &qubits) const;
 
-  double expectation_value_internal(const reg_t &qubits, const cmatrix_t &M) const;
-  complex_t expectation_value_pauli_internal(const reg_t &qubits, const std::string &matrices,
-					     uint_t first_index, uint_t last_index,
-					     uint_t num_Is) const;
+  double expectation_value_internal(const reg_t &qubits,
+                                    const cmatrix_t &M) const;
+  complex_t expectation_value_pauli_internal(const reg_t &qubits,
+                                             const std::string &matrices,
+                                             uint_t first_index,
+                                             uint_t last_index,
+                                             uint_t num_Is) const;
 
-   //----------------------------------------------------------------
-   // Function name: get_matrices_sizes
-   // Description: returns the size of the inner matrices of the MPS
-   //----------------------------------------------------------------
+  //----------------------------------------------------------------
+  // Function name: get_matrices_sizes
+  // Description: returns the size of the inner matrices of the MPS
+  //----------------------------------------------------------------
   std::vector<reg_t> get_matrices_sizes() const;
 
   //----------------------------------------------------------------
@@ -440,45 +449,48 @@ class MPS{
   //----------------------------------------------------------------
   MPS_Tensor state_vec_as_MPS(const reg_t &qubits);
 
-  // This function computes the state vector for all the consecutive qubits 
+  // This function computes the state vector for all the consecutive qubits
   // between first_index and last_index
   MPS_Tensor state_vec_as_MPS(uint_t first_index, uint_t last_index) const;
 
-  Vector<complex_t> full_state_vector_internal(const reg_t &qubits) ;
+  Vector<complex_t> full_state_vector_internal(const reg_t &qubits);
 
-  void get_probabilities_vector_internal(rvector_t& probvector, const reg_t &qubits) const;
+  void get_probabilities_vector_internal(rvector_t &probvector,
+                                         const reg_t &qubits) const;
 
   uint_t apply_measure_internal_single_qubit(uint_t qubit, const double rnd,
-					     uint_t next_measured_qubit);
+                                             uint_t next_measured_qubit);
 
-  uint_t sample_measure_single_qubit(uint_t qubit, double &prob, 
-				     double rnd, cmatrix_t &mat) const;
+  uint_t sample_measure_single_qubit(uint_t qubit, double &prob, double rnd,
+                                     cmatrix_t &mat) const;
   //----------------------------------------------------------------
   // Function name: get_single_probability0
-  // Description: Returns the probability that `qubit` will measure 0, given all the measurements
-  // of the previous qubits that are accumulated in mat.
+  // Description: Returns the probability that `qubit` will measure 0, given all
+  // the measurements of the previous qubits that are accumulated in mat.
   //----------------------------------------------------------------
   double get_single_probability0(uint_t qubit, const cmatrix_t &mat) const;
 
   //----------------------------------------------------------------
   // Function name: initialize_from_matrix
-  // Description: This method is similar to initialize_from_statevector, only here
-  //      the statevector has been converted to a 1xn matrix. The motivation is that
-  //      the algorithm works by iteratively reshaping the statevector into a matrix
-  //      and extracting one dimension every time to create one tensor of the mps.
+  // Description: This method is similar to initialize_from_statevector, only
+  // here
+  //      the statevector has been converted to a 1xn matrix. The motivation is
+  //      that the algorithm works by iteratively reshaping the statevector into
+  //      a matrix and extracting one dimension every time to create one tensor
+  //      of the mps.
   // Parameters: num_qubits - the number of qubits
   //             mat - contains the reshaped statevector to initialize from
   // Returns: none.
   //----------------------------------------------------------------
 
   void initialize_from_matrix(uint_t num_qubits, const cmatrix_t &mat);
-  void initialize_component_internal(const reg_t &qubits, 
-				     const cvector_t &statevector,
-				     RngEngine &rng);
+  void initialize_component_internal(const reg_t &qubits,
+                                     const cvector_t &statevector,
+                                     RngEngine &rng);
 
   void reset_internal(const reg_t &qubits, RngEngine &rng);
   void measure_reset_update_internal(const reg_t &qubits,
-				     const reg_t &meas_state);
+                                     const reg_t &meas_state);
 
   //----------------------------------------------------------------
   // Function name: centralize_qubits
@@ -486,17 +498,16 @@ class MPS{
   // moved to be in consecutive positions. Used for
   // computations involving a subset of the qubits.
   //----------------------------------------------------------------
-  void centralize_qubits(const reg_t &qubits,
-			 reg_t &centralized_qubits);
+  void centralize_qubits(const reg_t &qubits, reg_t &centralized_qubits);
 
   //----------------------------------------------------------------
   // Function name: find_centralized_indices
-  // Description: Performs the first part of centralize_qubits, i.e., returns the
+  // Description: Performs the first part of centralize_qubits, i.e., returns
+  // the
   //    new target indices, but does not actually change the MPS structure.
   //----------------------------------------------------------------
-  void find_centralized_indices(const reg_t &qubits, 
-				reg_t &sorted_indices,
-			        reg_t &centralized_qubits) const;
+  void find_centralized_indices(const reg_t &qubits, reg_t &sorted_indices,
+                                reg_t &centralized_qubits) const;
 
   //----------------------------------------------------------------
   // Function name: move_qubits_to_centralized_indices
@@ -504,7 +515,7 @@ class MPS{
   // qubits to the centralized indices
   //----------------------------------------------------------------
   void move_qubits_to_centralized_indices(const reg_t &sorted_indices,
-					  const reg_t &centralized_qubits);
+                                          const reg_t &centralized_qubits);
 
   // Function name: change_position
   // Description: Move qubit from src to dst in the MPS. Used only
@@ -523,8 +534,8 @@ class MPS{
 
   struct ordering {
     // order_ stores the current ordering of the qubits,
-    // location_ stores the location of each qubit in the vector. It is derived from order_ 
-    // at the end of every swap operation for performance reasons
+    // location_ stores the location of each qubit in the vector. It is derived
+    // from order_ at the end of every swap operation for performance reasons
     // for example: starting position order_ = location_ = 01234
     // cx(0,4) -> order_ = 04123, location_ = 02341
     reg_t order_;
@@ -534,13 +545,15 @@ class MPS{
   //-----------------------------------------------------------------------
   // Config settings
   //-----------------------------------------------------------------------
-  static uint_t omp_threads_;     // Disable multithreading by default
-  static uint_t omp_threshold_;  // Qubit threshold for multithreading when enabled
-  static Sample_measure_alg sample_measure_alg_; // Algorithm for computing sample_measure 
-
-  static double json_chop_threshold_;  // Threshold for choping small values
-                                    // in JSON serialization
-  static bool enable_gate_opt_;      // allow optimizations on gates
+  static uint_t omp_threads_; // Disable multithreading by default
+  static uint_t
+      omp_threshold_; // Qubit threshold for multithreading when enabled
+  static Sample_measure_alg
+      sample_measure_alg_; // Algorithm for computing sample_measure
+
+  static double json_chop_threshold_; // Threshold for choping small values
+                                      // in JSON serialization
+  static bool enable_gate_opt_;       // allow optimizations on gates
   static std::stringstream logging_str_;
   static bool mps_log_data_;
   static MPS_swap_direction mps_swap_direction_;
@@ -549,27 +562,22 @@ class MPS{
 inline std::ostream &operator<<(std::ostream &out, const rvector_t &vec) {
   out << "[";
   uint_t size = vec.size();
-  for (uint_t i = 0; i < size-1; ++i) {
+  for (uint_t i = 0; i < size - 1; ++i) {
     out << vec[i];
     out << ", ";
   }
-  out << vec[size-1] << "]";
+  out << vec[size - 1] << "]";
   return out;
 }
 
-inline std::ostream&
-operator <<(std::ostream& out, MPS& mps)
-{
+inline std::ostream &operator<<(std::ostream &out, MPS &mps) {
   return mps.print(out);
 }
 
-
-inline void to_json(json_t &js, const MPS &mps) {
-
-}
+inline void to_json(json_t &js, const MPS &mps) {}
 
 //-------------------------------------------------------------------------
-} // end namespace MPS
+} // namespace MatrixProductState
 //-------------------------------------------------------------------------
 } // end namespace AER
 //-------------------------------------------------------------------------
diff --git a/src/simulators/matrix_product_state/matrix_product_state_tensor.hpp b/src/simulators/matrix_product_state/matrix_product_state_tensor.hpp
index 09cf03b2e3..3ec3f1db07 100644
--- a/src/simulators/matrix_product_state/matrix_product_state_tensor.hpp
+++ b/src/simulators/matrix_product_state/matrix_product_state_tensor.hpp
@@ -12,28 +12,27 @@
  * that they have been altered from the originals.
  */
 
-
 #ifndef _tensor_tensor_hpp_
 #define _tensor_tensor_hpp_
 
+#include <complex>
 #include <cstdio>
-#include <iostream>
+#include <exception>
 #include <iomanip>
-#include <complex>
-#include <vector>
+#include <iostream>
 #include <math.h>
 #include <string.h>
-#include <exception>
+#include <vector>
 
-#include "svd.hpp"
-#include "svd.cpp"
 #include "framework/matrix.hpp"
 #include "framework/utils.hpp"
+#include "svd.cpp"
+#include "svd.hpp"
 
 namespace AER {
 namespace MatrixProductState {
 
-void apply_y_helper(cmatrix_t& mat1, cmatrix_t& mat2);
+void apply_y_helper(cmatrix_t &mat1, cmatrix_t &mat2);
 
 //============================================================================
 // MPS_Tensor class
@@ -43,79 +42,65 @@ void apply_y_helper(cmatrix_t& mat1, cmatrix_t& mat2);
 // In the stable state, each MPS_Tensor consists of two matrices -
 // the matrix with index 0 (data_[0]) represents the amplitude of |0> and
 // the matrix with index 1 (data_[1]) represents the amplitude of |1>.
-// When applying a two-qubit gate, we temporarily create an MPS_Tensor of four matrices,
-// corresponding to |00>, |01>, |10>, |11>.
-// These are later decomposed back to the stable state of two matrices MPS_Tensor (per qubit).
+// When applying a two-qubit gate, we temporarily create an MPS_Tensor of four
+// matrices, corresponding to |00>, |01>, |10>, |11>. These are later decomposed
+// back to the stable state of two matrices MPS_Tensor (per qubit).
 //----------------------------------------------------------------
 
-class MPS_Tensor
-{
+class MPS_Tensor {
 public:
-
   // Constructors of MPS_Tensor class
-  MPS_Tensor(){}
-  explicit MPS_Tensor(complex_t& alpha, complex_t& beta){
+  MPS_Tensor() {}
+  explicit MPS_Tensor(complex_t &alpha, complex_t &beta) {
     cmatrix_t A = cmatrix_t(1, 1), B = cmatrix_t(1, 1);
-    A(0,0) = alpha;
-    B(0,0) = beta;
+    A(0, 0) = alpha;
+    B(0, 0) = beta;
     data_.push_back(A);
     data_.push_back(B);
   }
-  MPS_Tensor(const MPS_Tensor& rhs){
-    data_ = rhs.data_;
-  }
+  MPS_Tensor(const MPS_Tensor &rhs) { data_ = rhs.data_; }
 
-  MPS_Tensor(const cmatrix_t& data0, const cmatrix_t& data1){
+  MPS_Tensor(const cmatrix_t &data0, const cmatrix_t &data1) {
     if (!data_.empty())
       data_.clear();
     data_.push_back(data0);
     data_.push_back(data1);
   }
 
-  MPS_Tensor(const std::vector<cmatrix_t> &data){
+  MPS_Tensor(const std::vector<cmatrix_t> &data) {
     if (!data_.empty())
       data_.clear();
-    for (uint_t i=0; i<data.size(); i++)
+    for (uint_t i = 0; i < data.size(); i++)
       data_.push_back(data[i]);
   }
 
-  MPS_Tensor(MPS_Tensor&& rhs) {
-    data_ = std::move(rhs.data_);
-  }
-  
-  MPS_Tensor& operator=(MPS_Tensor&& rhs) {
-    if (this != &rhs){
+  MPS_Tensor(MPS_Tensor &&rhs) { data_ = std::move(rhs.data_); }
+
+  MPS_Tensor &operator=(MPS_Tensor &&rhs) {
+    if (this != &rhs) {
       data_ = std::move(rhs.data_);
     }
     return *this;
   }
 
   // Destructor
-  virtual ~MPS_Tensor(){}
+  virtual ~MPS_Tensor() {}
 
   // Assignment operator
-  MPS_Tensor& operator=(const MPS_Tensor& rhs){
-    if (this != &rhs){
+  MPS_Tensor &operator=(const MPS_Tensor &rhs) {
+    if (this != &rhs) {
       data_.clear();
       data_ = rhs.data_;
     }
     return *this;
   }
-  virtual std::ostream& print(std::ostream& out) const;
+  virtual std::ostream &print(std::ostream &out) const;
   reg_t get_size() const;
   cvector_t get_data(uint_t a1, uint_t a2) const;
-  const cmatrix_t& get_data(uint_t i) const {
-    return data_[i];
-  }
-  cmatrix_t& get_data(uint_t i) {
-    return data_[i];
-  }
-  const std::vector<cmatrix_t>& get_data() const {
-    return data_;
-  }
-  std::vector<cmatrix_t>& get_data() {
-    return data_;
-  }
+  const cmatrix_t &get_data(uint_t i) const { return data_[i]; }
+  cmatrix_t &get_data(uint_t i) { return data_[i]; }
+  const std::vector<cmatrix_t> &get_data() const { return data_; }
+  std::vector<cmatrix_t> &get_data() { return data_; }
   void insert_data(uint_t a1, uint_t a2, cvector_t data);
 
   static void set_chop_threshold(double chop_threshold) {
@@ -130,26 +115,18 @@ class MPS_Tensor
     truncation_threshold_ = truncation_threshold;
   }
 
-  static double get_chop_threshold() {
-    return chop_threshold_;
-  }
+  static double get_chop_threshold() { return chop_threshold_; }
 
-  static uint_t get_max_bond_dimension() {
-    return max_bond_dimension_;
-  }
+  static uint_t get_max_bond_dimension() { return max_bond_dimension_; }
 
-  static double get_truncation_threshold() {
-    return truncation_threshold_;
-  }
+  static double get_truncation_threshold() { return truncation_threshold_; }
   //------------------------------------------------------------------
   // function name: get_dim
   // Description: Get the dimension of the physical index of the tensor
   // Parameters: none.
   // Returns: uint_t of the dimension of the physical index of the tensor.
   //------------------------------------------------------------------
-  uint_t get_dim() const {
-    return data_.size();
-  }
+  uint_t get_dim() const { return data_.size(); }
   void apply_pauli(char gate);
   void apply_x();
   void apply_y();
@@ -159,17 +136,13 @@ class MPS_Tensor
   void apply_sdg();
   void apply_t();
   void apply_tdg();
-  void apply_matrix(const cmatrix_t &mat, 
-		    bool is_diagonal=false);
-  void apply_matrix_2_qubits(const cmatrix_t &mat, 
-			     bool swapped=false,
-			     bool is_diagonal=false);
-  void apply_control_2_qubits(const cmatrix_t &mat, 
-			      bool swapped=false,
-			      bool is_diagonal=false);
-  void apply_matrix_helper(const cmatrix_t &mat, 
-			   bool is_diagonal,
-			   const std::vector<uint_t>& indices);
+  void apply_matrix(const cmatrix_t &mat, bool is_diagonal = false);
+  void apply_matrix_2_qubits(const cmatrix_t &mat, bool swapped = false,
+                             bool is_diagonal = false);
+  void apply_control_2_qubits(const cmatrix_t &mat, bool swapped = false,
+                              bool is_diagonal = false);
+  void apply_matrix_helper(const cmatrix_t &mat, bool is_diagonal,
+                           const std::vector<uint_t> &indices);
   void apply_cnot(bool swapped = false);
   void apply_swap();
   void apply_cy(bool swapped = false);
@@ -181,24 +154,25 @@ class MPS_Tensor
   void mul_Gamma_by_right_Lambda(const rvector_t &Lambda);
   void div_Gamma_by_left_Lambda(const rvector_t &Lambda);
   void div_Gamma_by_right_Lambda(const rvector_t &Lambda);
-  static MPS_Tensor contract(const MPS_Tensor &left_gamma, const rvector_t &lambda, const MPS_Tensor &right_gamma, bool mul_by_lambda);
-  static double Decompose(MPS_Tensor &temp, MPS_Tensor &left_gamma, rvector_t &lambda, MPS_Tensor &right_gamma);
-  static void reshape_for_3_qubits_before_SVD(const std::vector<cmatrix_t> data, MPS_Tensor &reshaped_tensor);
-static void contract_2_dimensions(const MPS_Tensor &left_gamma, 
-				  const MPS_Tensor &right_gamma,
-				  uint_t omp_threads,
-				  cmatrix_t &result);
+  static MPS_Tensor contract(const MPS_Tensor &left_gamma,
+                             const rvector_t &lambda,
+                             const MPS_Tensor &right_gamma, bool mul_by_lambda);
+  static double Decompose(MPS_Tensor &temp, MPS_Tensor &left_gamma,
+                          rvector_t &lambda, MPS_Tensor &right_gamma);
+  static void reshape_for_3_qubits_before_SVD(const std::vector<cmatrix_t> data,
+                                              MPS_Tensor &reshaped_tensor);
+  static void contract_2_dimensions(const MPS_Tensor &left_gamma,
+                                    const MPS_Tensor &right_gamma,
+                                    uint_t omp_threads, cmatrix_t &result);
 
   // public static class members
-static const double SQR_HALF;
-static constexpr uint_t NUMBER_OF_PRINTED_DIGITS = 3;
-static constexpr uint_t MATRIX_OMP_THRESHOLD = 8;
-
+  static const double SQR_HALF;
+  static constexpr uint_t NUMBER_OF_PRINTED_DIGITS = 3;
+  static constexpr uint_t MATRIX_OMP_THRESHOLD = 8;
 
 private:
-  void mul_Gamma_by_Lambda(const rvector_t &Lambda,
-			   bool right, /* or left */
-			   bool mul    /* or div */);
+  void mul_Gamma_by_Lambda(const rvector_t &Lambda, bool right, /* or left */
+                           bool mul /* or div */);
 
   std::vector<cmatrix_t> data_;
 
@@ -220,33 +194,35 @@ const double MPS_Tensor::SQR_HALF = sqrt(0.5);
 // function name: print
 // Description: Prints the Tensor. All the submatrices are aligned by rows.
 //-------------------------------------------------------------
-std::ostream& MPS_Tensor::print(std::ostream& out) const {
-    complex_t value;
+std::ostream &MPS_Tensor::print(std::ostream &out) const {
+  complex_t value;
 
-    out << "[" << std::endl;
-    if (data_.size() > 0){
-        //Printing the matrices row by row (i.e., not matrix by matrix)
+  out << "[" << std::endl;
+  if (data_.size() > 0) {
+    // Printing the matrices row by row (i.e., not matrix by matrix)
 
-        for (uint_t row = 0; row < data_[0].GetRows(); row++){
-            for(uint_t i = 0; i < data_.size(); i++)
-            {
-                out << " |";
+    for (uint_t row = 0; row < data_[0].GetRows(); row++) {
+      for (uint_t i = 0; i < data_.size(); i++) {
+        out << " |";
 
-                for (uint_t column = 0; column < data_[0].GetColumns(); column++){
+        for (uint_t column = 0; column < data_[0].GetColumns(); column++) {
 
-                    value = data_[i](row, column);
+          value = data_[i](row, column);
 
-                    out << "(" << std::fixed << std::setprecision(NUMBER_OF_PRINTED_DIGITS) << value.real() << ", ";
-                    out << std::fixed  << std::setprecision(NUMBER_OF_PRINTED_DIGITS) << value.imag() << ")," ;
-                }
-                out << "| ,";
-            }
-            out << std::endl;
+          out << "(" << std::fixed
+              << std::setprecision(NUMBER_OF_PRINTED_DIGITS) << value.real()
+              << ", ";
+          out << std::fixed << std::setprecision(NUMBER_OF_PRINTED_DIGITS)
+              << value.imag() << "),";
         }
+        out << "| ,";
+      }
+      out << std::endl;
     }
-    out << "]" << std::endl;
+  }
+  out << "]" << std::endl;
 
-    return out;
+  return out;
 }
 
 //**************************************************************
@@ -255,12 +231,11 @@ std::ostream& MPS_Tensor::print(std::ostream& out) const {
 // Parameters: none.
 // Returns: reg_t of size 2, for rows and columns.
 //**************************************************************
-reg_t MPS_Tensor::get_size() const
-{
-	reg_t result;
-	result.push_back(data_[0].GetRows());
-	result.push_back(data_[0].GetColumns());
-	return result;
+reg_t MPS_Tensor::get_size() const {
+  reg_t result;
+  result.push_back(data_[0].GetRows());
+  result.push_back(data_[0].GetColumns());
+  return result;
 }
 
 //----------------------------------------------------------------
@@ -271,10 +246,9 @@ reg_t MPS_Tensor::get_size() const
 // 2.	Parameters: uint_t i - index of a matrix in the MPS_Tensor
 // 		Returns: cmatrix_t of the data
 //---------------------------------------------------------------
-cvector_t MPS_Tensor::get_data(uint_t a1, uint_t a2) const
-{
+cvector_t MPS_Tensor::get_data(uint_t a1, uint_t a2) const {
   cvector_t Res;
-  for(uint_t i = 0; i < data_.size(); i++)
+  for (uint_t i = 0; i < data_.size(); i++)
     Res.push_back(data_[i](a1, a2));
   return Res;
 }
@@ -286,29 +260,27 @@ cvector_t MPS_Tensor::get_data(uint_t a1, uint_t a2) const
 // Parameters: cvector_t data - data to insert.
 // Returns: void.
 //---------------------------------------------------------------
-void MPS_Tensor::insert_data(uint_t a1, uint_t a2, cvector_t data)
-{
-  for(uint_t i = 0; i < data_.size(); i++)
-    data_[i](a1,a2) = data[i];
+void MPS_Tensor::insert_data(uint_t a1, uint_t a2, cvector_t data) {
+  for (uint_t i = 0; i < data_.size(); i++)
+    data_[i](a1, a2) = data[i];
 }
 
 void MPS_Tensor::apply_pauli(char gate) {
   switch (gate) {
   case 'X':
-     apply_x();
-     break;
+    apply_x();
+    break;
   case 'Y':
-     apply_y();
-     break;
+    apply_y();
+    break;
   case 'Z':
-     apply_z();
-     break;
+    apply_z();
+    break;
   case 'I':
-     break;
+    break;
   default:
-     throw std::invalid_argument("illegal gate for contract_with_self"); 
+    throw std::invalid_argument("illegal gate for contract_with_self");
   }
-
 }
 //---------------------------------------------------------------
 // function name: apply_x,y,z,...
@@ -317,161 +289,124 @@ void MPS_Tensor::apply_pauli(char gate) {
 // Parameters: none.
 // Returns: none.
 //---------------------------------------------------------------
-void MPS_Tensor::apply_x()
-{
-  std::swap(data_[0], data_[1]);
-}
+void MPS_Tensor::apply_x() { std::swap(data_[0], data_[1]); }
 
-void apply_y_helper(cmatrix_t& mat1, cmatrix_t& mat2)
-{
+void apply_y_helper(cmatrix_t &mat1, cmatrix_t &mat2) {
   mat1 = mat1 * complex_t(0, 1);
   mat2 = mat2 * complex_t(0, -1);
   std::swap(mat1, mat2);
-}  
-
-void MPS_Tensor::apply_y()
-{
-  apply_y_helper(data_[0], data_[1]);
 }
 
-void MPS_Tensor::apply_z()
-{
-  data_[1] = data_[1] * (-1.0);
-}
+void MPS_Tensor::apply_y() { apply_y_helper(data_[0], data_[1]); }
 
-void MPS_Tensor::apply_u1(double lambda)
-{
+void MPS_Tensor::apply_z() { data_[1] = data_[1] * (-1.0); }
+
+void MPS_Tensor::apply_u1(double lambda) {
   data_[1] = data_[1] * std::exp(complex_t(0.0, lambda));
 }
 
-void MPS_Tensor::apply_s()
-{
-  data_[1] = data_[1] * complex_t(0, 1);
-}
+void MPS_Tensor::apply_s() { data_[1] = data_[1] * complex_t(0, 1); }
 
-void MPS_Tensor::apply_sdg()
-{
-  data_[1] = data_[1] * complex_t(0, -1);
-}
+void MPS_Tensor::apply_sdg() { data_[1] = data_[1] * complex_t(0, -1); }
 
-void MPS_Tensor::apply_t()
-{
+void MPS_Tensor::apply_t() {
   data_[1] = data_[1] * complex_t(SQR_HALF, SQR_HALF);
 }
 
-void MPS_Tensor::apply_tdg()
-{
+void MPS_Tensor::apply_tdg() {
   data_[1] = data_[1] * complex_t(SQR_HALF, -SQR_HALF);
 }
-  
-void MPS_Tensor::apply_matrix(const cmatrix_t &mat, bool is_diagonal)
-{
+
+void MPS_Tensor::apply_matrix(const cmatrix_t &mat, bool is_diagonal) {
   std::vector<uint_t> indices;
   // note that mat.GetRows() is equal to 1 if mat is diagonal
-  for(uint_t i=0; i<mat.GetColumns(); ++i) {
+  for (uint_t i = 0; i < mat.GetColumns(); ++i) {
     indices.push_back(i);
   }
 
   apply_matrix_helper(mat, is_diagonal, indices);
 }
 
-void MPS_Tensor::apply_matrix_2_qubits(const cmatrix_t &mat, 
-				       bool swapped,
-				       bool is_diagonal)
-{
+void MPS_Tensor::apply_matrix_2_qubits(const cmatrix_t &mat, bool swapped,
+                                       bool is_diagonal) {
   std::vector<uint_t> indices;
   indices.push_back(0);
   if (swapped) {
     indices.push_back(2);
     indices.push_back(1);
-  }
-  else { 
+  } else {
     indices.push_back(1);
     indices.push_back(2);
   }
   indices.push_back(3);
-  
+
   apply_matrix_helper(mat, is_diagonal, indices);
 }
 
-void MPS_Tensor::apply_control_2_qubits(const cmatrix_t &mat, 
-					bool swapped,
-					bool is_diagonal)
-{
+void MPS_Tensor::apply_control_2_qubits(const cmatrix_t &mat, bool swapped,
+                                        bool is_diagonal) {
   std::vector<uint_t> indices;
   if (swapped) {
     indices.push_back(1);
     indices.push_back(3);
-  }
-  else { 
+  } else {
     indices.push_back(2);
     indices.push_back(3);
   }
-  
+
   apply_matrix_helper(mat, is_diagonal, indices);
-}    
+}
 
 void MPS_Tensor::apply_matrix_helper(const cmatrix_t &mat, bool is_diagonal,
-				     const std::vector<uint_t>& indices)
-{
-  if (is_diagonal) {  // diagonal matrix - the diagonal is contained in row 0
+                                     const std::vector<uint_t> &indices) {
+  if (is_diagonal) { // diagonal matrix - the diagonal is contained in row 0
     if (indices.size() != mat.GetColumns()) {
       throw std::runtime_error("Error: mismtach in the diagonal length");
     }
-    for (uint_t i=0; i<mat.GetColumns(); i++)
+    for (uint_t i = 0; i < mat.GetColumns(); i++)
       data_[indices[i]] = mat(0, i) * data_[indices[i]];
-  } else {            // full matrix
+  } else { // full matrix
     std::vector<cmatrix_t> new_data;
     new_data.resize(mat.GetRows());
     // initialize by multiplying first column of mat by data_[indices[0]]
-    for (uint_t i=0; i<mat.GetRows(); i++) 
+    for (uint_t i = 0; i < mat.GetRows(); i++)
       new_data[i] = (mat(i, 0) * data_[indices[0]]);
 
-    // add all other columns 
-    for (uint_t i=0; i<mat.GetRows(); i++) {
-      for (uint_t j=1; j<mat.GetColumns(); j++) {
-	new_data[i] += mat(i, j) * data_[indices[j]];
+    // add all other columns
+    for (uint_t i = 0; i < mat.GetRows(); i++) {
+      for (uint_t j = 1; j < mat.GetColumns(); j++) {
+        new_data[i] += mat(i, j) * data_[indices[j]];
       }
     }
 
-    for (uint_t i=0; i<mat.GetRows(); i++)
+    for (uint_t i = 0; i < mat.GetRows(); i++)
       data_[indices[i]] = new_data[i];
   }
 }
 
-void MPS_Tensor::apply_cnot(bool swapped)
-{
+void MPS_Tensor::apply_cnot(bool swapped) {
   if (swapped)
     std::swap(data_[1], data_[3]);
   else
     std::swap(data_[2], data_[3]);
 }
 
-void MPS_Tensor::apply_swap()
-{
-  std::swap(data_[1],data_[2]);
-}
+void MPS_Tensor::apply_swap() { std::swap(data_[1], data_[2]); }
 
-void MPS_Tensor::apply_cy(bool swapped)
-{
+void MPS_Tensor::apply_cy(bool swapped) {
   if (swapped)
     apply_y_helper(data_[1], data_[3]);
   else
     apply_y_helper(data_[2], data_[3]);
 }
 
-void MPS_Tensor::apply_cz()
-{
-  data_[3] = data_[3] * (-1.0);
-}
+void MPS_Tensor::apply_cz() { data_[3] = data_[3] * (-1.0); }
 
-void MPS_Tensor::apply_cu1(double lambda)
-{
+void MPS_Tensor::apply_cu1(double lambda) {
   data_[3] = data_[3] * std::exp(complex_t(0.0, lambda));
 }
 
-void MPS_Tensor::apply_ccx(uint_t target_qubit)
-{
+void MPS_Tensor::apply_ccx(uint_t target_qubit) {
   switch (target_qubit) {
   case 0:
     swap(data_[3], data_[7]);
@@ -483,12 +418,11 @@ void MPS_Tensor::apply_ccx(uint_t target_qubit)
     swap(data_[6], data_[7]);
     break;
   default:
-   throw std::invalid_argument("Target qubit for ccx must be 0, 1, or 2"); 
+    throw std::invalid_argument("Target qubit for ccx must be 0, 1, or 2");
   }
 }
 
-void MPS_Tensor::apply_cswap(uint_t control_qubit)
-{
+void MPS_Tensor::apply_cswap(uint_t control_qubit) {
   switch (control_qubit) {
   case 0:
     swap(data_[5], data_[6]);
@@ -500,55 +434,52 @@ void MPS_Tensor::apply_cswap(uint_t control_qubit)
     swap(data_[3], data_[5]);
     break;
   default:
-   throw std::invalid_argument("Control qubit for cswap must be 0, 1, or 2"); 
+    throw std::invalid_argument("Control qubit for cswap must be 0, 1, or 2");
   }
 }
 
 //-------------------------------------------------------------------------
-// The following functions mul/div Gamma by Lambda are used to keep the MPS in the
-// canonical form.
+// The following functions mul/div Gamma by Lambda are used to keep the MPS in
+// the canonical form.
 //
-// Before applying a 2-qubit gate, we must contract these qubits to relevant Gamma tensors.
-// To maintain the canonical form, we must consider the Lambda tensors from
-// the sides of the Gamma tensors. This is what the multiply functions do. After the
-// decomposition of the result of the gate, we need to divide back by what we
-// multiplied before. This is what the division functions do.
+// Before applying a 2-qubit gate, we must contract these qubits to relevant
+// Gamma tensors. To maintain the canonical form, we must consider the Lambda
+// tensors from the sides of the Gamma tensors. This is what the multiply
+// functions do. After the decomposition of the result of the gate, we need to
+// divide back by what we multiplied before. This is what the division functions
+// do.
 //-------------------------------------------------------------------------
-void MPS_Tensor::mul_Gamma_by_left_Lambda(const rvector_t &Lambda)
-{
-  mul_Gamma_by_Lambda(Lambda, false,/*left*/ true /*mul*/);
+void MPS_Tensor::mul_Gamma_by_left_Lambda(const rvector_t &Lambda) {
+  mul_Gamma_by_Lambda(Lambda, false, /*left*/ true /*mul*/);
 }
 
-void MPS_Tensor::mul_Gamma_by_right_Lambda(const rvector_t &Lambda)
-{
-  mul_Gamma_by_Lambda(Lambda, true,/*right*/ true /*mul*/);
+void MPS_Tensor::mul_Gamma_by_right_Lambda(const rvector_t &Lambda) {
+  mul_Gamma_by_Lambda(Lambda, true, /*right*/ true /*mul*/);
 }
 
-void MPS_Tensor::div_Gamma_by_left_Lambda(const rvector_t &Lambda)
-{
-  mul_Gamma_by_Lambda(Lambda, false,/*left*/ false /*div*/);
+void MPS_Tensor::div_Gamma_by_left_Lambda(const rvector_t &Lambda) {
+  mul_Gamma_by_Lambda(Lambda, false, /*left*/ false /*div*/);
 }
 
-void MPS_Tensor::div_Gamma_by_right_Lambda(const rvector_t &Lambda)
-{
-  mul_Gamma_by_Lambda(Lambda, true,/*right*/ false /*div*/);
+void MPS_Tensor::div_Gamma_by_right_Lambda(const rvector_t &Lambda) {
+  mul_Gamma_by_Lambda(Lambda, true, /*right*/ false /*div*/);
 }
 
 void MPS_Tensor::mul_Gamma_by_Lambda(const rvector_t &Lambda,
-			 bool right, /* or left */
-			 bool mul    /* or div */)
-{
-  if (Lambda == rvector_t {1.0}) return;
+                                     bool right, /* or left */
+                                     bool mul /* or div */) {
+  if (Lambda == rvector_t{1.0})
+    return;
   uint_t rows = data_[0].GetRows(), cols = data_[0].GetColumns();
-  for(uint_t i = 0; i < data_.size(); i++)
-    for(uint_t a1 = 0; a1 < rows; a1++)
-      for(uint_t a2 = 0; a2 < cols; a2++) {
-	uint_t factor = right ? a2 : a1;
-	if (mul) {
-	  data_[i](a1,a2) *= Lambda[factor];
-	} else{
-	  data_[i](a1,a2) /= Lambda[factor];
-	}
+  for (uint_t i = 0; i < data_.size(); i++)
+    for (uint_t a1 = 0; a1 < rows; a1++)
+      for (uint_t a2 = 0; a2 < cols; a2++) {
+        uint_t factor = right ? a2 : a1;
+        if (mul) {
+          data_[i](a1, a2) *= Lambda[factor];
+        } else {
+          data_[i](a1, a2) /= Lambda[factor];
+        }
       }
 }
 
@@ -560,18 +491,17 @@ void MPS_Tensor::mul_Gamma_by_Lambda(const rvector_t &Lambda,
 // 	       tensors to contract.
 // Returns: The result tensor of the contract
 //---------------------------------------------------------------
-MPS_Tensor MPS_Tensor::contract(const MPS_Tensor &left_gamma, 
-				const rvector_t &lambda, 
-				const MPS_Tensor &right_gamma,
-				bool mul_by_lambda=true)
-{
+MPS_Tensor MPS_Tensor::contract(const MPS_Tensor &left_gamma,
+                                const rvector_t &lambda,
+                                const MPS_Tensor &right_gamma,
+                                bool mul_by_lambda = true) {
   MPS_Tensor Res;
   MPS_Tensor new_left = left_gamma;
   if (mul_by_lambda) {
     new_left.mul_Gamma_by_right_Lambda(lambda);
   }
-  for(uint_t i = 0; i < new_left.data_.size(); i++)
-    for(uint_t j = 0; j < right_gamma.data_.size(); j++) {
+  for (uint_t i = 0; i < new_left.data_.size(); i++)
+    for (uint_t j = 0; j < right_gamma.data_.size(); j++) {
 
       Res.data_.push_back(new_left.data_[i] * right_gamma.data_[j]);
     }
@@ -580,26 +510,27 @@ MPS_Tensor MPS_Tensor::contract(const MPS_Tensor &left_gamma,
 
 //---------------------------------------------------------------
 // Function name: contract_2_dimensions
-// Description: Contract two Gamma tensors across 2 dimensions: left_columns/right_rows and
+// Description: Contract two Gamma tensors across 2 dimensions:
+// left_columns/right_rows and
 //                                                              left_size/right_size
 // Parameters: MPS_Tensor &left_gamma, &right_gamma - the tensors to contract.
 // Returns: The result matrix of the contract
 // Assumptions:
-//   1. We assume lambda was already multiplied into the gammas before this function
+//   1. We assume lambda was already multiplied into the gammas before this
+//   function
 //   2. We assume the tensors (t1 and t2) are of the form:
-//      t1   
+//      t1
 //      o--a1--o
 //     ||
 //      o--a2--o
 //      t2
-//  There is a double bond between tensor 1 and 2, and each of them has an additional bond of 
-//  dimension a1 and a2 respectively. The result matrix will be of size a2 x a1
+//  There is a double bond between tensor 1 and 2, and each of them has an
+//  additional bond of dimension a1 and a2 respectively. The result matrix will
+//  be of size a2 x a1
 //---------------------------------------------------------------
-void MPS_Tensor::contract_2_dimensions(const MPS_Tensor &left_gamma, 
-			               const MPS_Tensor &right_gamma,
-				       uint_t omp_threads,
-				       cmatrix_t &result)
-{
+void MPS_Tensor::contract_2_dimensions(const MPS_Tensor &left_gamma,
+                                       const MPS_Tensor &right_gamma,
+                                       uint_t omp_threads, cmatrix_t &result) {
   int_t left_rows = left_gamma.data_[0].GetRows();
   int_t left_columns = left_gamma.data_[0].GetColumns();
   int_t left_size = left_gamma.get_dim();
@@ -608,50 +539,58 @@ void MPS_Tensor::contract_2_dimensions(const MPS_Tensor &left_gamma,
   int_t right_size = right_gamma.get_dim();
 
   // left_columns/right_rows and left_size/right_size
-  if (left_columns != right_rows)   
+  if (left_columns != right_rows)
     throw std::runtime_error("left_columns != right_rows");
 
   if (left_size != right_size)
     throw std::runtime_error("left_size != right_size");
   result.resize(left_rows, right_columns);
 
-  uint_t omp_limit = left_rows*right_columns;
+  uint_t omp_limit = left_rows * right_columns;
 
 #ifdef _WIN32
-    #pragma omp parallel for if ((omp_limit > MATRIX_OMP_THRESHOLD) && (omp_threads > 1)) num_threads(omp_threads) 
+#pragma omp parallel for if ((omp_limit > MATRIX_OMP_THRESHOLD) &&             \
+                             (omp_threads > 1)) num_threads(omp_threads)
 #else
-    #pragma omp parallel for collapse(2) if ((omp_limit > MATRIX_OMP_THRESHOLD) && (omp_threads > 1)) num_threads(omp_threads) 
-#endif 
-      for (int_t l_row=0; l_row<left_rows; l_row++)
-         for (int_t r_col=0; r_col<right_columns; r_col++)
-           result(l_row, r_col) = 0;
+#pragma omp parallel for collapse(2) if ((omp_limit > MATRIX_OMP_THRESHOLD) && \
+                                         (omp_threads > 1))                    \
+    num_threads(omp_threads)
+#endif
+  for (int_t l_row = 0; l_row < left_rows; l_row++)
+    for (int_t r_col = 0; r_col < right_columns; r_col++)
+      result(l_row, r_col) = 0;
 
 #ifdef _WIN32
-    #pragma omp parallel for if ((omp_limit > MATRIX_OMP_THRESHOLD)  && (omp_threads > 1)) num_threads(omp_threads)
+#pragma omp parallel for if ((omp_limit > MATRIX_OMP_THRESHOLD) &&             \
+                             (omp_threads > 1)) num_threads(omp_threads)
 #else
-    #pragma omp parallel for collapse(2) if ((omp_limit > MATRIX_OMP_THRESHOLD)  && (omp_threads > 1)) num_threads(omp_threads)
+#pragma omp parallel for collapse(2) if ((omp_limit > MATRIX_OMP_THRESHOLD) && \
+                                         (omp_threads > 1))                    \
+    num_threads(omp_threads)
 #endif
-      for (int_t l_row=0; l_row<left_rows; l_row++)
-        for (int_t r_col=0; r_col<right_columns; r_col++) {
-
-          for (int_t size=0; size<left_size; size++)
-	      for (int_t index=0; index<left_columns ; index++) {
-		result(l_row, r_col) += left_gamma.data_[size](l_row, index) *
-		  right_gamma.data_[size](index, r_col);      
-	      }
-	}
+  for (int_t l_row = 0; l_row < left_rows; l_row++)
+    for (int_t r_col = 0; r_col < right_columns; r_col++) {
+
+      for (int_t size = 0; size < left_size; size++)
+        for (int_t index = 0; index < left_columns; index++) {
+          result(l_row, r_col) += left_gamma.data_[size](l_row, index) *
+                                  right_gamma.data_[size](index, r_col);
+        }
+    }
 }
 //---------------------------------------------------------------
 // function name: Decompose
 // Description: Decompose a tensor into two Gamma tensors and the Lambda between
-// 				them. Usually used after applying a 2-qubit gate.
-// Parameters: MPS_Tensor &temp - the tensor to decompose.
-//			   MPS_Tensor &left_gamma, &right_gamma , rvector_t &lambda -
+// 				them. Usually used after applying a 2-qubit
+// gate. Parameters: MPS_Tensor &temp - the tensor to decompose.
+//			   MPS_Tensor &left_gamma, &right_gamma , rvector_t
+//&lambda
+//-
 // 			   tensors for the result.
 // Returns: none.
 //---------------------------------------------------------------
-double MPS_Tensor::Decompose(MPS_Tensor &temp, MPS_Tensor &left_gamma, rvector_t &lambda, MPS_Tensor &right_gamma)
-{
+double MPS_Tensor::Decompose(MPS_Tensor &temp, MPS_Tensor &left_gamma,
+                             rvector_t &lambda, MPS_Tensor &right_gamma) {
   cmatrix_t C;
   C = reshape_before_SVD(temp.data_);
   cmatrix_t U, V;
@@ -659,21 +598,20 @@ double MPS_Tensor::Decompose(MPS_Tensor &temp, MPS_Tensor &left_gamma, rvector_t
 
   csvd_wrapper(C, U, S, V);
   double discarded_value = 0.0;
-  discarded_value = reduce_zeros(U, S, V, max_bond_dimension_, 
-				 truncation_threshold_);
+  discarded_value =
+      reduce_zeros(U, S, V, max_bond_dimension_, truncation_threshold_);
 
-  left_gamma.data_  = reshape_U_after_SVD(U);
-  lambda            = S;
+  left_gamma.data_ = reshape_U_after_SVD(U);
+  lambda = S;
   right_gamma.data_ = reshape_V_after_SVD(V);
   return discarded_value;
 }
 
-  void MPS_Tensor::reshape_for_3_qubits_before_SVD(const std::vector<cmatrix_t> data, 
-				     MPS_Tensor &reshaped_tensor)
-{
-// Turns 4 matrices A0,A1,A2,A3,A4,A5,A6,A7 to big matrix:
-//  A0 A1 A2 A3
-//  A4 A5 A6 A7
+void MPS_Tensor::reshape_for_3_qubits_before_SVD(
+    const std::vector<cmatrix_t> data, MPS_Tensor &reshaped_tensor) {
+  // Turns 4 matrices A0,A1,A2,A3,A4,A5,A6,A7 to big matrix:
+  //  A0 A1 A2 A3
+  //  A4 A5 A6 A7
 
   cmatrix_t temp0_1 = AER::Utils::concatenate(data[0], data[1], 1),
             temp2_3 = AER::Utils::concatenate(data[2], data[3], 1),
diff --git a/src/simulators/matrix_product_state/svd.cpp b/src/simulators/matrix_product_state/svd.cpp
index 3ecd91c29f..9a6624e60f 100644
--- a/src/simulators/matrix_product_state/svd.cpp
+++ b/src/simulators/matrix_product_state/svd.cpp
@@ -14,66 +14,58 @@
 
 /*
  * Adapted from: P. A. Businger and G. H. Golub, Comm. ACM 12, 564 (1969)
-*/
-
+ */
 
+#include "svd.hpp"
+#include "framework/linalg/almost_equal.hpp"
+#include "framework/utils.hpp"
+#include <cassert>
+#include <cmath>
+#include <complex>
 #include <iostream>
+#include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <math.h>
-#include <cmath>
-#include <complex>
-#include <cassert>
-#include "svd.hpp"
-#include "framework/utils.hpp"
-#include "framework/linalg/almost_equal.hpp"
 
 namespace AER {
 // default values
 constexpr auto mul_factor = 1e2;
 constexpr long double tiny_factor = 1e30;
-constexpr auto zero_threshold = 1e-50;  // threshold for comparing FP values
+constexpr auto zero_threshold = 1e-50; // threshold for comparing FP values
 constexpr auto THRESHOLD = 1e-9; // threshold for cutting values in reduce_zeros
 constexpr auto NUM_SVD_TRIES = 15;
 
 cmatrix_t diag(rvector_t S, uint_t m, uint_t n);
 
-cmatrix_t diag(rvector_t S, uint_t m, uint_t n)
-{
-	cmatrix_t Res = cmatrix_t(m, n);
-	for(uint_t i = 0; i < m; i++)
-	{
-		for(uint_t j = 0; j < n; j++)
-		{
-			Res(i,j) = (i==j ? complex_t(S[i]) : 0);
-		}
-	}
-	return Res;
+cmatrix_t diag(rvector_t S, uint_t m, uint_t n) {
+  cmatrix_t Res = cmatrix_t(m, n);
+  for (uint_t i = 0; i < m; i++) {
+    for (uint_t j = 0; j < n; j++) {
+      Res(i, j) = (i == j ? complex_t(S[i]) : 0);
+    }
+  }
+  return Res;
 }
 
-cmatrix_t reshape_before_SVD(std::vector<cmatrix_t> data)
-{
-//	Turns 4 matrices A0,A1,A2,A3 to big matrix:
-//	A0 A1
-//	A2 A3
-	cmatrix_t temp1 = AER::Utils::concatenate(data[0], data[1], 1),
-		  temp2 = AER::Utils::concatenate(data[2], data[3], 1);
-	return AER::Utils::concatenate(temp1, temp2, 0);
+cmatrix_t reshape_before_SVD(std::vector<cmatrix_t> data) {
+  //	Turns 4 matrices A0,A1,A2,A3 to big matrix:
+  //	A0 A1
+  //	A2 A3
+  cmatrix_t temp1 = AER::Utils::concatenate(data[0], data[1], 1),
+            temp2 = AER::Utils::concatenate(data[2], data[3], 1);
+  return AER::Utils::concatenate(temp1, temp2, 0);
 }
-std::vector<cmatrix_t> reshape_U_after_SVD(const cmatrix_t U)
-{
+std::vector<cmatrix_t> reshape_U_after_SVD(const cmatrix_t U) {
   std::vector<cmatrix_t> Res(2);
   AER::Utils::split(U, Res[0], Res[1], 0);
   return Res;
 }
-std::vector<cmatrix_t> reshape_V_after_SVD(const cmatrix_t V)
-{
+std::vector<cmatrix_t> reshape_V_after_SVD(const cmatrix_t V) {
   std::vector<cmatrix_t> Res(2);
-  AER::Utils::split(AER::Utils::dagger(V), Res[0], Res[1] ,1);
+  AER::Utils::split(AER::Utils::dagger(V), Res[0], Res[1], 1);
   return Res;
 }
 
-
 //-------------------------------------------------------------
 // function name: num_of_SV
 // Description: Computes the number of none-zero singular values
@@ -83,19 +75,17 @@ std::vector<cmatrix_t> reshape_V_after_SVD(const cmatrix_t V)
 // Returns: number of elements in S whose norm is greater than 0
 //			(actually greater than threshold)
 //-------------------------------------------------------------
-uint_t num_of_SV(rvector_t S, double threshold)
-{
-	uint_t sum = 0;
-	for(uint_t i = 0; i < S.size(); ++i)
-	{
-	  if(std::norm(S[i]) > threshold)
-		sum++;
-	}
-	return sum;
+uint_t num_of_SV(rvector_t S, double threshold) {
+  uint_t sum = 0;
+  for (uint_t i = 0; i < S.size(); ++i) {
+    if (std::norm(S[i]) > threshold)
+      sum++;
+  }
+  return sum;
 }
 
 double reduce_zeros(cmatrix_t &U, rvector_t &S, cmatrix_t &V,
-		  uint_t max_bond_dimension, double truncation_threshold) {
+                    uint_t max_bond_dimension, double truncation_threshold) {
   uint_t SV_num = num_of_SV(S, CHOP_THRESHOLD);
   uint_t new_SV_num = SV_num;
 
@@ -104,14 +94,14 @@ double reduce_zeros(cmatrix_t &U, rvector_t &S, cmatrix_t &V,
     // values in S, and discard all the rest
     new_SV_num = max_bond_dimension;
   }
-  // Remove the lowest Schmidt coefficients such that the sum of 
+  // Remove the lowest Schmidt coefficients such that the sum of
   // their squares is less than trunction_threshold
   double sum_squares = 0;
-  for (int_t i=new_SV_num-1; i>0; i--) {
+  for (int_t i = new_SV_num - 1; i > 0; i--) {
     if (sum_squares + std::norm(S[i]) < truncation_threshold) {
-      sum_squares +=std::norm(S[i]);
+      sum_squares += std::norm(S[i]);
     } else {
-      new_SV_num = i+1;
+      new_SV_num = i + 1;
       break;
     }
   }
@@ -119,37 +109,38 @@ double reduce_zeros(cmatrix_t &U, rvector_t &S, cmatrix_t &V,
   S.resize(new_SV_num);
   V.resize(V.GetRows(), new_SV_num);
 
-  // discarded_value is the sum of the squares of the Schmidt coeffients 
+  // discarded_value is the sum of the squares of the Schmidt coeffients
   // that were discarded by approximation
   double discarded_value = 0.0;
 
   if (new_SV_num < SV_num) {
-    for (uint_t i=new_SV_num; i<SV_num; i++) {
+    for (uint_t i = new_SV_num; i < SV_num; i++) {
       discarded_value += std::norm(S[i]);
     }
   }
   // Check if we need to re-normalize the values of S
   double new_sum_squares = 0;
-  for (uint_t i=0; i<S.size(); i++) 
-    new_sum_squares +=std::norm(S[i]);
+  for (uint_t i = 0; i < S.size(); i++)
+    new_sum_squares += std::norm(S[i]);
   if (!Linalg::almost_equal(1.0 - new_sum_squares, 0., THRESHOLD)) {
-	double sqrt_sum = std::sqrt(new_sum_squares);
-	for (uint_t i=0; i<S.size(); i++)
-	  S[i] /= sqrt_sum;
+    double sqrt_sum = std::sqrt(new_sum_squares);
+    for (uint_t i = 0; i < S.size(); i++)
+      S[i] /= sqrt_sum;
   }
   return discarded_value;
 }
 
-void validate_SVD_result(const cmatrix_t &A, const cmatrix_t &U, 
-			 const rvector_t &S, const cmatrix_t &V) {
+void validate_SVD_result(const cmatrix_t &A, const cmatrix_t &U,
+                         const rvector_t &S, const cmatrix_t &V) {
   const uint_t nrows = A.GetRows(), ncols = A.GetColumns();
   cmatrix_t diag_S = diag(S, nrows, ncols);
-  cmatrix_t product = U*diag_S;
+  cmatrix_t product = U * diag_S;
   product = product * AER::Utils::dagger(V);
-  for (uint_t ii=0; ii < nrows; ii++)
-    for (uint_t jj=0; jj < ncols; jj++)
-      if (!Linalg::almost_equal(std::abs(A(ii, jj)), std::abs(product(ii, jj)), THRESHOLD)) {
-	throw std::runtime_error("Error: Wrong SVD calculations: A != USV*");
+  for (uint_t ii = 0; ii < nrows; ii++)
+    for (uint_t jj = 0; jj < ncols; jj++)
+      if (!Linalg::almost_equal(std::abs(A(ii, jj)), std::abs(product(ii, jj)),
+                                THRESHOLD)) {
+        throw std::runtime_error("Error: Wrong SVD calculations: A != USV*");
       }
 }
 
@@ -157,401 +148,378 @@ void validate_SVD_result(const cmatrix_t &A, const cmatrix_t &U,
 status csvd(cmatrix_t &A, cmatrix_t &U, rvector_t &S, cmatrix_t &V) {
   int m = A.GetRows(), n = A.GetColumns(), size = std::max(m, n);
   rvector_t b(size, 0.0), c(size, 0.0), t(size, 0.0);
-  double cs = 0.0, eps = 0.0, f = 0.0 ,g = 0.0, h = 0.0, sn = 0.0 , w = 0.0, x = 0.0, y = 0.0, z = 0.0;
+  double cs = 0.0, eps = 0.0, f = 0.0, g = 0.0, h = 0.0, sn = 0.0, w = 0.0,
+         x = 0.0, y = 0.0, z = 0.0;
   double eta = 1e-10, tol = 1.5e-34;
-  // using int and not uint_t because uint_t caused bugs in loops with condition of >= 0
+  // using int and not uint_t because uint_t caused bugs in loops with condition
+  // of >= 0
   int i = 0, j = 0, k = 0, k1 = 0, l = 0, l1 = 0;
   complex_t q = 0;
   // Transpose when m < n
   bool transposed = false;
-  if (m < n)
-    {
-    	transposed = true;
-    	A = AER::Utils::dagger(A);
-	std::swap(m, n);
+  if (m < n) {
+    transposed = true;
+    A = AER::Utils::dagger(A);
+    std::swap(m, n);
+  }
+  cmatrix_t temp_A = A;
+  c[0] = 0;
+  while (true) {
+    k1 = k + 1;
+    z = 0.0;
+    for (i = k; i < m; i++) {
+      z = z + norm(A(i, k));
     }
-	cmatrix_t temp_A = A;
-	c[0] = 0;
-	while(true)
-	{
-		k1 = k + 1;
-		z = 0.0;
-		for(i = k; i < m; i++){
-			z = z + norm(A(i, k));
-		}
-		b[k] = 0.0;
-		if ( tol < z )
-		{
-			z = std::sqrt(z);
-			b[k] = z;
-			w = std::abs(A(k, k));
-			
-			if (Linalg::almost_equal(w, 0.0, zero_threshold)) {
-			  q = complex_t(1.0, 0.0);
-			} else {
-			q = A(k,k) / w;
-			}
-			A(k, k) = q * (z + w);
-
-			if (k != n - 1)
-			{
-				for(j = k1; j < n ; j++)
-				{
-
-					q = complex_t(0.0, 0.0);
-					for(i = k; i < m; i++){
-						q = q + std::conj(A(i,k)) * A(i,j);
-					}
-					q = q / ( z * ( z + w ) );
-
-					for(i = k; i < m; i++){
-					  A(i,j) = A(i, j) - q * A(i, k);
-					}
-
-				}
-//
-// Phase transformation.
-//
-				q = -std::conj(A(k, k))/std::abs(A(k, k));
-
-				for(j = k1; j < n; j++){
-					A(k,j) = q * A(k, j);
-				}
-			}
+    b[k] = 0.0;
+    if (tol < z) {
+      z = std::sqrt(z);
+      b[k] = z;
+      w = std::abs(A(k, k));
+
+      if (Linalg::almost_equal(w, 0.0, zero_threshold)) {
+        q = complex_t(1.0, 0.0);
+      } else {
+        q = A(k, k) / w;
+      }
+      A(k, k) = q * (z + w);
+
+      if (k != n - 1) {
+        for (j = k1; j < n; j++) {
+
+          q = complex_t(0.0, 0.0);
+          for (i = k; i < m; i++) {
+            q = q + std::conj(A(i, k)) * A(i, j);
+          }
+          q = q / (z * (z + w));
+
+          for (i = k; i < m; i++) {
+            A(i, j) = A(i, j) - q * A(i, k);
+          }
+        }
+        //
+        // Phase transformation.
+        //
+        q = -std::conj(A(k, k)) / std::abs(A(k, k));
+
+        for (j = k1; j < n; j++) {
+          A(k, j) = q * A(k, j);
         }
-		if ( k == n - 1 ) break;
-
-		z = 0.0;
-		for(j = k1; j < n; j++){
-			z = z + norm(A(k, j));
-		}
-		c[k1] = 0.0;
-
-		if ( tol < z )
-		{
-			z = std::sqrt( z );
-			c[k1] = z;
-			w = std::abs( A(k, k1) );
-
-			if (Linalg::almost_equal(w, 0.0, zero_threshold)) {
-			  q = complex_t( 1.0, 0.0 );
-			} else {
-			  q = A(k,k1) / w;
-			}
-			A(k,k1) = q * ( z + w );
-
-			for(i = k1; i < m; i++)
-			{
-				q = complex_t( 0.0, 0.0 );
-
-				for(j = k1; j < n; j++){
-					q = q + std::conj( A(k, j) ) * A(i, j);
-				}
-				q = q / ( z * ( z + w ) );
-
-				for( j = k1; j < n; j++){
-					A(i, j) = A(i, j) - q * A(k, j);
-				}
-			}
-//
-// Phase transformation.
-//
-			q = -std::conj(A(k,k1) )/std::abs(A(k,k1));
-			for( i = k1; i < m; i++){
-				A(i,k1) = A(i,k1) * q;
-			}
-		}
-		k = k1;
+      }
+    }
+    if (k == n - 1)
+      break;
+
+    z = 0.0;
+    for (j = k1; j < n; j++) {
+      z = z + norm(A(k, j));
+    }
+    c[k1] = 0.0;
+
+    if (tol < z) {
+      z = std::sqrt(z);
+      c[k1] = z;
+      w = std::abs(A(k, k1));
+
+      if (Linalg::almost_equal(w, 0.0, zero_threshold)) {
+        q = complex_t(1.0, 0.0);
+      } else {
+        q = A(k, k1) / w;
+      }
+      A(k, k1) = q * (z + w);
+
+      for (i = k1; i < m; i++) {
+        q = complex_t(0.0, 0.0);
+
+        for (j = k1; j < n; j++) {
+          q = q + std::conj(A(k, j)) * A(i, j);
+        }
+        q = q / (z * (z + w));
+
+        for (j = k1; j < n; j++) {
+          A(i, j) = A(i, j) - q * A(k, j);
+        }
+      }
+      //
+      // Phase transformation.
+      //
+      q = -std::conj(A(k, k1)) / std::abs(A(k, k1));
+      for (i = k1; i < m; i++) {
+        A(i, k1) = A(i, k1) * q;
+      }
+    }
+    k = k1;
+  }
+
+  eps = 0.0;
+  for (k = 0; k < n; k++) {
+    S[k] = b[k];
+    t[k] = c[k];
+    eps = std::max(eps, S[k] + t[k]);
+  }
+  eps = eps * eta;
+
+  //
+  // Initialization of U and V.
+  //
+  U.initialize(m, m);
+  V.initialize(n, n);
+  for (j = 0; j < m; j++) {
+    for (i = 0; i < m; i++) {
+      U(i, j) = complex_t(0.0, 0.0);
+    }
+    U(j, j) = complex_t(1.0, 0.0);
+  }
+
+  for (j = 0; j < n; j++) {
+    for (i = 0; i < n; i++) {
+      V(i, j) = complex_t(0.0, 0.0);
     }
+    V(j, j) = complex_t(1.0, 0.0);
+  }
+
+  for (k = n - 1; k >= 0; k--) {
+    while (true) {
+      bool jump = false;
+      for (l = k; l >= 0; l--) {
 
-    eps = 0.0;
-	for( k = 0; k < n; k++)
-	{
-		S[k] = b[k];
-		t[k] = c[k];
-		eps = std::max( eps, S[k] + t[k] );
-	}
-	eps = eps * eta;
-
-//
-// Initialization of U and V.
-//
-	U.initialize(m, m);
-	V.initialize(n, n);
-	for( j = 0; j < m; j++)
-	{
-		for( i = 0; i < m; i++){
-			U(i,j) = complex_t( 0.0, 0.0 );
-		}
-		U(j,j) = complex_t( 1.0, 0.0 );
-	}
-
-	for( j = 0; j < n; j++)
-	{
-		for( i = 0; i < n; i++){
-			V(i,j) = complex_t( 0.0, 0.0 );
-		}
-		V(j,j) = complex_t( 1.0, 0.0 );
-	}
-
-
-
-	for( k = n-1; k >= 0; k--)
-	{
-		while(true)
-		{
-			bool jump = false;
-			for( l = k; l >= 0; l--)
-			{
-
-				if ( std::abs( t[l] ) < eps )
-				{
-					jump = true;
-					break;
-				}
-				else if ( std::abs( S[l-1] ) < eps ) {
-					break;
-				}
-			}
-			if(!jump)
-			{
-				cs = 0.0;
-				sn = 1.0;
-				l1 = l - 1;
-
-				for( i = l; i <= k; i++)
-				{
-					f = sn * t[i];
-					t[i] = cs * t[i];
-
-					if ( std::abs(f) < eps ) {
-						break;
-					}
-					h = S[i];
-					w = std::sqrt( f * f + h * h );
-					S[i] = w;
-					cs = h / w;
-					sn = - f / w;
-
-					for( j = 0; j < n; j++)
-					{
-						x = std::real( U(j,l1) );
-						y = std::real( U(j,i) );
-						U(j,l1) = complex_t( x * cs + y * sn, 0.0 );
-						U(j,i)  = complex_t( y * cs - x * sn, 0.0 );
-					}
-				}
-			}
-			w = S[k];
-			if ( l == k ){
-				break;
-			}
-			x = S[l];
-			y = S[k-1];
-			g = t[k-1];
-			h = t[k];
-			f = ( ( y - w ) * ( y + w ) + ( g - h ) * ( g + h ) )/ ( 2.0 * h * y );
-			g = std::sqrt( f * f + 1.0 );
-			if ( f < -1.0e-13){ //if ( f < 0.0){ //didn't work when f was negative very close to 0 (because of numerical reasons)
-				g = -g;
-			}
-			f = ( ( x - w ) * ( x + w ) + ( y / ( f + g ) - h ) * h ) / x;
-			cs = 1.0;
-			sn = 1.0;
-			l1 = l + 1;
-			for( i = l1; i <= k; i++)
-			{
-				g = t[i];
-				y = S[i];
-				h = sn * g;
-				g = cs * g;
-				w = std::sqrt( h * h + f * f );
-				if (Linalg::almost_equal(w, 0.0, zero_threshold)) {
+        if (std::abs(t[l]) < eps) {
+          jump = true;
+          break;
+        } else if (std::abs(S[l - 1]) < eps) {
+          break;
+        }
+      }
+      if (!jump) {
+        cs = 0.0;
+        sn = 1.0;
+        l1 = l - 1;
+
+        for (i = l; i <= k; i++) {
+          f = sn * t[i];
+          t[i] = cs * t[i];
+
+          if (std::abs(f) < eps) {
+            break;
+          }
+          h = S[i];
+          w = std::sqrt(f * f + h * h);
+          S[i] = w;
+          cs = h / w;
+          sn = -f / w;
+
+          for (j = 0; j < n; j++) {
+            x = std::real(U(j, l1));
+            y = std::real(U(j, i));
+            U(j, l1) = complex_t(x * cs + y * sn, 0.0);
+            U(j, i) = complex_t(y * cs - x * sn, 0.0);
+          }
+        }
+      }
+      w = S[k];
+      if (l == k) {
+        break;
+      }
+      x = S[l];
+      y = S[k - 1];
+      g = t[k - 1];
+      h = t[k];
+      f = ((y - w) * (y + w) + (g - h) * (g + h)) / (2.0 * h * y);
+      g = std::sqrt(f * f + 1.0);
+      if (f < -1.0e-13) { // if ( f < 0.0){ //didn't work when f was negative
+                          // very close to 0 (because of numerical reasons)
+        g = -g;
+      }
+      f = ((x - w) * (x + w) + (y / (f + g) - h) * h) / x;
+      cs = 1.0;
+      sn = 1.0;
+      l1 = l + 1;
+      for (i = l1; i <= k; i++) {
+        g = t[i];
+        y = S[i];
+        h = sn * g;
+        g = cs * g;
+        w = std::sqrt(h * h + f * f);
+        if (Linalg::almost_equal(w, 0.0, zero_threshold)) {
 #ifdef DEBUG
-				  std::cout << "ERROR 1: w is exactly 0: h = " << h << " , f = " << f << std::endl;
-				  std::cout << " w = " << w << std::endl;
+          std::cout << "ERROR 1: w is exactly 0: h = " << h << " , f = " << f
+                    << std::endl;
+          std::cout << " w = " << w << std::endl;
 #endif
-				}
-				t[i-1] = w;
-				cs = f / w;
-				sn = h / w;
-				f = x * cs + g * sn; // might be 0
-
-				long double large_f = 0;
-				if (Linalg::almost_equal(f, 0.0, zero_threshold)) {
+        }
+        t[i - 1] = w;
+        cs = f / w;
+        sn = h / w;
+        f = x * cs + g * sn; // might be 0
+
+        long double large_f = 0;
+        if (Linalg::almost_equal(f, 0.0, zero_threshold)) {
 #ifdef DEBUG
-				  std::cout << "f == 0 because " << "x = " << x << ", cs = " << cs << ", g = " << g << ", sn = " << sn  <<std::endl;
+          std::cout << "f == 0 because "
+                    << "x = " << x << ", cs = " << cs << ", g = " << g
+                    << ", sn = " << sn << std::endl;
 #endif
-				  long double large_x =   x * tiny_factor;
-				  long double large_g =   g * tiny_factor;
-				  long double large_cs = cs * tiny_factor;
-				  long double large_sn = sn * tiny_factor;
-				  large_f = large_x * large_cs + large_g * large_sn;
+          long double large_x = x * tiny_factor;
+          long double large_g = g * tiny_factor;
+          long double large_cs = cs * tiny_factor;
+          long double large_sn = sn * tiny_factor;
+          large_f = large_x * large_cs + large_g * large_sn;
 
 #ifdef DEBUG
-				  std::cout << large_x * large_cs <<std::endl;;
-				  std::cout << large_g * large_sn <<std::endl;
-				  std::cout << "new f = " << large_f << std::endl;
+          std::cout << large_x * large_cs << std::endl;
+          ;
+          std::cout << large_g * large_sn << std::endl;
+          std::cout << "new f = " << large_f << std::endl;
 
 #endif
-				}
-				g = g * cs - x * sn;
-				h = y * sn; // h == 0 because y==0
-				y = y * cs;
-
-				for( j = 0; j < n; j++)
-				{
-					x = std::real( V(j,i-1) );
-					w = std::real( V(j,i) );
-					V(j,i-1) = complex_t( x * cs + w * sn, 0.0 );
-					V(j,i)   = complex_t( w * cs - x * sn, 0.0 );
-				}
-
-				bool tiny_w = false;
+        }
+        g = g * cs - x * sn;
+        h = y * sn; // h == 0 because y==0
+        y = y * cs;
+
+        for (j = 0; j < n; j++) {
+          x = std::real(V(j, i - 1));
+          w = std::real(V(j, i));
+          V(j, i - 1) = complex_t(x * cs + w * sn, 0.0);
+          V(j, i) = complex_t(w * cs - x * sn, 0.0);
+        }
+
+        bool tiny_w = false;
 #ifdef DEBUG
-				std::cout << " h = " << h << " f = " << f << " large_f = " << large_f << std::endl;
+        std::cout << " h = " << h << " f = " << f << " large_f = " << large_f
+                  << std::endl;
 #endif
-				if (std::abs(h) < 1e-13 && std::abs(f) < 1e-13 && 
-				    !Linalg::almost_equal<long double>(large_f, 0.0, zero_threshold)) {
-				  tiny_w = true;
-				} else {
-				  w = std::sqrt( h * h + f * f );
-				}
-				w = std::sqrt( h * h + f * f );
-				if (Linalg::almost_equal(w, 0.0, zero_threshold)  && !tiny_w) {
+        if (std::abs(h) < 1e-13 && std::abs(f) < 1e-13 &&
+            !Linalg::almost_equal<long double>(large_f, 0.0, zero_threshold)) {
+          tiny_w = true;
+        } else {
+          w = std::sqrt(h * h + f * f);
+        }
+        w = std::sqrt(h * h + f * f);
+        if (Linalg::almost_equal(w, 0.0, zero_threshold) && !tiny_w) {
 
 #ifdef DEBUG
-				  std::cout << "ERROR: w is exactly 0: h = " << h << " , f = " << f << std::endl;
-				  std::cout << " w = " << w << std::endl;
+          std::cout << "ERROR: w is exactly 0: h = " << h << " , f = " << f
+                    << std::endl;
+          std::cout << " w = " << w << std::endl;
 #endif
-				  return FAILURE;
-				}
-
-				S[i-1] = w;
-				if (tiny_w) {
-				  cs = 1.0; // because h==0, so w = f
-				  sn = 0;
-				} else {
-				  cs = f / w;
-				  sn = h / w;
-				}
-
-				f = cs * g + sn * y;
-				x = cs * y - sn * g;
-				for( j = 0; j < n; j++)
-				{
-					y = std::real( U(j,i-1) );
-					w = std::real( U(j,i) );
-					U(j,i-1) = complex_t( y * cs + w * sn, 0.0 );
-					U(j,i)   = complex_t( w * cs - y * sn, 0.0 );
-				}
-			}
-			t[l] = 0.0;
-			t[k] = f;
-			S[k] = x;
-		}
-
-
-        if ( w < -1e-13 ) //
-		{
-			S[k] = - w;
-			for( j = 0; j < n; j++){
-				V(j,k) = - V(j,k);
-			}
-		}
-	}
-
-//
-//  Sort the singular values.
-//
-	for( k = 0; k < n; k++)
-	{
-		g = - 1.0;
-		j = k;
-        for( i = k; i < n; i++)
-		{
-			if ( g < S[i] )
-			{
-				g = S[i];
-				j = i;
-			}
+          return FAILURE;
+        }
+
+        S[i - 1] = w;
+        if (tiny_w) {
+          cs = 1.0; // because h==0, so w = f
+          sn = 0;
+        } else {
+          cs = f / w;
+          sn = h / w;
         }
 
-        if ( j != k )
-		{
-			S[j] = S[k];
-			S[k] = g;
-
-			for( i = 0; i < n; i++)
-			{
-				q      = V(i,j);
-				V(i,j) = V(i,k);
-				V(i,k) = q;
-			}
-
-			for( i = 0; i < n; i++)
-			{
-				q      = U(i,j);
-				U(i,j) = U(i,k);
-				U(i,k) = q;
-			}
+        f = cs * g + sn * y;
+        x = cs * y - sn * g;
+        for (j = 0; j < n; j++) {
+          y = std::real(U(j, i - 1));
+          w = std::real(U(j, i));
+          U(j, i - 1) = complex_t(y * cs + w * sn, 0.0);
+          U(j, i) = complex_t(w * cs - y * sn, 0.0);
         }
+      }
+      t[l] = 0.0;
+      t[k] = f;
+      S[k] = x;
     }
 
-    for( k = n-1 ; k >= 0; k--) {
-      if (!Linalg::almost_equal(b[k], 0.0, zero_threshold)) {
-	q = -A(k,k) / std::abs( A(k,k) );
-	for( j = 0; j < m; j++) {
-	  U(k,j) = q * U(k,j);
-	}
-	for( j = 0; j < m; j++)	{
-	  q = complex_t( 0.0, 0.0 );
-	  for( i = k; i < m; i++) {
-	    q = q + std::conj( A(i,k) ) * U(i,j);
-	  }
-	  q = q / ( std::abs( A(k,k) ) * b[k] );
-	  for( i = k; i < m; i++) {
-	    U(i,j) = U(i,j) - q * A(i,k);
-	  }
-	}
+    if (w < -1e-13) //
+    {
+      S[k] = -w;
+      for (j = 0; j < n; j++) {
+        V(j, k) = -V(j, k);
       }
     }
+  }
 
-    for( k = n-1 -1; k >= 0; k--) {
-      k1 = k + 1;
-      if ( !Linalg::almost_equal(c[k1], 0.0, zero_threshold)) {
-	q = -std::conj( A(k,k1) ) / std::abs( A(k,k1) );
-	
-	for( j = 0; j < n; j++){
-	  V(k1,j) = q * V(k1,j);
-	}
-	
-	for( j = 0; j < n; j++) {
-	  q = complex_t( 0.0, 0.0 );
-	  for( i = k1 ; i < n; i++){
-	    q = q + A(k,i) * V(i,j);
-	  }
-	  q = q / ( std::abs( A(k,k1) ) * c[k1] );
-	  for( i = k1; i < n; i++) {
-	    V(i,j) = V(i,j) - q * std::conj( A(k,i) );
-	  }
-	}
+  //
+  //  Sort the singular values.
+  //
+  for (k = 0; k < n; k++) {
+    g = -1.0;
+    j = k;
+    for (i = k; i < n; i++) {
+      if (g < S[i]) {
+        g = S[i];
+        j = i;
       }
     }
+
+    if (j != k) {
+      S[j] = S[k];
+      S[k] = g;
+
+      for (i = 0; i < n; i++) {
+        q = V(i, j);
+        V(i, j) = V(i, k);
+        V(i, k) = q;
+      }
+
+      for (i = 0; i < n; i++) {
+        q = U(i, j);
+        U(i, j) = U(i, k);
+        U(i, k) = q;
+      }
+    }
+  }
+
+  for (k = n - 1; k >= 0; k--) {
+    if (!Linalg::almost_equal(b[k], 0.0, zero_threshold)) {
+      q = -A(k, k) / std::abs(A(k, k));
+      for (j = 0; j < m; j++) {
+        U(k, j) = q * U(k, j);
+      }
+      for (j = 0; j < m; j++) {
+        q = complex_t(0.0, 0.0);
+        for (i = k; i < m; i++) {
+          q = q + std::conj(A(i, k)) * U(i, j);
+        }
+        q = q / (std::abs(A(k, k)) * b[k]);
+        for (i = k; i < m; i++) {
+          U(i, j) = U(i, j) - q * A(i, k);
+        }
+      }
+    }
+  }
+
+  for (k = n - 1 - 1; k >= 0; k--) {
+    k1 = k + 1;
+    if (!Linalg::almost_equal(c[k1], 0.0, zero_threshold)) {
+      q = -std::conj(A(k, k1)) / std::abs(A(k, k1));
+
+      for (j = 0; j < n; j++) {
+        V(k1, j) = q * V(k1, j);
+      }
+
+      for (j = 0; j < n; j++) {
+        q = complex_t(0.0, 0.0);
+        for (i = k1; i < n; i++) {
+          q = q + A(k, i) * V(i, j);
+        }
+        q = q / (std::abs(A(k, k1)) * c[k1]);
+        for (i = k1; i < n; i++) {
+          V(i, j) = V(i, j) - q * std::conj(A(k, i));
+        }
+      }
+    }
+  }
 #ifdef DEBUG
-    validate_SVD_result(temp_A, U, S, V);
+  validate_SVD_result(temp_A, U, S, V);
 #endif
 
-    // Transpose again if m < n
-    if(transposed)
-      std::swap(U,V);
-    
-    return SUCCESS;
-}
+  // Transpose again if m < n
+  if (transposed)
+    std::swap(U, V);
 
+  return SUCCESS;
+}
 
-void csvd_wrapper(cmatrix_t &A, cmatrix_t &U, rvector_t &S, cmatrix_t &V)
-{
+void csvd_wrapper(cmatrix_t &A, cmatrix_t &U, rvector_t &S, cmatrix_t &V) {
   cmatrix_t copied_A = A;
   int times = 0;
 #ifdef DEBUG
@@ -559,34 +527,29 @@ void csvd_wrapper(cmatrix_t &A, cmatrix_t &U, rvector_t &S, cmatrix_t &V)
 #endif
   status current_status = csvd(A, U, S, V);
   if (current_status == SUCCESS) {
-      return;
+    return;
   }
 
-  while(times <= NUM_SVD_TRIES && current_status == FAILURE)
-    {
-      times++;
-      copied_A = copied_A * mul_factor;
-      A = copied_A;
+  while (times <= NUM_SVD_TRIES && current_status == FAILURE) {
+    times++;
+    copied_A = copied_A * mul_factor;
+    A = copied_A;
 
 #ifdef DEBUG
-      std::cout << "SVD trial #" << times << std::endl;
+    std::cout << "SVD trial #" << times << std::endl;
 #endif
 
-      current_status = csvd(A, U, S, V);
-    }
-  if(times == NUM_SVD_TRIES) {
+    current_status = csvd(A, U, S, V);
+  }
+  if (times == NUM_SVD_TRIES) {
     std::stringstream ss;
     ss << "SVD failed";
     throw std::runtime_error(ss.str());
   }
 
-  //Divide by mul_factor every singular value after we multiplied matrix a
-  for(uint_t k = 0; k < S.size(); k++)
+  // Divide by mul_factor every singular value after we multiplied matrix a
+  for (uint_t k = 0; k < S.size(); k++)
     S[k] /= pow(mul_factor, times);
-
 }
 
 } // namespace AER
-
-
-
diff --git a/src/simulators/matrix_product_state/svd.hpp b/src/simulators/matrix_product_state/svd.hpp
index b64498cb0b..2a999e40d4 100644
--- a/src/simulators/matrix_product_state/svd.hpp
+++ b/src/simulators/matrix_product_state/svd.hpp
@@ -12,14 +12,13 @@
  * that they have been altered from the originals.
  */
 
-
 #ifndef SVD_HPP_
 #define SVD_HPP_
 
+#include "framework/types.hpp"
+#include "framework/utils.hpp"
 #include <complex>
 #include <vector>
-#include "framework/utils.hpp"
-#include "framework/types.hpp"
 
 #define CHOP_THRESHOLD 1e-16
 
@@ -27,7 +26,7 @@ namespace AER {
 // Data types
 using long_complex_t = std::complex<long double>;
 
-enum status {SUCCESS, FAILURE};
+enum status { SUCCESS, FAILURE };
 
 cmatrix_t reshape_before_SVD(std::vector<cmatrix_t> data);
 std::vector<cmatrix_t> reshape_U_after_SVD(cmatrix_t U);
@@ -35,14 +34,13 @@ rvector_t reshape_S_after_SVD(rvector_t S);
 std::vector<cmatrix_t> reshape_V_after_SVD(const cmatrix_t V);
 uint_t num_of_SV(rvector_t S, double threshold);
 double reduce_zeros(cmatrix_t &U, rvector_t &S, cmatrix_t &V,
-                  uint_t max_bond_dimension, double truncation_threshold);
-status csvd(cmatrix_t &C, cmatrix_t &U,rvector_t &S,cmatrix_t &V);
-void csvd_wrapper(cmatrix_t &C, cmatrix_t &U,rvector_t &S,cmatrix_t &V);
-void validate_SVD_result(const cmatrix_t &A, const cmatrix_t &U, 
-			 const rvector_t &S, const cmatrix_t &V);
+                    uint_t max_bond_dimension, double truncation_threshold);
+status csvd(cmatrix_t &C, cmatrix_t &U, rvector_t &S, cmatrix_t &V);
+void csvd_wrapper(cmatrix_t &C, cmatrix_t &U, rvector_t &S, cmatrix_t &V);
+void validate_SVD_result(const cmatrix_t &A, const cmatrix_t &U,
+                         const rvector_t &S, const cmatrix_t &V);
 
 //-------------------------------------------------------------------------
 } // end namespace AER
 //-------------------------------------------------------------------------
 #endif
-
diff --git a/src/simulators/stabilizer/binary_vector.hpp b/src/simulators/stabilizer/binary_vector.hpp
index a982097c17..ca21d55c16 100644
--- a/src/simulators/stabilizer/binary_vector.hpp
+++ b/src/simulators/stabilizer/binary_vector.hpp
@@ -12,15 +12,14 @@
  * that they have been altered from the originals.
  */
 
-
 #ifndef _binary_vector_hpp_
 #define _binary_vector_hpp_
 
 #include <cmath>
+#include <cstdint>
 #include <stdexcept>
 #include <string>
 #include <vector>
-#include <cstdint>
 
 namespace BV {
 
@@ -79,7 +78,6 @@ class BinaryVector {
   static const uint64_t ONE_;
 };
 
-
 /*******************************************************************************
  *
  * Related Functions
@@ -90,7 +88,6 @@ inline bool operator==(const BinaryVector &lhs, const BinaryVector &rhs) {
   return lhs.isSame(rhs, true);
 }
 
-
 inline int64_t gauss_eliminate(std::vector<BinaryVector> &M,
                                const int64_t start_col = 0)
 // returns the rank of M.
@@ -120,10 +117,8 @@ inline int64_t gauss_eliminate(std::vector<BinaryVector> &M,
   return rank;
 }
 
-
-inline std::vector<uint64_t> string_to_bignum(std::string val,
-                                              uint64_t blockSize,
-                                              uint64_t base) {
+inline std::vector<uint64_t>
+string_to_bignum(std::string val, uint64_t blockSize, uint64_t base) {
   std::vector<uint64_t> ret;
   if (blockSize * log2(base) > 64) {
     throw std::runtime_error(
@@ -140,7 +135,6 @@ inline std::vector<uint64_t> string_to_bignum(std::string val,
   return ret;
 }
 
-
 inline std::vector<uint64_t> string_to_bignum(std::string val) {
   std::string type = val.substr(0, 2);
   if (type == "0b" || type == "0B")
@@ -156,7 +150,6 @@ inline std::vector<uint64_t> string_to_bignum(std::string val) {
   }
 }
 
-
 /*******************************************************************************
  *
  * BinaryVector Class Methods
@@ -171,7 +164,6 @@ BinaryVector::BinaryVector(std::string val) {
   m_length = m_data.size();
 }
 
-
 void BinaryVector::setLength(uint64_t length) {
   if (length == 0 || m_length > 0)
     return;
@@ -180,7 +172,6 @@ void BinaryVector::setLength(uint64_t length) {
   m_data.assign((length - 1) / BLOCK_SIZE + 1, ZERO_);
 }
 
-
 void BinaryVector::setValue(bool value, uint64_t pos) {
   auto q = pos / BLOCK_SIZE;
   auto r = pos % BLOCK_SIZE;
@@ -190,14 +181,12 @@ void BinaryVector::setValue(bool value, uint64_t pos) {
     m_data[q] &= ~(ONE_ << r);
 }
 
-
 void BinaryVector::flipAt(const uint64_t pos) {
   auto q = pos / BLOCK_SIZE;
   auto r = pos % BLOCK_SIZE;
   m_data[q] ^= (ONE_ << r);
 }
 
-
 BinaryVector &BinaryVector::operator+=(const BinaryVector &rhs) {
   const auto size = m_data.size();
   for (size_t i = 0; i < size; i++)
@@ -205,14 +194,12 @@ BinaryVector &BinaryVector::operator+=(const BinaryVector &rhs) {
   return (*this);
 }
 
-
 bool BinaryVector::operator[](const uint64_t pos) const {
   auto q = pos / BLOCK_SIZE;
   auto r = pos % BLOCK_SIZE;
   return ((m_data[q] & (ONE_ << r)) != 0);
 }
 
-
 void BinaryVector::swap(BinaryVector &rhs) {
   uint64_t tmp;
   tmp = rhs.m_length;
@@ -222,7 +209,6 @@ void BinaryVector::swap(BinaryVector &rhs) {
   m_data.swap(rhs.m_data);
 }
 
-
 bool BinaryVector::isZero() const {
   const size_t size = m_data.size();
   for (size_t i = 0; i < size; i++)
@@ -231,7 +217,6 @@ bool BinaryVector::isZero() const {
   return true;
 }
 
-
 bool BinaryVector::isSame(const BinaryVector &rhs) const {
   if (m_length != rhs.m_length)
     return false;
@@ -243,7 +228,6 @@ bool BinaryVector::isSame(const BinaryVector &rhs) const {
   return true;
 }
 
-
 bool BinaryVector::isSame(const BinaryVector &rhs, bool pad) const {
   if (!pad)
     return isSame(rhs);
@@ -267,7 +251,6 @@ bool BinaryVector::isSame(const BinaryVector &rhs, bool pad) const {
   return true;
 }
 
-
 std::vector<uint64_t> BinaryVector::nonzeroIndices() const {
   std::vector<uint64_t> result;
   size_t i = 0;
@@ -293,7 +276,6 @@ std::vector<uint64_t> BinaryVector::nonzeroIndices() const {
   return result;
 }
 
-
 //------------------------------------------------------------------------------
 } // end namespace BV
 //------------------------------------------------------------------------------
diff --git a/src/simulators/stabilizer/clifford.hpp b/src/simulators/stabilizer/clifford.hpp
index bee03ed7e2..bffa711e2c 100644
--- a/src/simulators/stabilizer/clifford.hpp
+++ b/src/simulators/stabilizer/clifford.hpp
@@ -15,8 +15,8 @@
 #ifndef _clifford_hpp_
 #define _clifford_hpp_
 
-#include "pauli.hpp"
 #include "../../framework/json_parser.hpp"
+#include "pauli.hpp"
 
 namespace Clifford {
 
@@ -42,34 +42,35 @@ class Clifford {
   //-----------------------------------------------------------------------
 
   // Get number of qubits of the Clifford table
-  uint64_t num_qubits() const {return num_qubits_;}
+  uint64_t num_qubits() const { return num_qubits_; }
 
   // Return true if the number of qubits is 0
-  bool empty() const {return (num_qubits_ == 0);}
+  bool empty() const { return (num_qubits_ == 0); }
 
   // Return JSON serialization of QubitVector;
   json_t json() const;
 
   // Access stabilizer table
-  Pauli::Pauli &operator[](uint64_t j) {return table_[j];}
-  const Pauli::Pauli& operator[](uint64_t j) const {return table_[j];}
+  Pauli::Pauli &operator[](uint64_t j) { return table_[j]; }
+  const Pauli::Pauli &operator[](uint64_t j) const { return table_[j]; }
 
   // Return reference to internal Stabilizer table
-  std::vector<Pauli::Pauli>& table() {return table_;}
-  const std::vector<Pauli::Pauli>& table() const {return table_;}
+  std::vector<Pauli::Pauli> &table() { return table_; }
+  const std::vector<Pauli::Pauli> &table() const { return table_; }
 
   // Return reference to internal phases vector
-  phasevec_t& phases() {return phases_;}
-  const phasevec_t& phases() const {return phases_;}
+  phasevec_t &phases() { return phases_; }
+  const phasevec_t &phases() const { return phases_; }
 
   // Return n-th destabilizer from internal stabilizer table
-  Pauli::Pauli &destabilizer(uint64_t n) {return table_[n];}
-  const Pauli::Pauli& destabilizer(uint64_t n) const {return table_[n];}
+  Pauli::Pauli &destabilizer(uint64_t n) { return table_[n]; }
+  const Pauli::Pauli &destabilizer(uint64_t n) const { return table_[n]; }
 
   // Return n-th stabilizer from internal stabilizer table
-  Pauli::Pauli &stabilizer(uint64_t n) {return table_[num_qubits_ + n];}
-  const Pauli::Pauli& stabilizer(uint64_t n) const {return table_[num_qubits_ + n];}
-
+  Pauli::Pauli &stabilizer(uint64_t n) { return table_[num_qubits_ + n]; }
+  const Pauli::Pauli &stabilizer(uint64_t n) const {
+    return table_[num_qubits_ + n];
+  }
 
   //-----------------------------------------------------------------------
   // Apply basic Clifford gates
@@ -97,9 +98,9 @@ class Clifford {
   // Measurement
   //-----------------------------------------------------------------------
 
-  // If we perform a single qubit Z measurement, 
+  // If we perform a single qubit Z measurement,
   // will the outcome be random or deterministic.
-  bool is_deterministic_outcome(const uint64_t& qubit) const;
+  bool is_deterministic_outcome(const uint64_t &qubit) const;
 
   // Return the outcome (0 or 1) of a single qubit Z measurement, and
   // update the stabilizer to the conditional (post measurement) state if
@@ -114,23 +115,22 @@ class Clifford {
   void set_json_chop_threshold(double threshold);
 
   // Set the threshold for chopping values to 0 in JSON
-  double get_json_chop_threshold() {return json_chop_threshold_;}
+  double get_json_chop_threshold() { return json_chop_threshold_; }
 
   // Set the maximum number of OpenMP thread for operations.
   void set_omp_threads(int n);
 
   // Get the maximum number of OpenMP thread for operations.
-  uint64_t get_omp_threads() {return omp_threads_;}
+  uint64_t get_omp_threads() { return omp_threads_; }
 
   // Set the qubit threshold for activating OpenMP.
   // If self.qubits() > threshold OpenMP will be activated.
   void set_omp_threshold(int n);
 
   // Get the qubit threshold for activating OpenMP.
-  uint64_t get_omp_threshold() {return omp_threshold_;}
+  uint64_t get_omp_threshold() { return omp_threshold_; }
 
 private:
-
   //-----------------------------------------------------------------------
   // Protected data members
   //-----------------------------------------------------------------------
@@ -143,10 +143,11 @@ class Clifford {
   // Config settings
   //-----------------------------------------------------------------------
 
-  uint64_t omp_threads_ = 1;          // Disable multithreading by default
-  uint64_t omp_threshold_ = 1000;     // Qubit threshold for multithreading when enabled
-  double json_chop_threshold_ = 0;  // Threshold for chopping small values
-                                    // in JSON serialization
+  uint64_t omp_threads_ = 1; // Disable multithreading by default
+  uint64_t omp_threshold_ =
+      1000; // Qubit threshold for multithreading when enabled
+  double json_chop_threshold_ = 0; // Threshold for chopping small values
+                                   // in JSON serialization
 
   //-----------------------------------------------------------------------
   // Helper functions
@@ -193,16 +194,18 @@ void Clifford::set_omp_threshold(int n) {
 //------------------------------------------------------------------------------
 
 Clifford::Clifford(uint64_t nq) : num_qubits_(nq) {
-  // initial state = all zeros
-  // add destabilizers
-  #pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+// initial state = all zeros
+// add destabilizers
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
   for (int64_t i = 0; i < static_cast<int64_t>(nq); i++) {
     Pauli::Pauli P(nq);
     P.X.setValue(1, i);
     table_.push_back(P);
   }
-  // add stabilizers
-  #pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+// add stabilizers
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
   for (int64_t i = 0; i < static_cast<int64_t>(nq); i++) {
     Pauli::Pauli P(nq);
     P.Z.setValue(1, i);
@@ -217,17 +220,19 @@ Clifford::Clifford(uint64_t nq) : num_qubits_(nq) {
 //------------------------------------------------------------------------------
 
 void Clifford::append_cx(const uint64_t qcon, const uint64_t qtar) {
-  #pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
   for (int64_t i = 0; i < static_cast<int64_t>(2 * num_qubits_); i++) {
     phases_[i] ^= (table_[i].X[qcon] && table_[i].Z[qtar] &&
-                  (table_[i].X[qtar] ^ table_[i].Z[qcon] ^ 1));
+                   (table_[i].X[qtar] ^ table_[i].Z[qcon] ^ 1));
     table_[i].X.setValue(table_[i].X[qtar] ^ table_[i].X[qcon], qtar);
     table_[i].Z.setValue(table_[i].Z[qtar] ^ table_[i].Z[qcon], qcon);
   }
 }
 
 void Clifford::append_h(const uint64_t qubit) {
-  #pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
   for (int64_t i = 0; i < static_cast<int64_t>(2 * num_qubits_); i++) {
     phases_[i] ^= (table_[i].X[qubit] && table_[i].Z[qubit]);
     // exchange X and Z
@@ -238,7 +243,8 @@ void Clifford::append_h(const uint64_t qubit) {
 }
 
 void Clifford::append_s(const uint64_t qubit) {
-  #pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
   for (int64_t i = 0; i < static_cast<int64_t>(2 * num_qubits_); i++) {
     phases_[i] ^= (table_[i].X[qubit] && table_[i].Z[qubit]);
     table_[i].Z.setValue(table_[i].Z[qubit] ^ table_[i].X[qubit], qubit);
@@ -246,29 +252,32 @@ void Clifford::append_s(const uint64_t qubit) {
 }
 
 void Clifford::append_x(const uint64_t qubit) {
-  #pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
   for (int64_t i = 0; i < static_cast<int64_t>(2 * num_qubits_); i++)
     phases_[i] ^= table_[i].Z[qubit];
 }
 
 void Clifford::append_y(const uint64_t qubit) {
-  #pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
   for (int64_t i = 0; i < static_cast<int64_t>(2 * num_qubits_); i++)
     phases_[i] ^= (table_[i].Z[qubit] ^ table_[i].X[qubit]);
 }
 
 void Clifford::append_z(const uint64_t qubit) {
-  #pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
   for (int64_t i = 0; i < static_cast<int64_t>(2 * num_qubits_); i++)
     phases_[i] ^= table_[i].X[qubit];
 }
 
-
 //------------------------------------------------------------------------------
 // Utility
 //------------------------------------------------------------------------------
 
-std::pair<bool, uint64_t> Clifford::z_anticommuting(const uint64_t qubit) const {
+std::pair<bool, uint64_t>
+Clifford::z_anticommuting(const uint64_t qubit) const {
   for (uint64_t p = num_qubits_; p < 2 * num_qubits_; p++) {
     if (table_[p].X[qubit])
       return std::make_pair(true, p);
@@ -276,8 +285,8 @@ std::pair<bool, uint64_t> Clifford::z_anticommuting(const uint64_t qubit) const
   return std::make_pair(false, 0);
 }
 
-
-std::pair<bool, uint64_t> Clifford::x_anticommuting(const uint64_t qubit) const {
+std::pair<bool, uint64_t>
+Clifford::x_anticommuting(const uint64_t qubit) const {
   for (uint64_t p = num_qubits_; p < 2 * num_qubits_; p++) {
     if (table_[p].Z[qubit])
       return std::make_pair(true, p);
@@ -289,14 +298,15 @@ std::pair<bool, uint64_t> Clifford::x_anticommuting(const uint64_t qubit) const
 // Measurement
 //------------------------------------------------------------------------------
 
-bool Clifford::is_deterministic_outcome(const uint64_t& qubit) const {
+bool Clifford::is_deterministic_outcome(const uint64_t &qubit) const {
   // Clifford state measurements only have three probabilities:
   // (p0, p1) = (0.5, 0.5), (1, 0), or (0, 1)
   // The random case happens if there is a row anti-commuting with Z[qubit]
   return !z_anticommuting(qubit).first;
 }
 
-bool Clifford::measure_and_update(const uint64_t qubit, const uint64_t randint) {
+bool Clifford::measure_and_update(const uint64_t qubit,
+                                  const uint64_t randint) {
   // Clifford state measurements only have three probabilities:
   // (p0, p1) = (0.5, 0.5), (1, 0), or (0, 1)
   // The random case happens if there is a row anti-commuting with Z[qubit]
@@ -325,8 +335,8 @@ bool Clifford::measure_and_update(const uint64_t qubit, const uint64_t randint)
     phase_t outcome = 0;
     for (uint64_t i = 0; i < num_qubits_; i++) {
       if (table_[i].X[qubit]) {
-        rowsum_helper(table_[i + num_qubits_], phases_[i + num_qubits_],
-                      accum, outcome);
+        rowsum_helper(table_[i + num_qubits_], phases_[i + num_qubits_], accum,
+                      outcome);
       }
     }
     return outcome;
@@ -336,7 +346,8 @@ bool Clifford::measure_and_update(const uint64_t qubit, const uint64_t randint)
 void Clifford::rowsum_helper(const Pauli::Pauli &row, const phase_t row_phase,
                              Pauli::Pauli &accum, phase_t &accum_phase) const {
   int8_t newr = ((2 * row_phase + 2 * accum_phase) +
-                 Pauli::Pauli::phase_exponent(row, accum)) % 4;
+                 Pauli::Pauli::phase_exponent(row, accum)) %
+                4;
   // Since we are only using +1 and -1 phases in our Clifford phases
   // the exponent must be 0 (for +1) or 2 (for -1)
   if ((newr != 0) && (newr != 2)) {
@@ -369,13 +380,12 @@ json_t Clifford::json() const {
   return js;
 }
 
-inline void to_json(json_t &js, const Clifford &clif) {
-  js = clif.json();
-}
+inline void to_json(json_t &js, const Clifford &clif) { js = clif.json(); }
 
 template <typename inputdata_t>
-void build_from(const inputdata_t& input, Clifford& clif){
-  bool has_keys = AER::Parser<inputdata_t>::check_keys({"stabilizer", "destabilizer"}, input);
+void build_from(const inputdata_t &input, Clifford &clif) {
+  bool has_keys = AER::Parser<inputdata_t>::check_keys(
+      {"stabilizer", "destabilizer"}, input);
   if (!has_keys)
     throw std::invalid_argument("Invalid Clifford JSON.");
 
@@ -385,7 +395,8 @@ void build_from(const inputdata_t& input, Clifford& clif){
 
   const auto nq = stab.size();
   if (nq != destab.size()) {
-    throw std::invalid_argument("Invalid Clifford JSON: stabilizer and destabilizer lengths do not match.");
+    throw std::invalid_argument("Invalid Clifford JSON: stabilizer and "
+                                "destabilizer lengths do not match.");
   }
 
   clif = Clifford(nq);
@@ -394,46 +405,46 @@ void build_from(const inputdata_t& input, Clifford& clif){
     // Get destabilizer
     label = destab[i];
     switch (label[0]) {
-      case '-':
-        clif.phases()[i] = 1;
-        clif.table()[i] = Pauli::Pauli(label.substr(1, nq));
-        break;
-      case '+':
-        clif.table()[i] = Pauli::Pauli(label.substr(1, nq));
-        break;
-      case 'I':
-      case 'X':
-      case 'Y':
-      case 'Z':
-        clif.table()[i] = Pauli::Pauli(label);
-        break;
-      default:
-        throw std::invalid_argument("Invalid Stabilizer JSON string.");
+    case '-':
+      clif.phases()[i] = 1;
+      clif.table()[i] = Pauli::Pauli(label.substr(1, nq));
+      break;
+    case '+':
+      clif.table()[i] = Pauli::Pauli(label.substr(1, nq));
+      break;
+    case 'I':
+    case 'X':
+    case 'Y':
+    case 'Z':
+      clif.table()[i] = Pauli::Pauli(label);
+      break;
+    default:
+      throw std::invalid_argument("Invalid Stabilizer JSON string.");
     }
     // Get stabilizer
     label = stab[i];
     switch (label[0]) {
-      case '-':
-        clif.phases()[i + nq] = 1;
-        clif.table()[i + nq] = Pauli::Pauli(label.substr(1, nq));
-        break;
-      case '+':
-        clif.table()[i + nq] = Pauli::Pauli(label.substr(1, nq));
-        break;
-      case 'I':
-      case 'X':
-      case 'Y':
-      case 'Z':
-        clif.table()[i + nq] = Pauli::Pauli(label);
-        break;
-      default:
-        throw std::invalid_argument("Invalid Stabilizer JSON string.");
+    case '-':
+      clif.phases()[i + nq] = 1;
+      clif.table()[i + nq] = Pauli::Pauli(label.substr(1, nq));
+      break;
+    case '+':
+      clif.table()[i + nq] = Pauli::Pauli(label.substr(1, nq));
+      break;
+    case 'I':
+    case 'X':
+    case 'Y':
+    case 'Z':
+      clif.table()[i + nq] = Pauli::Pauli(label);
+      break;
+    default:
+      throw std::invalid_argument("Invalid Stabilizer JSON string.");
     }
   }
 }
 
 inline void from_json(const json_t &js, Clifford &clif) {
-    build_from(js, clif);
+  build_from(js, clif);
 }
 
 //------------------------------------------------------------------------------
diff --git a/src/simulators/stabilizer/pauli.hpp b/src/simulators/stabilizer/pauli.hpp
index ecf0ec5673..0bbc218af1 100644
--- a/src/simulators/stabilizer/pauli.hpp
+++ b/src/simulators/stabilizer/pauli.hpp
@@ -15,8 +15,8 @@
 #ifndef _pauli_hpp_
 #define _pauli_hpp_
 
-#include <iostream>
 #include "binary_vector.hpp"
+#include <iostream>
 
 namespace Pauli {
 
@@ -33,10 +33,10 @@ class Pauli {
   BV::BinaryVector Z;
 
   // Construct an empty pauli
-  Pauli() : X(0), Z(0) {};
+  Pauli() : X(0), Z(0){};
 
   // Construct an n-qubit identity Pauli
-  explicit Pauli(uint64_t len) : X(len), Z(len) {};
+  explicit Pauli(uint64_t len) : X(len), Z(len){};
 
   // Construct an n-qubit Pauli from a string label;
   explicit Pauli(const std::string &label);
@@ -45,10 +45,9 @@ class Pauli {
   std::string str() const;
 
   // exponent g of i such that P(x1,z1) P(x2,z2) = i^g P(x1+x2,z1+z2)
-  static int8_t phase_exponent(const Pauli& pauli1, const Pauli& pauli2);
+  static int8_t phase_exponent(const Pauli &pauli1, const Pauli &pauli2);
 };
 
-
 /*******************************************************************************
  *
  * Implementations
@@ -61,23 +60,23 @@ Pauli::Pauli(const std::string &label) {
   Z = BV::BinaryVector(num_qubits);
   // The label corresponds to tensor product order
   // So the first element of label is the last qubit and vice versa
-  for (size_t i =0; i < num_qubits; i++) {
+  for (size_t i = 0; i < num_qubits; i++) {
     const auto qubit_i = num_qubits - 1 - i;
     switch (label[i]) {
-      case 'I':
-        break;
-      case 'X':
-        X.set1(qubit_i);
-        break;
-      case 'Y':
-        X.set1(qubit_i);
-        Z.set1(qubit_i);
-        break;
-      case 'Z':
-        Z.set1(qubit_i);
-        break;
-      default:
-        throw std::invalid_argument("Invalid Pauli label");
+    case 'I':
+      break;
+    case 'X':
+      X.set1(qubit_i);
+      break;
+    case 'Y':
+      X.set1(qubit_i);
+      Z.set1(qubit_i);
+      break;
+    case 'Z':
+      Z.set1(qubit_i);
+      break;
+    default:
+      throw std::invalid_argument("Invalid Pauli label");
     }
   }
 }
@@ -86,9 +85,10 @@ std::string Pauli::str() const {
   // Check X and Z are same length
   const auto num_qubits = X.getLength();
   if (Z.getLength() != num_qubits)
-    throw std::runtime_error("Pauli::str X and Z vectors are different length.");
+    throw std::runtime_error(
+        "Pauli::str X and Z vectors are different length.");
   std::string label;
-  for (size_t i =0; i < num_qubits; i++) {
+  for (size_t i = 0; i < num_qubits; i++) {
     const auto qubit_i = num_qubits - 1 - i;
     if (!X[qubit_i] && !Z[qubit_i])
       label.push_back('I');
@@ -102,15 +102,17 @@ std::string Pauli::str() const {
   return label;
 }
 
-int8_t Pauli::phase_exponent(const Pauli& pauli1, const Pauli& pauli2) {
+int8_t Pauli::phase_exponent(const Pauli &pauli1, const Pauli &pauli2) {
   int8_t exponent = 0;
   for (size_t q = 0; q < pauli1.X.getLength(); q++) {
-    exponent += pauli2.X[q] * pauli1.Z[q] * (1 + 2 * pauli2.Z[q] + 2 * pauli1.X[q]);
-    exponent -= pauli1.X[q] * pauli2.Z[q] * (1 + 2 * pauli1.Z[q] + 2 * pauli2.X[q]);
+    exponent +=
+        pauli2.X[q] * pauli1.Z[q] * (1 + 2 * pauli2.Z[q] + 2 * pauli1.X[q]);
+    exponent -=
+        pauli1.X[q] * pauli2.Z[q] * (1 + 2 * pauli1.Z[q] + 2 * pauli2.X[q]);
     exponent %= 4;
   }
   if (exponent < 0)
-      exponent += 4;
+    exponent += 4;
   return exponent;
 }
 
@@ -127,4 +129,3 @@ inline std::ostream &operator<<(std::ostream &out, const Pauli::Pauli &pauli) {
 
 //------------------------------------------------------------------------------
 #endif
-
diff --git a/src/simulators/stabilizer/stabilizer_state.hpp b/src/simulators/stabilizer/stabilizer_state.hpp
index 3bdf41bd6f..40de044276 100644
--- a/src/simulators/stabilizer/stabilizer_state.hpp
+++ b/src/simulators/stabilizer/stabilizer_state.hpp
@@ -15,10 +15,10 @@
 #ifndef _aer_stabilizer_state_hpp
 #define _aer_stabilizer_state_hpp
 
-#include "framework/utils.hpp"
+#include "clifford.hpp"
 #include "framework/json.hpp"
+#include "framework/utils.hpp"
 #include "simulators/state.hpp"
-#include "clifford.hpp"
 
 namespace AER {
 namespace Stabilizer {
@@ -30,38 +30,38 @@ using OpType = Operations::OpType;
 
 // OpSet of supported instructions
 const Operations::OpSet StateOpSet(
-  // Op types
-  {OpType::gate, OpType::measure,
-    OpType::reset, OpType::snapshot,
-    OpType::barrier, OpType::bfunc, OpType::qerror_loc,
-    OpType::roerror, OpType::save_expval,
-    OpType::save_expval_var, OpType::save_probs,
-    OpType::save_probs_ket, OpType::save_amps_sq,
-    OpType::save_stabilizer, OpType::save_clifford,
-    OpType::save_state, OpType::set_stabilizer,
-    OpType::jump, OpType::mark
-  },
-  // Gates
-  {"CX", "cx", "cy", "cz", "swap", "id", "x", "y", "z", "h", "s", "sdg",
-   "sx", "sxdg", "delay", "pauli"},
-  // Snapshots
-  {"stabilizer", "memory", "register", "probabilities",
-    "probabilities_with_variance", "expectation_value_pauli",
-    "expectation_value_pauli_with_variance",
-    "expectation_value_pauli_single_shot"}
-);
-
-enum class Gates {id, x, y, z, h, s, sdg, sx, sxdg, cx, cy, cz, swap, pauli};
+    // Op types
+    {OpType::gate, OpType::measure, OpType::reset, OpType::snapshot,
+     OpType::barrier, OpType::bfunc, OpType::qerror_loc, OpType::roerror,
+     OpType::save_expval, OpType::save_expval_var, OpType::save_probs,
+     OpType::save_probs_ket, OpType::save_amps_sq, OpType::save_stabilizer,
+     OpType::save_clifford, OpType::save_state, OpType::set_stabilizer,
+     OpType::jump, OpType::mark},
+    // Gates
+    {"CX", "cx", "cy", "cz", "swap", "id", "x", "y", "z", "h", "s", "sdg", "sx",
+     "sxdg", "delay", "pauli"},
+    // Snapshots
+    {"stabilizer", "memory", "register", "probabilities",
+     "probabilities_with_variance", "expectation_value_pauli",
+     "expectation_value_pauli_with_variance",
+     "expectation_value_pauli_single_shot"});
+
+enum class Gates { id, x, y, z, h, s, sdg, sx, sxdg, cx, cy, cz, swap, pauli };
 
 // Allowed snapshots enum class
 enum class Snapshots {
-  stabilizer, cmemory, cregister,
-    probs, probs_var,
-    expval_pauli, expval_pauli_var, expval_pauli_shot
+  stabilizer,
+  cmemory,
+  cregister,
+  probs,
+  probs_var,
+  expval_pauli,
+  expval_pauli_var,
+  expval_pauli_shot
 };
 
 // Enum class for different types of expectation values
-enum class SnapshotDataType {average, average_var, pershot};
+enum class SnapshotDataType { average, average_var, pershot };
 
 //============================================================================
 // Stabilizer Table state class
@@ -81,35 +81,31 @@ class State : public QuantumState::State<Clifford::Clifford> {
   //-----------------------------------------------------------------------
 
   // Return the string name of the State class
-  virtual std::string name() const override {return "stabilizer";}
+  virtual std::string name() const override { return "stabilizer"; }
 
   // Apply an operation
   // If the op is not in allowed_ops an exeption will be raised.
-  virtual void apply_op(const Operations::Op &op,
-                        ExperimentResult &result,
-                        RngEngine &rng,
-                        bool final_op = false) override;
+  virtual void apply_op(const Operations::Op &op, ExperimentResult &result,
+                        RngEngine &rng, bool final_op = false) override;
 
   // Initializes an n-qubit state to the all |0> state
   virtual void initialize_qreg(uint_t num_qubits) override;
 
   // TODO: currently returns 0
   // Returns the required memory for storing an n-qubit state in megabytes.
-  virtual size_t required_memory_mb(uint_t num_qubits,
-                                    const std::vector<Operations::Op> &ops)
-                                    const override;
+  virtual size_t
+  required_memory_mb(uint_t num_qubits,
+                     const std::vector<Operations::Op> &ops) const override;
 
   // Load any settings for the State class from a config JSON
   virtual void set_config(const json_t &config) override;
 
   // Sample n-measurement outcomes without applying the measure operation
   // to the system state
-  virtual std::vector<reg_t> sample_measure(const reg_t& qubits,
-                                            uint_t shots,
+  virtual std::vector<reg_t> sample_measure(const reg_t &qubits, uint_t shots,
                                             RngEngine &rng) override;
 
 protected:
-
   //-----------------------------------------------------------------------
   // Apply instructions
   //-----------------------------------------------------------------------
@@ -120,16 +116,14 @@ class State : public QuantumState::State<Clifford::Clifford> {
 
   // Applies a sypported Gate operation to the state class.
   // If the input is not in allowed_gates an exeption will be raised.
-  void apply_pauli(const reg_t &qubits, const std::string& pauli);
+  void apply_pauli(const reg_t &qubits, const std::string &pauli);
 
   // Measure qubits and return a list of outcomes [q0, q1, ...]
   // If a state subclass supports this function then "measure"
   // should be contained in the set returned by the 'allowed_ops'
   // method.
-  virtual void apply_measure(const reg_t &qubits,
-                             const reg_t &cmemory,
-                             const reg_t &cregister,
-                             RngEngine &rng);
+  virtual void apply_measure(const reg_t &qubits, const reg_t &cmemory,
+                             const reg_t &cregister, RngEngine &rng);
 
   // Reset the specified qubits to the |0> state by simulating
   // a measurement, applying a conditional x-gate if the outcome is 1, and
@@ -138,7 +132,8 @@ class State : public QuantumState::State<Clifford::Clifford> {
 
   // Apply a supported snapshot instruction
   // If the input is not in allowed_snapshots an exeption will be raised.
-  virtual void apply_snapshot(const Operations::Op &op, ExperimentResult &result);
+  virtual void apply_snapshot(const Operations::Op &op,
+                              ExperimentResult &result);
 
   // Set the state of the simulator to a given Clifford
   void apply_set_stabilizer(const Clifford::Clifford &clifford);
@@ -148,7 +143,8 @@ class State : public QuantumState::State<Clifford::Clifford> {
   //-----------------------------------------------------------------------
 
   // Save Clifford state of simulator
-  void apply_save_stabilizer(const Operations::Op &op, ExperimentResult &result);
+  void apply_save_stabilizer(const Operations::Op &op,
+                             ExperimentResult &result);
 
   // Save probabilities
   void apply_save_probs(const Operations::Op &op, ExperimentResult &result);
@@ -159,22 +155,18 @@ class State : public QuantumState::State<Clifford::Clifford> {
 
   // Helper function for computing expectation value
   virtual double expval_pauli(const reg_t &qubits,
-                              const std::string& pauli) override;
+                              const std::string &pauli) override;
 
   // Return the probability of an outcome bitstring.
   double get_probability(const reg_t &qubits, const std::string &outcome);
 
   template <typename T>
-  void get_probabilities_auxiliary(const reg_t& qubits,
-					std::string outcome,
-					double outcome_prob,
-					T& probs);
-
-  void get_probability_helper(const reg_t& qubits,
-	                            const std::string &outcome,
-                              std::string &outcome_carry,
-                              double &prob_carry);
-  
+  void get_probabilities_auxiliary(const reg_t &qubits, std::string outcome,
+                                   double outcome_prob, T &probs);
+
+  void get_probability_helper(const reg_t &qubits, const std::string &outcome,
+                              std::string &outcome_carry, double &prob_carry);
+
   //-----------------------------------------------------------------------
   // Measurement Helpers
   //-----------------------------------------------------------------------
@@ -193,15 +185,13 @@ class State : public QuantumState::State<Clifford::Clifford> {
   // Snapshot the stabilizer state of the simulator.
   // This returns a list of stabilizer generators
   void snapshot_stabilizer(const Operations::Op &op, ExperimentResult &result);
-                            
+
   // Snapshot current qubit probabilities for a measurement (average)
   void snapshot_probabilities(const Operations::Op &op,
-                              ExperimentResult &result,
-                              bool variance);
+                              ExperimentResult &result, bool variance);
 
   // Snapshot the expectation value of a Pauli operator
-  void snapshot_pauli_expval(const Operations::Op &op,
-                             ExperimentResult &result,
+  void snapshot_pauli_expval(const Operations::Op &op, ExperimentResult &result,
                              SnapshotDataType type);
 
   //-----------------------------------------------------------------------
@@ -220,46 +210,42 @@ class State : public QuantumState::State<Clifford::Clifford> {
 
   // Table of allowed snapshot types to enum class members
   const static stringmap_t<Snapshots> snapshotset_;
-
 };
 
-
 //============================================================================
 // Implementation: Allowed ops and gateset
 //============================================================================
 
 const stringmap_t<Gates> State::gateset_({
-  // Single qubit gates
-  {"delay", Gates::id},// Delay gate
-  {"id", Gates::id},   // Pauli-Identity gate
-  {"x", Gates::x},     // Pauli-X gate
-  {"y", Gates::y},     // Pauli-Y gate
-  {"z", Gates::z},     // Pauli-Z gate
-  {"s", Gates::s},     // Phase gate (aka sqrt(Z) gate)
-  {"sdg", Gates::sdg}, // Conjugate-transpose of Phase gate
-  {"h", Gates::h},     // Hadamard gate (X + Z / sqrt(2))
-  {"sx", Gates::sx},   // Sqrt X gate.
-  {"sxdg", Gates::sxdg}, // Inverse Sqrt X gate.
-  // Two-qubit gates
-  {"CX", Gates::cx},    // Controlled-X gate (CNOT)
-  {"cx", Gates::cx},    // Controlled-X gate (CNOT),
-  {"cy", Gates::cy},    // Controlled-Y gate
-  {"cz", Gates::cz},    // Controlled-Z gate
-  {"swap", Gates::swap},  // SWAP gate
-  {"pauli", Gates::pauli} // Pauli gate
-});
-
-const stringmap_t<Snapshots> State::snapshotset_({
-  {"stabilizer", Snapshots::stabilizer},
-  {"memory", Snapshots::cmemory},
-  {"register", Snapshots::cregister},
-  {"probabilities", Snapshots::probs},
-  {"probabilities_with_variance", Snapshots::probs_var},
-  {"expectation_value_pauli", Snapshots::expval_pauli}, 
-  {"expectation_value_pauli_with_variance", Snapshots::expval_pauli_var},
-  {"expectation_value_pauli_single_shot", Snapshots::expval_pauli_shot}
+    // Single qubit gates
+    {"delay", Gates::id},  // Delay gate
+    {"id", Gates::id},     // Pauli-Identity gate
+    {"x", Gates::x},       // Pauli-X gate
+    {"y", Gates::y},       // Pauli-Y gate
+    {"z", Gates::z},       // Pauli-Z gate
+    {"s", Gates::s},       // Phase gate (aka sqrt(Z) gate)
+    {"sdg", Gates::sdg},   // Conjugate-transpose of Phase gate
+    {"h", Gates::h},       // Hadamard gate (X + Z / sqrt(2))
+    {"sx", Gates::sx},     // Sqrt X gate.
+    {"sxdg", Gates::sxdg}, // Inverse Sqrt X gate.
+    // Two-qubit gates
+    {"CX", Gates::cx},      // Controlled-X gate (CNOT)
+    {"cx", Gates::cx},      // Controlled-X gate (CNOT),
+    {"cy", Gates::cy},      // Controlled-Y gate
+    {"cz", Gates::cz},      // Controlled-Z gate
+    {"swap", Gates::swap},  // SWAP gate
+    {"pauli", Gates::pauli} // Pauli gate
 });
 
+const stringmap_t<Snapshots> State::snapshotset_(
+    {{"stabilizer", Snapshots::stabilizer},
+     {"memory", Snapshots::cmemory},
+     {"register", Snapshots::cregister},
+     {"probabilities", Snapshots::probs},
+     {"probabilities_with_variance", Snapshots::probs_var},
+     {"expectation_value_pauli", Snapshots::expval_pauli},
+     {"expectation_value_pauli_with_variance", Snapshots::expval_pauli_var},
+     {"expectation_value_pauli_single_shot", Snapshots::expval_pauli_shot}});
 
 //============================================================================
 // Implementation: Base class method overrides
@@ -278,8 +264,7 @@ void State::initialize_qreg(uint_t num_qubits) {
 //-------------------------------------------------------------------------
 
 size_t State::required_memory_mb(uint_t num_qubits,
-                                 const std::vector<Operations::Op> &ops)
-                                 const  {
+                                 const std::vector<Operations::Op> &ops) const {
   (void)ops; // avoid unused variable compiler warning
   // The Clifford object requires very little memory.
   // A Pauli vector consists of 2 binary vectors each with
@@ -288,7 +273,7 @@ size_t State::required_memory_mb(uint_t num_qubits,
   size_t mem = 16 * (4 + num_qubits); // Pauli bytes
   // Clifford = 2n * Pauli + 2n phase ints
   mem = 2 * num_qubits * (mem + 16); // Clifford bytes
-  mem = mem >> 20; // Clifford mb
+  mem = mem >> 20;                   // Clifford mb
   return mem;
 }
 
@@ -297,7 +282,8 @@ void State::set_config(const json_t &config) {
   JSON::get_value(json_chop_threshold_, "zero_threshold", config);
 
   // Load max snapshot qubit size and set hard limit of 64 qubits.
-  JSON::get_value(max_qubits_snapshot_probs_, "stabilizer_max_snapshot_probabilities", config);
+  JSON::get_value(max_qubits_snapshot_probs_,
+                  "stabilizer_max_snapshot_probabilities", config);
   max_qubits_snapshot_probs_ = std::max<uint_t>(max_qubits_snapshot_probs_, 64);
 }
 
@@ -305,145 +291,145 @@ void State::set_config(const json_t &config) {
 // Implementation: apply operations
 //=========================================================================
 
-void State::apply_op(const Operations::Op &op,
-                     ExperimentResult &result,
+void State::apply_op(const Operations::Op &op, ExperimentResult &result,
                      RngEngine &rng, bool final_op) {
   if (BaseState::creg().check_conditional(op)) {
     switch (op.type) {
-      case OpType::barrier:
-      case OpType::qerror_loc:
-        break;
-      case OpType::reset:
-        apply_reset(op.qubits, rng);
-        break;
-      case OpType::measure:
-        apply_measure(op.qubits, op.memory, op.registers, rng);
-        break;
-      case OpType::bfunc:
-        BaseState::creg().apply_bfunc(op);
-        break;
-      case OpType::roerror:
-        BaseState::creg().apply_roerror(op, rng);
-        break;
-      case OpType::gate:
-        apply_gate(op);
-        break;
-      case OpType::snapshot:
-        apply_snapshot(op, result);
-        break;
-      case OpType::set_stabilizer:
-        apply_set_stabilizer(op.clifford);
-        break;
-      case OpType::save_expval:
-      case OpType::save_expval_var:
-        apply_save_expval(op, result);
-        break;
-      case OpType::save_probs:
-      case OpType::save_probs_ket:
-        apply_save_probs(op, result);
-        break;
-      case OpType::save_amps_sq:
-        apply_save_amplitudes_sq(op, result);
-        break;
-      case OpType::save_state:
-      case OpType::save_stabilizer:
-      case OpType::save_clifford:
-        apply_save_stabilizer(op, result);
-        break;
-      default:
-        throw std::invalid_argument("Stabilizer::State::invalid instruction \'" +
-                                    op.name + "\'.");
-    }
-  }
-}
-
-void State::apply_gate(const Operations::Op &op) {
-  // Check Op is supported by State
-  auto it = gateset_.find(op.name);
-  if (it == gateset_.end())
-    throw std::invalid_argument("Stabilizer::State::invalid gate instruction \'" +
-                                op.name + "\'.");
-  switch (it -> second) {
-    case Gates::id:
-      break;
-    case Gates::x:
-      BaseState::qreg_.append_x(op.qubits[0]);
-      break;
-    case Gates::y:
-      BaseState::qreg_.append_y(op.qubits[0]);
+    case OpType::barrier:
+    case OpType::qerror_loc:
       break;
-    case Gates::z:
-      BaseState::qreg_.append_z(op.qubits[0]);
+    case OpType::reset:
+      apply_reset(op.qubits, rng);
       break;
-    case Gates::h:
-      BaseState::qreg_.append_h(op.qubits[0]);
+    case OpType::measure:
+      apply_measure(op.qubits, op.memory, op.registers, rng);
       break;
-    case Gates::s:
-      BaseState::qreg_.append_s(op.qubits[0]);
+    case OpType::bfunc:
+      BaseState::creg().apply_bfunc(op);
       break;
-    case Gates::sdg:
-      BaseState::qreg_.append_z(op.qubits[0]);
-      BaseState::qreg_.append_s(op.qubits[0]);
+    case OpType::roerror:
+      BaseState::creg().apply_roerror(op, rng);
       break;
-    case Gates::sx:
-      BaseState::qreg_.append_z(op.qubits[0]);
-      BaseState::qreg_.append_s(op.qubits[0]);
-      BaseState::qreg_.append_h(op.qubits[0]);
-      BaseState::qreg_.append_z(op.qubits[0]);
-      BaseState::qreg_.append_s(op.qubits[0]);
+    case OpType::gate:
+      apply_gate(op);
       break;
-    case Gates::sxdg:
-      BaseState::qreg_.append_s(op.qubits[0]);
-      BaseState::qreg_.append_h(op.qubits[0]);
-      BaseState::qreg_.append_s(op.qubits[0]);
+    case OpType::snapshot:
+      apply_snapshot(op, result);
       break;
-    case Gates::cx:
-      BaseState::qreg_.append_cx(op.qubits[0], op.qubits[1]);
+    case OpType::set_stabilizer:
+      apply_set_stabilizer(op.clifford);
       break;
-    case Gates::cz:
-      BaseState::qreg_.append_h(op.qubits[1]);
-      BaseState::qreg_.append_cx(op.qubits[0], op.qubits[1]);
-      BaseState::qreg_.append_h(op.qubits[1]);
+    case OpType::save_expval:
+    case OpType::save_expval_var:
+      apply_save_expval(op, result);
       break;
-    case Gates::cy:
-      BaseState::qreg_.append_z(op.qubits[1]);
-      BaseState::qreg_.append_s(op.qubits[1]);
-      BaseState::qreg_.append_cx(op.qubits[0], op.qubits[1]);
-      BaseState::qreg_.append_s(op.qubits[1]);
+    case OpType::save_probs:
+    case OpType::save_probs_ket:
+      apply_save_probs(op, result);
       break;
-    case Gates::swap:
-      BaseState::qreg_.append_cx(op.qubits[0], op.qubits[1]);
-      BaseState::qreg_.append_cx(op.qubits[1], op.qubits[0]);
-      BaseState::qreg_.append_cx(op.qubits[0], op.qubits[1]);
+    case OpType::save_amps_sq:
+      apply_save_amplitudes_sq(op, result);
       break;
-    case Gates::pauli:
-      apply_pauli(op.qubits, op.string_params[0]);
+    case OpType::save_state:
+    case OpType::save_stabilizer:
+    case OpType::save_clifford:
+      apply_save_stabilizer(op, result);
       break;
     default:
-      // We shouldn't reach here unless there is a bug in gateset
-      throw std::invalid_argument("Stabilizer::State::invalid gate instruction \'" +
+      throw std::invalid_argument("Stabilizer::State::invalid instruction \'" +
                                   op.name + "\'.");
+    }
+  }
+}
+
+void State::apply_gate(const Operations::Op &op) {
+  // Check Op is supported by State
+  auto it = gateset_.find(op.name);
+  if (it == gateset_.end())
+    throw std::invalid_argument(
+        "Stabilizer::State::invalid gate instruction \'" + op.name + "\'.");
+  switch (it->second) {
+  case Gates::id:
+    break;
+  case Gates::x:
+    BaseState::qreg_.append_x(op.qubits[0]);
+    break;
+  case Gates::y:
+    BaseState::qreg_.append_y(op.qubits[0]);
+    break;
+  case Gates::z:
+    BaseState::qreg_.append_z(op.qubits[0]);
+    break;
+  case Gates::h:
+    BaseState::qreg_.append_h(op.qubits[0]);
+    break;
+  case Gates::s:
+    BaseState::qreg_.append_s(op.qubits[0]);
+    break;
+  case Gates::sdg:
+    BaseState::qreg_.append_z(op.qubits[0]);
+    BaseState::qreg_.append_s(op.qubits[0]);
+    break;
+  case Gates::sx:
+    BaseState::qreg_.append_z(op.qubits[0]);
+    BaseState::qreg_.append_s(op.qubits[0]);
+    BaseState::qreg_.append_h(op.qubits[0]);
+    BaseState::qreg_.append_z(op.qubits[0]);
+    BaseState::qreg_.append_s(op.qubits[0]);
+    break;
+  case Gates::sxdg:
+    BaseState::qreg_.append_s(op.qubits[0]);
+    BaseState::qreg_.append_h(op.qubits[0]);
+    BaseState::qreg_.append_s(op.qubits[0]);
+    break;
+  case Gates::cx:
+    BaseState::qreg_.append_cx(op.qubits[0], op.qubits[1]);
+    break;
+  case Gates::cz:
+    BaseState::qreg_.append_h(op.qubits[1]);
+    BaseState::qreg_.append_cx(op.qubits[0], op.qubits[1]);
+    BaseState::qreg_.append_h(op.qubits[1]);
+    break;
+  case Gates::cy:
+    BaseState::qreg_.append_z(op.qubits[1]);
+    BaseState::qreg_.append_s(op.qubits[1]);
+    BaseState::qreg_.append_cx(op.qubits[0], op.qubits[1]);
+    BaseState::qreg_.append_s(op.qubits[1]);
+    break;
+  case Gates::swap:
+    BaseState::qreg_.append_cx(op.qubits[0], op.qubits[1]);
+    BaseState::qreg_.append_cx(op.qubits[1], op.qubits[0]);
+    BaseState::qreg_.append_cx(op.qubits[0], op.qubits[1]);
+    break;
+  case Gates::pauli:
+    apply_pauli(op.qubits, op.string_params[0]);
+    break;
+  default:
+    // We shouldn't reach here unless there is a bug in gateset
+    throw std::invalid_argument(
+        "Stabilizer::State::invalid gate instruction \'" + op.name + "\'.");
   }
 }
 
-void State::apply_pauli(const reg_t &qubits, const std::string& pauli) {
+void State::apply_pauli(const reg_t &qubits, const std::string &pauli) {
   const auto size = qubits.size();
   for (size_t i = 0; i < qubits.size(); ++i) {
     const auto qubit = qubits[size - 1 - i];
     switch (pauli[i]) {
-      case 'I':
-        break;
-      case 'X':
-        BaseState::qreg_.append_x(qubit);
-        break;
-      case 'Y':
-        BaseState::qreg_.append_y(qubit);
-        break;
-      case 'Z':
-        BaseState::qreg_.append_z(qubit);
-        break;
-      default:
-        throw std::invalid_argument("invalid Pauli \'" + std::to_string(pauli[i]) + "\'.");
+    case 'I':
+      break;
+    case 'X':
+      BaseState::qreg_.append_x(qubit);
+      break;
+    case 'Y':
+      BaseState::qreg_.append_y(qubit);
+      break;
+    case 'Z':
+      BaseState::qreg_.append_z(qubit);
+      break;
+    default:
+      throw std::invalid_argument("invalid Pauli \'" +
+                                  std::to_string(pauli[i]) + "\'.");
     }
   }
 }
@@ -452,34 +438,28 @@ void State::apply_pauli(const reg_t &qubits, const std::string& pauli) {
 // Implementation: Reset and Measurement Sampling
 //=========================================================================
 
-
-void State::apply_measure(const reg_t &qubits,
-                          const reg_t &cmemory,
-                          const reg_t &cregister,
-                          RngEngine &rng) {
+void State::apply_measure(const reg_t &qubits, const reg_t &cmemory,
+                          const reg_t &cregister, RngEngine &rng) {
   // Apply measurement and get classical outcome
   reg_t outcome = apply_measure_and_update(qubits, rng);
   // Add measurement outcome to creg
   BaseState::creg().store_measure(outcome, cmemory, cregister);
 }
 
-
 void State::apply_reset(const reg_t &qubits, RngEngine &rng) {
 
   // Apply measurement and get classical outcome
   reg_t outcome = apply_measure_and_update(qubits, rng);
   // Use the outcome to apply X gate to any qubits left in the
   // |1> state after measure, then discard outcome.
-  for (size_t j=0; j < qubits.size(); j++) {
+  for (size_t j = 0; j < qubits.size(); j++) {
     if (outcome[j] == 1) {
       qreg_.append_x(qubits[j]);
     }
   }
 }
 
-
-reg_t State::apply_measure_and_update(const reg_t &qubits,
-                                      RngEngine &rng) {
+reg_t State::apply_measure_and_update(const reg_t &qubits, RngEngine &rng) {
   // Measurement outcome probabilities in the clifford
   // table are either deterministic or random.
   // We generate the distribution for the random case
@@ -495,10 +475,10 @@ reg_t State::apply_measure_and_update(const reg_t &qubits,
   return outcome;
 }
 
-std::vector<reg_t> State::sample_measure(const reg_t &qubits,
-                                         uint_t shots,
+std::vector<reg_t> State::sample_measure(const reg_t &qubits, uint_t shots,
                                          RngEngine &rng) {
-  // TODO: see if we can improve efficiency by directly sampling from Clifford table
+  // TODO: see if we can improve efficiency by directly sampling from Clifford
+  // table
   auto qreg_cache = BaseState::qreg_;
   std::vector<reg_t> samples;
   samples.reserve(shots);
@@ -512,9 +492,9 @@ std::vector<reg_t> State::sample_measure(const reg_t &qubits,
 void State::apply_set_stabilizer(const Clifford::Clifford &clifford) {
   if (clifford.num_qubits() != BaseState::qreg_.num_qubits()) {
     throw std::invalid_argument(
-      "set stabilizer must be defined on full width of qubits (" +
-      std::to_string(clifford.num_qubits()) + " != " +
-      std::to_string(BaseState::qreg_.num_qubits()) + ").");
+        "set stabilizer must be defined on full width of qubits (" +
+        std::to_string(clifford.num_qubits()) +
+        " != " + std::to_string(BaseState::qreg_.num_qubits()) + ").");
   }
   BaseState::qreg_.table() = clifford.table();
   BaseState::qreg_.phases() = clifford.phases();
@@ -525,30 +505,32 @@ void State::apply_set_stabilizer(const Clifford::Clifford &clifford) {
 //=========================================================================
 
 void State::apply_save_stabilizer(const Operations::Op &op,
-                                ExperimentResult &result) {
+                                  ExperimentResult &result) {
   std::string key = op.string_params[0];
   OpType op_type = op.type;
   switch (op_type) {
-    case OpType::save_clifford: {
-      if (key == "_method_") {
-        key = "clifford";
-      }
-      break;
+  case OpType::save_clifford: {
+    if (key == "_method_") {
+      key = "clifford";
     }
-    case OpType::save_stabilizer:
-    case OpType::save_state: {
-      if (key == "_method_") {
-        key = "stabilizer";
-      }
-      op_type = OpType::save_stabilizer;
-      break;
+    break;
+  }
+  case OpType::save_stabilizer:
+  case OpType::save_state: {
+    if (key == "_method_") {
+      key = "stabilizer";
     }
-    default:
-      // We shouldn't ever reach here...
-      throw std::invalid_argument("Invalid save state instruction for stabilizer");
+    op_type = OpType::save_stabilizer;
+    break;
+  }
+  default:
+    // We shouldn't ever reach here...
+    throw std::invalid_argument(
+        "Invalid save state instruction for stabilizer");
   }
   json_t clifford = BaseState::qreg_;
-  result.save_data_pershot(creg(), key, std::move(clifford), op_type, op.save_type);
+  result.save_data_pershot(creg(), key, std::move(clifford), op_type,
+                           op.save_type);
 }
 
 void State::apply_save_probs(const Operations::Op &op,
@@ -560,106 +542,110 @@ void State::apply_save_probs(const Operations::Op &op,
   // to store.
   const size_t num_qubits = op.qubits.size();
   if (num_qubits > max_qubits_snapshot_probs_) {
-    std::string msg =
-        "Stabilizer::State::snapshot_probabilities: "
-        "cannot return measure probabilities for " +
-        std::to_string(num_qubits) + "-qubit measurement. Maximum is set to " +
-        std::to_string(max_qubits_snapshot_probs_);
+    std::string msg = "Stabilizer::State::snapshot_probabilities: "
+                      "cannot return measure probabilities for " +
+                      std::to_string(num_qubits) +
+                      "-qubit measurement. Maximum is set to " +
+                      std::to_string(max_qubits_snapshot_probs_);
     throw std::runtime_error(msg);
   }
   if (op.type == OpType::save_probs_ket) {
     std::map<std::string, double> probs;
-    get_probabilities_auxiliary(
-        op.qubits, std::string(op.qubits.size(), 'X'), 1, probs);
-    result.save_data_average(creg(), op.string_params[0],
-                             std::move(probs), op.type, op.save_type);
+    get_probabilities_auxiliary(op.qubits, std::string(op.qubits.size(), 'X'),
+                                1, probs);
+    result.save_data_average(creg(), op.string_params[0], std::move(probs),
+                             op.type, op.save_type);
   } else {
     std::vector<double> probs(1ULL << op.qubits.size(), 0.);
-    get_probabilities_auxiliary(
-      op.qubits, std::string(op.qubits.size(), 'X'), 1, probs); 
-    result.save_data_average(creg(), op.string_params[0],
-                             std::move(probs), op.type, op.save_type);
+    get_probabilities_auxiliary(op.qubits, std::string(op.qubits.size(), 'X'),
+                                1, probs);
+    result.save_data_average(creg(), op.string_params[0], std::move(probs),
+                             op.type, op.save_type);
   }
 }
 
 void State::apply_save_amplitudes_sq(const Operations::Op &op,
                                      ExperimentResult &result) {
   if (op.int_params.empty()) {
-    throw std::invalid_argument("Invalid save_amplitudes_sq instructions (empty params).");
+    throw std::invalid_argument(
+        "Invalid save_amplitudes_sq instructions (empty params).");
   }
   uint_t num_qubits = op.qubits.size();
   if (num_qubits != BaseState::qreg_.num_qubits()) {
-    throw std::invalid_argument("Save amplitude square must be defined on full width of qubits.");
+    throw std::invalid_argument(
+        "Save amplitude square must be defined on full width of qubits.");
   }
-  rvector_t amps_sq(op.int_params.size(), 1.0); // Must be initialized in 1 for helper func
+  rvector_t amps_sq(op.int_params.size(),
+                    1.0); // Must be initialized in 1 for helper func
   for (size_t i = 0; i < op.int_params.size(); i++) {
-    amps_sq[i] = get_probability(op.qubits, Utils::int2bin(op.int_params[i], num_qubits));
+    amps_sq[i] = get_probability(op.qubits,
+                                 Utils::int2bin(op.int_params[i], num_qubits));
   }
-  result.save_data_average(creg(), op.string_params[0],
-                           std::move(amps_sq), op.type, op.save_type);
+  result.save_data_average(creg(), op.string_params[0], std::move(amps_sq),
+                           op.type, op.save_type);
 }
 
-double State::expval_pauli(const reg_t &qubits,
-                           const std::string& pauli) {
+double State::expval_pauli(const reg_t &qubits, const std::string &pauli) {
   // Construct Pauli on N-qubits
   const auto num_qubits = BaseState::qreg_.num_qubits();
   Pauli::Pauli P(num_qubits);
   uint_t phase = 0;
   for (size_t i = 0; i < qubits.size(); ++i) {
     switch (pauli[pauli.size() - 1 - i]) {
-      case 'X':
-        P.X.set1(qubits[i]);
-        break;
-      case 'Y':
-        P.X.set1(qubits[i]);
-        P.Z.set1(qubits[i]);
-        phase += 1;
-        break;
-      case 'Z':
-        P.Z.set1(qubits[i]);
-        break;
-      default:
-        break;
+    case 'X':
+      P.X.set1(qubits[i]);
+      break;
+    case 'Y':
+      P.X.set1(qubits[i]);
+      P.Z.set1(qubits[i]);
+      phase += 1;
+      break;
+    case 'Z':
+      P.Z.set1(qubits[i]);
+      break;
+    default:
+      break;
     };
   }
 
-  // Check if there is a stabilizer that anti-commutes with an odd number of qubits
-  // If so expectation value is 0
+  // Check if there is a stabilizer that anti-commutes with an odd number of
+  // qubits If so expectation value is 0
   for (size_t i = 0; i < num_qubits; i++) {
-    const auto& stabi = BaseState::qreg_.stabilizer(i);
+    const auto &stabi = BaseState::qreg_.stabilizer(i);
     size_t num_anti = 0;
-    for (const auto& qubit : qubits) {
+    for (const auto &qubit : qubits) {
       if (P.Z[qubit] & stabi.X[qubit]) {
-	      num_anti++;
+        num_anti++;
       }
       if (P.X[qubit] & stabi.Z[qubit]) {
-	      num_anti++;
+        num_anti++;
       }
     }
-    if(num_anti % 2 == 1)
+    if (num_anti % 2 == 1)
       return 0.0;
   }
 
   // Otherwise P is (-1)^a prod_j S_j^b_j for Clifford stabilizers
   // If P anti-commutes with D_j then b_j = 1.
   // Multiply P by stabilizers with anti-commuting destabilizers
-  auto PZ = P.Z; // Make a copy of P.Z 
+  auto PZ = P.Z; // Make a copy of P.Z
   for (size_t i = 0; i < num_qubits; i++) {
     // Check if destabilizer anti-commutes
-    const auto& destabi = BaseState::qreg_.destabilizer(i);
+    const auto &destabi = BaseState::qreg_.destabilizer(i);
     size_t num_anti = 0;
-    for (const auto& qubit : qubits) {
+    for (const auto &qubit : qubits) {
       if (P.Z[qubit] & destabi.X[qubit]) {
-	      num_anti++;
+        num_anti++;
       }
       if (P.X[qubit] & destabi.Z[qubit]) {
-	      num_anti++;
+        num_anti++;
       }
     }
-    if (num_anti % 2 == 0) continue;
+    if (num_anti % 2 == 0)
+      continue;
 
     // If anti-commutes multiply Pauli by stabilizer
-    const auto& stabi = BaseState::qreg_.stabilizer(i);
+    const auto &stabi = BaseState::qreg_.stabilizer(i);
     phase += 2 * BaseState::qreg_.phases()[i + num_qubits];
     for (size_t k = 0; k < num_qubits; k++) {
       phase += stabi.Z[k] & stabi.X[k];
@@ -670,23 +656,20 @@ double State::expval_pauli(const reg_t &qubits,
   return (phase % 4) ? -1.0 : 1.0;
 }
 
-static void set_value_helper(std::map<std::string, double>& probs,
-                             const std::string &outcome,
-                             double value) {
+static void set_value_helper(std::map<std::string, double> &probs,
+                             const std::string &outcome, double value) {
   probs[Utils::bin2hex(outcome)] = value;
 }
 
-static void set_value_helper(std::vector<double>& probs,
-                             const std::string &outcome,
-                             double value) {
+static void set_value_helper(std::vector<double> &probs,
+                             const std::string &outcome, double value) {
   probs[std::stoull(outcome, 0, 2)] = value;
 }
 
 template <typename T>
 void State::get_probabilities_auxiliary(const reg_t &qubits,
                                         std::string outcome,
-                                        double outcome_prob,
-                                        T &probs) {
+                                        double outcome_prob, T &probs) {
   uint_t qubit_for_branching = -1;
   for (uint_t i = 0; i < qubits.size(); ++i) {
     uint_t qubit = qubits[qubits.size() - i - 1];
@@ -776,61 +759,57 @@ void State::get_probability_helper(const reg_t &qubits,
 // Implementation: Snapshots
 //=========================================================================
 
-void State::apply_snapshot(const Operations::Op &op,
-                           ExperimentResult &result) {
+void State::apply_snapshot(const Operations::Op &op, ExperimentResult &result) {
 
-// Look for snapshot type in snapshotset
+  // Look for snapshot type in snapshotset
   auto it = snapshotset_.find(op.name);
   if (it == snapshotset_.end())
-    throw std::invalid_argument("Stabilizer::State::invalid snapshot instruction \'" + 
-                                op.name + "\'.");
+    throw std::invalid_argument(
+        "Stabilizer::State::invalid snapshot instruction \'" + op.name + "\'.");
   switch (it->second) {
-    case Snapshots::stabilizer:
-      snapshot_stabilizer(op, result);
-      break;
-    case Snapshots::cmemory:
-      BaseState::snapshot_creg_memory(op, result);
-      break;
-    case Snapshots::cregister:
-      BaseState::snapshot_creg_register(op, result);
-      break;
-    case Snapshots::probs: {
-      snapshot_probabilities(op, result, false);
-    } break;
-    case Snapshots::probs_var: {
-      snapshot_probabilities(op, result, true);
-    } break;
-    case Snapshots::expval_pauli: {
-      snapshot_pauli_expval(op, result, SnapshotDataType::average);
-    } break;
-    case Snapshots::expval_pauli_var: {
-      snapshot_pauli_expval(op, result, SnapshotDataType::average_var);
-    } break;
-    case Snapshots::expval_pauli_shot: {
-      snapshot_pauli_expval(op, result, SnapshotDataType::pershot);
-    } break;
-    default:
-      // We shouldn't get here unless there is a bug in the snapshotset
-      throw std::invalid_argument("Stabilizer::State::invalid snapshot instruction \'" +
-                                  op.name + "\'.");
+  case Snapshots::stabilizer:
+    snapshot_stabilizer(op, result);
+    break;
+  case Snapshots::cmemory:
+    BaseState::snapshot_creg_memory(op, result);
+    break;
+  case Snapshots::cregister:
+    BaseState::snapshot_creg_register(op, result);
+    break;
+  case Snapshots::probs: {
+    snapshot_probabilities(op, result, false);
+  } break;
+  case Snapshots::probs_var: {
+    snapshot_probabilities(op, result, true);
+  } break;
+  case Snapshots::expval_pauli: {
+    snapshot_pauli_expval(op, result, SnapshotDataType::average);
+  } break;
+  case Snapshots::expval_pauli_var: {
+    snapshot_pauli_expval(op, result, SnapshotDataType::average_var);
+  } break;
+  case Snapshots::expval_pauli_shot: {
+    snapshot_pauli_expval(op, result, SnapshotDataType::pershot);
+  } break;
+  default:
+    // We shouldn't get here unless there is a bug in the snapshotset
+    throw std::invalid_argument(
+        "Stabilizer::State::invalid snapshot instruction \'" + op.name + "\'.");
   }
 }
 
-
-void State::snapshot_stabilizer(const Operations::Op &op, ExperimentResult &result) {
+void State::snapshot_stabilizer(const Operations::Op &op,
+                                ExperimentResult &result) {
   // We don't want to snapshot the full Clifford table, only the
   // stabilizer part. First Convert simulator clifford table to JSON
   json_t clifford = BaseState::qreg_;
   // Then extract the stabilizer generator list
-  result.legacy_data.add_pershot_snapshot("stabilizer",
-                               op.string_params[0],
-                               clifford["stabilizer"]);
+  result.legacy_data.add_pershot_snapshot("stabilizer", op.string_params[0],
+                                          clifford["stabilizer"]);
 }
 
-
 void State::snapshot_probabilities(const Operations::Op &op,
-                                   ExperimentResult &result,
-                                   bool variance) {
+                                   ExperimentResult &result, bool variance) {
   // Check number of qubits being measured is less than 64.
   // otherwise we cant use 64-bit int logic.
   // Practical limits are much lower. For example:
@@ -838,26 +817,27 @@ void State::snapshot_probabilities(const Operations::Op &op,
   // to store.
   const size_t num_qubits = op.qubits.size();
   if (num_qubits > max_qubits_snapshot_probs_) {
-    std::string msg =
-        "Stabilizer::State::snapshot_probabilities: "
-        "cannot return measure probabilities for " +
-        std::to_string(num_qubits) + "-qubit measurement. Maximum is set to " +
-        std::to_string(max_qubits_snapshot_probs_);
+    std::string msg = "Stabilizer::State::snapshot_probabilities: "
+                      "cannot return measure probabilities for " +
+                      std::to_string(num_qubits) +
+                      "-qubit measurement. Maximum is set to " +
+                      std::to_string(max_qubits_snapshot_probs_);
     throw std::runtime_error(msg);
   }
 
   std::map<std::string, double> probs;
-  get_probabilities_auxiliary(
-      op.qubits, std::string(op.qubits.size(), 'X'), 1, probs);
+  get_probabilities_auxiliary(op.qubits, std::string(op.qubits.size(), 'X'), 1,
+                              probs);
 
   // Add snapshot to data
   result.legacy_data.add_average_snapshot("probabilities", op.string_params[0],
-                            BaseState::creg().memory_hex(), probs, variance);
+                                          BaseState::creg().memory_hex(), probs,
+                                          variance);
 }
 
-
 void State::snapshot_pauli_expval(const Operations::Op &op,
-                                  ExperimentResult &result, SnapshotDataType type) {
+                                  ExperimentResult &result,
+                                  SnapshotDataType type) {
   // Check empty edge case
   if (op.params_expval_pauli.empty()) {
     throw std::invalid_argument(
@@ -875,21 +855,23 @@ void State::snapshot_pauli_expval(const Operations::Op &op,
   // add to snapshot
   Utils::chop_inplace(expval, json_chop_threshold_);
   switch (type) {
-    case SnapshotDataType::average:
-      result.legacy_data.add_average_snapshot("expectation_value", op.string_params[0],
-                            BaseState::creg().memory_hex(), expval, false);
-      break;
-    case SnapshotDataType::average_var:
-      result.legacy_data.add_average_snapshot("expectation_value", op.string_params[0],
-                            BaseState::creg().memory_hex(), expval, true);
-      break;
-    case SnapshotDataType::pershot:
-      result.legacy_data.add_pershot_snapshot("expectation_values", op.string_params[0], expval);
-      break;
+  case SnapshotDataType::average:
+    result.legacy_data.add_average_snapshot(
+        "expectation_value", op.string_params[0],
+        BaseState::creg().memory_hex(), expval, false);
+    break;
+  case SnapshotDataType::average_var:
+    result.legacy_data.add_average_snapshot(
+        "expectation_value", op.string_params[0],
+        BaseState::creg().memory_hex(), expval, true);
+    break;
+  case SnapshotDataType::pershot:
+    result.legacy_data.add_pershot_snapshot("expectation_values",
+                                            op.string_params[0], expval);
+    break;
   }
 }
 
-
 //------------------------------------------------------------------------------
 } // end namespace Stabilizer
 //------------------------------------------------------------------------------
diff --git a/src/simulators/state.hpp b/src/simulators/state.hpp
index 8436042e0d..5fcb420c97 100644
--- a/src/simulators/state.hpp
+++ b/src/simulators/state.hpp
@@ -15,11 +15,11 @@
 #ifndef _aer_base_state_hpp_
 #define _aer_base_state_hpp_
 
+#include "framework/creg.hpp"
 #include "framework/json.hpp"
 #include "framework/opset.hpp"
-#include "framework/types.hpp"
-#include "framework/creg.hpp"
 #include "framework/results/experiment_result.hpp"
+#include "framework/types.hpp"
 
 #include "noise/noise_model.hpp"
 
@@ -60,9 +60,7 @@ class Base {
   // For snapshot ops allowed snapshots are specified by a set of string names,
   // For example this could include {"probabilities", "pauli_observable"}
 
-  Base(const Operations::OpSet &opset) : opset_(opset) {
-    cregs_.resize(1);
-  }
+  Base(const Operations::OpSet &opset) : opset_(opset) { cregs_.resize(1); }
 
   virtual ~Base() = default;
 
@@ -71,8 +69,8 @@ class Base {
   //-----------------------------------------------------------------------
 
   // Return the state creg object
-  auto &creg(uint_t idx=0) { return cregs_[idx]; }
-  const auto &creg(uint_t idx=0) const { return cregs_[idx]; }
+  auto &creg(uint_t idx = 0) { return cregs_[idx]; }
+  const auto &creg(uint_t idx = 0) const { return cregs_[idx]; }
   std::vector<ClassicalRegister> &cregs() { return cregs_; }
   const std::vector<ClassicalRegister> &cregs() const { return cregs_; }
 
@@ -94,24 +92,27 @@ class Base {
   //
   // The implementation of these methods must be defined in all subclasses
   //-----------------------------------------------------------------------
-  
+
   // Return a string name for the State type
   virtual std::string name() const = 0;
 
   // Return an estimate of the required memory for implementing the
   // specified sequence of operations on a `num_qubit` sized State.
-  virtual size_t required_memory_mb(uint_t num_qubits,
-                                    const std::vector<Operations::Op> &ops)
-                                    const = 0;
-
-  //memory allocation (previously called before inisitalize_qreg)
-  virtual bool allocate(uint_t num_qubits,uint_t block_bits,uint_t num_parallel_shots = 1){return true;}
+  virtual size_t
+  required_memory_mb(uint_t num_qubits,
+                     const std::vector<Operations::Op> &ops) const = 0;
+
+  // memory allocation (previously called before inisitalize_qreg)
+  virtual bool allocate(uint_t num_qubits, uint_t block_bits,
+                        uint_t num_parallel_shots = 1) {
+    return true;
+  }
 
   // Return the expectation value of a N-qubit Pauli operator
   // If the simulator does not support Pauli expectation value this should
   // raise an exception.
   virtual double expval_pauli(const reg_t &qubits,
-                              const std::string& pauli) = 0;
+                              const std::string &pauli) = 0;
 
   // Initializes the State to the default state.
   // Typically this is the n-qubit all |0> state
@@ -125,8 +126,7 @@ class Base {
   virtual void initialize_creg(uint_t num_memory, uint_t num_register);
 
   // Initialize classical memory and register to specific values
-  virtual void initialize_creg(uint_t num_memory,
-                               uint_t num_register,
+  virtual void initialize_creg(uint_t num_memory, uint_t num_register,
                                const std::string &memory_hex,
                                const std::string &register_hex);
 
@@ -135,16 +135,14 @@ class Base {
   //-----------------------------------------------------------------------
 
   // Apply the global phase
-  virtual void apply_global_phase() {};
+  virtual void apply_global_phase(){};
 
   // Apply a single operation
   // The `final_op` flag indicates no more instructions will be applied
   // to the state after this sequence, so the state can be modified at the
   // end of the instructions.
-  virtual void apply_op(const Operations::Op &op,
-                        ExperimentResult &result,
-                        RngEngine& rng,
-                        bool final_op = false) = 0;
+  virtual void apply_op(const Operations::Op &op, ExperimentResult &result,
+                        RngEngine &rng, bool final_op = false) = 0;
 
   // Apply a sequence of operations to the current state of the State class.
   // It is up to the State subclass to decide how this sequence should be
@@ -154,18 +152,18 @@ class Base {
   // The `final_ops` flag indicates no more instructions will be applied
   // to the state after this sequence, so the state can be modified at the
   // end of the instructions.
-  virtual void apply_ops(OpItr first, OpItr last,
-                         ExperimentResult &result, RngEngine &rng, bool final_ops = false);
+  virtual void apply_ops(OpItr first, OpItr last, ExperimentResult &result,
+                         RngEngine &rng, bool final_ops = false);
 
-  //apply ops to multiple shots
-  //this function should be separately defined since apply_ops is called in quantum_error
+  // apply ops to multiple shots
+  // this function should be separately defined since apply_ops is called in
+  // quantum_error
   void apply_ops_multi_shots(OpItr first, OpItr last,
                              const Noise::NoiseModel &noise,
-                             ExperimentResult &result,
-                             uint_t rng_seed,
-                             bool final_ops = false)
-  {
-    throw std::invalid_argument("apply_ops_multi_shots is not supported in State " + name());
+                             ExperimentResult &result, uint_t rng_seed,
+                             bool final_ops = false) {
+    throw std::invalid_argument(
+        "apply_ops_multi_shots is not supported in State " + name());
   }
 
   //-----------------------------------------------------------------------
@@ -176,12 +174,11 @@ class Base {
   virtual void set_config(const json_t &config);
 
   //-----------------------------------------------------------------------
-  // Optional: Add information to metadata 
+  // Optional: Add information to metadata
   //-----------------------------------------------------------------------
 
   // Every state can add information to the metadata structure
-  virtual void add_metadata(ExperimentResult &result) const {
-  }
+  virtual void add_metadata(ExperimentResult &result) const {}
 
   //-----------------------------------------------------------------------
   // Optional: measurement sampling
@@ -194,8 +191,7 @@ class Base {
   // to the system state. Even though this method is not marked as const
   // at the end of sample the system should be left in the same state
   // as before sampling
-  virtual std::vector<reg_t> sample_measure(const reg_t &qubits,
-                                            uint_t shots,
+  virtual std::vector<reg_t> sample_measure(const reg_t &qubits, uint_t shots,
                                             RngEngine &rng);
 
   //-----------------------------------------------------------------------
@@ -204,7 +200,7 @@ class Base {
 
   // Sets the number of threads available to the State implementation
   // If negative there is no restriction on the backend
-  virtual inline void set_parallelization(int n) {threads_ = n;}
+  virtual inline void set_parallelization(int n) { threads_ = n; }
 
   // Set a complex global phase value exp(1j * theta) for the state
   void set_global_phase(double theta);
@@ -212,28 +208,25 @@ class Base {
   // Set a complex global phase value exp(1j * theta) for the state
   void add_global_phase(double theta);
 
-  //set number of processes to be distributed
-  virtual void set_distribution(uint_t nprocs){}
+  // set number of processes to be distributed
+  virtual void set_distribution(uint_t nprocs) {}
 
-  //set maximum number of qubits for matrix multiplication
-  virtual void set_max_matrix_qubits(int_t bits)
-  {
-    max_matrix_qubits_ = bits;
-  }
+  // set maximum number of qubits for matrix multiplication
+  virtual void set_max_matrix_qubits(int_t bits) { max_matrix_qubits_ = bits; }
 
-  //set max number of shots to execute in a batch (used in StateChunk class)
-  virtual void set_max_bached_shots(uint_t shots){}
+  // set max number of shots to execute in a batch (used in StateChunk class)
+  virtual void set_max_bached_shots(uint_t shots) {}
 
-  //Does this state support multi-chunk distribution?
-  virtual bool multi_chunk_distribution_supported(void){return false;}
+  // Does this state support multi-chunk distribution?
+  virtual bool multi_chunk_distribution_supported(void) { return false; }
 
-  //Does this state support multi-shot parallelization?
-  virtual bool multi_shot_parallelization_supported(void){return false;}
+  // Does this state support multi-shot parallelization?
+  virtual bool multi_shot_parallelization_supported(void) { return false; }
 
   //-----------------------------------------------------------------------
   // Common instructions
   //-----------------------------------------------------------------------
- 
+
   // Apply a save expectation value instruction
   void apply_save_expval(const Operations::Op &op, ExperimentResult &result);
 
@@ -246,11 +239,11 @@ class Base {
                             std::string name = "memory") const;
 
   // Snapshot the classical register bits state (single-shot)
-  void snapshot_creg_register(const Operations::Op &op, ExperimentResult &result,
+  void snapshot_creg_register(const Operations::Op &op,
+                              ExperimentResult &result,
                               std::string name = "register") const;
 
 protected:
-
   // Classical register data
   std::vector<ClassicalRegister> cregs_;
 
@@ -270,21 +263,19 @@ class Base {
   std::string sim_device_name_ = "CPU";
 };
 
-void Base::set_config(const json_t &config) 
-{
+void Base::set_config(const json_t &config) {
   JSON::get_value(sim_device_name_, "device", config);
 }
 
-std::vector<reg_t> Base::sample_measure(const reg_t &qubits,
-                                             uint_t shots,
-                                             RngEngine &rng) {
-  (ignore_argument)qubits;
-  (ignore_argument)shots;
+std::vector<reg_t> Base::sample_measure(const reg_t &qubits, uint_t shots,
+                                        RngEngine &rng) {
+  (ignore_argument) qubits;
+  (ignore_argument) shots;
   return std::vector<reg_t>();
 }
 
 void Base::apply_ops(const OpItr first, const OpItr last,
-                          ExperimentResult &result, RngEngine &rng, bool final_ops) {
+                     ExperimentResult &result, RngEngine &rng, bool final_ops) {
 
   std::unordered_map<std::string, OpItr> marks;
   // Simple loop over vector of input operations
@@ -296,7 +287,7 @@ void Base::apply_ops(const OpItr first, const OpItr last,
     }
     case Operations::OpType::jump: {
       if (creg().check_conditional(*it)) {
-        const auto& mark_name = it->string_params[0];
+        const auto &mark_name = it->string_params[0];
         auto mark_it = marks.find(mark_name);
         if (mark_it != marks.end()) {
           it = mark_it->second;
@@ -311,7 +302,8 @@ void Base::apply_ops(const OpItr first, const OpItr last,
           }
           if (it == last) {
             std::stringstream msg;
-            msg << "Invalid jump destination:\"" << mark_name << "\"." << std::endl;
+            msg << "Invalid jump destination:\"" << mark_name << "\"."
+                << std::endl;
             throw std::runtime_error(msg.str());
           }
         }
@@ -325,20 +317,17 @@ void Base::apply_ops(const OpItr first, const OpItr last,
   }
 };
 
-void Base::initialize_creg(uint_t num_memory, uint_t num_register) 
-{
+void Base::initialize_creg(uint_t num_memory, uint_t num_register) {
   creg().initialize(num_memory, num_register);
 }
 
-void Base::initialize_creg(uint_t num_memory,
-                                uint_t num_register,
-                                const std::string &memory_hex,
-                                const std::string &register_hex) {
+void Base::initialize_creg(uint_t num_memory, uint_t num_register,
+                           const std::string &memory_hex,
+                           const std::string &register_hex) {
   creg().initialize(num_memory, num_register, memory_hex, register_hex);
 }
 
-template <class state_t>
-class State: public Base {
+template <class state_t> class State : public Base {
 
 public:
   using ignore_argument = void;
@@ -369,12 +358,11 @@ class State: public Base {
 
   State(const Operations::OpSet &opset) : Base(opset) {}
 
-  State(const Operations::OpSet::optypeset_t &optypes,
-        const stringset_t &gates,
+  State(const Operations::OpSet::optypeset_t &optypes, const stringset_t &gates,
         const stringset_t &snapshots)
-    : State(Operations::OpSet(optypes, gates, snapshots)) {};
+      : State(Operations::OpSet(optypes, gates, snapshots)){};
 
-  virtual ~State() {};
+  virtual ~State(){};
 
   //-----------------------------------------------------------------------
   // Data accessors
@@ -389,16 +377,17 @@ class State: public Base {
   //-----------------------------------------------------------------------
 
   // Snapshot the current statevector (single-shot)
-  // if type_label is the empty string the operation type will be used for the type
-  virtual void snapshot_state(const Operations::Op &op, ExperimentResult &result,
-                      std::string name = "") const;
+  // if type_label is the empty string the operation type will be used for the
+  // type
+  virtual void snapshot_state(const Operations::Op &op,
+                              ExperimentResult &result,
+                              std::string name = "") const;
 
 protected:
   // The quantum state data structure
   state_t qreg_;
 };
 
-
 template <class state_t>
 void State<state_t>::snapshot_state(const Operations::Op &op,
                                     ExperimentResult &result,
@@ -411,41 +400,36 @@ void Base::set_global_phase(double theta) {
   if (Linalg::almost_equal(theta, 0.0)) {
     has_global_phase_ = false;
     global_phase_ = 1;
-  }
-  else {
+  } else {
     has_global_phase_ = true;
     global_phase_ = std::exp(complex_t(0.0, theta));
   }
 }
 
 void Base::add_global_phase(double theta) {
-  if (Linalg::almost_equal(theta, 0.0)) 
+  if (Linalg::almost_equal(theta, 0.0))
     return;
-  
+
   has_global_phase_ = true;
   global_phase_ *= std::exp(complex_t(0.0, theta));
 }
 
 void Base::snapshot_creg_memory(const Operations::Op &op,
-                                          ExperimentResult &result,
-                                          std::string name) const {
-  result.legacy_data.add_pershot_snapshot(name,
-                               op.string_params[0],
-                               creg().memory_hex());
+                                ExperimentResult &result,
+                                std::string name) const {
+  result.legacy_data.add_pershot_snapshot(name, op.string_params[0],
+                                          creg().memory_hex());
 }
 
-
 void Base::snapshot_creg_register(const Operations::Op &op,
-                                            ExperimentResult &result,
-                                            std::string name) const {
-  result.legacy_data.add_pershot_snapshot(name,
-                               op.string_params[0],
-                               creg().register_hex());
+                                  ExperimentResult &result,
+                                  std::string name) const {
+  result.legacy_data.add_pershot_snapshot(name, op.string_params[0],
+                                          creg().register_hex());
 }
 
-
 void Base::apply_save_expval(const Operations::Op &op,
-                                       ExperimentResult &result){
+                             ExperimentResult &result) {
   // Check empty edge case
   if (op.expval_params.empty()) {
     throw std::invalid_argument(
@@ -467,16 +451,18 @@ void Base::apply_save_expval(const Operations::Op &op,
   }
   if (variance) {
     std::vector<double> expval_var(2);
-    expval_var[0] = expval;  // mean
-    expval_var[1] = sq_expval - expval * expval;  // variance
-    result.save_data_average(creg(), op.string_params[0], expval_var, op.type, op.save_type);
+    expval_var[0] = expval;                      // mean
+    expval_var[1] = sq_expval - expval * expval; // variance
+    result.save_data_average(creg(), op.string_params[0], expval_var, op.type,
+                             op.save_type);
   } else {
-    result.save_data_average(creg(), op.string_params[0], expval, op.type, op.save_type);
+    result.save_data_average(creg(), op.string_params[0], expval, op.type,
+                             op.save_type);
   }
 }
 
 //-------------------------------------------------------------------------
-} // end namespace Base
+} // namespace QuantumState
 //-------------------------------------------------------------------------
 } // end namespace AER
 //-------------------------------------------------------------------------
diff --git a/src/simulators/state_chunk.hpp b/src/simulators/state_chunk.hpp
index 73c9b059eb..4888977c23 100644
--- a/src/simulators/state_chunk.hpp
+++ b/src/simulators/state_chunk.hpp
@@ -15,11 +15,11 @@
 #ifndef _aer_base_state_chunk_hpp_
 #define _aer_base_state_chunk_hpp_
 
+#include "framework/creg.hpp"
 #include "framework/json.hpp"
 #include "framework/opset.hpp"
-#include "framework/types.hpp"
-#include "framework/creg.hpp"
 #include "framework/results/experiment_result.hpp"
+#include "framework/types.hpp"
 
 #include "noise/noise_model.hpp"
 
@@ -35,15 +35,15 @@ namespace AER {
 
 namespace QuantumState {
 
-#define STATE_APPLY_TO_ALL_CHUNKS     0
+#define STATE_APPLY_TO_ALL_CHUNKS 0
 
 //=========================================================================
 // StateChunk interface base class with multiple chunks for Qiskit-Aer
-// The base state class that supports multi-chunk distribution/ multi-shot parallelization 
+// The base state class that supports multi-chunk distribution/ multi-shot
+// parallelization
 //=========================================================================
 
-template <class state_t>
-class StateChunk : public State<state_t> {
+template <class state_t> class StateChunk : public State<state_t> {
 
 public:
   using ignore_argument = void;
@@ -74,8 +74,7 @@ class StateChunk : public State<state_t> {
   // For snapshot ops allowed snapshots are specified by a set of string names,
   // For example this could include {"probabilities", "pauli_observable"}
 
-  StateChunk(const Operations::OpSet &opset) : BaseState(opset)
-  {
+  StateChunk(const Operations::OpSet &opset) : BaseState(opset) {
     num_global_chunks_ = 0;
     num_local_chunks_ = 0;
 
@@ -102,12 +101,16 @@ class StateChunk : public State<state_t> {
   //-----------------------------------------------------------------------
 
   // Return the state qreg object
-  auto &qreg(int_t idx=0) { return qregs_[idx]; }
-  const auto &qreg(int_t idx=0) const { return qregs_[idx]; }
+  auto &qreg(int_t idx = 0) { return qregs_[idx]; }
+  const auto &qreg(int_t idx = 0) const { return qregs_[idx]; }
 
   // Return the creg object
-  auto &chunk_creg(uint_t iChunk) { return BaseState::creg(get_global_shot_index(iChunk)); }
-  const auto &chunk_creg(uint_t iChunk) const { return BaseState::creg(get_global_shot_index(iChunk)); }
+  auto &chunk_creg(uint_t iChunk) {
+    return BaseState::creg(get_global_shot_index(iChunk));
+  }
+  const auto &chunk_creg(uint_t iChunk) const {
+    return BaseState::creg(get_global_shot_index(iChunk));
+  }
 
   //=======================================================================
   // Subclass Override Methods
@@ -123,7 +126,7 @@ class StateChunk : public State<state_t> {
   //
   // The implementation of these methods must be defined in all subclasses
   //-----------------------------------------------------------------------
-  
+
   // Return a string name for the StateChunk type
   virtual std::string name() const = 0;
 
@@ -133,20 +136,24 @@ class StateChunk : public State<state_t> {
 
   // Return an estimate of the required memory for implementing the
   // specified sequence of operations on a `num_qubit` sized StateChunk.
-  virtual size_t required_memory_mb(uint_t num_qubits,
-                                    const std::vector<Operations::Op> &ops)
-                                    const = 0;
+  virtual size_t
+  required_memory_mb(uint_t num_qubits,
+                     const std::vector<Operations::Op> &ops) const = 0;
 
-  //memory allocation (previously called before inisitalize_qreg)
-  virtual bool allocate(uint_t num_qubits,uint_t block_bits,uint_t num_parallel_shots = 1);
+  // memory allocation (previously called before inisitalize_qreg)
+  virtual bool allocate(uint_t num_qubits, uint_t block_bits,
+                        uint_t num_parallel_shots = 1);
 
   // Return the expectation value of a N-qubit Pauli operator
   // If the simulator does not support Pauli expectation value this should
   // raise an exception.
-  double expval_pauli(const reg_t &qubits,const std::string& pauli) override final {return 0.0;}
+  double expval_pauli(const reg_t &qubits,
+                      const std::string &pauli) override final {
+    return 0.0;
+  }
 
   virtual double expval_pauli(const int_t iChunk, const reg_t &qubits,
-                              const std::string& pauli) = 0;
+                              const std::string &pauli) = 0;
 
   //-----------------------------------------------------------------------
   // Optional: Load config settings
@@ -170,42 +177,35 @@ class StateChunk : public State<state_t> {
   // to the state after this sequence, so the state can be modified at the
   // end of the instructions.
 
-  //this is not used for StateChunk
-  void apply_op(const Operations::Op &op,
-                      ExperimentResult &result,
-                      RngEngine& rng,
-                      bool final_op = false) override final { apply_op(0, op, result, rng, final_op); }
+  // this is not used for StateChunk
+  void apply_op(const Operations::Op &op, ExperimentResult &result,
+                RngEngine &rng, bool final_op = false) override final {
+    apply_op(0, op, result, rng, final_op);
+  }
 
-  //so this one is used
+  // so this one is used
   virtual void apply_op(const int_t iChunk, const Operations::Op &op,
-                        ExperimentResult &result,
-                        RngEngine& rng,
+                        ExperimentResult &result, RngEngine &rng,
                         bool final_op = false) = 0;
 
-
-  // Apply a sequence of operations to the current state of the StateChunk class.
-  // It is up to the StateChunk subclass to decide how this sequence should be
-  // executed (ie in sequence, or some other execution strategy.)
-  // If this sequence contains operations not in the supported opset
-  // an exeption will be thrown.
-  // The `final_ops` flag indicates no more instructions will be applied
-  // to the state after this sequence, so the state can be modified at the
-  // end of the instructions.
-  void apply_ops(OpItr first,
-                 OpItr last,
-                 ExperimentResult &result,
-                 RngEngine &rng,
-                 bool final_ops = false) override;
-
-  //apply ops to multiple shots
-  //this function should be separately defined since apply_ops is called in quantum_error
+  // Apply a sequence of operations to the current state of the StateChunk
+  // class. It is up to the StateChunk subclass to decide how this sequence
+  // should be executed (ie in sequence, or some other execution strategy.) If
+  // this sequence contains operations not in the supported opset an exeption
+  // will be thrown. The `final_ops` flag indicates no more instructions will be
+  // applied to the state after this sequence, so the state can be modified at
+  // the end of the instructions.
+  void apply_ops(OpItr first, OpItr last, ExperimentResult &result,
+                 RngEngine &rng, bool final_ops = false) override;
+
+  // apply ops to multiple shots
+  // this function should be separately defined since apply_ops is called in
+  // quantum_error
   template <typename InputIterator>
-  void apply_ops_multi_shots(InputIterator first,
-                 InputIterator last,
-                 const Noise::NoiseModel &noise,
-                 ExperimentResult &result,
-                 uint_t rng_seed,
-                 bool final_ops = false);
+  void apply_ops_multi_shots(InputIterator first, InputIterator last,
+                             const Noise::NoiseModel &noise,
+                             ExperimentResult &result, uint_t rng_seed,
+                             bool final_ops = false);
 
   //-----------------------------------------------------------------------
   // Initialization
@@ -224,279 +224,286 @@ class StateChunk : public State<state_t> {
   virtual void initialize_creg(uint_t num_memory, uint_t num_register);
 
   // Initialize classical memory and register to specific values
-  virtual void initialize_creg(uint_t num_memory,
-                       uint_t num_register,
-                       const std::string &memory_hex,
-                       const std::string &register_hex);
+  virtual void initialize_creg(uint_t num_memory, uint_t num_register,
+                               const std::string &memory_hex,
+                               const std::string &register_hex);
 
   //-----------------------------------------------------------------------
   // Common instructions
   //-----------------------------------------------------------------------
- 
+
   // Apply a save expectation value instruction
-  void apply_save_expval(const int_t iChunk, const Operations::Op &op, ExperimentResult &result);
+  void apply_save_expval(const int_t iChunk, const Operations::Op &op,
+                         ExperimentResult &result);
 
   //-----------------------------------------------------------------------
   // Standard snapshots
   //-----------------------------------------------------------------------
 
   // Snapshot the current statevector (single-shot)
-  // if type_label is the empty string the operation type will be used for the type
-  virtual void snapshot_state(const int_t iChunk, const Operations::Op &op, ExperimentResult &result,
-                      std::string name = "") const;
+  // if type_label is the empty string the operation type will be used for the
+  // type
+  virtual void snapshot_state(const int_t iChunk, const Operations::Op &op,
+                              ExperimentResult &result,
+                              std::string name = "") const;
 
   // Snapshot the classical memory bits state (single-shot)
-  void snapshot_creg_memory(const int_t iChunk, const Operations::Op &op, ExperimentResult &result,
+  void snapshot_creg_memory(const int_t iChunk, const Operations::Op &op,
+                            ExperimentResult &result,
                             std::string name = "memory") const;
 
   // Snapshot the classical register bits state (single-shot)
-  void snapshot_creg_register(const int_t iChunk, const Operations::Op &op, ExperimentResult &result,
+  void snapshot_creg_register(const int_t iChunk, const Operations::Op &op,
+                              ExperimentResult &result,
                               std::string name = "register") const;
 
-
   //-----------------------------------------------------------------------
   // Config Settings
   //-----------------------------------------------------------------------
 
-
-  //set number of processes to be distributed
+  // set number of processes to be distributed
   virtual void set_distribution(uint_t nprocs);
 
-  //set max number of shots to execute in a batch
-  void set_max_bached_shots(uint_t shots)
-  {
-    max_batched_shots_ = shots;
-  }
+  // set max number of shots to execute in a batch
+  void set_max_bached_shots(uint_t shots) { max_batched_shots_ = shots; }
 
-  //Does this state support multi-chunk distribution?
-  virtual bool multi_chunk_distribution_supported(void){return true;}
-  //Does this state support multi-shot parallelization?
-  virtual bool multi_shot_parallelization_supported(void){return true;}
+  // Does this state support multi-chunk distribution?
+  virtual bool multi_chunk_distribution_supported(void) { return true; }
+  // Does this state support multi-shot parallelization?
+  virtual bool multi_shot_parallelization_supported(void) { return true; }
 
 protected:
-
   // The array of the quantum state data structure
   std::vector<state_t> qregs_;
 
-  //number of qubits for the circuit
+  // number of qubits for the circuit
   uint_t num_qubits_;
 
-  //extra parameters for parallel simulations
-  uint_t num_global_chunks_;    //number of total chunks 
-  uint_t num_local_chunks_;     //number of local chunks
-  uint_t chunk_bits_;           //number of qubits per chunk
-  uint_t block_bits_;           //number of cache blocked qubits
-
-  uint_t global_chunk_index_;   //beginning chunk index for this process
-  reg_t chunk_index_begin_;     //beginning chunk index for each process
-  reg_t chunk_index_end_;       //ending chunk index for each process
-  uint_t local_shot_index_;    //local shot ID of current batch loop
-
-  uint_t myrank_;               //process ID
-  uint_t nprocs_;               //number of processes
-  uint_t distributed_rank_;     //process ID in communicator group
-  uint_t distributed_procs_;    //number of processes in communicator group
-  uint_t distributed_group_;    //group id of distribution
-  int_t distributed_proc_bits_; //distributed_procs_=2^distributed_proc_bits_  (if nprocs != power of 2, set -1)
-
-  bool chunk_omp_parallel_;     //using thread parallel to process loop of chunks or not
-  bool global_chunk_indexing_;  //using global index for control qubits and diagonal matrix
-
-  bool multi_chunk_distribution_ = false; //distributing chunks to apply cache blocking parallelization
-  bool multi_shots_parallelization_ = false; //using chunks as multiple shots parallelization
-  bool set_parallelization_called_ = false;    //this flag is used to check set_parallelization is already called, if yes the call sets max_batched_shots_
-  uint_t max_batched_shots_ = 1;    //max number of shots can be stored on available memory
-
-  reg_t qubit_map_;             //qubit map to restore swapped qubits
-
-  bool multi_chunk_swap_enable_ = true;     //enable multi-chunk swaps
-  uint_t chunk_swap_buffer_qubits_ = 15;    //maximum buffer size in qubits for chunk swap
-  uint_t max_multi_swap_;                 //maximum swaps can be applied at a time, calculated by chunk_swap_buffer_bits_
-
-  //group of states (GPU devices)
-  uint_t num_groups_;            //number of groups of chunks
+  // extra parameters for parallel simulations
+  uint_t num_global_chunks_; // number of total chunks
+  uint_t num_local_chunks_;  // number of local chunks
+  uint_t chunk_bits_;        // number of qubits per chunk
+  uint_t block_bits_;        // number of cache blocked qubits
+
+  uint_t global_chunk_index_; // beginning chunk index for this process
+  reg_t chunk_index_begin_;   // beginning chunk index for each process
+  reg_t chunk_index_end_;     // ending chunk index for each process
+  uint_t local_shot_index_;   // local shot ID of current batch loop
+
+  uint_t myrank_;               // process ID
+  uint_t nprocs_;               // number of processes
+  uint_t distributed_rank_;     // process ID in communicator group
+  uint_t distributed_procs_;    // number of processes in communicator group
+  uint_t distributed_group_;    // group id of distribution
+  int_t distributed_proc_bits_; // distributed_procs_=2^distributed_proc_bits_
+                                // (if nprocs != power of 2, set -1)
+
+  bool chunk_omp_parallel_; // using thread parallel to process loop of chunks
+                            // or not
+  bool global_chunk_indexing_; // using global index for control qubits and
+                               // diagonal matrix
+
+  bool multi_chunk_distribution_ =
+      false; // distributing chunks to apply cache blocking parallelization
+  bool multi_shots_parallelization_ =
+      false; // using chunks as multiple shots parallelization
+  bool set_parallelization_called_ =
+      false; // this flag is used to check set_parallelization is already
+             // called, if yes the call sets max_batched_shots_
+  uint_t max_batched_shots_ =
+      1; // max number of shots can be stored on available memory
+
+  reg_t qubit_map_; // qubit map to restore swapped qubits
+
+  bool multi_chunk_swap_enable_ = true; // enable multi-chunk swaps
+  uint_t chunk_swap_buffer_qubits_ =
+      15;                 // maximum buffer size in qubits for chunk swap
+  uint_t max_multi_swap_; // maximum swaps can be applied at a time, calculated
+                          // by chunk_swap_buffer_bits_
+
+  // group of states (GPU devices)
+  uint_t num_groups_; // number of groups of chunks
   reg_t top_chunk_of_group_;
   reg_t num_chunks_in_group_;
-  int num_threads_per_group_;   //number of outer threads per group
+  int num_threads_per_group_; // number of outer threads per group
 
-  //cuStateVec settings
+  // cuStateVec settings
   bool cuStateVec_enable_ = false;
 
   //-----------------------------------------------------------------------
   // Apply circuits and ops
   //-----------------------------------------------------------------------
-  //apply ops for multi-chunk distribution
+  // apply ops for multi-chunk distribution
   template <typename InputIterator>
-  void apply_ops_chunks(InputIterator first,
-                 InputIterator last,
-                 ExperimentResult &result,
-                 RngEngine &rng,
-                 bool final_ops = false);
+  void apply_ops_chunks(InputIterator first, InputIterator last,
+                        ExperimentResult &result, RngEngine &rng,
+                        bool final_ops = false);
 
-  //apply cache blocked ops in each chunk
+  // apply cache blocked ops in each chunk
   template <typename InputIterator>
   void apply_cache_blocking_ops(const int_t iGroup, InputIterator first,
-                 InputIterator last,
-                 ExperimentResult &result,
-                 RngEngine &rng);
+                                InputIterator last, ExperimentResult &result,
+                                RngEngine &rng);
 
-  //apply ops for multi-shots to one group
+  // apply ops for multi-shots to one group
   template <typename InputIterator>
-  void apply_ops_multi_shots_for_group(int_t i_group, 
-                               InputIterator first, InputIterator last,
-                               const Noise::NoiseModel &noise,
-                               ExperimentResult &result,
-                               uint_t rng_seed,
-                               bool final_ops);
-
-  //apply op to multiple shots , return flase if op is not supported to execute in a batch
+  void apply_ops_multi_shots_for_group(int_t i_group, InputIterator first,
+                                       InputIterator last,
+                                       const Noise::NoiseModel &noise,
+                                       ExperimentResult &result,
+                                       uint_t rng_seed, bool final_ops);
+
+  // apply op to multiple shots , return flase if op is not supported to execute
+  // in a batch
   virtual bool apply_batched_op(const int_t iChunk, const Operations::Op &op,
                                 ExperimentResult &result,
                                 std::vector<RngEngine> &rng,
-                                bool final_op = false){return false;}
+                                bool final_op = false) {
+    return false;
+  }
 
-  //apply sampled noise to multiple-shots (this is used for ops contains non-Pauli operators)
-  void apply_batched_noise_ops(const int_t i_group, const std::vector<std::vector<Operations::Op>> &ops, 
-                               ExperimentResult &result,
-                               std::vector<RngEngine> &rng);
+  // apply sampled noise to multiple-shots (this is used for ops contains
+  // non-Pauli operators)
+  void apply_batched_noise_ops(
+      const int_t i_group, const std::vector<std::vector<Operations::Op>> &ops,
+      ExperimentResult &result, std::vector<RngEngine> &rng);
 
-  //check conditional
+  // check conditional
   bool check_conditional(const int_t iChunk, const Operations::Op &op);
 
-  //this function is used to scale chunk qubits for multi-chunk distribution
-  virtual int qubit_scale(void)
-  {
-    return 1;     //scale of qubit number (x2 for density and unitary matrices)
+  // this function is used to scale chunk qubits for multi-chunk distribution
+  virtual int qubit_scale(void) {
+    return 1; // scale of qubit number (x2 for density and unitary matrices)
   }
   uint_t get_process_by_chunk(uint_t cid);
 
-  //allocate qregs
+  // allocate qregs
   bool allocate_qregs(uint_t num_chunks);
 
-
   //-----------------------------------------------------------------------
-  //Functions for multi-chunk distribution
+  // Functions for multi-chunk distribution
   //-----------------------------------------------------------------------
-  //swap between chunks
+  // swap between chunks
   virtual void apply_chunk_swap(const reg_t &qubits);
 
-  //apply multiple swaps between chunks
+  // apply multiple swaps between chunks
   virtual void apply_multi_chunk_swap(const reg_t &qubits);
 
-  //apply X gate over chunks
+  // apply X gate over chunks
   virtual void apply_chunk_x(const uint_t qubit);
 
-  //send/receive chunk in receive buffer
+  // send/receive chunk in receive buffer
   void send_chunk(uint_t local_chunk_index, uint_t global_chunk_index);
   void recv_chunk(uint_t local_chunk_index, uint_t global_chunk_index);
 
   template <class data_t>
-  void send_data(data_t* pSend, uint_t size, uint_t myid,uint_t pairid);
+  void send_data(data_t *pSend, uint_t size, uint_t myid, uint_t pairid);
   template <class data_t>
-  void recv_data(data_t* pRecv, uint_t size, uint_t myid,uint_t pairid);
+  void recv_data(data_t *pRecv, uint_t size, uint_t myid, uint_t pairid);
 
-  //reduce values over processes
-  void reduce_sum(reg_t& sum) const;
-  void reduce_sum(rvector_t& sum) const;
-  void reduce_sum(complex_t& sum) const;
-  void reduce_sum(double& sum) const;
+  // reduce values over processes
+  void reduce_sum(reg_t &sum) const;
+  void reduce_sum(rvector_t &sum) const;
+  void reduce_sum(complex_t &sum) const;
+  void reduce_sum(double &sum) const;
 
-  //gather values on each process
-  void gather_value(rvector_t& val) const;
+  // gather values on each process
+  void gather_value(rvector_t &val) const;
 
-  //gather cregs 
+  // gather cregs
   void gather_creg_memory(void);
 
-  //barrier all processes
+  // barrier all processes
   void sync_process(void) const;
 
-  //gather distributed state into vector (if memory is enough)
+  // gather distributed state into vector (if memory is enough)
   template <class data_t>
-  void gather_state(std::vector<std::complex<data_t>>& state);
+  void gather_state(std::vector<std::complex<data_t>> &state);
 
   template <class data_t>
-  void gather_state(AER::Vector<std::complex<data_t>>& state);
+  void gather_state(AER::Vector<std::complex<data_t>> &state);
 
   // block diagonal matrix in chunk
-  void block_diagonal_matrix(const int_t iChunk, reg_t &qubits, cvector_t &diag);
-  void qubits_inout(const reg_t& qubits, reg_t& qubits_in,reg_t& qubits_out) const;
+  void block_diagonal_matrix(const int_t iChunk, reg_t &qubits,
+                             cvector_t &diag);
+  void qubits_inout(const reg_t &qubits, reg_t &qubits_in,
+                    reg_t &qubits_out) const;
 
-  //collect matrix over multiple chunks
+  // collect matrix over multiple chunks
   auto apply_to_matrix(bool copy = false);
 
   // Apply the global phase
   virtual void apply_global_phase() override {}
 
-  //check if the operator should be applied to each chunk
+  // check if the operator should be applied to each chunk
   virtual bool is_applied_to_each_chunk(const Operations::Op &op);
 
-  //return global shot index for the chunk
-  inline int_t get_global_shot_index(const int_t iChunk) const
-  {
-    return multi_shots_parallelization_ ? (iChunk + local_shot_index_ + global_chunk_index_) : 0;
+  // return global shot index for the chunk
+  inline int_t get_global_shot_index(const int_t iChunk) const {
+    return multi_shots_parallelization_
+               ? (iChunk + local_shot_index_ + global_chunk_index_)
+               : 0;
   }
 
-  //separate inside and outside qubits for (multi) control gates
-  void get_inout_ctrl_qubits(const Operations::Op &op, reg_t& qubits_out, reg_t& qubits_in);
+  // separate inside and outside qubits for (multi) control gates
+  void get_inout_ctrl_qubits(const Operations::Op &op, reg_t &qubits_out,
+                             reg_t &qubits_in);
 
-  //remake gate operation by qubits inside chunk
-  Operations::Op remake_gate_in_chunk_qubits(const Operations::Op &op, reg_t& qubits_in);
+  // remake gate operation by qubits inside chunk
+  Operations::Op remake_gate_in_chunk_qubits(const Operations::Op &op,
+                                             reg_t &qubits_in);
 
 #ifdef AER_MPI
-  //communicator group to simulate a circuit (for multi-experiments)
+  // communicator group to simulate a circuit (for multi-experiments)
   MPI_Comm distributed_comm_;
 #endif
 
   uint_t mapped_index(const uint_t idx);
 };
 
-
 //=========================================================================
 // Implementations
 //=========================================================================
 
-template <class state_t>
-StateChunk<state_t>::~StateChunk(void)
-{
+template <class state_t> StateChunk<state_t>::~StateChunk(void) {
 #ifdef AER_MPI
-  if(distributed_comm_ != MPI_COMM_WORLD){
+  if (distributed_comm_ != MPI_COMM_WORLD) {
     MPI_Comm_free(&distributed_comm_);
   }
 #endif
 }
 
 template <class state_t>
-void StateChunk<state_t>::set_config(const json_t &config) 
-{
+void StateChunk<state_t>::set_config(const json_t &config) {
   BaseState::set_config(config);
 
   num_threads_per_group_ = 1;
-  if(JSON::check_key("num_threads_per_device", config)) {
+  if (JSON::check_key("num_threads_per_device", config)) {
     JSON::get_value(num_threads_per_group_, "num_threads_per_device", config);
   }
 
-  if(JSON::check_key("chunk_swap_buffer_qubits", config)) {
-    JSON::get_value(chunk_swap_buffer_qubits_, "chunk_swap_buffer_qubits", config);
+  if (JSON::check_key("chunk_swap_buffer_qubits", config)) {
+    JSON::get_value(chunk_swap_buffer_qubits_, "chunk_swap_buffer_qubits",
+                    config);
   }
 
 #ifdef AER_CUSTATEVEC
-  //cuStateVec configs
-  if(JSON::check_key("cuStateVec_enable", config)) {
+  // cuStateVec configs
+  if (JSON::check_key("cuStateVec_enable", config)) {
     JSON::get_value(cuStateVec_enable_, "cuStateVec_enable", config);
   }
 #endif
 }
 
 template <class state_t>
-void StateChunk<state_t>::set_distribution(uint_t nprocs)
-{
+void StateChunk<state_t>::set_distribution(uint_t nprocs) {
   myrank_ = 0;
   nprocs_ = 1;
 #ifdef AER_MPI
   int t;
-  MPI_Comm_size(MPI_COMM_WORLD,&t);
+  MPI_Comm_size(MPI_COMM_WORLD, &t);
   nprocs_ = t;
-  MPI_Comm_rank(MPI_COMM_WORLD,&t);
+  MPI_Comm_rank(MPI_COMM_WORLD, &t);
   myrank_ = t;
 #endif
 
@@ -507,8 +514,8 @@ void StateChunk<state_t>::set_distribution(uint_t nprocs)
   distributed_proc_bits_ = 0;
   int proc_bits = 0;
   uint_t p = distributed_procs_;
-  while(p > 1){
-    if((p & 1) != 0){   //procs is not power of 2
+  while (p > 1) {
+    if ((p & 1) != 0) { // procs is not power of 2
       distributed_proc_bits_ = -1;
       break;
     }
@@ -517,101 +524,99 @@ void StateChunk<state_t>::set_distribution(uint_t nprocs)
   }
 
 #ifdef AER_MPI
-  if(nprocs != nprocs_){
-    MPI_Comm_split(MPI_COMM_WORLD,(int)distributed_group_,(int)distributed_rank_,&distributed_comm_);
-  }
-  else{
+  if (nprocs != nprocs_) {
+    MPI_Comm_split(MPI_COMM_WORLD, (int)distributed_group_,
+                   (int)distributed_rank_, &distributed_comm_);
+  } else {
     distributed_comm_ = MPI_COMM_WORLD;
   }
 #endif
 }
 
 template <class state_t>
-bool StateChunk<state_t>::allocate(uint_t num_qubits,uint_t block_bits,uint_t num_parallel_shots)
-{
+bool StateChunk<state_t>::allocate(uint_t num_qubits, uint_t block_bits,
+                                   uint_t num_parallel_shots) {
   int_t i;
   num_qubits_ = num_qubits;
   block_bits_ = block_bits;
 
-  if(block_bits_ > 0){
+  if (block_bits_ > 0) {
     chunk_bits_ = block_bits_;
-    if(chunk_bits_ > num_qubits_){
+    if (chunk_bits_ > num_qubits_) {
       chunk_bits_ = num_qubits_;
     }
-  }
-  else{
+  } else {
     chunk_bits_ = num_qubits_;
   }
 
-  if(chunk_bits_ < num_qubits_){
-    //multi-chunk distribution with cache blocking transpiler
+  if (chunk_bits_ < num_qubits_) {
+    // multi-chunk distribution with cache blocking transpiler
     multi_chunk_distribution_ = true;
     multi_shots_parallelization_ = false;
-    num_global_chunks_ = 1ull << ((num_qubits_ - chunk_bits_)*qubit_scale());
+    num_global_chunks_ = 1ull << ((num_qubits_ - chunk_bits_) * qubit_scale());
 
     BaseState::cregs_.resize(1);
-  }
-  else{
-    //multi-shots parallelization
+  } else {
+    // multi-shots parallelization
     multi_chunk_distribution_ = false;
-    if(num_parallel_shots > 1)
+    if (num_parallel_shots > 1)
       multi_shots_parallelization_ = true;
     else
       multi_shots_parallelization_ = false;
     num_global_chunks_ = num_parallel_shots;
 
-    //classical registers for all shots
+    // classical registers for all shots
     BaseState::cregs_.resize(num_parallel_shots);
   }
 
   chunk_index_begin_.resize(distributed_procs_);
   chunk_index_end_.resize(distributed_procs_);
-  for(i=0;i<distributed_procs_;i++){
-    chunk_index_begin_[i] = num_global_chunks_*i / distributed_procs_;
-    chunk_index_end_[i] = num_global_chunks_*(i+1) / distributed_procs_;
+  for (i = 0; i < distributed_procs_; i++) {
+    chunk_index_begin_[i] = num_global_chunks_ * i / distributed_procs_;
+    chunk_index_end_[i] = num_global_chunks_ * (i + 1) / distributed_procs_;
   }
 
-  num_local_chunks_ = chunk_index_end_[distributed_rank_] - chunk_index_begin_[distributed_rank_];
+  num_local_chunks_ = chunk_index_end_[distributed_rank_] -
+                      chunk_index_begin_[distributed_rank_];
   global_chunk_index_ = chunk_index_begin_[distributed_rank_];
   local_shot_index_ = 0;
 
   global_chunk_indexing_ = false;
   chunk_omp_parallel_ = false;
-  if(BaseState::sim_device_name_ == "GPU"){
+  if (BaseState::sim_device_name_ == "GPU") {
 #ifdef _OPENMP
-    if(omp_get_num_threads() == 1)
+    if (omp_get_num_threads() == 1)
       chunk_omp_parallel_ = true;
 #endif
 
-    //set cuStateVec_enable_ 
-    if(cuStateVec_enable_){
-      if(multi_shots_parallelization_)
-        cuStateVec_enable_ = false;   //multi-shots parallelization is not supported for cuStateVec
+    // set cuStateVec_enable_
+    if (cuStateVec_enable_) {
+      if (multi_shots_parallelization_)
+        cuStateVec_enable_ = false; // multi-shots parallelization is not
+                                    // supported for cuStateVec
     }
 
-    if(!cuStateVec_enable_)
-      global_chunk_indexing_ = true;    //cuStateVec does not handle global chunk index for diagonal matrix
-  }
-  else if(BaseState::sim_device_name_ == "Thrust"){
+    if (!cuStateVec_enable_)
+      global_chunk_indexing_ = true; // cuStateVec does not handle global chunk
+                                     // index for diagonal matrix
+  } else if (BaseState::sim_device_name_ == "Thrust") {
     global_chunk_indexing_ = true;
     chunk_omp_parallel_ = false;
   }
 
-  if(multi_shots_parallelization_){
-    allocate_qregs(std::min(num_local_chunks_,max_batched_shots_));
-  }
-  else{
+  if (multi_shots_parallelization_) {
+    allocate_qregs(std::min(num_local_chunks_, max_batched_shots_));
+  } else {
     allocate_qregs(num_local_chunks_);
   }
 
-
-  //initialize qubit map
+  // initialize qubit map
   qubit_map_.resize(num_qubits_);
-  for(i=0;i<num_qubits_;i++){
+  for (i = 0; i < num_qubits_; i++) {
     qubit_map_[i] = i;
   }
 
-  if(chunk_bits_ <= chunk_swap_buffer_qubits_ + 1)
+  if (chunk_bits_ <= chunk_swap_buffer_qubits_ + 1)
     multi_chunk_swap_enable_ = false;
   else
     max_multi_swap_ = chunk_bits_ - chunk_swap_buffer_qubits_;
@@ -620,56 +625,57 @@ bool StateChunk<state_t>::allocate(uint_t num_qubits,uint_t block_bits,uint_t nu
 }
 
 template <class state_t>
-bool StateChunk<state_t>::allocate_qregs(uint_t num_chunks)
-{
+bool StateChunk<state_t>::allocate_qregs(uint_t num_chunks) {
   int_t i;
-  //deallocate qregs before reallocation
-  if(qregs_.size() > 0){
-    if(qregs_.size() == num_chunks)
-      return true;  //can reuse allocated chunks
+  // deallocate qregs before reallocation
+  if (qregs_.size() > 0) {
+    if (qregs_.size() == num_chunks)
+      return true; // can reuse allocated chunks
 
     qregs_.clear();
   }
 
   qregs_.resize(num_chunks);
 
-  //allocate qregs
+  // allocate qregs
   uint_t chunk_id = multi_chunk_distribution_ ? global_chunk_index_ : 0;
   bool ret = true;
   qregs_[0].set_max_matrix_bits(BaseState::max_matrix_qubits_);
   qregs_[0].set_num_threads_per_group(num_threads_per_group_);
   qregs_[0].cuStateVec_enable(cuStateVec_enable_);
-  ret &= qregs_[0].chunk_setup(chunk_bits_*qubit_scale(), num_qubits_*qubit_scale(), chunk_id, num_chunks);
-  for(i=1;i<num_chunks;i++){
+  ret &=
+      qregs_[0].chunk_setup(chunk_bits_ * qubit_scale(),
+                            num_qubits_ * qubit_scale(), chunk_id, num_chunks);
+  for (i = 1; i < num_chunks; i++) {
     uint_t gid = i + chunk_id;
-    ret &= qregs_[i].chunk_setup(qregs_[0],gid);
+    ret &= qregs_[i].chunk_setup(qregs_[0], gid);
     qregs_[i].set_num_threads_per_group(num_threads_per_group_);
   }
 
-  //initialize groups
+  // initialize groups
   top_chunk_of_group_.clear();
   num_groups_ = 0;
-  for(i=0;i<qregs_.size();i++){
-    if(qregs_[i].top_of_group()){
+  for (i = 0; i < qregs_.size(); i++) {
+    if (qregs_[i].top_of_group()) {
       top_chunk_of_group_.push_back(i);
       num_groups_++;
     }
   }
   top_chunk_of_group_.push_back(qregs_.size());
   num_chunks_in_group_.resize(num_groups_);
-  for(i=0;i<num_groups_;i++){
-    num_chunks_in_group_[i] = top_chunk_of_group_[i+1] - top_chunk_of_group_[i];
+  for (i = 0; i < num_groups_; i++) {
+    num_chunks_in_group_[i] =
+        top_chunk_of_group_[i + 1] - top_chunk_of_group_[i];
   }
 
   return ret;
 }
 
 template <class state_t>
-uint_t StateChunk<state_t>::get_process_by_chunk(uint_t cid)
-{
+uint_t StateChunk<state_t>::get_process_by_chunk(uint_t cid) {
   uint_t i;
-  for(i=0;i<distributed_procs_;i++){
-    if(cid >= chunk_index_begin_[i] && cid < chunk_index_end_[i]){
+  for (i = 0; i < distributed_procs_; i++) {
+    if (cid >= chunk_index_begin_[i] && cid < chunk_index_end_[i]) {
       return i;
     }
   }
@@ -678,15 +684,12 @@ uint_t StateChunk<state_t>::get_process_by_chunk(uint_t cid)
 
 template <class state_t>
 void StateChunk<state_t>::apply_ops(OpItr first, OpItr last,
-                               ExperimentResult &result,
-                               RngEngine &rng,
-                               bool final_ops) 
-{
-  if(multi_chunk_distribution_){
-    apply_ops_chunks(first,last,result,rng,final_ops);
-  }
-  else{
-    Base::apply_ops(first, last, result, rng,final_ops);
+                                    ExperimentResult &result, RngEngine &rng,
+                                    bool final_ops) {
+  if (multi_chunk_distribution_) {
+    apply_ops_chunks(first, last, result, rng, final_ops);
+  } else {
+    Base::apply_ops(first, last, result, rng, final_ops);
   }
 
   qregs_[0].synchronize();
@@ -698,36 +701,39 @@ void StateChunk<state_t>::apply_ops(OpItr first, OpItr last,
 
 template <class state_t>
 template <typename InputIterator>
-void StateChunk<state_t>::apply_ops_chunks(InputIterator first, InputIterator last,
-                               ExperimentResult &result,
-                               RngEngine &rng,
-                               bool final_ops) 
-{
-  uint_t iOp,nOp;
+void StateChunk<state_t>::apply_ops_chunks(InputIterator first,
+                                           InputIterator last,
+                                           ExperimentResult &result,
+                                           RngEngine &rng, bool final_ops) {
+  uint_t iOp, nOp;
   reg_t multi_swap;
 
   nOp = std::distance(first, last);
   iOp = 0;
 
-  while(iOp < nOp){
+  while (iOp < nOp) {
     const Operations::Op op_iOp = *(first + iOp);
 
-    if(op_iOp.type == Operations::OpType::gate && op_iOp.name == "swap_chunk"){
-      //apply swap between chunks
-      if(multi_chunk_swap_enable_ && op_iOp.qubits[0] < chunk_bits_ && op_iOp.qubits[1] >= chunk_bits_){
-        if(distributed_proc_bits_ < 0 || (op_iOp.qubits[1] >= (num_qubits_*qubit_scale() - distributed_proc_bits_))){   //apply multi-swap when swap is cross qubits
+    if (op_iOp.type == Operations::OpType::gate &&
+        op_iOp.name == "swap_chunk") {
+      // apply swap between chunks
+      if (multi_chunk_swap_enable_ && op_iOp.qubits[0] < chunk_bits_ &&
+          op_iOp.qubits[1] >= chunk_bits_) {
+        if (distributed_proc_bits_ < 0 ||
+            (op_iOp.qubits[1] >=
+             (num_qubits_ * qubit_scale() -
+              distributed_proc_bits_))) { // apply multi-swap when swap is cross
+                                          // qubits
           multi_swap.push_back(op_iOp.qubits[0]);
           multi_swap.push_back(op_iOp.qubits[1]);
-          if(multi_swap.size() >= max_multi_swap_*2){
+          if (multi_swap.size() >= max_multi_swap_ * 2) {
             apply_multi_chunk_swap(multi_swap);
             multi_swap.clear();
           }
-        }
-        else
+        } else
           apply_chunk_swap(op_iOp.qubits);
-      }
-      else{
-        if(multi_swap.size() > 0){
+      } else {
+        if (multi_swap.size() > 0) {
           apply_multi_chunk_swap(multi_swap);
           multi_swap.clear();
         }
@@ -735,77 +741,78 @@ void StateChunk<state_t>::apply_ops_chunks(InputIterator first, InputIterator la
       }
       iOp++;
       continue;
-    }
-    else if(multi_swap.size() > 0){
+    } else if (multi_swap.size() > 0) {
       apply_multi_chunk_swap(multi_swap);
       multi_swap.clear();
     }
 
-    if(op_iOp.type == Operations::OpType::sim_op && op_iOp.name == "begin_blocking"){
-      //applying sequence of gates inside each chunk
+    if (op_iOp.type == Operations::OpType::sim_op &&
+        op_iOp.name == "begin_blocking") {
+      // applying sequence of gates inside each chunk
 
       uint_t iOpEnd = iOp;
-      while(iOpEnd < nOp){
+      while (iOpEnd < nOp) {
         const Operations::Op op_iOpEnd = *(first + iOpEnd);
-        if(op_iOpEnd.type == Operations::OpType::sim_op && op_iOpEnd.name == "end_blocking"){
+        if (op_iOpEnd.type == Operations::OpType::sim_op &&
+            op_iOpEnd.name == "end_blocking") {
           break;
         }
         iOpEnd++;
       }
 
       uint_t iOpBegin = iOp + 1;
-      if(num_groups_ > 1 && chunk_omp_parallel_){
-#pragma omp parallel for  num_threads(num_groups_)
-        for(int_t ig=0;ig<num_groups_;ig++)
-          apply_cache_blocking_ops(ig, first + iOpBegin, first + iOpEnd, result, rng);
-      }
-      else{
-        for(int_t ig=0;ig<num_groups_;ig++)
-          apply_cache_blocking_ops(ig, first + iOpBegin, first + iOpEnd, result, rng);
+      if (num_groups_ > 1 && chunk_omp_parallel_) {
+#pragma omp parallel for num_threads(num_groups_)
+        for (int_t ig = 0; ig < num_groups_; ig++)
+          apply_cache_blocking_ops(ig, first + iOpBegin, first + iOpEnd, result,
+                                   rng);
+      } else {
+        for (int_t ig = 0; ig < num_groups_; ig++)
+          apply_cache_blocking_ops(ig, first + iOpBegin, first + iOpEnd, result,
+                                   rng);
       }
       iOp = iOpEnd;
-    }
-    else if(is_applied_to_each_chunk(op_iOp)){
-      if(num_groups_ > 1 && chunk_omp_parallel_){
+    } else if (is_applied_to_each_chunk(op_iOp)) {
+      if (num_groups_ > 1 && chunk_omp_parallel_) {
 #pragma omp parallel for num_threads(num_groups_)
-        for(int_t ig=0;ig<num_groups_;ig++)
-          apply_cache_blocking_ops(ig, first + iOp, first + iOp+1, result, rng);
-      }
-      else{
-        for(int_t ig=0;ig<num_groups_;ig++)
-          apply_cache_blocking_ops(ig, first + iOp, first + iOp+1, result, rng);
+        for (int_t ig = 0; ig < num_groups_; ig++)
+          apply_cache_blocking_ops(ig, first + iOp, first + iOp + 1, result,
+                                   rng);
+      } else {
+        for (int_t ig = 0; ig < num_groups_; ig++)
+          apply_cache_blocking_ops(ig, first + iOp, first + iOp + 1, result,
+                                   rng);
       }
-    }
-    else{
-      //parallelize inside state implementations
-      apply_op(STATE_APPLY_TO_ALL_CHUNKS, op_iOp,result,rng,final_ops && nOp == iOp + 1);
+    } else {
+      // parallelize inside state implementations
+      apply_op(STATE_APPLY_TO_ALL_CHUNKS, op_iOp, result, rng,
+               final_ops && nOp == iOp + 1);
     }
     iOp++;
   }
 
-  if(multi_swap.size() > 0)
+  if (multi_swap.size() > 0)
     apply_multi_chunk_swap(multi_swap);
 
-  if(num_groups_ > 1 && chunk_omp_parallel_){
-#pragma omp parallel for  num_threads(num_groups_)
-    for(int_t ig=0;ig<num_groups_;ig++)
+  if (num_groups_ > 1 && chunk_omp_parallel_) {
+#pragma omp parallel for num_threads(num_groups_)
+    for (int_t ig = 0; ig < num_groups_; ig++)
       qregs_[top_chunk_of_group_[ig]].synchronize();
-  }
-  else{
-    for(int_t ig=0;ig<num_groups_;ig++)
+  } else {
+    for (int_t ig = 0; ig < num_groups_; ig++)
       qregs_[top_chunk_of_group_[ig]].synchronize();
   }
 
-  if(BaseState::sim_device_name_ == "GPU"){
+  if (BaseState::sim_device_name_ == "GPU") {
 #ifdef AER_THRUST_CUDA
     int nDev;
     if (cudaGetDeviceCount(&nDev) != cudaSuccess) {
       cudaGetLastError();
       nDev = 0;
     }
-    if(nDev > num_groups_)
+    if (nDev > num_groups_)
       nDev = num_groups_;
-    result.metadata.add(nDev,"cacheblocking", "chunk_parallel_gpus");
+    result.metadata.add(nDev, "cacheblocking", "chunk_parallel_gpus");
 #endif
 
 #ifdef AER_CUSTATEVEC
@@ -814,40 +821,46 @@ void StateChunk<state_t>::apply_ops_chunks(InputIterator first, InputIterator la
   }
 
 #ifdef AER_MPI
-  result.metadata.add(multi_chunk_swap_enable_,"cacheblocking", "multiple_chunk_swaps_enable");
-  if(multi_chunk_swap_enable_){
-    result.metadata.add(chunk_swap_buffer_qubits_,"cacheblocking", "multiple_chunk_swaps_buffer_qubits");
-    result.metadata.add(max_multi_swap_,"cacheblocking", "max_multiple_chunk_swaps");
+  result.metadata.add(multi_chunk_swap_enable_, "cacheblocking",
+                      "multiple_chunk_swaps_enable");
+  if (multi_chunk_swap_enable_) {
+    result.metadata.add(chunk_swap_buffer_qubits_, "cacheblocking",
+                        "multiple_chunk_swaps_buffer_qubits");
+    result.metadata.add(max_multi_swap_, "cacheblocking",
+                        "max_multiple_chunk_swaps");
   }
 #endif
 }
 
 template <class state_t>
 template <typename InputIterator>
-void StateChunk<state_t>::apply_cache_blocking_ops(const int_t iGroup, InputIterator first,
-               InputIterator last,
-               ExperimentResult &result,
-               RngEngine &rng)
-{
-  //for each chunk in group
-  for(int_t iChunk = top_chunk_of_group_[iGroup];iChunk < top_chunk_of_group_[iGroup + 1];iChunk++){
-    //fecth chunk in cache
-    if(qregs_[iChunk].fetch_chunk()){
+void StateChunk<state_t>::apply_cache_blocking_ops(const int_t iGroup,
+                                                   InputIterator first,
+                                                   InputIterator last,
+                                                   ExperimentResult &result,
+                                                   RngEngine &rng) {
+  // for each chunk in group
+  for (int_t iChunk = top_chunk_of_group_[iGroup];
+       iChunk < top_chunk_of_group_[iGroup + 1]; iChunk++) {
+    // fecth chunk in cache
+    if (qregs_[iChunk].fetch_chunk()) {
       for (auto it = first; it != last; ++it) {
         apply_op(iChunk, *it, result, rng, false);
       }
-      //release chunk from cache
+      // release chunk from cache
       qregs_[iChunk].release_chunk();
     }
   }
 }
 
 template <class state_t>
-void StateChunk<state_t>::get_inout_ctrl_qubits(const Operations::Op &op, reg_t& qubits_out, reg_t& qubits_in)
-{
-  if(op.type == Operations::OpType::gate && (op.name[0] == 'c' || op.name.find("mc") == 0)){
-    for(int i=0;i<op.qubits.size();i++){
-      if(op.qubits[i] < chunk_bits_)
+void StateChunk<state_t>::get_inout_ctrl_qubits(const Operations::Op &op,
+                                                reg_t &qubits_out,
+                                                reg_t &qubits_in) {
+  if (op.type == Operations::OpType::gate &&
+      (op.name[0] == 'c' || op.name.find("mc") == 0)) {
+    for (int i = 0; i < op.qubits.size(); i++) {
+      if (op.qubits[i] < chunk_bits_)
         qubits_in.push_back(op.qubits[i]);
       else
         qubits_out.push_back(op.qubits[i]);
@@ -856,115 +869,117 @@ void StateChunk<state_t>::get_inout_ctrl_qubits(const Operations::Op &op, reg_t&
 }
 
 template <class state_t>
-Operations::Op StateChunk<state_t>::remake_gate_in_chunk_qubits(const Operations::Op &op, reg_t& qubits_in)
-{
+Operations::Op
+StateChunk<state_t>::remake_gate_in_chunk_qubits(const Operations::Op &op,
+                                                 reg_t &qubits_in) {
   Operations::Op new_op = op;
   new_op.qubits = qubits_in;
-  //change gate name if there is no control qubits inside chunk
-  if(op.name.find("swap") != std::string::npos && qubits_in.size() == 2){
+  // change gate name if there is no control qubits inside chunk
+  if (op.name.find("swap") != std::string::npos && qubits_in.size() == 2) {
     new_op.name = "swap";
   }
-  if(op.name.find("ccx") != std::string::npos){
-    if(qubits_in.size() == 1)
+  if (op.name.find("ccx") != std::string::npos) {
+    if (qubits_in.size() == 1)
       new_op.name = "x";
     else
       new_op.name = "cx";
-  }
-  else if(qubits_in.size() == 1){
-    if(op.name[0] == 'c')
+  } else if (qubits_in.size() == 1) {
+    if (op.name[0] == 'c')
       new_op.name = op.name.substr(1);
-    else if(op.name == "mcphase")
+    else if (op.name == "mcphase")
       new_op.name = "p";
     else
-      new_op.name = op.name.substr(2);  //remove "mc"
+      new_op.name = op.name.substr(2); // remove "mc"
   }
   return new_op;
 }
 
 template <class state_t>
-bool StateChunk<state_t>::is_applied_to_each_chunk(const Operations::Op &op)
-{
-  if(op.type == Operations::OpType::gate || op.type == Operations::OpType::matrix || 
-            op.type == Operations::OpType::diagonal_matrix || op.type == Operations::OpType::multiplexer ||
-            op.type == Operations::OpType::superop){
+bool StateChunk<state_t>::is_applied_to_each_chunk(const Operations::Op &op) {
+  if (op.type == Operations::OpType::gate ||
+      op.type == Operations::OpType::matrix ||
+      op.type == Operations::OpType::diagonal_matrix ||
+      op.type == Operations::OpType::multiplexer ||
+      op.type == Operations::OpType::superop) {
     return true;
   }
   return false;
 }
 
 template <class state_t>
-bool StateChunk<state_t>::check_conditional(const int_t iChunk, const Operations::Op &op)
-{
-  if(multi_shots_parallelization_){
-    //multi-shots parallelization
-    if(op.conditional){
+bool StateChunk<state_t>::check_conditional(const int_t iChunk,
+                                            const Operations::Op &op) {
+  if (multi_shots_parallelization_) {
+    // multi-shots parallelization
+    if (op.conditional) {
       qregs_[iChunk].set_conditional(op.conditional_reg);
     }
     return true;
-  }
-  else{
+  } else {
     return BaseState::cregs_[0].check_conditional(op);
   }
 }
 
 template <class state_t>
 template <typename InputIterator>
-void StateChunk<state_t>::apply_ops_multi_shots(InputIterator first, InputIterator last,
-                               const Noise::NoiseModel &noise,
-                               ExperimentResult &result,
-                               uint_t rng_seed,
-                               bool final_ops) 
-{
+void StateChunk<state_t>::apply_ops_multi_shots(
+    InputIterator first, InputIterator last, const Noise::NoiseModel &noise,
+    ExperimentResult &result, uint_t rng_seed, bool final_ops) {
   int_t i;
-  int_t i_begin,n_shots;
+  int_t i_begin, n_shots;
 
   i_begin = 0;
-  while(i_begin<num_local_chunks_){
+  while (i_begin < num_local_chunks_) {
     local_shot_index_ = i_begin;
 
-    //loop for states can be stored in available memory
+    // loop for states can be stored in available memory
     n_shots = qregs_.size();
-    if(i_begin+n_shots > num_local_chunks_){
+    if (i_begin + n_shots > num_local_chunks_) {
       n_shots = num_local_chunks_ - i_begin;
-      //resize qregs
+      // resize qregs
       allocate_qregs(n_shots);
     }
-    //initialization (equivalent to initialize_qreg + initialize_creg)
-    auto init_group = [this](int_t ig){
-      for(uint_t j=top_chunk_of_group_[ig];j<top_chunk_of_group_[ig+1];j++){
-        //enabling batch shots optimization
+    // initialization (equivalent to initialize_qreg + initialize_creg)
+    auto init_group = [this](int_t ig) {
+      for (uint_t j = top_chunk_of_group_[ig]; j < top_chunk_of_group_[ig + 1];
+           j++) {
+        // enabling batch shots optimization
         qregs_[j].enable_batch(true);
 
-        //initialize qreg here
+        // initialize qreg here
         qregs_[j].set_num_qubits(chunk_bits_);
         qregs_[j].initialize();
 
-        //initialize creg here
-        qregs_[j].initialize_creg(this->creg(0).memory_size(), this->creg(0).register_size());
+        // initialize creg here
+        qregs_[j].initialize_creg(this->creg(0).memory_size(),
+                                  this->creg(0).register_size());
       }
     };
-    Utils::apply_omp_parallel_for((num_groups_ > 1 && chunk_omp_parallel_),0,num_groups_,init_group);
+    Utils::apply_omp_parallel_for((num_groups_ > 1 && chunk_omp_parallel_), 0,
+                                  num_groups_, init_group);
 
-    apply_global_phase(); //this is parallelized in StateChunk sub-classes
+    apply_global_phase(); // this is parallelized in StateChunk sub-classes
 
-    //apply ops to multiple-shots
-    if(num_groups_ > 1 && chunk_omp_parallel_){
+    // apply ops to multiple-shots
+    if (num_groups_ > 1 && chunk_omp_parallel_) {
       std::vector<ExperimentResult> par_results(num_groups_);
 #pragma omp parallel for num_threads(num_groups_)
-      for(i=0;i<num_groups_;i++)
-        apply_ops_multi_shots_for_group(i, first, last, noise, par_results[i], rng_seed, final_ops);
+      for (i = 0; i < num_groups_; i++)
+        apply_ops_multi_shots_for_group(i, first, last, noise, par_results[i],
+                                        rng_seed, final_ops);
 
       for (auto &res : par_results)
         result.combine(std::move(res));
-    }
-    else{
-      for(i=0;i<num_groups_;i++)
-        apply_ops_multi_shots_for_group(i, first, last, noise, result, rng_seed, final_ops);
+    } else {
+      for (i = 0; i < num_groups_; i++)
+        apply_ops_multi_shots_for_group(i, first, last, noise, result, rng_seed,
+                                        final_ops);
     }
 
-    //collect measured bits and copy memory
-    for(i=0;i<n_shots;i++){
-      qregs_[i].read_measured_data(this->creg(global_chunk_index_ + i_begin + i));
+    // collect measured bits and copy memory
+    for (i = 0; i < n_shots; i++) {
+      qregs_[i].read_measured_data(
+          this->creg(global_chunk_index_ + i_begin + i));
     }
 
     i_begin += n_shots;
@@ -973,28 +988,25 @@ void StateChunk<state_t>::apply_ops_multi_shots(InputIterator first, InputIterat
   gather_creg_memory();
 
 #ifdef AER_THRUST_CUDA
-  if(BaseState::sim_device_name_ == "GPU"){
+  if (BaseState::sim_device_name_ == "GPU") {
     int nDev;
     if (cudaGetDeviceCount(&nDev) != cudaSuccess) {
       cudaGetLastError();
       nDev = 0;
     }
-    if(nDev > num_groups_)
+    if (nDev > num_groups_)
       nDev = num_groups_;
-    result.metadata.add(nDev,"batched_shots_optimization_parallel_gpus");
+    result.metadata.add(nDev, "batched_shots_optimization_parallel_gpus");
   }
 #endif
 }
 
 template <class state_t>
 template <typename InputIterator>
-void StateChunk<state_t>::apply_ops_multi_shots_for_group(int_t i_group, 
-                               InputIterator first, InputIterator last,
-                               const Noise::NoiseModel &noise,
-                               ExperimentResult &result,
-                               uint_t rng_seed,
-                               bool final_ops)
-{
+void StateChunk<state_t>::apply_ops_multi_shots_for_group(
+    int_t i_group, InputIterator first, InputIterator last,
+    const Noise::NoiseModel &noise, ExperimentResult &result, uint_t rng_seed,
+    bool final_ops) {
   uint_t istate = top_chunk_of_group_[i_group];
   std::vector<RngEngine> rng(num_chunks_in_group_[i_group]);
 #ifdef _OPENMP
@@ -1003,41 +1015,48 @@ void StateChunk<state_t>::apply_ops_multi_shots_for_group(int_t i_group,
   int num_inner_threads = 1;
 #endif
 
-  for(uint_t j=top_chunk_of_group_[i_group];j<top_chunk_of_group_[i_group+1];j++)
-    rng[j-top_chunk_of_group_[i_group]].set_seed(rng_seed + global_chunk_index_ + local_shot_index_ + j);
+  for (uint_t j = top_chunk_of_group_[i_group];
+       j < top_chunk_of_group_[i_group + 1]; j++)
+    rng[j - top_chunk_of_group_[i_group]].set_seed(
+        rng_seed + global_chunk_index_ + local_shot_index_ + j);
 
   for (auto op = first; op != last; ++op) {
-    if(op->type == Operations::OpType::qerror_loc){
-      //sample error here
+    if (op->type == Operations::OpType::qerror_loc) {
+      // sample error here
       uint_t count = num_chunks_in_group_[i_group];
       std::vector<std::vector<Operations::Op>> noise_ops(count);
 
       uint_t count_ops = 0;
       uint_t non_pauli_gate_count = 0;
-      if(num_inner_threads > 1){
+      if (num_inner_threads > 1) {
 #pragma omp parallel for reduction(+: count_ops,non_pauli_gate_count) num_threads(num_inner_threads)
-        for(int_t j=0;j<count;j++){
-          noise_ops[j] = noise.sample_noise_loc(*op,rng[j]);
+        for (int_t j = 0; j < count; j++) {
+          noise_ops[j] = noise.sample_noise_loc(*op, rng[j]);
 
-          if(!(noise_ops[j].size() == 0 || (noise_ops[j].size() == 1 && noise_ops[j][0].name == "id"))){
+          if (!(noise_ops[j].size() == 0 ||
+                (noise_ops[j].size() == 1 && noise_ops[j][0].name == "id"))) {
             count_ops++;
-            for(int_t k=0;k<noise_ops[j].size();k++){
-              if(noise_ops[j][k].name != "id" && noise_ops[j][k].name != "x" && noise_ops[j][k].name != "y" && noise_ops[j][k].name != "z" && noise_ops[j][k].name != "pauli"){
+            for (int_t k = 0; k < noise_ops[j].size(); k++) {
+              if (noise_ops[j][k].name != "id" && noise_ops[j][k].name != "x" &&
+                  noise_ops[j][k].name != "y" && noise_ops[j][k].name != "z" &&
+                  noise_ops[j][k].name != "pauli") {
                 non_pauli_gate_count++;
                 break;
               }
             }
           }
         }
-      }
-      else{
-        for(int_t j=0;j<count;j++){
-          noise_ops[j] = noise.sample_noise_loc(*op,rng[j]);
+      } else {
+        for (int_t j = 0; j < count; j++) {
+          noise_ops[j] = noise.sample_noise_loc(*op, rng[j]);
 
-          if(!(noise_ops[j].size() == 0 || (noise_ops[j].size() == 1 && noise_ops[j][0].name == "id"))){
+          if (!(noise_ops[j].size() == 0 ||
+                (noise_ops[j].size() == 1 && noise_ops[j][0].name == "id"))) {
             count_ops++;
-            for(int_t k=0;k<noise_ops[j].size();k++){
-              if(noise_ops[j][k].name != "id" && noise_ops[j][k].name != "x" && noise_ops[j][k].name != "y" && noise_ops[j][k].name != "z" && noise_ops[j][k].name != "pauli"){
+            for (int_t k = 0; k < noise_ops[j].size(); k++) {
+              if (noise_ops[j][k].name != "id" && noise_ops[j][k].name != "x" &&
+                  noise_ops[j][k].name != "y" && noise_ops[j][k].name != "z" &&
+                  noise_ops[j][k].name != "pauli") {
                 non_pauli_gate_count++;
                 break;
               }
@@ -1046,23 +1065,24 @@ void StateChunk<state_t>::apply_ops_multi_shots_for_group(int_t i_group,
         }
       }
 
-      if(count_ops == 0){
-        continue;   //do nothing
+      if (count_ops == 0) {
+        continue; // do nothing
       }
-      if(non_pauli_gate_count == 0){   //ptimization for Pauli error
+      if (non_pauli_gate_count == 0) { // ptimization for Pauli error
         qregs_[istate].apply_batched_pauli_ops(noise_ops);
+      } else {
+        // otherwise execute each circuit
+        apply_batched_noise_ops(i_group, noise_ops, result, rng);
       }
-      else{
-        //otherwise execute each circuit
-        apply_batched_noise_ops(i_group, noise_ops,result, rng);
-      }
-    }
-    else{
-      if(!apply_batched_op(istate, *op, result, rng, final_ops && (op + 1 == last))){
-        //call apply_op for each state
-        for(uint_t j=top_chunk_of_group_[i_group];j<top_chunk_of_group_[i_group+1];j++){
+    } else {
+      if (!apply_batched_op(istate, *op, result, rng,
+                            final_ops && (op + 1 == last))) {
+        // call apply_op for each state
+        for (uint_t j = top_chunk_of_group_[i_group];
+             j < top_chunk_of_group_[i_group + 1]; j++) {
           qregs_[j].enable_batch(false);
-          apply_op(j, *op, result, rng[j-top_chunk_of_group_[i_group]], final_ops && (op + 1 == last) );
+          apply_op(j, *op, result, rng[j - top_chunk_of_group_[i_group]],
+                   final_ops && (op + 1 == last));
           qregs_[j].enable_batch(true);
         }
       }
@@ -1071,74 +1091,78 @@ void StateChunk<state_t>::apply_ops_multi_shots_for_group(int_t i_group,
 }
 
 template <class state_t>
-void StateChunk<state_t>::apply_batched_noise_ops(const int_t i_group, const std::vector<std::vector<Operations::Op>> &ops, 
-                             ExperimentResult &result,
-                             std::vector<RngEngine> &rng)
-{
-  int_t i,j,k,count,nop,pos = 0;
+void StateChunk<state_t>::apply_batched_noise_ops(
+    const int_t i_group, const std::vector<std::vector<Operations::Op>> &ops,
+    ExperimentResult &result, std::vector<RngEngine> &rng) {
+  int_t i, j, k, count, nop, pos = 0;
   uint_t istate = top_chunk_of_group_[i_group];
   count = ops.size();
 
   reg_t mask(count);
-  std::vector<bool> finished(count,false);
-  for(i=0;i<count;i++){
+  std::vector<bool> finished(count, false);
+  for (i = 0; i < count; i++) {
     int_t cond_reg = -1;
 
-    if(finished[i])
+    if (finished[i])
       continue;
-    if(ops[i].size() == 0 || (ops[i].size() == 1 && ops[i][0].name == "id")){
+    if (ops[i].size() == 0 || (ops[i].size() == 1 && ops[i][0].name == "id")) {
       finished[i] = true;
       continue;
     }
     mask[i] = 1;
 
-    //find same ops to be exectuted in a batch
-    for(j=i+1;j<count;j++){
-      if(finished[j]){
+    // find same ops to be exectuted in a batch
+    for (j = i + 1; j < count; j++) {
+      if (finished[j]) {
         mask[j] = 0;
         continue;
       }
-      if(ops[j].size() == 0 || (ops[j].size() == 1 && ops[j][0].name == "id")){
+      if (ops[j].size() == 0 ||
+          (ops[j].size() == 1 && ops[j][0].name == "id")) {
         mask[j] = 0;
         finished[j] = true;
         continue;
       }
 
-      if(ops[i].size() != ops[j].size()){
+      if (ops[i].size() != ops[j].size()) {
         mask[j] = 0;
         continue;
       }
 
       mask[j] = true;
-      for(k=0;k<ops[i].size();k++){
-        if(ops[i][k].conditional){
+      for (k = 0; k < ops[i].size(); k++) {
+        if (ops[i][k].conditional) {
           cond_reg = ops[i][k].conditional_reg;
         }
-        if(ops[i][k].type != ops[j][k].type || ops[i][k].name != ops[j][k].name){
+        if (ops[i][k].type != ops[j][k].type ||
+            ops[i][k].name != ops[j][k].name) {
           mask[j] = false;
           break;
         }
       }
-      if(mask[j])
+      if (mask[j])
         finished[j] = true;
     }
 
-    //mask conditional register
-    int_t sys_reg = qregs_[istate].set_batched_system_conditional(cond_reg, mask);
+    // mask conditional register
+    int_t sys_reg =
+        qregs_[istate].set_batched_system_conditional(cond_reg, mask);
 
-    //batched execution on same ops
-    for(k=0;k<ops[i].size();k++){
+    // batched execution on same ops
+    for (k = 0; k < ops[i].size(); k++) {
       Operations::Op cop = ops[i][k];
 
-      //mark op conditional to mask shots
+      // mark op conditional to mask shots
       cop.conditional = true;
       cop.conditional_reg = sys_reg;
 
-      if(!apply_batched_op(istate, cop, result,rng, false)){
-        //call apply_op for each state
-        for(uint_t j=top_chunk_of_group_[i_group];j<top_chunk_of_group_[i_group+1];j++){
+      if (!apply_batched_op(istate, cop, result, rng, false)) {
+        // call apply_op for each state
+        for (uint_t j = top_chunk_of_group_[i_group];
+             j < top_chunk_of_group_[i_group + 1]; j++) {
           qregs_[j].enable_batch(false);
-          apply_op(j, cop, result ,rng[j-top_chunk_of_group_[i_group]],false);
+          apply_op(j, cop, result, rng[j - top_chunk_of_group_[i_group]],
+                   false);
           qregs_[j].enable_batch(true);
         }
       }
@@ -1149,61 +1173,58 @@ void StateChunk<state_t>::apply_batched_noise_ops(const int_t i_group, const std
 }
 
 template <class state_t>
-void StateChunk<state_t>::initialize_creg(uint_t num_memory, uint_t num_register) 
-{
-  for(int_t i=0;i<BaseState::cregs_.size();i++){
+void StateChunk<state_t>::initialize_creg(uint_t num_memory,
+                                          uint_t num_register) {
+  for (int_t i = 0; i < BaseState::cregs_.size(); i++) {
     BaseState::cregs_[i].initialize(num_memory, num_register);
   }
 }
 
-
 template <class state_t>
 void StateChunk<state_t>::initialize_creg(uint_t num_memory,
-                                     uint_t num_register,
-                                     const std::string &memory_hex,
-                                     const std::string &register_hex) {
-  for(int_t i=0;i<BaseState::cregs_.size();i++){
-    BaseState::cregs_[i].initialize(num_memory, num_register, memory_hex, register_hex);
+                                          uint_t num_register,
+                                          const std::string &memory_hex,
+                                          const std::string &register_hex) {
+  for (int_t i = 0; i < BaseState::cregs_.size(); i++) {
+    BaseState::cregs_[i].initialize(num_memory, num_register, memory_hex,
+                                    register_hex);
   }
 }
 
 template <class state_t>
-void StateChunk<state_t>::snapshot_state(const int_t iChunk, const Operations::Op &op,
-                                    ExperimentResult &result,
-                                    std::string name) const 
-{
+void StateChunk<state_t>::snapshot_state(const int_t iChunk,
+                                         const Operations::Op &op,
+                                         ExperimentResult &result,
+                                         std::string name) const {
   name = (name.empty()) ? op.name : name;
-  result.legacy_data.add_pershot_snapshot(name, op.string_params[0], qregs_[iChunk]);
+  result.legacy_data.add_pershot_snapshot(name, op.string_params[0],
+                                          qregs_[iChunk]);
 }
 
-
 template <class state_t>
-void StateChunk<state_t>::snapshot_creg_memory(const int_t iChunk, const Operations::Op &op,
-                                          ExperimentResult &result,
-                                          std::string name) const 
-{
+void StateChunk<state_t>::snapshot_creg_memory(const int_t iChunk,
+                                               const Operations::Op &op,
+                                               ExperimentResult &result,
+                                               std::string name) const {
   int_t ishot = get_global_shot_index(iChunk);
-  result.legacy_data.add_pershot_snapshot(name,
-                               op.string_params[0],
-                               BaseState::cregs_[ishot].memory_hex());
+  result.legacy_data.add_pershot_snapshot(
+      name, op.string_params[0], BaseState::cregs_[ishot].memory_hex());
 }
 
-
 template <class state_t>
-void StateChunk<state_t>::snapshot_creg_register(const int_t iChunk, const Operations::Op &op,
-                                            ExperimentResult &result,
-                                            std::string name) const 
-{
+void StateChunk<state_t>::snapshot_creg_register(const int_t iChunk,
+                                                 const Operations::Op &op,
+                                                 ExperimentResult &result,
+                                                 std::string name) const {
   int_t ishot = get_global_shot_index(iChunk);
-  result.legacy_data.add_pershot_snapshot(name,
-                               op.string_params[0],
-                               BaseState::cregs_[ishot].register_hex());
+  result.legacy_data.add_pershot_snapshot(
+      name, op.string_params[0], BaseState::cregs_[ishot].register_hex());
 }
 
-
 template <class state_t>
-void StateChunk<state_t>::apply_save_expval(const int_t iChunk, const Operations::Op &op,
-                                       ExperimentResult &result){
+void StateChunk<state_t>::apply_save_expval(const int_t iChunk,
+                                            const Operations::Op &op,
+                                            ExperimentResult &result) {
   // Check empty edge case
   if (op.expval_params.empty()) {
     throw std::invalid_argument(
@@ -1225,11 +1246,15 @@ void StateChunk<state_t>::apply_save_expval(const int_t iChunk, const Operations
   }
   if (variance) {
     std::vector<double> expval_var(2);
-    expval_var[0] = expval;  // mean
-    expval_var[1] = sq_expval - expval * expval;  // variance
-    result.save_data_average(BaseState::cregs_[get_global_shot_index(iChunk)], op.string_params[0], expval_var, op.type, op.save_type);
+    expval_var[0] = expval;                      // mean
+    expval_var[1] = sq_expval - expval * expval; // variance
+    result.save_data_average(BaseState::cregs_[get_global_shot_index(iChunk)],
+                             op.string_params[0], expval_var, op.type,
+                             op.save_type);
   } else {
-    result.save_data_average(BaseState::cregs_[get_global_shot_index(iChunk)], op.string_params[0], expval, op.type, op.save_type);
+    result.save_data_average(BaseState::cregs_[get_global_shot_index(iChunk)],
+                             op.string_params[0], expval, op.type,
+                             op.save_type);
   }
 }
 
@@ -1237,8 +1262,9 @@ void StateChunk<state_t>::apply_save_expval(const int_t iChunk, const Operations
 // functions for multi-chunk distribution
 //-------------------------------------------------------------------------
 template <class state_t>
-void StateChunk<state_t>::block_diagonal_matrix(const int_t iChunk, reg_t &qubits, cvector_t &diag)
-{
+void StateChunk<state_t>::block_diagonal_matrix(const int_t iChunk,
+                                                reg_t &qubits,
+                                                cvector_t &diag) {
   uint_t gid = global_chunk_index_ + iChunk;
   uint_t i;
   uint_t mask_out = 0;
@@ -1247,24 +1273,23 @@ void StateChunk<state_t>::block_diagonal_matrix(const int_t iChunk, reg_t &qubit
   reg_t qubits_in;
   cvector_t diag_in;
 
-  for(i=0;i<qubits.size();i++){
-    if(qubits[i] < chunk_bits_){ //in chunk
+  for (i = 0; i < qubits.size(); i++) {
+    if (qubits[i] < chunk_bits_) { // in chunk
       qubits_in.push_back(qubits[i]);
-    }
-    else{
+    } else {
       mask_out |= (1ull << i);
-      if((gid >> (qubits[i] - chunk_bits_)) & 1)
+      if ((gid >> (qubits[i] - chunk_bits_)) & 1)
         mask_id |= (1ull << i);
     }
   }
 
-  if(qubits_in.size() < qubits.size()){
-    for(i=0;i<diag.size();i++){
-      if((i & mask_out) == mask_id)
+  if (qubits_in.size() < qubits.size()) {
+    for (i = 0; i < diag.size(); i++) {
+      if ((i & mask_out) == mask_id)
         diag_in.push_back(diag[i]);
     }
 
-    if(qubits_in.size() == 0){
+    if (qubits_in.size() == 0) {
       qubits_in.push_back(0);
       diag_in.resize(2);
       diag_in[1] = diag_in[0];
@@ -1275,172 +1300,182 @@ void StateChunk<state_t>::block_diagonal_matrix(const int_t iChunk, reg_t &qubit
 }
 
 template <class state_t>
-void StateChunk<state_t>::qubits_inout(const reg_t& qubits, reg_t& qubits_in,reg_t& qubits_out) const
-{
+void StateChunk<state_t>::qubits_inout(const reg_t &qubits, reg_t &qubits_in,
+                                       reg_t &qubits_out) const {
   int_t i;
   qubits_in.clear();
   qubits_out.clear();
-  for(i=0;i<qubits.size();i++){
-    if(qubits[i] < chunk_bits_){ //in chunk
+  for (i = 0; i < qubits.size(); i++) {
+    if (qubits[i] < chunk_bits_) { // in chunk
       qubits_in.push_back(qubits[i]);
-    }
-    else{
+    } else {
       qubits_out.push_back(qubits[i]);
     }
   }
 }
 
-
 template <class state_t>
 template <typename list_t>
-void StateChunk<state_t>::initialize_from_vector(const int_t iChunkIn, const list_t &vec)
-{
+void StateChunk<state_t>::initialize_from_vector(const int_t iChunkIn,
+                                                 const list_t &vec) {
   int_t iChunk;
 
-  if(multi_chunk_distribution_){
-    if(chunk_omp_parallel_ && num_groups_ > 1){
+  if (multi_chunk_distribution_) {
+    if (chunk_omp_parallel_ && num_groups_ > 1) {
 #pragma omp parallel for private(iChunk)
-      for(int_t ig=0;ig<num_groups_;ig++){
-        for(iChunk = top_chunk_of_group_[ig];iChunk < top_chunk_of_group_[ig + 1];iChunk++){
-          list_t tmp(1ull << (chunk_bits_*qubit_scale()));
-          for(int_t i=0;i<(1ull << (chunk_bits_*qubit_scale()));i++){
-            tmp[i] = vec[((global_chunk_index_ + iChunk) << (chunk_bits_*qubit_scale())) + i];
+      for (int_t ig = 0; ig < num_groups_; ig++) {
+        for (iChunk = top_chunk_of_group_[ig];
+             iChunk < top_chunk_of_group_[ig + 1]; iChunk++) {
+          list_t tmp(1ull << (chunk_bits_ * qubit_scale()));
+          for (int_t i = 0; i < (1ull << (chunk_bits_ * qubit_scale())); i++) {
+            tmp[i] = vec[((global_chunk_index_ + iChunk)
+                          << (chunk_bits_ * qubit_scale())) +
+                         i];
           }
           qregs_[iChunk].initialize_from_vector(tmp);
         }
       }
-    }
-    else{
-      for(iChunk=0;iChunk<num_local_chunks_;iChunk++){
-        list_t tmp(1ull << (chunk_bits_*qubit_scale()));
-        for(int_t i=0;i<(1ull << (chunk_bits_*qubit_scale()));i++){
-          tmp[i] = vec[((global_chunk_index_ + iChunk) << (chunk_bits_*qubit_scale())) + i];
+    } else {
+      for (iChunk = 0; iChunk < num_local_chunks_; iChunk++) {
+        list_t tmp(1ull << (chunk_bits_ * qubit_scale()));
+        for (int_t i = 0; i < (1ull << (chunk_bits_ * qubit_scale())); i++) {
+          tmp[i] = vec[((global_chunk_index_ + iChunk)
+                        << (chunk_bits_ * qubit_scale())) +
+                       i];
         }
         qregs_[iChunk].initialize_from_vector(tmp);
       }
     }
-  }
-  else{
-    if(iChunkIn == STATE_APPLY_TO_ALL_CHUNKS){
-      for(iChunk=0;iChunk<num_local_chunks_;iChunk++){
+  } else {
+    if (iChunkIn == STATE_APPLY_TO_ALL_CHUNKS) {
+      for (iChunk = 0; iChunk < num_local_chunks_; iChunk++) {
         qregs_[iChunk].initialize_from_vector(vec);
       }
-    }
-    else
+    } else
       qregs_[iChunkIn].initialize_from_vector(vec);
   }
 }
 
 template <class state_t>
 template <typename list_t>
-void StateChunk<state_t>::initialize_from_matrix(const int_t iChunkIn, const list_t &mat)
-{
+void StateChunk<state_t>::initialize_from_matrix(const int_t iChunkIn,
+                                                 const list_t &mat) {
   int_t iChunk;
-  if(multi_chunk_distribution_){
-    if(chunk_omp_parallel_ && num_groups_ > 1){
+  if (multi_chunk_distribution_) {
+    if (chunk_omp_parallel_ && num_groups_ > 1) {
 #pragma omp parallel for private(iChunk)
-      for(int_t ig=0;ig<num_groups_;ig++){
-        for(iChunk = top_chunk_of_group_[ig];iChunk < top_chunk_of_group_[ig + 1];iChunk++){
-          list_t tmp(1ull << (chunk_bits_),1ull << (chunk_bits_));
-          uint_t irow_chunk = ((iChunk + global_chunk_index_) >> ((num_qubits_ - chunk_bits_))) << (chunk_bits_);
-          uint_t icol_chunk = ((iChunk + global_chunk_index_) & ((1ull << ((num_qubits_ - chunk_bits_)))-1)) << (chunk_bits_);
-
-          //copy part of state for this chunk
-          uint_t i,row,col;
-          for(i=0;i<(1ull << (chunk_bits_*qubit_scale()));i++){
-            uint_t icol = i & ((1ull << chunk_bits_)-1);
+      for (int_t ig = 0; ig < num_groups_; ig++) {
+        for (iChunk = top_chunk_of_group_[ig];
+             iChunk < top_chunk_of_group_[ig + 1]; iChunk++) {
+          list_t tmp(1ull << (chunk_bits_), 1ull << (chunk_bits_));
+          uint_t irow_chunk =
+              ((iChunk + global_chunk_index_) >> ((num_qubits_ - chunk_bits_)))
+              << (chunk_bits_);
+          uint_t icol_chunk = ((iChunk + global_chunk_index_) &
+                               ((1ull << ((num_qubits_ - chunk_bits_))) - 1))
+                              << (chunk_bits_);
+
+          // copy part of state for this chunk
+          uint_t i, row, col;
+          for (i = 0; i < (1ull << (chunk_bits_ * qubit_scale())); i++) {
+            uint_t icol = i & ((1ull << chunk_bits_) - 1);
             uint_t irow = i >> chunk_bits_;
-            tmp[i] = mat[icol_chunk + icol + ((irow_chunk + irow) << num_qubits_)];
+            tmp[i] =
+                mat[icol_chunk + icol + ((irow_chunk + irow) << num_qubits_)];
           }
           qregs_[iChunk].initialize_from_matrix(tmp);
         }
       }
-    }
-    else{
-      for(iChunk=0;iChunk<num_local_chunks_;iChunk++){
-        list_t tmp(1ull << (chunk_bits_),1ull << (chunk_bits_));
-        uint_t irow_chunk = ((iChunk + global_chunk_index_) >> ((num_qubits_ - chunk_bits_))) << (chunk_bits_);
-        uint_t icol_chunk = ((iChunk + global_chunk_index_) & ((1ull << ((num_qubits_ - chunk_bits_)))-1)) << (chunk_bits_);
-
-        //copy part of state for this chunk
-        uint_t i,row,col;
-        for(i=0;i<(1ull << (chunk_bits_*qubit_scale()));i++){
-          uint_t icol = i & ((1ull << chunk_bits_)-1);
+    } else {
+      for (iChunk = 0; iChunk < num_local_chunks_; iChunk++) {
+        list_t tmp(1ull << (chunk_bits_), 1ull << (chunk_bits_));
+        uint_t irow_chunk =
+            ((iChunk + global_chunk_index_) >> ((num_qubits_ - chunk_bits_)))
+            << (chunk_bits_);
+        uint_t icol_chunk = ((iChunk + global_chunk_index_) &
+                             ((1ull << ((num_qubits_ - chunk_bits_))) - 1))
+                            << (chunk_bits_);
+
+        // copy part of state for this chunk
+        uint_t i, row, col;
+        for (i = 0; i < (1ull << (chunk_bits_ * qubit_scale())); i++) {
+          uint_t icol = i & ((1ull << chunk_bits_) - 1);
           uint_t irow = i >> chunk_bits_;
-          tmp[i] = mat[icol_chunk + icol + ((irow_chunk + irow) << num_qubits_)];
+          tmp[i] =
+              mat[icol_chunk + icol + ((irow_chunk + irow) << num_qubits_)];
         }
         qregs_[iChunk].initialize_from_matrix(tmp);
       }
     }
-  }
-  else{
-    if(iChunkIn == STATE_APPLY_TO_ALL_CHUNKS){
-      for(iChunk=0;iChunk<num_local_chunks_;iChunk++){
+  } else {
+    if (iChunkIn == STATE_APPLY_TO_ALL_CHUNKS) {
+      for (iChunk = 0; iChunk < num_local_chunks_; iChunk++) {
         qregs_[iChunk].initialize_from_matrix(mat);
       }
-    }
-    else
+    } else
       qregs_[iChunkIn].initialize_from_matrix(mat);
   }
 }
 
-template <class state_t>
-auto StateChunk<state_t>::apply_to_matrix(bool copy)
-{
-  //this function is used to collect states over chunks
+template <class state_t> auto StateChunk<state_t>::apply_to_matrix(bool copy) {
+  // this function is used to collect states over chunks
   int_t iChunk;
-  uint_t size = 1ull << (chunk_bits_*qubit_scale());
+  uint_t size = 1ull << (chunk_bits_ * qubit_scale());
   uint_t mask = (1ull << (chunk_bits_)) - 1;
   uint_t num_threads = qregs_[0].get_omp_threads();
 
-  size_t size_required = 2*(sizeof(std::complex<double>) << (num_qubits_*2)) + (sizeof(std::complex<double>) << (chunk_bits_*2))*num_local_chunks_;
-  if((size_required>>20) > Utils::get_system_memory_mb()){
-    throw std::runtime_error(std::string("There is not enough memory to store states as matrix"));
+  size_t size_required =
+      2 * (sizeof(std::complex<double>) << (num_qubits_ * 2)) +
+      (sizeof(std::complex<double>) << (chunk_bits_ * 2)) * num_local_chunks_;
+  if ((size_required >> 20) > Utils::get_system_memory_mb()) {
+    throw std::runtime_error(
+        std::string("There is not enough memory to store states as matrix"));
   }
 
   auto matrix = qregs_[0].copy_to_matrix();
 
-  if(distributed_rank_ == 0){
-    matrix.resize(1ull << (num_qubits_),1ull << (num_qubits_));
+  if (distributed_rank_ == 0) {
+    matrix.resize(1ull << (num_qubits_), 1ull << (num_qubits_));
 
     auto tmp = qregs_[0].copy_to_matrix();
-    for(iChunk=0;iChunk<num_global_chunks_;iChunk++){
+    for (iChunk = 0; iChunk < num_global_chunks_; iChunk++) {
       int_t i;
-      uint_t irow_chunk = (iChunk >> ((num_qubits_ - chunk_bits_))) << chunk_bits_;
-      uint_t icol_chunk = (iChunk & ((1ull << ((num_qubits_ - chunk_bits_)))-1)) << chunk_bits_;
-
-      if(iChunk < num_local_chunks_){
-        if(copy)
+      uint_t irow_chunk = (iChunk >> ((num_qubits_ - chunk_bits_)))
+                          << chunk_bits_;
+      uint_t icol_chunk =
+          (iChunk & ((1ull << ((num_qubits_ - chunk_bits_))) - 1))
+          << chunk_bits_;
+
+      if (iChunk < num_local_chunks_) {
+        if (copy)
           tmp = qregs_[iChunk].copy_to_matrix();
         else
           tmp = qregs_[iChunk].move_to_matrix();
       }
 #ifdef AER_MPI
       else
-        recv_data(tmp.data(),size,0,iChunk);
+        recv_data(tmp.data(), size, 0, iChunk);
 #endif
-#pragma omp parallel for if(num_threads > 1) num_threads(num_threads)
-      for(i=0;i<size;i++){
+#pragma omp parallel for if (num_threads > 1) num_threads(num_threads)
+      for (i = 0; i < size; i++) {
         uint_t irow = i >> (chunk_bits_);
         uint_t icol = i & mask;
-        uint_t idx = ((irow+irow_chunk) << (num_qubits_)) + icol_chunk + icol;
+        uint_t idx = ((irow + irow_chunk) << (num_qubits_)) + icol_chunk + icol;
         matrix[idx] = tmp[i];
       }
     }
-  }
-  else{
+  } else {
 #ifdef AER_MPI
-    //send matrices to process 0
-    for(iChunk=0;iChunk<num_global_chunks_;iChunk++){
+    // send matrices to process 0
+    for (iChunk = 0; iChunk < num_global_chunks_; iChunk++) {
       uint_t iProc = get_process_by_chunk(iChunk);
-      if(iProc == distributed_rank_){
-        if(copy){
-          auto tmp = qregs_[iChunk-global_chunk_index_].copy_to_matrix();
-          send_data(tmp.data(),size,iChunk,0);
-        }
-        else{
-          auto tmp = qregs_[iChunk-global_chunk_index_].move_to_matrix();
-          send_data(tmp.data(),size,iChunk,0);
+      if (iProc == distributed_rank_) {
+        if (copy) {
+          auto tmp = qregs_[iChunk - global_chunk_index_].copy_to_matrix();
+          send_data(tmp.data(), size, iChunk, 0);
+        } else {
+          auto tmp = qregs_[iChunk - global_chunk_index_].move_to_matrix();
+          send_data(tmp.data(), size, iChunk, 0);
         }
       }
     }
@@ -1450,15 +1485,13 @@ auto StateChunk<state_t>::apply_to_matrix(bool copy)
   return matrix;
 }
 
-
 template <class state_t>
-uint_t StateChunk<state_t>::mapped_index(const uint_t idx)
-{
-  uint_t i,ret = 0;
+uint_t StateChunk<state_t>::mapped_index(const uint_t idx) {
+  uint_t i, ret = 0;
   uint_t t = idx;
 
-  for(i=0;i<num_qubits_;i++){
-    if(t & 1){
+  for (i = 0; i < num_qubits_; i++) {
+    if (t & 1) {
       ret |= (1ull << qubit_map_[i]);
     }
     t >>= 1;
@@ -1467,128 +1500,134 @@ uint_t StateChunk<state_t>::mapped_index(const uint_t idx)
 }
 
 template <class state_t>
-void StateChunk<state_t>::apply_chunk_swap(const reg_t &qubits)
-{
+void StateChunk<state_t>::apply_chunk_swap(const reg_t &qubits) {
   uint_t nLarge = 1;
-  uint_t q0,q1;
+  uint_t q0, q1;
   int_t iChunk;
 
   q0 = qubits[qubits.size() - 2];
   q1 = qubits[qubits.size() - 1];
 
-  if(qubit_scale() == 1){
-    std::swap(qubit_map_[q0],qubit_map_[q1]);
+  if (qubit_scale() == 1) {
+    std::swap(qubit_map_[q0], qubit_map_[q1]);
   }
 
-  if(q0 > q1){
-    std::swap(q0,q1);
+  if (q0 > q1) {
+    std::swap(q0, q1);
   }
 
-  if(q1 < chunk_bits_*qubit_scale()){
-    //inside chunk
-    if(chunk_omp_parallel_ && num_groups_ > 1){
-#pragma omp parallel for num_threads(num_groups_) 
-      for(int_t ig=0;ig<num_groups_;ig++){
-        for(int_t iChunk = top_chunk_of_group_[ig];iChunk < top_chunk_of_group_[ig + 1];iChunk++)
+  if (q1 < chunk_bits_ * qubit_scale()) {
+    // inside chunk
+    if (chunk_omp_parallel_ && num_groups_ > 1) {
+#pragma omp parallel for num_threads(num_groups_)
+      for (int_t ig = 0; ig < num_groups_; ig++) {
+        for (int_t iChunk = top_chunk_of_group_[ig];
+             iChunk < top_chunk_of_group_[ig + 1]; iChunk++)
           qregs_[iChunk].apply_mcswap(qubits);
       }
-    }
-    else{
-      for(int_t ig=0;ig<num_groups_;ig++){
-        for(int_t iChunk = top_chunk_of_group_[ig];iChunk < top_chunk_of_group_[ig + 1];iChunk++)
+    } else {
+      for (int_t ig = 0; ig < num_groups_; ig++) {
+        for (int_t iChunk = top_chunk_of_group_[ig];
+             iChunk < top_chunk_of_group_[ig + 1]; iChunk++)
           qregs_[iChunk].apply_mcswap(qubits);
       }
     }
-  }
-  else{ //swap over chunks
-    uint_t mask0,mask1;
+  } else { // swap over chunks
+    uint_t mask0, mask1;
 
     mask0 = (1ull << q0);
     mask1 = (1ull << q1);
-    mask0 >>= (chunk_bits_*qubit_scale());
-    mask1 >>= (chunk_bits_*qubit_scale());
-
-    if(distributed_procs_ == 1 || (distributed_proc_bits_ >= 0 && q1 < (num_qubits_*qubit_scale() - distributed_proc_bits_))){   //no data transfer between processes is needed
-      auto apply_chunk_swap_1qubit = [this, mask1, qubits](int_t iGroup)
-      {
-        for(int_t ic = top_chunk_of_group_[iGroup];ic < top_chunk_of_group_[iGroup + 1];ic++){
+    mask0 >>= (chunk_bits_ * qubit_scale());
+    mask1 >>= (chunk_bits_ * qubit_scale());
+
+    if (distributed_procs_ == 1 ||
+        (distributed_proc_bits_ >= 0 &&
+         q1 < (num_qubits_ * qubit_scale() -
+               distributed_proc_bits_))) { // no data transfer between processes
+                                           // is needed
+      auto apply_chunk_swap_1qubit = [this, mask1, qubits](int_t iGroup) {
+        for (int_t ic = top_chunk_of_group_[iGroup];
+             ic < top_chunk_of_group_[iGroup + 1]; ic++) {
           uint_t baseChunk;
           baseChunk = ic & (~mask1);
-          if(ic == baseChunk)
-            qregs_[ic].apply_chunk_swap(qubits,qregs_[ic | mask1],true);
+          if (ic == baseChunk)
+            qregs_[ic].apply_chunk_swap(qubits, qregs_[ic | mask1], true);
         }
       };
-      auto apply_chunk_swap_2qubits = [this, mask0, mask1, qubits](int_t iGroup)
-      {
-        for(int_t ic = top_chunk_of_group_[iGroup];ic < top_chunk_of_group_[iGroup + 1];ic++){
+      auto apply_chunk_swap_2qubits = [this, mask0, mask1,
+                                       qubits](int_t iGroup) {
+        for (int_t ic = top_chunk_of_group_[iGroup];
+             ic < top_chunk_of_group_[iGroup + 1]; ic++) {
           uint_t baseChunk;
           baseChunk = ic & (~(mask0 | mask1));
           uint_t iChunk1 = baseChunk | mask0;
           uint_t iChunk2 = baseChunk | mask1;
-          if(ic == iChunk1)
-            qregs_[iChunk1].apply_chunk_swap(qubits,qregs_[iChunk2],true);
+          if (ic == iChunk1)
+            qregs_[iChunk1].apply_chunk_swap(qubits, qregs_[iChunk2], true);
         }
       };
-      if(q0 < chunk_bits_*qubit_scale())
-        Utils::apply_omp_parallel_for((chunk_omp_parallel_ && num_groups_ > 1), 0, num_groups_, apply_chunk_swap_1qubit);
+      if (q0 < chunk_bits_ * qubit_scale())
+        Utils::apply_omp_parallel_for((chunk_omp_parallel_ && num_groups_ > 1),
+                                      0, num_groups_, apply_chunk_swap_1qubit);
       else
-        Utils::apply_omp_parallel_for((chunk_omp_parallel_ && num_groups_ > 1), 0, num_groups_, apply_chunk_swap_2qubits);
+        Utils::apply_omp_parallel_for((chunk_omp_parallel_ && num_groups_ > 1),
+                                      0, num_groups_, apply_chunk_swap_2qubits);
     }
 #ifdef AER_MPI
-    else{
+    else {
       int_t iPair;
       uint_t nPair;
-      uint_t baseChunk,iChunk1,iChunk2;
+      uint_t baseChunk, iChunk1, iChunk2;
 
-      if(q0 < chunk_bits_*qubit_scale())
+      if (q0 < chunk_bits_ * qubit_scale())
         nLarge = 1;
       else
         nLarge = 2;
 
-      //chunk scheduler that supports any number of processes
+      // chunk scheduler that supports any number of processes
       uint_t nu[3];
       uint_t ub[3];
       uint_t iu[3];
       uint_t add;
-      uint_t iLocalChunk,iRemoteChunk,iProc;
+      uint_t iLocalChunk, iRemoteChunk, iProc;
       int i;
 
-      if(q0 < chunk_bits_*qubit_scale()){
+      if (q0 < chunk_bits_ * qubit_scale()) {
         nLarge = 1;
-        nu[0] = 1ull << (q1 - chunk_bits_*qubit_scale());
+        nu[0] = 1ull << (q1 - chunk_bits_ * qubit_scale());
         ub[0] = 0;
         iu[0] = 0;
 
-        nu[1] = 1ull << (num_qubits_*qubit_scale() - q1 - 1);
-        ub[1] = (q1 - chunk_bits_*qubit_scale()) + 1;
+        nu[1] = 1ull << (num_qubits_ * qubit_scale() - q1 - 1);
+        ub[1] = (q1 - chunk_bits_ * qubit_scale()) + 1;
         iu[1] = 0;
-      }
-      else{
+      } else {
         nLarge = 2;
-        nu[0] = 1ull << (q0 - chunk_bits_*qubit_scale());
+        nu[0] = 1ull << (q0 - chunk_bits_ * qubit_scale());
         ub[0] = 0;
         iu[0] = 0;
 
         nu[1] = 1ull << (q1 - q0 - 1);
-        ub[1] = (q0 - chunk_bits_*qubit_scale()) + 1;
+        ub[1] = (q0 - chunk_bits_ * qubit_scale()) + 1;
         iu[1] = 0;
 
-        nu[2] = 1ull << (num_qubits_*qubit_scale() - q1 - 1);
-        ub[2] = (q1 - chunk_bits_*qubit_scale()) + 1;
+        nu[2] = 1ull << (num_qubits_ * qubit_scale() - q1 - 1);
+        ub[2] = (q1 - chunk_bits_ * qubit_scale()) + 1;
         iu[2] = 0;
       }
-      nPair = 1ull << (num_qubits_*qubit_scale() - chunk_bits_*qubit_scale() - nLarge);
+      nPair = 1ull << (num_qubits_ * qubit_scale() -
+                       chunk_bits_ * qubit_scale() - nLarge);
 
-      for(iPair=0;iPair<nPair;iPair++){
-        //calculate index of pair of chunks
+      for (iPair = 0; iPair < nPair; iPair++) {
+        // calculate index of pair of chunks
         baseChunk = 0;
         add = 1;
-        for(i=nLarge;i>=0;i--){
+        for (i = nLarge; i >= 0; i--) {
           baseChunk += (iu[i] << ub[i]);
-          //update for next
+          // update for next
           iu[i] += add;
           add = 0;
-          if(iu[i] >= nu[i]){
+          if (iu[i] >= nu[i]) {
             iu[i] = 0;
             add = 1;
           }
@@ -1597,42 +1636,51 @@ void StateChunk<state_t>::apply_chunk_swap(const reg_t &qubits)
         iChunk1 = baseChunk | mask0;
         iChunk2 = baseChunk | mask1;
 
-        if(iChunk1 >= chunk_index_begin_[distributed_rank_] && iChunk1 < chunk_index_end_[distributed_rank_]){    //chunk1 is on this process
-          if(iChunk2 >= chunk_index_begin_[distributed_rank_] && iChunk2 < chunk_index_end_[distributed_rank_]){    //chunk2 is on this process
-            qregs_[iChunk1 - global_chunk_index_].apply_chunk_swap(qubits,qregs_[iChunk2 - global_chunk_index_],true);
+        if (iChunk1 >= chunk_index_begin_[distributed_rank_] &&
+            iChunk1 < chunk_index_end_[distributed_rank_]) { // chunk1 is on
+                                                             // this process
+          if (iChunk2 >= chunk_index_begin_[distributed_rank_] &&
+              iChunk2 < chunk_index_end_[distributed_rank_]) { // chunk2 is on
+                                                               // this process
+            qregs_[iChunk1 - global_chunk_index_].apply_chunk_swap(
+                qubits, qregs_[iChunk2 - global_chunk_index_], true);
             continue;
-          }
-          else{
+          } else {
             iLocalChunk = iChunk1;
             iRemoteChunk = iChunk2;
             iProc = get_process_by_chunk(iChunk2);
           }
-        }
-        else{
-          if(iChunk2 >= chunk_index_begin_[distributed_rank_] && iChunk2 < chunk_index_end_[distributed_rank_]){    //chunk2 is on this process
+        } else {
+          if (iChunk2 >= chunk_index_begin_[distributed_rank_] &&
+              iChunk2 < chunk_index_end_[distributed_rank_]) { // chunk2 is on
+                                                               // this process
             iLocalChunk = iChunk2;
             iRemoteChunk = iChunk1;
             iProc = get_process_by_chunk(iChunk1);
-          }
-          else{
-            continue;   //there is no chunk for this pair on this process
+          } else {
+            continue; // there is no chunk for this pair on this process
           }
         }
 
-        MPI_Request reqSend,reqRecv;
+        MPI_Request reqSend, reqRecv;
         MPI_Status st;
-        uint_t sizeRecv,sizeSend;
+        uint_t sizeRecv, sizeSend;
 
-        auto pRecv = qregs_[iLocalChunk - global_chunk_index_].recv_buffer(sizeRecv);
-        MPI_Irecv(pRecv,sizeRecv,MPI_BYTE,iProc,iPair,distributed_comm_,&reqRecv);
+        auto pRecv =
+            qregs_[iLocalChunk - global_chunk_index_].recv_buffer(sizeRecv);
+        MPI_Irecv(pRecv, sizeRecv, MPI_BYTE, iProc, iPair, distributed_comm_,
+                  &reqRecv);
 
-        auto pSend = qregs_[iLocalChunk - global_chunk_index_].send_buffer(sizeSend);
-        MPI_Isend(pSend,sizeSend,MPI_BYTE,iProc,iPair,distributed_comm_,&reqSend);
+        auto pSend =
+            qregs_[iLocalChunk - global_chunk_index_].send_buffer(sizeSend);
+        MPI_Isend(pSend, sizeSend, MPI_BYTE, iProc, iPair, distributed_comm_,
+                  &reqSend);
 
-        MPI_Wait(&reqSend,&st);
-        MPI_Wait(&reqRecv,&st);
+        MPI_Wait(&reqSend, &st);
+        MPI_Wait(&reqRecv, &st);
 
-        qregs_[iLocalChunk - global_chunk_index_].apply_chunk_swap(qubits,iRemoteChunk);
+        qregs_[iLocalChunk - global_chunk_index_].apply_chunk_swap(
+            qubits, iRemoteChunk);
       }
     }
 #endif
@@ -1640,35 +1688,37 @@ void StateChunk<state_t>::apply_chunk_swap(const reg_t &qubits)
 }
 
 template <class state_t>
-void StateChunk<state_t>::apply_multi_chunk_swap(const reg_t &qubits)
-{
-  int_t nswap = qubits.size()/2;
-  reg_t chunk_shuffle_qubits(nswap,0);
+void StateChunk<state_t>::apply_multi_chunk_swap(const reg_t &qubits) {
+  int_t nswap = qubits.size() / 2;
+  reg_t chunk_shuffle_qubits(nswap, 0);
   reg_t local_swaps;
   uint_t baseChunk = 0;
   uint_t nchunk = 1ull << nswap;
   reg_t chunk_procs(nchunk);
   reg_t chunk_offset(nchunk);
 
-  if(qubit_scale() == 1){
-    for(int_t i=0;i<nswap;i++)
-      std::swap(qubit_map_[qubits[i*2]],qubit_map_[qubits[i*2]+1]);
+  if (qubit_scale() == 1) {
+    for (int_t i = 0; i < nswap; i++)
+      std::swap(qubit_map_[qubits[i * 2]], qubit_map_[qubits[i * 2] + 1]);
   }
 
-  //define local swaps
-  for(int_t i=0;i<nswap;i++){
-    if(qubits[i*2] >= chunk_bits_*qubit_scale() - nswap)  //no swap required
-      chunk_shuffle_qubits[qubits[i*2] + nswap - chunk_bits_*qubit_scale()] = qubits[i*2 + 1];
+  // define local swaps
+  for (int_t i = 0; i < nswap; i++) {
+    if (qubits[i * 2] >= chunk_bits_ * qubit_scale() - nswap) // no swap
+                                                              // required
+      chunk_shuffle_qubits[qubits[i * 2] + nswap -
+                           chunk_bits_ * qubit_scale()] = qubits[i * 2 + 1];
   }
   int_t pos = 0;
-  for(int_t i=0;i<nswap;i++){
-    if(qubits[i*2] < chunk_bits_*qubit_scale() - nswap){  //local swap required
-      //find empty position
-      while(pos < nswap){
-        if(chunk_shuffle_qubits[pos] < chunk_bits_*qubit_scale()){
-          chunk_shuffle_qubits[pos] = qubits[i*2 + 1];
-          local_swaps.push_back(qubits[i*2]);
-          local_swaps.push_back(chunk_bits_*qubit_scale() - nswap + pos);
+  for (int_t i = 0; i < nswap; i++) {
+    if (qubits[i * 2] <
+        chunk_bits_ * qubit_scale() - nswap) { // local swap required
+      // find empty position
+      while (pos < nswap) {
+        if (chunk_shuffle_qubits[pos] < chunk_bits_ * qubit_scale()) {
+          chunk_shuffle_qubits[pos] = qubits[i * 2 + 1];
+          local_swaps.push_back(qubits[i * 2]);
+          local_swaps.push_back(chunk_bits_ * qubit_scale() - nswap + pos);
           pos++;
           break;
         }
@@ -1676,35 +1726,37 @@ void StateChunk<state_t>::apply_multi_chunk_swap(const reg_t &qubits)
       }
     }
   }
-  for(int_t i=0;i<nswap;i++)
-    chunk_shuffle_qubits[i] -= chunk_bits_*qubit_scale();
+  for (int_t i = 0; i < nswap; i++)
+    chunk_shuffle_qubits[i] -= chunk_bits_ * qubit_scale();
 
-  //swap inside chunks to prepare for all-to-all shuffle
-  if(chunk_omp_parallel_ && num_groups_ > 1){
-#pragma omp parallel for 
-    for(int_t ig=0;ig<num_groups_;ig++){
-      for(int_t iChunk = top_chunk_of_group_[ig];iChunk < top_chunk_of_group_[ig + 1];iChunk++)
+  // swap inside chunks to prepare for all-to-all shuffle
+  if (chunk_omp_parallel_ && num_groups_ > 1) {
+#pragma omp parallel for
+    for (int_t ig = 0; ig < num_groups_; ig++) {
+      for (int_t iChunk = top_chunk_of_group_[ig];
+           iChunk < top_chunk_of_group_[ig + 1]; iChunk++)
         qregs_[iChunk].apply_multi_swaps(local_swaps);
     }
-  }
-  else{
-    for(int_t ig=0;ig<num_groups_;ig++){
-      for(int_t iChunk = top_chunk_of_group_[ig];iChunk < top_chunk_of_group_[ig + 1];iChunk++)
+  } else {
+    for (int_t ig = 0; ig < num_groups_; ig++) {
+      for (int_t iChunk = top_chunk_of_group_[ig];
+           iChunk < top_chunk_of_group_[ig + 1]; iChunk++)
         qregs_[iChunk].apply_multi_swaps(local_swaps);
     }
   }
 
-  //apply all-to-all chunk shuffle
+  // apply all-to-all chunk shuffle
   int_t nPair;
   reg_t chunk_shuffle_qubits_sorted = chunk_shuffle_qubits;
-  std::sort(chunk_shuffle_qubits_sorted.begin(), chunk_shuffle_qubits_sorted.end());
+  std::sort(chunk_shuffle_qubits_sorted.begin(),
+            chunk_shuffle_qubits_sorted.end());
 
   nPair = num_global_chunks_ >> nswap;
 
-  for(uint_t i=0;i<nchunk;i++){
+  for (uint_t i = 0; i < nchunk; i++) {
     chunk_offset[i] = 0;
-    for(uint_t k=0;k<nswap;k++){
-      if(((i >> k) & 1) != 0)
+    for (uint_t k = 0; k < nswap; k++) {
+      if (((i >> k) & 1) != 0)
         chunk_offset[i] += (1ull << chunk_shuffle_qubits[k]);
     }
   }
@@ -1714,199 +1766,210 @@ void StateChunk<state_t>::apply_multi_chunk_swap(const reg_t &qubits)
   std::vector<MPI_Request> reqRecv(nchunk);
 #endif
 
-  for(int_t iPair=0;iPair<nPair;iPair++){
-    uint_t i1,i2,k,ii,t;
+  for (int_t iPair = 0; iPair < nPair; iPair++) {
+    uint_t i1, i2, k, ii, t;
     baseChunk = 0;
     ii = iPair;
-    for(k=0;k<nswap;k++){
+    for (k = 0; k < nswap; k++) {
       t = ii & ((1ull << chunk_shuffle_qubits_sorted[k]) - 1);
       baseChunk += t;
       ii = (ii - t) << 1;
     }
     baseChunk += ii;
 
-    for(i1=0;i1<nchunk;i1++){
+    for (i1 = 0; i1 < nchunk; i1++) {
       chunk_procs[i1] = get_process_by_chunk(baseChunk + chunk_offset[i1]);
     }
 
-    //all-to-all
-    //send data
-    for(uint_t iswap=1;iswap<nchunk;iswap++){
-      uint_t sizeRecv,sizeSend;
+    // all-to-all
+    // send data
+    for (uint_t iswap = 1; iswap < nchunk; iswap++) {
+      uint_t sizeRecv, sizeSend;
       uint_t num_local_swap = 0;
-      for(i1=0;i1<nchunk;i1++){
+      for (i1 = 0; i1 < nchunk; i1++) {
         i2 = i1 ^ iswap;
-        if(i1 >= i2)
+        if (i1 >= i2)
           continue;
 
         uint_t iProc1 = chunk_procs[i1];
         uint_t iProc2 = chunk_procs[i2];
-        if(iProc1 != distributed_rank_ && iProc2 != distributed_rank_)
+        if (iProc1 != distributed_rank_ && iProc2 != distributed_rank_)
           continue;
-        if(iProc1 == iProc2){  //on the same process
+        if (iProc1 == iProc2) { // on the same process
           num_local_swap++;
-          continue;   //swap while data is exchanged between processes
+          continue; // swap while data is exchanged between processes
         }
 #ifdef AER_MPI
-        uint_t offset1 = i1 << (chunk_bits_*qubit_scale() - nswap);
-        uint_t offset2 = i2 << (chunk_bits_*qubit_scale() - nswap);
+        uint_t offset1 = i1 << (chunk_bits_ * qubit_scale() - nswap);
+        uint_t offset2 = i2 << (chunk_bits_ * qubit_scale() - nswap);
         uint_t iChunk1 = baseChunk + chunk_offset[i1] - global_chunk_index_;
         uint_t iChunk2 = baseChunk + chunk_offset[i2] - global_chunk_index_;
 
         int_t tid = (iPair << nswap) + iswap;
 
-        if(iProc1 == distributed_rank_){
+        if (iProc1 == distributed_rank_) {
           auto pRecv = qregs_[iChunk1].recv_buffer(sizeRecv);
-          MPI_Irecv(pRecv + offset2,(sizeRecv >> nswap),MPI_BYTE,iProc2,tid,distributed_comm_,&reqRecv[i2]);
+          MPI_Irecv(pRecv + offset2, (sizeRecv >> nswap), MPI_BYTE, iProc2, tid,
+                    distributed_comm_, &reqRecv[i2]);
 
           auto pSend = qregs_[iChunk1].send_buffer(sizeSend);
-          MPI_Isend(pSend + offset2,(sizeSend >> nswap),MPI_BYTE,iProc2,tid,distributed_comm_,&reqSend[i2]);
-        }
-        else{
+          MPI_Isend(pSend + offset2, (sizeSend >> nswap), MPI_BYTE, iProc2, tid,
+                    distributed_comm_, &reqSend[i2]);
+        } else {
           auto pRecv = qregs_[iChunk2].recv_buffer(sizeRecv);
-          MPI_Irecv(pRecv + offset1,(sizeRecv >> nswap),MPI_BYTE,iProc1,tid,distributed_comm_,&reqRecv[i1]);
+          MPI_Irecv(pRecv + offset1, (sizeRecv >> nswap), MPI_BYTE, iProc1, tid,
+                    distributed_comm_, &reqRecv[i1]);
 
           auto pSend = qregs_[iChunk2].send_buffer(sizeSend);
-          MPI_Isend(pSend + offset1,(sizeSend >> nswap),MPI_BYTE,iProc1,tid,distributed_comm_,&reqSend[i1]);
+          MPI_Isend(pSend + offset1, (sizeSend >> nswap), MPI_BYTE, iProc1, tid,
+                    distributed_comm_, &reqSend[i1]);
         }
 #endif
       }
 
-      //swaps inside process
-      if(num_local_swap > 0){
-        for(i1=0;i1<nchunk;i1++){
+      // swaps inside process
+      if (num_local_swap > 0) {
+        for (i1 = 0; i1 < nchunk; i1++) {
           i2 = i1 ^ iswap;
-          if(i1 > i2)
+          if (i1 > i2)
             continue;
 
           uint_t iProc1 = chunk_procs[i1];
           uint_t iProc2 = chunk_procs[i2];
-          if(iProc1 != distributed_rank_ && iProc2 != distributed_rank_)
+          if (iProc1 != distributed_rank_ && iProc2 != distributed_rank_)
             continue;
-          if(iProc1 == iProc2){  //on the same process
-            uint_t offset1 = i1 << (chunk_bits_*qubit_scale() - nswap);
-            uint_t offset2 = i2 << (chunk_bits_*qubit_scale() - nswap);
+          if (iProc1 == iProc2) { // on the same process
+            uint_t offset1 = i1 << (chunk_bits_ * qubit_scale() - nswap);
+            uint_t offset2 = i2 << (chunk_bits_ * qubit_scale() - nswap);
             uint_t iChunk1 = baseChunk + chunk_offset[i1] - global_chunk_index_;
             uint_t iChunk2 = baseChunk + chunk_offset[i2] - global_chunk_index_;
-            qregs_[iChunk1].apply_chunk_swap(qregs_[iChunk2],offset2,offset1,(1ull << (chunk_bits_*qubit_scale() - nswap)) );
+            qregs_[iChunk1].apply_chunk_swap(
+                qregs_[iChunk2], offset2, offset1,
+                (1ull << (chunk_bits_ * qubit_scale() - nswap)));
           }
         }
       }
 
 #ifdef AER_MPI
-      //recv data
-      for(i1=0;i1<nchunk;i1++){
+      // recv data
+      for (i1 = 0; i1 < nchunk; i1++) {
         i2 = i1 ^ iswap;
 
         uint_t iProc1 = chunk_procs[i1];
         uint_t iProc2 = chunk_procs[i2];
-        if(iProc1 != distributed_rank_)
+        if (iProc1 != distributed_rank_)
           continue;
-        if(iProc1 == iProc2){  //on the same process
+        if (iProc1 == iProc2) { // on the same process
           continue;
         }
         uint_t iChunk1 = baseChunk + chunk_offset[i1] - global_chunk_index_;
-        uint_t offset2 = i2 << (chunk_bits_*qubit_scale() - nswap);
+        uint_t offset2 = i2 << (chunk_bits_ * qubit_scale() - nswap);
 
         MPI_Status st;
-        MPI_Wait(&reqSend[i2],&st);
-        MPI_Wait(&reqRecv[i2],&st);
+        MPI_Wait(&reqSend[i2], &st);
+        MPI_Wait(&reqRecv[i2], &st);
 
-        //copy states from recv buffer to chunk
-        qregs_[iChunk1].apply_chunk_swap(qregs_[iChunk1],offset2,offset2,(1ull << (chunk_bits_*qubit_scale() - nswap)) );
+        // copy states from recv buffer to chunk
+        qregs_[iChunk1].apply_chunk_swap(
+            qregs_[iChunk1], offset2, offset2,
+            (1ull << (chunk_bits_ * qubit_scale() - nswap)));
       }
 #endif
     }
   }
 
-  //restore qubits order
-  if(chunk_omp_parallel_ && num_groups_ > 1){
-#pragma omp parallel for 
-    for(int_t ig=0;ig<num_groups_;ig++){
-      for(int_t iChunk = top_chunk_of_group_[ig];iChunk < top_chunk_of_group_[ig + 1];iChunk++)
+  // restore qubits order
+  if (chunk_omp_parallel_ && num_groups_ > 1) {
+#pragma omp parallel for
+    for (int_t ig = 0; ig < num_groups_; ig++) {
+      for (int_t iChunk = top_chunk_of_group_[ig];
+           iChunk < top_chunk_of_group_[ig + 1]; iChunk++)
         qregs_[iChunk].apply_multi_swaps(local_swaps);
     }
-  }
-  else{
-    for(int_t ig=0;ig<num_groups_;ig++){
-      for(int_t iChunk = top_chunk_of_group_[ig];iChunk < top_chunk_of_group_[ig + 1];iChunk++)
+  } else {
+    for (int_t ig = 0; ig < num_groups_; ig++) {
+      for (int_t iChunk = top_chunk_of_group_[ig];
+           iChunk < top_chunk_of_group_[ig + 1]; iChunk++)
         qregs_[iChunk].apply_multi_swaps(local_swaps);
     }
   }
 }
 
-
 template <class state_t>
-void StateChunk<state_t>::apply_chunk_x(const uint_t qubit)
-{
+void StateChunk<state_t>::apply_chunk_x(const uint_t qubit) {
   int_t iChunk;
   uint_t nLarge = 1;
 
-
-  if(qubit < chunk_bits_*qubit_scale()){
-    auto apply_mcx = [this, qubit](int_t ig)
-    {
-      reg_t qubits(1,qubit);
-      for(int_t iChunk = top_chunk_of_group_[ig];iChunk < top_chunk_of_group_[ig + 1];iChunk++)
+  if (qubit < chunk_bits_ * qubit_scale()) {
+    auto apply_mcx = [this, qubit](int_t ig) {
+      reg_t qubits(1, qubit);
+      for (int_t iChunk = top_chunk_of_group_[ig];
+           iChunk < top_chunk_of_group_[ig + 1]; iChunk++)
         qregs_[iChunk].apply_mcx(qubits);
     };
-    Utils::apply_omp_parallel_for((chunk_omp_parallel_ && num_groups_ > 1),0,num_groups_,apply_mcx);
-  }
-  else{ //exchange over chunks
+    Utils::apply_omp_parallel_for((chunk_omp_parallel_ && num_groups_ > 1), 0,
+                                  num_groups_, apply_mcx);
+  } else { // exchange over chunks
     int_t iPair;
-    uint_t nPair,mask;
-    uint_t baseChunk,iChunk1,iChunk2;
+    uint_t nPair, mask;
+    uint_t baseChunk, iChunk1, iChunk2;
     reg_t qubits(2);
     qubits[0] = qubit;
     qubits[1] = qubit;
 
     mask = (1ull << qubit);
-    mask >>= (chunk_bits_*qubit_scale());
+    mask >>= (chunk_bits_ * qubit_scale());
 
-    if(distributed_procs_ == 1 || (distributed_proc_bits_ >= 0 && qubit < (num_qubits_*qubit_scale() - distributed_proc_bits_))){   //no data transfer between processes is needed
+    if (distributed_procs_ == 1 ||
+        (distributed_proc_bits_ >= 0 &&
+         qubit < (num_qubits_ * qubit_scale() -
+                  distributed_proc_bits_))) { // no data transfer between
+                                              // processes is needed
       nPair = num_local_chunks_ >> 1;
 
-      auto apply_chunk_swap = [this, mask, qubits](int_t iGroup)
-      {
-        for(int_t ic = top_chunk_of_group_[iGroup];ic < top_chunk_of_group_[iGroup + 1];ic++){
+      auto apply_chunk_swap = [this, mask, qubits](int_t iGroup) {
+        for (int_t ic = top_chunk_of_group_[iGroup];
+             ic < top_chunk_of_group_[iGroup + 1]; ic++) {
           uint_t pairChunk;
           pairChunk = ic ^ mask;
-          if(ic < pairChunk)
-            qregs_[ic].apply_chunk_swap(qubits,qregs_[pairChunk],true);
+          if (ic < pairChunk)
+            qregs_[ic].apply_chunk_swap(qubits, qregs_[pairChunk], true);
         }
       };
-      Utils::apply_omp_parallel_for((chunk_omp_parallel_ && num_groups_ > 1),0, nPair, apply_chunk_swap);
+      Utils::apply_omp_parallel_for((chunk_omp_parallel_ && num_groups_ > 1), 0,
+                                    nPair, apply_chunk_swap);
     }
 #ifdef AER_MPI
-    else{
-      //chunk scheduler that supports any number of processes
+    else {
+      // chunk scheduler that supports any number of processes
       uint_t nu[3];
       uint_t ub[3];
       uint_t iu[3];
       uint_t add;
-      uint_t iLocalChunk,iRemoteChunk,iProc;
+      uint_t iLocalChunk, iRemoteChunk, iProc;
       int i;
 
       nLarge = 1;
-      nu[0] = 1ull << (qubit - chunk_bits_*qubit_scale());
+      nu[0] = 1ull << (qubit - chunk_bits_ * qubit_scale());
       ub[0] = 0;
       iu[0] = 0;
 
-      nu[1] = 1ull << (num_qubits_*qubit_scale() - qubit - 1);
-      ub[1] = (qubit - chunk_bits_*qubit_scale()) + 1;
+      nu[1] = 1ull << (num_qubits_ * qubit_scale() - qubit - 1);
+      ub[1] = (qubit - chunk_bits_ * qubit_scale()) + 1;
       iu[1] = 0;
-      nPair = 1ull << (num_qubits_*qubit_scale() - chunk_bits_*qubit_scale() - 1);
+      nPair = 1ull << (num_qubits_ * qubit_scale() -
+                       chunk_bits_ * qubit_scale() - 1);
 
-      for(iPair=0;iPair<nPair;iPair++){
-        //calculate index of pair of chunks
+      for (iPair = 0; iPair < nPair; iPair++) {
+        // calculate index of pair of chunks
         baseChunk = 0;
         add = 1;
-        for(i=1;i>=0;i--){
+        for (i = 1; i >= 0; i--) {
           baseChunk += (iu[i] << ub[i]);
-          //update for next
+          // update for next
           iu[i] += add;
           add = 0;
-          if(iu[i] >= nu[i]){
+          if (iu[i] >= nu[i]) {
             iu[i] = 0;
             add = 1;
           }
@@ -1915,52 +1978,60 @@ void StateChunk<state_t>::apply_chunk_x(const uint_t qubit)
         iChunk1 = baseChunk;
         iChunk2 = baseChunk | mask;
 
-        if(iChunk1 >= chunk_index_begin_[distributed_rank_] && iChunk1 < chunk_index_end_[distributed_rank_]){    //chunk1 is on this process
-          if(iChunk2 >= chunk_index_begin_[distributed_rank_] && iChunk2 < chunk_index_end_[distributed_rank_]){    //chunk2 is on this process
-            qregs_[iChunk1 - global_chunk_index_].apply_chunk_swap(qubits,qregs_[iChunk2 - global_chunk_index_],true);
+        if (iChunk1 >= chunk_index_begin_[distributed_rank_] &&
+            iChunk1 < chunk_index_end_[distributed_rank_]) { // chunk1 is on
+                                                             // this process
+          if (iChunk2 >= chunk_index_begin_[distributed_rank_] &&
+              iChunk2 < chunk_index_end_[distributed_rank_]) { // chunk2 is on
+                                                               // this process
+            qregs_[iChunk1 - global_chunk_index_].apply_chunk_swap(
+                qubits, qregs_[iChunk2 - global_chunk_index_], true);
             continue;
-          }
-          else{
+          } else {
             iLocalChunk = iChunk1;
             iRemoteChunk = iChunk2;
             iProc = get_process_by_chunk(iChunk2);
           }
-        }
-        else{
-          if(iChunk2 >= chunk_index_begin_[distributed_rank_] && iChunk2 < chunk_index_end_[distributed_rank_]){    //chunk2 is on this process
+        } else {
+          if (iChunk2 >= chunk_index_begin_[distributed_rank_] &&
+              iChunk2 < chunk_index_end_[distributed_rank_]) { // chunk2 is on
+                                                               // this process
             iLocalChunk = iChunk2;
             iRemoteChunk = iChunk1;
             iProc = get_process_by_chunk(iChunk1);
-          }
-          else{
-            continue;   //there is no chunk for this pair on this process
+          } else {
+            continue; // there is no chunk for this pair on this process
           }
         }
 
-        MPI_Request reqSend,reqRecv;
+        MPI_Request reqSend, reqRecv;
         MPI_Status st;
-        uint_t sizeRecv,sizeSend;
+        uint_t sizeRecv, sizeSend;
 
-        auto pSend = qregs_[iLocalChunk - global_chunk_index_].send_buffer(sizeSend);
-        MPI_Isend(pSend,sizeSend,MPI_BYTE,iProc,iPair,distributed_comm_,&reqSend);
+        auto pSend =
+            qregs_[iLocalChunk - global_chunk_index_].send_buffer(sizeSend);
+        MPI_Isend(pSend, sizeSend, MPI_BYTE, iProc, iPair, distributed_comm_,
+                  &reqSend);
 
-        auto pRecv = qregs_[iLocalChunk - global_chunk_index_].recv_buffer(sizeRecv);
-        MPI_Irecv(pRecv,sizeRecv,MPI_BYTE,iProc,iPair,distributed_comm_,&reqRecv);
+        auto pRecv =
+            qregs_[iLocalChunk - global_chunk_index_].recv_buffer(sizeRecv);
+        MPI_Irecv(pRecv, sizeRecv, MPI_BYTE, iProc, iPair, distributed_comm_,
+                  &reqRecv);
 
-        MPI_Wait(&reqSend,&st);
-        MPI_Wait(&reqRecv,&st);
+        MPI_Wait(&reqSend, &st);
+        MPI_Wait(&reqRecv, &st);
 
-        qregs_[iLocalChunk - global_chunk_index_].apply_chunk_swap(qubits,iRemoteChunk);
+        qregs_[iLocalChunk - global_chunk_index_].apply_chunk_swap(
+            qubits, iRemoteChunk);
       }
     }
 #endif
-
   }
 }
 
 template <class state_t>
-void StateChunk<state_t>::send_chunk(uint_t local_chunk_index, uint_t global_pair_index)
-{
+void StateChunk<state_t>::send_chunk(uint_t local_chunk_index,
+                                     uint_t global_pair_index) {
 #ifdef AER_MPI
   MPI_Request reqSend;
   MPI_Status st;
@@ -1970,17 +2041,19 @@ void StateChunk<state_t>::send_chunk(uint_t local_chunk_index, uint_t global_pai
   iProc = get_process_by_chunk(global_pair_index);
 
   auto pSend = qregs_[local_chunk_index].send_buffer(sizeSend);
-  MPI_Isend(pSend,sizeSend,MPI_BYTE,iProc,local_chunk_index + global_chunk_index_,distributed_comm_,&reqSend);
+  MPI_Isend(pSend, sizeSend, MPI_BYTE, iProc,
+            local_chunk_index + global_chunk_index_, distributed_comm_,
+            &reqSend);
 
-  MPI_Wait(&reqSend,&st);
+  MPI_Wait(&reqSend, &st);
 
   qregs_[local_chunk_index].release_send_buffer();
 #endif
 }
 
 template <class state_t>
-void StateChunk<state_t>::recv_chunk(uint_t local_chunk_index, uint_t global_pair_index)
-{
+void StateChunk<state_t>::recv_chunk(uint_t local_chunk_index,
+                                     uint_t global_pair_index) {
 #ifdef AER_MPI
   MPI_Request reqRecv;
   MPI_Status st;
@@ -1990,16 +2063,17 @@ void StateChunk<state_t>::recv_chunk(uint_t local_chunk_index, uint_t global_pai
   iProc = get_process_by_chunk(global_pair_index);
 
   auto pRecv = qregs_[local_chunk_index].recv_buffer(sizeRecv);
-  MPI_Irecv(pRecv,sizeRecv,MPI_BYTE,iProc,global_pair_index,distributed_comm_,&reqRecv);
+  MPI_Irecv(pRecv, sizeRecv, MPI_BYTE, iProc, global_pair_index,
+            distributed_comm_, &reqRecv);
 
-  MPI_Wait(&reqRecv,&st);
+  MPI_Wait(&reqRecv, &st);
 #endif
 }
 
 template <class state_t>
 template <class data_t>
-void StateChunk<state_t>::send_data(data_t* pSend, uint_t size, uint_t myid,uint_t pairid)
-{
+void StateChunk<state_t>::send_data(data_t *pSend, uint_t size, uint_t myid,
+                                    uint_t pairid) {
 #ifdef AER_MPI
   MPI_Request reqSend;
   MPI_Status st;
@@ -2007,16 +2081,17 @@ void StateChunk<state_t>::send_data(data_t* pSend, uint_t size, uint_t myid,uint
 
   iProc = get_process_by_chunk(pairid);
 
-  MPI_Isend(pSend,size*sizeof(data_t),MPI_BYTE,iProc,myid,distributed_comm_,&reqSend);
+  MPI_Isend(pSend, size * sizeof(data_t), MPI_BYTE, iProc, myid,
+            distributed_comm_, &reqSend);
 
-  MPI_Wait(&reqSend,&st);
+  MPI_Wait(&reqSend, &st);
 #endif
 }
 
 template <class state_t>
 template <class data_t>
-void StateChunk<state_t>::recv_data(data_t* pRecv, uint_t size, uint_t myid,uint_t pairid)
-{
+void StateChunk<state_t>::recv_data(data_t *pRecv, uint_t size, uint_t myid,
+                                    uint_t pairid) {
 #ifdef AER_MPI
   MPI_Request reqRecv;
   MPI_Status st;
@@ -2024,21 +2099,22 @@ void StateChunk<state_t>::recv_data(data_t* pRecv, uint_t size, uint_t myid,uint
 
   iProc = get_process_by_chunk(pairid);
 
-  MPI_Irecv(pRecv,size*sizeof(data_t),MPI_BYTE,iProc,pairid,distributed_comm_,&reqRecv);
+  MPI_Irecv(pRecv, size * sizeof(data_t), MPI_BYTE, iProc, pairid,
+            distributed_comm_, &reqRecv);
 
-  MPI_Wait(&reqRecv,&st);
+  MPI_Wait(&reqRecv, &st);
 #endif
 }
 
 template <class state_t>
-void StateChunk<state_t>::reduce_sum(reg_t& sum) const
-{
+void StateChunk<state_t>::reduce_sum(reg_t &sum) const {
 #ifdef AER_MPI
-  if(distributed_procs_ > 1){
-    uint_t i,n = sum.size();
+  if (distributed_procs_ > 1) {
+    uint_t i, n = sum.size();
     reg_t tmp(n);
-    MPI_Allreduce(&sum[0],&tmp[0],n,MPI_UINT64_T,MPI_SUM,distributed_comm_);
-    for(i=0;i<n;i++){
+    MPI_Allreduce(&sum[0], &tmp[0], n, MPI_UINT64_T, MPI_SUM,
+                  distributed_comm_);
+    for (i = 0; i < n; i++) {
       sum[i] = tmp[i];
     }
   }
@@ -2046,14 +2122,14 @@ void StateChunk<state_t>::reduce_sum(reg_t& sum) const
 }
 
 template <class state_t>
-void StateChunk<state_t>::reduce_sum(rvector_t& sum) const
-{
+void StateChunk<state_t>::reduce_sum(rvector_t &sum) const {
 #ifdef AER_MPI
-  if(distributed_procs_ > 1){
-    uint_t i,n = sum.size();
+  if (distributed_procs_ > 1) {
+    uint_t i, n = sum.size();
     rvector_t tmp(n);
-    MPI_Allreduce(&sum[0],&tmp[0],n,MPI_DOUBLE_PRECISION,MPI_SUM,distributed_comm_);
-    for(i=0;i<n;i++){
+    MPI_Allreduce(&sum[0], &tmp[0], n, MPI_DOUBLE_PRECISION, MPI_SUM,
+                  distributed_comm_);
+    for (i = 0; i < n; i++) {
       sum[i] = tmp[i];
     }
   }
@@ -2061,82 +2137,84 @@ void StateChunk<state_t>::reduce_sum(rvector_t& sum) const
 }
 
 template <class state_t>
-void StateChunk<state_t>::reduce_sum(complex_t& sum) const
-{
+void StateChunk<state_t>::reduce_sum(complex_t &sum) const {
 #ifdef AER_MPI
-  if(distributed_procs_ > 1){
+  if (distributed_procs_ > 1) {
     complex_t tmp;
-    MPI_Allreduce(&sum,&tmp,2,MPI_DOUBLE_PRECISION,MPI_SUM,distributed_comm_);
+    MPI_Allreduce(&sum, &tmp, 2, MPI_DOUBLE_PRECISION, MPI_SUM,
+                  distributed_comm_);
     sum = tmp;
   }
 #endif
 }
 
 template <class state_t>
-void StateChunk<state_t>::reduce_sum(double& sum) const
-{
+void StateChunk<state_t>::reduce_sum(double &sum) const {
 #ifdef AER_MPI
-  if(distributed_procs_ > 1){
+  if (distributed_procs_ > 1) {
     double tmp;
-    MPI_Allreduce(&sum,&tmp,1,MPI_DOUBLE_PRECISION,MPI_SUM,distributed_comm_);
+    MPI_Allreduce(&sum, &tmp, 1, MPI_DOUBLE_PRECISION, MPI_SUM,
+                  distributed_comm_);
     sum = tmp;
   }
 #endif
 }
 
 template <class state_t>
-void StateChunk<state_t>::gather_value(rvector_t& val) const
-{
+void StateChunk<state_t>::gather_value(rvector_t &val) const {
 #ifdef AER_MPI
-  if(distributed_procs_ > 1){
+  if (distributed_procs_ > 1) {
     rvector_t tmp = val;
-    MPI_Alltoall(&tmp[0],1,MPI_DOUBLE_PRECISION,&val[0],1,MPI_DOUBLE_PRECISION,distributed_comm_);
+    MPI_Alltoall(&tmp[0], 1, MPI_DOUBLE_PRECISION, &val[0], 1,
+                 MPI_DOUBLE_PRECISION, distributed_comm_);
   }
 #endif
 }
 
-template <class state_t>
-void StateChunk<state_t>::sync_process(void) const
-{
+template <class state_t> void StateChunk<state_t>::sync_process(void) const {
 #ifdef AER_MPI
-  if(distributed_procs_ > 1){
+  if (distributed_procs_ > 1) {
     MPI_Barrier(distributed_comm_);
   }
 #endif
 }
 
-//gather distributed state into vector (if memory is enough)
+// gather distributed state into vector (if memory is enough)
 template <class state_t>
 template <class data_t>
-void StateChunk<state_t>::gather_state(std::vector<std::complex<data_t>>& state)
-{
+void StateChunk<state_t>::gather_state(
+    std::vector<std::complex<data_t>> &state) {
 #ifdef AER_MPI
-  if(distributed_procs_ > 1){
-    uint_t size,local_size,global_size,offset;
+  if (distributed_procs_ > 1) {
+    uint_t size, local_size, global_size, offset;
     int i;
     std::vector<int> recv_counts(distributed_procs_);
     std::vector<int> recv_offset(distributed_procs_);
 
     global_size = 0;
-    for(i=0;i<distributed_procs_;i++){
-      recv_offset[i] = (int)(chunk_index_begin_[i] << (chunk_bits_*qubit_scale()))*2;
-      recv_counts[i] = (int)((chunk_index_end_[i] - chunk_index_begin_[i]) << (chunk_bits_*qubit_scale()));
+    for (i = 0; i < distributed_procs_; i++) {
+      recv_offset[i] =
+          (int)(chunk_index_begin_[i] << (chunk_bits_ * qubit_scale())) * 2;
+      recv_counts[i] = (int)((chunk_index_end_[i] - chunk_index_begin_[i])
+                             << (chunk_bits_ * qubit_scale()));
       global_size += recv_counts[i];
       recv_counts[i] *= 2;
     }
-    if((global_size >> 21) > Utils::get_system_memory_mb()){
-      throw std::runtime_error(std::string("There is not enough memory to gather state"));
+    if ((global_size >> 21) > Utils::get_system_memory_mb()) {
+      throw std::runtime_error(
+          std::string("There is not enough memory to gather state"));
     }
     std::vector<std::complex<data_t>> local_state = state;
     state.resize(global_size);
 
-    if(sizeof(std::complex<data_t>) == 16){
-      MPI_Allgatherv(local_state.data(),recv_counts[distributed_rank_],MPI_DOUBLE_PRECISION,
-                     state.data(),&recv_counts[0],&recv_offset[0],MPI_DOUBLE_PRECISION,distributed_comm_);
-    }
-    else{
-      MPI_Allgatherv(local_state.data(),recv_counts[distributed_rank_],MPI_FLOAT,
-                     state.data(),&recv_counts[0],&recv_offset[0],MPI_FLOAT,distributed_comm_);
+    if (sizeof(std::complex<data_t>) == 16) {
+      MPI_Allgatherv(local_state.data(), recv_counts[distributed_rank_],
+                     MPI_DOUBLE_PRECISION, state.data(), &recv_counts[0],
+                     &recv_offset[0], MPI_DOUBLE_PRECISION, distributed_comm_);
+    } else {
+      MPI_Allgatherv(local_state.data(), recv_counts[distributed_rank_],
+                     MPI_FLOAT, state.data(), &recv_counts[0], &recv_offset[0],
+                     MPI_FLOAT, distributed_comm_);
     }
   }
 #endif
@@ -2144,88 +2222,92 @@ void StateChunk<state_t>::gather_state(std::vector<std::complex<data_t>>& state)
 
 template <class state_t>
 template <class data_t>
-void StateChunk<state_t>::gather_state(AER::Vector<std::complex<data_t>>& state)
-{
+void StateChunk<state_t>::gather_state(
+    AER::Vector<std::complex<data_t>> &state) {
 #ifdef AER_MPI
-  if(distributed_procs_ > 1){
-    uint_t size,local_size,global_size,offset;
+  if (distributed_procs_ > 1) {
+    uint_t size, local_size, global_size, offset;
     int i;
 
     std::vector<int> recv_counts(distributed_procs_);
     std::vector<int> recv_offset(distributed_procs_);
 
     global_size = 0;
-    for(i=0;i<distributed_procs_;i++){
-      recv_offset[i] = (int)(chunk_index_begin_[i] << (chunk_bits_*qubit_scale()))*2;
-      recv_counts[i] = (int)((chunk_index_end_[i] - chunk_index_begin_[i]) << (chunk_bits_*qubit_scale()));
+    for (i = 0; i < distributed_procs_; i++) {
+      recv_offset[i] =
+          (int)(chunk_index_begin_[i] << (chunk_bits_ * qubit_scale())) * 2;
+      recv_counts[i] = (int)((chunk_index_end_[i] - chunk_index_begin_[i])
+                             << (chunk_bits_ * qubit_scale()));
       global_size += recv_counts[i];
       recv_counts[i] *= 2;
     }
-    if((global_size >> 21) > Utils::get_system_memory_mb()){
-      throw std::runtime_error(std::string("There is not enough memory to gather state"));
+    if ((global_size >> 21) > Utils::get_system_memory_mb()) {
+      throw std::runtime_error(
+          std::string("There is not enough memory to gather state"));
     }
     AER::Vector<std::complex<data_t>> local_state = state;
     state.resize(global_size);
 
-    if(sizeof(std::complex<data_t>) == 16){
-      MPI_Allgatherv(local_state.data(),recv_counts[distributed_rank_],MPI_DOUBLE_PRECISION,
-                     state.data(),&recv_counts[0],&recv_offset[0],MPI_DOUBLE_PRECISION,distributed_comm_);
-    }
-    else{
-      MPI_Allgatherv(local_state.data(),recv_counts[distributed_rank_],MPI_FLOAT,
-                     state.data(),&recv_counts[0],&recv_offset[0],MPI_FLOAT,distributed_comm_);
+    if (sizeof(std::complex<data_t>) == 16) {
+      MPI_Allgatherv(local_state.data(), recv_counts[distributed_rank_],
+                     MPI_DOUBLE_PRECISION, state.data(), &recv_counts[0],
+                     &recv_offset[0], MPI_DOUBLE_PRECISION, distributed_comm_);
+    } else {
+      MPI_Allgatherv(local_state.data(), recv_counts[distributed_rank_],
+                     MPI_FLOAT, state.data(), &recv_counts[0], &recv_offset[0],
+                     MPI_FLOAT, distributed_comm_);
     }
   }
 #endif
 }
 
-template <class state_t>
-void StateChunk<state_t>::gather_creg_memory(void)
-{
+template <class state_t> void StateChunk<state_t>::gather_creg_memory(void) {
 #ifdef AER_MPI
-  int_t i,j;
-  uint_t n64,i64,ibit;
+  int_t i, j;
+  uint_t n64, i64, ibit;
 
-  if(distributed_procs_ == 1)
+  if (distributed_procs_ == 1)
     return;
-  if(BaseState::cregs_[0].memory_size() == 0)
+  if (BaseState::cregs_[0].memory_size() == 0)
     return;
 
-  //number of 64-bit integers per memory
+  // number of 64-bit integers per memory
   n64 = (BaseState::cregs_[0].memory_size() + 63) >> 6;
 
-  reg_t bin_memory(n64*num_local_chunks_,0);
-  //compress memory string to binary
-#pragma omp parallel for private(i,j,i64,ibit)
-  for(i=0;i<num_local_chunks_;i++){
-    for(j=0;j<BaseState::cregs_[0].memory_size();j++){
+  reg_t bin_memory(n64 * num_local_chunks_, 0);
+  // compress memory string to binary
+#pragma omp parallel for private(i, j, i64, ibit)
+  for (i = 0; i < num_local_chunks_; i++) {
+    for (j = 0; j < BaseState::cregs_[0].memory_size(); j++) {
       i64 = j >> 6;
       ibit = j & 63;
-      if(BaseState::cregs_[global_chunk_index_ + i].creg_memory()[j] == '1'){
-        bin_memory[i*n64 + i64] |= (1ull << ibit);
+      if (BaseState::cregs_[global_chunk_index_ + i].creg_memory()[j] == '1') {
+        bin_memory[i * n64 + i64] |= (1ull << ibit);
       }
     }
   }
 
-  reg_t recv(n64*num_global_chunks_);
+  reg_t recv(n64 * num_global_chunks_);
   std::vector<int> recv_counts(distributed_procs_);
   std::vector<int> recv_offset(distributed_procs_);
 
-  for(i=0;i<distributed_procs_;i++){
+  for (i = 0; i < distributed_procs_; i++) {
     recv_offset[i] = num_global_chunks_ * i / distributed_procs_;
-    recv_counts[i] = (num_global_chunks_ * (i+1) / distributed_procs_) - recv_offset[i];
+    recv_counts[i] =
+        (num_global_chunks_ * (i + 1) / distributed_procs_) - recv_offset[i];
   }
 
-  MPI_Allgatherv(&bin_memory[0],n64*num_local_chunks_,MPI_UINT64_T,
-                 &recv[0],&recv_counts[0],&recv_offset[0],MPI_UINT64_T,distributed_comm_);
+  MPI_Allgatherv(&bin_memory[0], n64 * num_local_chunks_, MPI_UINT64_T,
+                 &recv[0], &recv_counts[0], &recv_offset[0], MPI_UINT64_T,
+                 distributed_comm_);
 
-  //store gathered memory
-#pragma omp parallel for private(i,j,i64,ibit)
-  for(i=0;i<num_global_chunks_;i++){
-    for(j=0;j<BaseState::cregs_[0].memory_size();j++){
+  // store gathered memory
+#pragma omp parallel for private(i, j, i64, ibit)
+  for (i = 0; i < num_global_chunks_; i++) {
+    for (j = 0; j < BaseState::cregs_[0].memory_size(); j++) {
       i64 = j >> 6;
       ibit = j & 63;
-      if(((recv[i*n64 + i64] >> ibit) & 1) == 1)
+      if (((recv[i * n64 + i64] >> ibit) & 1) == 1)
         BaseState::cregs_[i].creg_memory()[j] = '1';
       else
         BaseState::cregs_[i].creg_memory()[j] = '0';
@@ -2234,9 +2316,8 @@ void StateChunk<state_t>::gather_creg_memory(void)
 #endif
 }
 
-
 //-------------------------------------------------------------------------
-} // end namespace Base
+} // namespace QuantumState
 //-------------------------------------------------------------------------
 } // end namespace AER
 //-------------------------------------------------------------------------
diff --git a/src/simulators/statevector/chunk/chunk.hpp b/src/simulators/statevector/chunk/chunk.hpp
index 2dcfbfc2ab..3ba9e65e33 100644
--- a/src/simulators/statevector/chunk/chunk.hpp
+++ b/src/simulators/statevector/chunk/chunk.hpp
@@ -22,29 +22,25 @@
 #include "simulators/statevector/chunk/cuStateVec_chunk_container.hpp"
 #endif
 
-
 namespace AER {
 namespace QV {
 namespace Chunk {
 
-
 //============================================================================
 // chunk class
 //============================================================================
-template <typename data_t>
-class Chunk 
-{
+template <typename data_t> class Chunk {
 protected:
-  mutable std::weak_ptr<ChunkContainer<data_t>> chunk_container_;   //pointer to chunk container
-  std::shared_ptr<Chunk<data_t>> cache_;                 //pointer to cache chunk on device
-  uint_t chunk_pos_;                    //position in container
-  int place_;                           //container ID
-  uint_t num_qubits_;                   //total number of qubits
-  uint_t chunk_index_;                  //global chunk index
-  bool mapped_;                         //mapped to qubitvector
+  mutable std::weak_ptr<ChunkContainer<data_t>>
+      chunk_container_;                  // pointer to chunk container
+  std::shared_ptr<Chunk<data_t>> cache_; // pointer to cache chunk on device
+  uint_t chunk_pos_;                     // position in container
+  int place_;                            // container ID
+  uint_t num_qubits_;                    // total number of qubits
+  uint_t chunk_index_;                   // global chunk index
+  bool mapped_;                          // mapped to qubitvector
 public:
-  Chunk()
-  {
+  Chunk() {
     chunk_pos_ = 0;
     place_ = -1;
     num_qubits_ = 0;
@@ -53,8 +49,7 @@ class Chunk
     cache_ = nullptr;
   }
 
-  Chunk(std::weak_ptr<ChunkContainer<data_t>> cc,uint_t pos)
-  {
+  Chunk(std::weak_ptr<ChunkContainer<data_t>> cc, uint_t pos) {
     chunk_container_ = cc;
     chunk_pos_ = pos;
     place_ = chunk_container_.lock()->place();
@@ -63,7 +58,8 @@ class Chunk
     mapped_ = false;
     cache_ = nullptr;
   }
-  Chunk(Chunk<data_t>& chunk)   //map chunk from exisiting chunk (used fo cache chunk)
+  Chunk(Chunk<data_t>
+            &chunk) // map chunk from exisiting chunk (used fo cache chunk)
   {
     chunk_container_ = chunk.chunk_container_;
     chunk_pos_ = chunk.chunk_pos_;
@@ -73,398 +69,344 @@ class Chunk
     mapped_ = true;
     cache_ = nullptr;
   }
-  ~Chunk()
-  {
-    if(cache_)
+  ~Chunk() {
+    if (cache_)
       cache_.reset();
   }
 
-  void set_device(void) const
-  {
-    chunk_container_.lock()->set_device();
-  }
-  int device(void)
-  {
-    return chunk_container_.lock()->device();
-  }
+  void set_device(void) const { chunk_container_.lock()->set_device(); }
+  int device(void) { return chunk_container_.lock()->device(); }
 
-  std::shared_ptr<ChunkContainer<data_t>> container()
-  {
+  std::shared_ptr<ChunkContainer<data_t>> container() {
     return chunk_container_.lock();
   }
 
-  void map(std::weak_ptr<ChunkContainer<data_t>> cc,uint_t pos)
-  {
+  void map(std::weak_ptr<ChunkContainer<data_t>> cc, uint_t pos) {
     chunk_container_ = cc;
     chunk_pos_ = pos;
     place_ = chunk_container_.lock()->place();
     mapped_ = true;
   }
 
-  uint_t pos(void)
-  {
-    return chunk_pos_;
-  }
-  int place(void)
-  {
-    return place_;
-  }
-  void set_place(int ip)
-  {
-    place_ = ip;
-  }
-  void map_cache(Chunk<data_t>& chunk)
-  {
+  uint_t pos(void) { return chunk_pos_; }
+  int place(void) { return place_; }
+  void set_place(int ip) { place_ = ip; }
+  void map_cache(Chunk<data_t> &chunk) {
     cache_ = std::make_shared<Chunk<data_t>>(chunk);
   }
-  void unmap_cache(void)
-  {
-    if(cache_){
+  void unmap_cache(void) {
+    if (cache_) {
       cache_->unmap();
       cache_.reset();
       cache_ = nullptr;
     }
   }
-  
-  bool is_mapped(void)
-  {
-    return mapped_;
-  }
-  void unmap(void)
-  {
+
+  bool is_mapped(void) { return mapped_; }
+  void unmap(void) {
     mapped_ = false;
-    if(cache_)
+    if (cache_)
       unmap_cache();
   }
 
-  void set_num_qubits(uint_t qubits)
-  {
-    num_qubits_ = qubits;
-  }
-  void set_chunk_index(uint_t id)
-  {
-    chunk_index_ = id;
-  }
-  uint_t chunk_index(void)
-  {
-    return chunk_index_;
-  }
+  void set_num_qubits(uint_t qubits) { num_qubits_ = qubits; }
+  void set_chunk_index(uint_t id) { chunk_index_ = id; }
+  uint_t chunk_index(void) { return chunk_index_; }
 
-  uint_t matrix_bits(void)
-  {
-    return chunk_container_.lock()->matrix_bits();
-  }
+  uint_t matrix_bits(void) { return chunk_container_.lock()->matrix_bits(); }
 
-  void Set(uint_t i,const thrust::complex<data_t>& t)
-  {
+  void Set(uint_t i, const thrust::complex<data_t> &t) {
     auto sel_chunk_container = chunk_container_.lock();
     sel_chunk_container->synchronize(chunk_pos_);
-    sel_chunk_container->Set(i + (chunk_pos_ << sel_chunk_container->chunk_bits()),t);
+    sel_chunk_container->Set(
+        i + (chunk_pos_ << sel_chunk_container->chunk_bits()), t);
   }
-  thrust::complex<data_t> Get(uint_t i) const
-  {
+  thrust::complex<data_t> Get(uint_t i) const {
     auto sel_chunk_container = chunk_container_.lock();
     sel_chunk_container->synchronize(chunk_pos_);
-    return sel_chunk_container->Get(i + (chunk_pos_ << sel_chunk_container->chunk_bits()));
+    return sel_chunk_container->Get(
+        i + (chunk_pos_ << sel_chunk_container->chunk_bits()));
   }
 
-  thrust::complex<data_t>& operator[](uint_t i)
-  {
+  thrust::complex<data_t> &operator[](uint_t i) {
     auto sel_chunk_container = chunk_container_.lock();
     sel_chunk_container->synchronize(chunk_pos_);
-    return (*sel_chunk_container)[i + (chunk_pos_ << sel_chunk_container->chunk_bits())];
+    return (*sel_chunk_container)[i + (chunk_pos_
+                                       << sel_chunk_container->chunk_bits())];
   }
 
-  thrust::complex<data_t>* pointer(void)
-  {
+  thrust::complex<data_t> *pointer(void) {
     return chunk_container_.lock()->chunk_pointer(chunk_pos_);
   }
-  thrust::complex<data_t>* buffer_pointer(void)
-  {
+  thrust::complex<data_t> *buffer_pointer(void) {
     return chunk_container_.lock()->buffer_pointer();
   }
 
-  void StoreMatrix(const std::vector<std::complex<double>>& mat)
-  {
-    if(cache_){
+  void StoreMatrix(const std::vector<std::complex<double>> &mat) {
+    if (cache_) {
       cache_->StoreMatrix(mat);
-    }
-    else{
-      chunk_container_.lock()->StoreMatrix(mat,chunk_pos_);
+    } else {
+      chunk_container_.lock()->StoreMatrix(mat, chunk_pos_);
     }
   }
-  void StoreMatrix(const std::complex<double>* mat,uint_t size)
-  {
-    if(cache_){
-      cache_->StoreMatrix(mat,size);
-    }
-    else{
-      chunk_container_.lock()->StoreMatrix(mat,chunk_pos_,size);
+  void StoreMatrix(const std::complex<double> *mat, uint_t size) {
+    if (cache_) {
+      cache_->StoreMatrix(mat, size);
+    } else {
+      chunk_container_.lock()->StoreMatrix(mat, chunk_pos_, size);
     }
   }
-  void StoreUintParams(const std::vector<uint_t>& prm)
-  {
-    if(cache_){
+  void StoreUintParams(const std::vector<uint_t> &prm) {
+    if (cache_) {
       cache_->StoreUintParams(prm);
-    }
-    else{
-      chunk_container_.lock()->StoreUintParams(prm,chunk_pos_);
+    } else {
+      chunk_container_.lock()->StoreUintParams(prm, chunk_pos_);
     }
   }
 
-  void ResizeMatrixBuffers(int bits)
-  {
-    //synchronize all kernel execution before changing matrix buffer size
+  void ResizeMatrixBuffers(int bits) {
+    // synchronize all kernel execution before changing matrix buffer size
     chunk_container_.lock()->synchronize(chunk_pos_);
     chunk_container_.lock()->ResizeMatrixBuffers(bits);
   }
 
-  void CopyIn(Chunk<data_t>& src)
-  {
-    chunk_container_.lock()->CopyIn(src,chunk_pos_);
+  void CopyIn(Chunk<data_t> &src) {
+    chunk_container_.lock()->CopyIn(src, chunk_pos_);
   }
-  void CopyOut(Chunk<data_t>& dest)
-  {
-    chunk_container_.lock()->CopyOut(dest,chunk_pos_);
+  void CopyOut(Chunk<data_t> &dest) {
+    chunk_container_.lock()->CopyOut(dest, chunk_pos_);
   }
-  void CopyIn(thrust::complex<data_t>* src, uint_t size)
-  {
+  void CopyIn(thrust::complex<data_t> *src, uint_t size) {
     chunk_container_.lock()->CopyIn(src, chunk_pos_, size);
   }
-  void CopyOut(thrust::complex<data_t>* dest, uint_t size)
-  {
+  void CopyOut(thrust::complex<data_t> *dest, uint_t size) {
     chunk_container_.lock()->CopyOut(dest, chunk_pos_, size);
   }
-  void Swap(Chunk<data_t>& src, uint_t dest_offset = 0, uint_t src_offset = 0, uint_t size = 0, bool write_back = true)
-  {
-    chunk_container_.lock()->Swap(src,chunk_pos_, dest_offset, src_offset, size, write_back);
+  void Swap(Chunk<data_t> &src, uint_t dest_offset = 0, uint_t src_offset = 0,
+            uint_t size = 0, bool write_back = true) {
+    chunk_container_.lock()->Swap(src, chunk_pos_, dest_offset, src_offset,
+                                  size, write_back);
   }
 
-  template <typename Function>
-  void Execute(Function func,uint_t count)
-  {
-    if(cache_){
-      cache_->chunk_container_.lock()->Execute(func,cache_->chunk_pos_,chunk_index_,count);
-    }
-    else{
-      chunk_container_.lock()->Execute(func,chunk_pos_,chunk_index_,count);
+  template <typename Function> void Execute(Function func, uint_t count) {
+    if (cache_) {
+      cache_->chunk_container_.lock()->Execute(func, cache_->chunk_pos_,
+                                               chunk_index_, count);
+    } else {
+      chunk_container_.lock()->Execute(func, chunk_pos_, chunk_index_, count);
     }
   }
 
   template <typename Function>
-  void ExecuteSum(double* pSum,Function func,uint_t count) const
-  {
-    if(cache_){
-      cache_->ExecuteSum(pSum,func,count);
-    }
-    else{
-      chunk_container_.lock()->ExecuteSum(pSum,func,chunk_pos_,count);
+  void ExecuteSum(double *pSum, Function func, uint_t count) const {
+    if (cache_) {
+      cache_->ExecuteSum(pSum, func, count);
+    } else {
+      chunk_container_.lock()->ExecuteSum(pSum, func, chunk_pos_, count);
     }
   }
 
   template <typename Function>
-  void ExecuteSum2(double* pSum,Function func,uint_t count) const
-  {
-    if(cache_){
-      cache_->ExecuteSum2(pSum,func,count);
-    }
-    else{
-      chunk_container_.lock()->ExecuteSum2(pSum,func,chunk_pos_,count);
+  void ExecuteSum2(double *pSum, Function func, uint_t count) const {
+    if (cache_) {
+      cache_->ExecuteSum2(pSum, func, count);
+    } else {
+      chunk_container_.lock()->ExecuteSum2(pSum, func, chunk_pos_, count);
     }
   }
 
-  reg_t sample_measure(const std::vector<double> &rnds,uint_t stride = 1,bool dot = true,uint_t count = 1) const
-  {
-    return chunk_container_.lock()->sample_measure(chunk_pos_,rnds,stride,dot,count);
+  reg_t sample_measure(const std::vector<double> &rnds, uint_t stride = 1,
+                       bool dot = true, uint_t count = 1) const {
+    return chunk_container_.lock()->sample_measure(chunk_pos_, rnds, stride,
+                                                   dot, count);
   }
 
-  double norm(uint_t count) const
-  {
-    return chunk_container_.lock()->norm(chunk_pos_,count);
+  double norm(uint_t count) const {
+    return chunk_container_.lock()->norm(chunk_pos_, count);
   }
-  double trace(uint_t row, uint_t count) const
-  {
-    return chunk_container_.lock()->trace(chunk_pos_,row,count);
+  double trace(uint_t row, uint_t count) const {
+    return chunk_container_.lock()->trace(chunk_pos_, row, count);
   }
 
 #ifdef AER_THRUST_CUDA
-  cudaStream_t stream(void)
-  {
-    return std::static_pointer_cast<DeviceChunkContainer<data_t>>(chunk_container_.lock())->stream(chunk_pos_);
+  cudaStream_t stream(void) {
+    return std::static_pointer_cast<DeviceChunkContainer<data_t>>(
+               chunk_container_.lock())
+        ->stream(chunk_pos_);
   }
 #endif
 
-  thrust::complex<double>* matrix_pointer(void)
-  {
+  thrust::complex<double> *matrix_pointer(void) {
     return chunk_container_.lock()->matrix_pointer(chunk_pos_);
   }
-  uint_t* param_pointer(void)
-  {
+  uint_t *param_pointer(void) {
     return chunk_container_.lock()->param_pointer(chunk_pos_);
   }
-  double* reduce_buffer(void)
-  {
-    if(cache_){
+  double *reduce_buffer(void) {
+    if (cache_) {
       return cache_->reduce_buffer();
     }
     return chunk_container_.lock()->reduce_buffer(chunk_pos_);
   }
-  uint_t reduce_buffer_size(void)
-  {
-    if(cache_){
+  uint_t reduce_buffer_size(void) {
+    if (cache_) {
       return cache_->reduce_buffer_size();
     }
     return chunk_container_.lock()->reduce_buffer_size();
   }
-  double* probability_buffer(void)
-  {
-    if(cache_){
+  double *probability_buffer(void) {
+    if (cache_) {
       return cache_->probability_buffer();
     }
     return chunk_container_.lock()->probability_buffer(chunk_pos_);
   }
 
-  void synchronize(void) const
-  {
-    if(cache_){
+  void synchronize(void) const {
+    if (cache_) {
       cache_->synchronize();
-    }
-    else{
+    } else {
       chunk_container_.lock()->synchronize(chunk_pos_);
     }
   }
 
-  //set qubits to be blocked
-  void set_blocked_qubits(const reg_t& qubits)
-  {
-    chunk_container_.lock()->set_blocked_qubits(chunk_pos_,qubits);
+  // set qubits to be blocked
+  void set_blocked_qubits(const reg_t &qubits) {
+    chunk_container_.lock()->set_blocked_qubits(chunk_pos_, qubits);
   }
 
-  //do all gates stored in queue
-  void apply_blocked_gates(void)
-  {
+  // do all gates stored in queue
+  void apply_blocked_gates(void) {
     chunk_container_.lock()->apply_blocked_gates(chunk_pos_);
   }
 
-  //queue gate for blocked execution
-  void queue_blocked_gate(char gate,uint_t qubit,uint_t mask,const std::complex<double>* pMat = nullptr)
-  {
-    chunk_container_.lock()->queue_blocked_gate(chunk_pos_,gate,qubit,mask,pMat);
+  // queue gate for blocked execution
+  void queue_blocked_gate(char gate, uint_t qubit, uint_t mask,
+                          const std::complex<double> *pMat = nullptr) {
+    chunk_container_.lock()->queue_blocked_gate(chunk_pos_, gate, qubit, mask,
+                                                pMat);
   }
 
-  int measured_cbit(int qubit)
-  {
-    return chunk_container_.lock()->measured_cbit(chunk_pos_,qubit);
+  int measured_cbit(int qubit) {
+    return chunk_container_.lock()->measured_cbit(chunk_pos_, qubit);
   }
 
-
-  void set_conditional(int_t bit)
-  {
-    //top chunk only sets conditional bit
-    if(chunk_pos_ == 0)
+  void set_conditional(int_t bit) {
+    // top chunk only sets conditional bit
+    if (chunk_pos_ == 0)
       chunk_container_.lock()->set_conditional(bit);
   }
-  int_t get_conditional(void)
-  {
+  int_t get_conditional(void) {
     return chunk_container_.lock()->get_conditional();
   }
-  void keep_conditional(bool keep)
-  {
-    //top chunk only sets conditional bit
-    if(chunk_pos_ == 0)
+  void keep_conditional(bool keep) {
+    // top chunk only sets conditional bit
+    if (chunk_pos_ == 0)
       chunk_container_.lock()->keep_conditional(keep);
   }
 
-  //apply matrix
-  void apply_matrix(const reg_t& qubits,const int_t control_bits,const cvector_t<double> &mat,const uint_t count)
-  {
-    if(cache_)
-      cache_->chunk_container_.lock()->apply_matrix(cache_->chunk_pos_, qubits,control_bits,mat,chunk_index_,count);
+  // apply matrix
+  void apply_matrix(const reg_t &qubits, const int_t control_bits,
+                    const cvector_t<double> &mat, const uint_t count) {
+    if (cache_)
+      cache_->chunk_container_.lock()->apply_matrix(
+          cache_->chunk_pos_, qubits, control_bits, mat, chunk_index_, count);
     else
-      chunk_container_.lock()->apply_matrix(chunk_pos_,qubits,control_bits,mat,chunk_index_,count);
-  }
-  //apply diagonal matrix
-  void apply_diagonal_matrix(const reg_t& qubits,const int_t control_bits,const cvector_t<double> &diag,const uint_t count)
-  {
-    if(cache_)
-      cache_->chunk_container_.lock()->apply_diagonal_matrix(cache_->chunk_pos_, qubits,control_bits,diag,chunk_index_,count);
+      chunk_container_.lock()->apply_matrix(chunk_pos_, qubits, control_bits,
+                                            mat, chunk_index_, count);
+  }
+  // apply diagonal matrix
+  void apply_diagonal_matrix(const reg_t &qubits, const int_t control_bits,
+                             const cvector_t<double> &diag,
+                             const uint_t count) {
+    if (cache_)
+      cache_->chunk_container_.lock()->apply_diagonal_matrix(
+          cache_->chunk_pos_, qubits, control_bits, diag, chunk_index_, count);
     else
-      chunk_container_.lock()->apply_diagonal_matrix(chunk_pos_,qubits,control_bits,diag,chunk_index_,count);
-  }
-  //apply (controlled) X
-  void apply_X(const reg_t& qubits,const uint_t count)
-  {
-    if(cache_)
-      cache_->chunk_container_.lock()->apply_X(cache_->chunk_pos_, qubits,chunk_index_,count);
+      chunk_container_.lock()->apply_diagonal_matrix(
+          chunk_pos_, qubits, control_bits, diag, chunk_index_, count);
+  }
+  // apply (controlled) X
+  void apply_X(const reg_t &qubits, const uint_t count) {
+    if (cache_)
+      cache_->chunk_container_.lock()->apply_X(cache_->chunk_pos_, qubits,
+                                               chunk_index_, count);
     else
-      chunk_container_.lock()->apply_X(chunk_pos_,qubits,chunk_index_,count);
+      chunk_container_.lock()->apply_X(chunk_pos_, qubits, chunk_index_, count);
   }
-  //apply (controlled) Y
-  void apply_Y(const reg_t& qubits,const uint_t count)
-  {
-    if(cache_)
-      cache_->chunk_container_.lock()->apply_Y(cache_->chunk_pos_, qubits,chunk_index_,count);
+  // apply (controlled) Y
+  void apply_Y(const reg_t &qubits, const uint_t count) {
+    if (cache_)
+      cache_->chunk_container_.lock()->apply_Y(cache_->chunk_pos_, qubits,
+                                               chunk_index_, count);
     else
-      chunk_container_.lock()->apply_Y(chunk_pos_,qubits,chunk_index_,count);
-  }
-  //apply (controlled) phase
-  void apply_phase(const reg_t& qubits,const int_t control_bits,const std::complex<double> phase,const uint_t count)
-  {
-    if(cache_)
-      cache_->chunk_container_.lock()->apply_phase(cache_->chunk_pos_, qubits,control_bits,phase,chunk_index_,count);
+      chunk_container_.lock()->apply_Y(chunk_pos_, qubits, chunk_index_, count);
+  }
+  // apply (controlled) phase
+  void apply_phase(const reg_t &qubits, const int_t control_bits,
+                   const std::complex<double> phase, const uint_t count) {
+    if (cache_)
+      cache_->chunk_container_.lock()->apply_phase(
+          cache_->chunk_pos_, qubits, control_bits, phase, chunk_index_, count);
     else
-      chunk_container_.lock()->apply_phase(chunk_pos_,qubits,control_bits,phase,chunk_index_,count);
-  }
-  //apply (controlled) swap gate
-  void apply_swap(const reg_t& qubits,const int_t control_bits,const uint_t count)
-  {
-    if(cache_)
-      cache_->chunk_container_.lock()->apply_swap(cache_->chunk_pos_, qubits,control_bits,chunk_index_,count);
+      chunk_container_.lock()->apply_phase(chunk_pos_, qubits, control_bits,
+                                           phase, chunk_index_, count);
+  }
+  // apply (controlled) swap gate
+  void apply_swap(const reg_t &qubits, const int_t control_bits,
+                  const uint_t count) {
+    if (cache_)
+      cache_->chunk_container_.lock()->apply_swap(
+          cache_->chunk_pos_, qubits, control_bits, chunk_index_, count);
     else
-      chunk_container_.lock()->apply_swap(chunk_pos_,qubits,control_bits,chunk_index_,count);
-  }
-  //apply multiple swap gates
-  void apply_multi_swaps(const reg_t& qubits,const uint_t count)
-  {
-    if(cache_)
-      cache_->chunk_container_.lock()->apply_multi_swaps(cache_->chunk_pos_, qubits,chunk_index_,count);
+      chunk_container_.lock()->apply_swap(chunk_pos_, qubits, control_bits,
+                                          chunk_index_, count);
+  }
+  // apply multiple swap gates
+  void apply_multi_swaps(const reg_t &qubits, const uint_t count) {
+    if (cache_)
+      cache_->chunk_container_.lock()->apply_multi_swaps(
+          cache_->chunk_pos_, qubits, chunk_index_, count);
     else
-      chunk_container_.lock()->apply_multi_swaps(chunk_pos_,qubits,chunk_index_,count);
-  }
-  //apply permutation
-  void apply_permutation(const reg_t& qubits,const std::vector<std::pair<uint_t, uint_t>> &pairs, const uint_t count)
-  {
-    if(cache_)
-      cache_->chunk_container_.lock()->apply_permutation(cache_->chunk_pos_, qubits,pairs,chunk_index_,count);
+      chunk_container_.lock()->apply_multi_swaps(chunk_pos_, qubits,
+                                                 chunk_index_, count);
+  }
+  // apply permutation
+  void apply_permutation(const reg_t &qubits,
+                         const std::vector<std::pair<uint_t, uint_t>> &pairs,
+                         const uint_t count) {
+    if (cache_)
+      cache_->chunk_container_.lock()->apply_permutation(
+          cache_->chunk_pos_, qubits, pairs, chunk_index_, count);
     else
-      chunk_container_.lock()->apply_permutation(chunk_pos_,qubits,pairs,chunk_index_,count);
+      chunk_container_.lock()->apply_permutation(chunk_pos_, qubits, pairs,
+                                                 chunk_index_, count);
   }
 
-  //apply rotation around axis
-  void apply_rotation(const reg_t &qubits, const Rotation r, const double theta, const uint_t count)
-  {
-    if(cache_)
-      cache_->chunk_container_.lock()->apply_rotation(cache_->chunk_pos_, qubits,r,theta,chunk_index_,count);
+  // apply rotation around axis
+  void apply_rotation(const reg_t &qubits, const Rotation r, const double theta,
+                      const uint_t count) {
+    if (cache_)
+      cache_->chunk_container_.lock()->apply_rotation(
+          cache_->chunk_pos_, qubits, r, theta, chunk_index_, count);
     else
-      chunk_container_.lock()->apply_rotation(chunk_pos_,qubits,r,theta,chunk_index_,count);
+      chunk_container_.lock()->apply_rotation(chunk_pos_, qubits, r, theta,
+                                              chunk_index_, count);
   }
 
-  //get probabilities of chunk
-  void probabilities(std::vector<double>& probs, const reg_t& qubits) const
-  {
-    chunk_container_.lock()->probabilities(probs, chunk_pos_,qubits);
+  // get probabilities of chunk
+  void probabilities(std::vector<double> &probs, const reg_t &qubits) const {
+    chunk_container_.lock()->probabilities(probs, chunk_pos_, qubits);
   }
-  //Pauli expectation values
-  double expval_pauli(const reg_t& qubits,const std::string &pauli,const complex_t initial_phase) const
-  {
-    return chunk_container_.lock()->expval_pauli(chunk_pos_,qubits,pauli,initial_phase);
+  // Pauli expectation values
+  double expval_pauli(const reg_t &qubits, const std::string &pauli,
+                      const complex_t initial_phase) const {
+    return chunk_container_.lock()->expval_pauli(chunk_pos_, qubits, pauli,
+                                                 initial_phase);
   }
-
-
 };
 
 //------------------------------------------------------------------------------
-}  // end namespace Chunk
+} // end namespace Chunk
 } // end namespace QV
 } // end namespace AER
 //------------------------------------------------------------------------------
diff --git a/src/simulators/statevector/chunk/chunk_container.hpp b/src/simulators/statevector/chunk/chunk_container.hpp
index be86e9065f..c8e4664835 100644
--- a/src/simulators/statevector/chunk/chunk_container.hpp
+++ b/src/simulators/statevector/chunk/chunk_container.hpp
@@ -12,7 +12,6 @@
  * that they have been altered from the originals.
  */
 
-
 #ifndef _qv_chunk_container_hpp_
 #define _qv_chunk_container_hpp_
 
@@ -31,17 +30,17 @@ DISABLE_WARNING_POP
 #include <cmath>
 #include <complex>
 #include <cstdint>
-#include <string>
-#include <vector>
 #include <iostream>
 #include <sstream>
 #include <stdexcept>
+#include <string>
+#include <vector>
 
-#define AER_DEFAULT_MATRIX_BITS   6
+#define AER_DEFAULT_MATRIX_BITS 6
 
-#define AER_CHUNK_BITS        21
-#define AER_MAX_BUFFERS       1
-#define AER_DUMMY_BUFFERS     4     //reserved storage for parameters
+#define AER_CHUNK_BITS 21
+#define AER_MAX_BUFFERS 1
+#define AER_DUMMY_BUFFERS 4 // reserved storage for parameters
 
 #define QV_CUDA_NUM_THREADS 1024
 #define QV_MAX_REGISTERS 10
@@ -73,46 +72,46 @@ template <typename data_t> class Chunk;
 template <typename data_t> class DeviceChunkContainer;
 template <typename data_t> class HostChunkContainer;
 
-struct BlockedGateParams
-{
+struct BlockedGateParams {
   uint_t mask_;
   char gate_;
   unsigned char qubit_;
 };
 
-
 //============================================================================
 // chunk container base class
 //============================================================================
 template <typename data_t>
-class ChunkContainer : public std::enable_shared_from_this<ChunkContainer<data_t>>
-{
+class ChunkContainer
+    : public std::enable_shared_from_this<ChunkContainer<data_t>> {
 protected:
-  int_t chunk_bits_;                  //number of qubits for a chunk
-  int_t num_qubits_;                  //total qubits
-  int_t place_id_;                    //index of a container (device index + host)
+  int_t chunk_bits_; // number of qubits for a chunk
+  int_t num_qubits_; // total qubits
+  int_t place_id_;   // index of a container (device index + host)
   int_t num_places_;
-  uint_t num_chunks_;                 //number of chunks in this container
-  uint_t chunk_index_;                //global chunk index for the first chunk in this container
-  uint_t num_buffers_;                //number of buffers (buffer chunks) in this container
-  uint_t num_chunk_mapped_;           //number of chunks mapped
+  uint_t num_chunks_; // number of chunks in this container
+  uint_t
+      chunk_index_; // global chunk index for the first chunk in this container
+  uint_t num_buffers_; // number of buffers (buffer chunks) in this container
+  uint_t num_chunk_mapped_; // number of chunks mapped
   reg_t blocked_qubits_;
-  std::vector<bool> chunks_map_;      //chunk mapper
+  std::vector<bool> chunks_map_; // chunk mapper
   mutable reg_t reduced_queue_begin_;
   mutable reg_t reduced_queue_end_;
-  uint_t matrix_bits_;                //max matrix bits
-  uint_t num_creg_bits_;              //number of cregs
+  uint_t matrix_bits_;   // max matrix bits
+  uint_t num_creg_bits_; // number of cregs
   uint_t num_cregisters_;
   uint_t num_cmemory_;
   mutable int_t conditional_bit_;
-  bool keep_conditional_bit_;         //keep conditional bit alive
-  int_t num_pow2_qubits_;             //largest number of qubits that meets num_chunks_ = m*(2^num_pow2_qubits_)
+  bool keep_conditional_bit_; // keep conditional bit alive
+  int_t num_pow2_qubits_; // largest number of qubits that meets num_chunks_ =
+                          // m*(2^num_pow2_qubits_)
   bool density_matrix_;
 
-  int_t omp_threads_;                 //number of threads can be used for parallelization on CPU
+  int_t omp_threads_; // number of threads can be used for parallelization on
+                      // CPU
 public:
-  ChunkContainer()
-  {
+  ChunkContainer() {
     chunk_bits_ = 0;
     place_id_ = 0;
     num_chunks_ = 0;
@@ -125,268 +124,216 @@ class ChunkContainer : public std::enable_shared_from_this<ChunkContainer<data_t
     density_matrix_ = false;
     omp_threads_ = 1;
   }
-  virtual ~ChunkContainer(){}
+  virtual ~ChunkContainer() {}
 
-  int_t chunk_bits(void)
-  {
-    return chunk_bits_;
-  }
-  int_t place(void)
-  {
-    return place_id_;
-  }
-  void set_place(int_t id,int_t n)
-  {
+  int_t chunk_bits(void) { return chunk_bits_; }
+  int_t place(void) { return place_id_; }
+  void set_place(int_t id, int_t n) {
     place_id_ = id;
     num_places_ = n;
   }
-  uint_t num_chunks(void)
-  {
-    return num_chunks_;
-  }
-  uint_t num_buffers(void)
-  {
-    return num_buffers_;
-  }
-  uint_t chunk_size(void)
-  {
-    return (1ull << chunk_bits_);
-  }
-  uint_t num_chunk_mapped(void)
-  {
-    return num_chunk_mapped_;
-  }
-  uint_t matrix_bits(void)
-  {
-    return matrix_bits_;
-  }
+  uint_t num_chunks(void) { return num_chunks_; }
+  uint_t num_buffers(void) { return num_buffers_; }
+  uint_t chunk_size(void) { return (1ull << chunk_bits_); }
+  uint_t num_chunk_mapped(void) { return num_chunk_mapped_; }
+  uint_t matrix_bits(void) { return matrix_bits_; }
 
-  virtual void set_device(void) const
-  {
-  }
+  virtual void set_device(void) const {}
 
 #ifdef AER_THRUST_CUDA
-  virtual cudaStream_t stream(uint_t iChunk) const
-  {
-    return nullptr;
-  }
+  virtual cudaStream_t stream(uint_t iChunk) const { return nullptr; }
 #endif
 
   virtual uint_t size(void) = 0;
-  virtual int device(void)
-  {
-    return -1;
-  }
+  virtual int device(void) { return -1; }
 
-  virtual bool peer_access(int i_dest)
-  {
-    return false;
-  }
+  virtual bool peer_access(int i_dest) { return false; }
 
-  void set_conditional(int_t reg)
-  {
-    conditional_bit_ = reg;
-  }
-  int_t get_conditional(void)
-  {
-    return conditional_bit_;
-  }
-  void keep_conditional(bool keep)
-  {
-    keep_conditional_bit_ = keep;
-  }
+  void set_conditional(int_t reg) { conditional_bit_ = reg; }
+  int_t get_conditional(void) { return conditional_bit_; }
+  void keep_conditional(bool keep) { keep_conditional_bit_ = keep; }
 
-  void set_chunk_index(uint_t chunk_index)
-  {
-    chunk_index_ = chunk_index;
-  }
+  void set_chunk_index(uint_t chunk_index) { chunk_index_ = chunk_index; }
 
-  void set_omp_threads(int_t nthreads)
-  {
-    omp_threads_ = nthreads;
-  }
+  void set_omp_threads(int_t nthreads) { omp_threads_ = nthreads; }
 
-  virtual thrust::complex<data_t>& operator[](uint_t i) = 0;
+  virtual thrust::complex<data_t> &operator[](uint_t i) = 0;
 
-  virtual uint_t Allocate(int idev,int chunk_bits,int num_qubits,uint_t chunks,uint_t buffers = AER_MAX_BUFFERS,bool multi_shots = false,int matrix_bit = AER_DEFAULT_MATRIX_BITS, bool density_matrix = false) = 0;
+  virtual uint_t Allocate(int idev, int chunk_bits, int num_qubits,
+                          uint_t chunks, uint_t buffers = AER_MAX_BUFFERS,
+                          bool multi_shots = false,
+                          int matrix_bit = AER_DEFAULT_MATRIX_BITS,
+                          bool density_matrix = false) = 0;
   virtual void Deallocate(void) = 0;
 
-  virtual void Set(uint_t i,const thrust::complex<data_t>& t) = 0;
+  virtual void Set(uint_t i, const thrust::complex<data_t> &t) = 0;
   virtual thrust::complex<data_t> Get(uint_t i) const = 0;
 
-  virtual void StoreMatrix(const std::vector<std::complex<double>>& mat,uint_t iChunk) = 0;
-  virtual void StoreMatrix(const std::complex<double>* mat,uint_t iChunk,uint_t size) = 0;
-  virtual void StoreUintParams(const std::vector<uint_t>& prm,uint_t iChunk) = 0;
+  virtual void StoreMatrix(const std::vector<std::complex<double>> &mat,
+                           uint_t iChunk) = 0;
+  virtual void StoreMatrix(const std::complex<double> *mat, uint_t iChunk,
+                           uint_t size) = 0;
+  virtual void StoreUintParams(const std::vector<uint_t> &prm,
+                               uint_t iChunk) = 0;
   virtual void ResizeMatrixBuffers(int bits) = 0;
 
-  virtual void CopyIn(Chunk<data_t>& src,uint_t iChunk) = 0;
-  virtual void CopyOut(Chunk<data_t>& dest,uint_t iChunk) = 0;
-  virtual void CopyIn(thrust::complex<data_t>* src,uint_t iChunk, uint_t size) = 0;
-  virtual void CopyOut(thrust::complex<data_t>* dest,uint_t iChunk, uint_t size) = 0;
-  virtual void Swap(Chunk<data_t>& src,uint_t iChunk, uint_t dest_offset = 0, uint_t src_offset = 0, uint_t size = 0, bool write_back = true) = 0;
+  virtual void CopyIn(Chunk<data_t> &src, uint_t iChunk) = 0;
+  virtual void CopyOut(Chunk<data_t> &dest, uint_t iChunk) = 0;
+  virtual void CopyIn(thrust::complex<data_t> *src, uint_t iChunk,
+                      uint_t size) = 0;
+  virtual void CopyOut(thrust::complex<data_t> *dest, uint_t iChunk,
+                       uint_t size) = 0;
+  virtual void Swap(Chunk<data_t> &src, uint_t iChunk, uint_t dest_offset = 0,
+                    uint_t src_offset = 0, uint_t size = 0,
+                    bool write_back = true) = 0;
 
-  virtual void Zero(uint_t iChunk,uint_t count) = 0;
+  virtual void Zero(uint_t iChunk, uint_t count) = 0;
 
   template <typename Function>
-  void Execute(Function func,uint_t iChunk,const uint_t gid, const uint_t count);
+  void Execute(Function func, uint_t iChunk, const uint_t gid,
+               const uint_t count);
 
   template <typename Function>
-  void ExecuteSum(double* pSum,Function func,uint_t iChunk,uint_t count) const;
+  void ExecuteSum(double *pSum, Function func, uint_t iChunk,
+                  uint_t count) const;
 
   template <typename Function>
-  void ExecuteSum2(double* pSum,Function func,uint_t iChunk,uint_t count) const;
-
-  virtual reg_t sample_measure(uint_t iChunk,const std::vector<double> &rnds, uint_t stride = 1, bool dot = true,uint_t count = 1) const = 0;
-  virtual double norm(uint_t iChunk,uint_t count) const;
-  virtual double trace(uint_t iChunk,uint_t row,uint_t count) const;
+  void ExecuteSum2(double *pSum, Function func, uint_t iChunk,
+                   uint_t count) const;
 
+  virtual reg_t sample_measure(uint_t iChunk, const std::vector<double> &rnds,
+                               uint_t stride = 1, bool dot = true,
+                               uint_t count = 1) const = 0;
+  virtual double norm(uint_t iChunk, uint_t count) const;
+  virtual double trace(uint_t iChunk, uint_t row, uint_t count) const;
 
-  size_t size_of_complex(void)
-  {
-    return sizeof(thrust::complex<data_t>);
-  }
+  size_t size_of_complex(void) { return sizeof(thrust::complex<data_t>); }
 
-  bool MapChunk(Chunk<data_t>& chunk);
-  bool MapBufferChunk(Chunk<data_t>& chunk);
-  void UnmapChunk(Chunk<data_t>& chunk);
-  void UnmapBuffer(Chunk<data_t>& chunk);
+  bool MapChunk(Chunk<data_t> &chunk);
+  bool MapBufferChunk(Chunk<data_t> &chunk);
+  void UnmapChunk(Chunk<data_t> &chunk);
+  void UnmapBuffer(Chunk<data_t> &chunk);
   void unmap_all(void);
 
-  virtual thrust::complex<data_t>* chunk_pointer(uint_t iChunk) const
-  {
-    return NULL;
-  }
-  virtual thrust::complex<data_t>* buffer_pointer(void) const
-  {
+  virtual thrust::complex<data_t> *chunk_pointer(uint_t iChunk) const {
     return NULL;
   }
-  virtual thrust::complex<double>* matrix_pointer(uint_t iChunk) const
-  {
+  virtual thrust::complex<data_t> *buffer_pointer(void) const { return NULL; }
+  virtual thrust::complex<double> *matrix_pointer(uint_t iChunk) const {
     return NULL;
   }
-  virtual uint_t* param_pointer(uint_t iChunk) const
-  {
-    return NULL;
-  }
-
+  virtual uint_t *param_pointer(uint_t iChunk) const { return NULL; }
 
-  virtual void synchronize(uint_t iChunk)
-  {
-    ;
-  }
+  virtual void synchronize(uint_t iChunk) { ; }
 
-  //set qubits to be blocked
-  virtual void set_blocked_qubits(uint_t iChunk,const reg_t& qubits)
-  {
-    ;
-  }
+  // set qubits to be blocked
+  virtual void set_blocked_qubits(uint_t iChunk, const reg_t &qubits) { ; }
 
-  //do all gates stored in queue
-  virtual void apply_blocked_gates(uint_t iChunk)
-  {
-    ;
-  }
+  // do all gates stored in queue
+  virtual void apply_blocked_gates(uint_t iChunk) { ; }
 
-  //queue gate for blocked execution
-  virtual void queue_blocked_gate(uint_t iChunk,char gate,uint_t qubit,uint_t mask,const std::complex<double>* pMat = NULL)
-  {
+  // queue gate for blocked execution
+  virtual void queue_blocked_gate(uint_t iChunk, char gate, uint_t qubit,
+                                  uint_t mask,
+                                  const std::complex<double> *pMat = NULL) {
     ;
   }
 
-  virtual double* reduce_buffer(uint_t iChunk) const
-  {
-    return NULL;
-  }
-  virtual uint_t reduce_buffer_size() const
-  {
-    return 1;
-  }
-  virtual double* condition_buffer(uint_t iChunk) const
-  {
-    return NULL;
-  }
-  virtual double* probability_buffer(uint_t iChunk) const
-  {
-    return NULL;
-  }
-
-  virtual void copy_to_probability_buffer(std::vector<double>& buf,int pos){}
-
-  //classical register to store measured bits/used for bfunc operations
-  virtual void allocate_creg(uint_t num_mem,uint_t num_reg){}
-  virtual int measured_cbit(uint_t iChunk,int qubit)
-  {
-    return 0;
-  }
-
-  virtual uint_t* creg_buffer(uint_t iChunk) const
-  {
-    return NULL;
-  }
-  virtual void request_creg_update(void){}
-
-  //apply matrix 
-  virtual void apply_matrix(const uint_t iChunk,const reg_t& qubits,const int_t control_bits,const cvector_t<double> &mat,const uint_t gid, const uint_t count);
-
-  //apply diagonal matrix
-  virtual void apply_diagonal_matrix(const uint_t iChunk,const reg_t& qubits,const int_t control_bits,const cvector_t<double> &diag,const uint_t gid, const uint_t count);
-
-  //apply (controlled) X
-  virtual void apply_X(const uint_t iChunk,const reg_t& qubits,const uint_t gid, const uint_t count);
-
-  //apply (controlled) Y
-  virtual void apply_Y(const uint_t iChunk,const reg_t& qubits,const uint_t gid, const uint_t count);
-
-  //apply (controlled) phase
-  virtual void apply_phase(const uint_t iChunk,const reg_t& qubits,const int_t control_bits,const std::complex<double> phase,const uint_t gid, const uint_t count);
-
-  //apply (controlled) swap gate
-  virtual void apply_swap(const uint_t iChunk,const reg_t& qubits,const int_t control_bits,const uint_t gid, const uint_t count);
-
-  //apply multiple swap gates
-  virtual void apply_multi_swaps(const uint_t iChunk,const reg_t& qubits,const uint_t gid, const uint_t count);
-
-  //apply permutation
-  virtual void apply_permutation(const uint_t iChunk,const reg_t& qubits,const std::vector<std::pair<uint_t, uint_t>> &pairs, const uint_t gid, const uint_t count);
-
-  //apply rotation around axis
-  virtual void apply_rotation(const uint_t iChunk,const reg_t &qubits, const Rotation r, const double theta, const uint_t gid, const uint_t count);
-
-  //get probabilities of chunk
-  virtual void probabilities(std::vector<double>& probs, const uint_t iChunk, const reg_t& qubits) const;
-
-  //Pauli expectation values
-  virtual double expval_pauli(const uint_t iChunk,const reg_t& qubits,const std::string &pauli,const complex_t initial_phase) const;
+  virtual double *reduce_buffer(uint_t iChunk) const { return NULL; }
+  virtual uint_t reduce_buffer_size() const { return 1; }
+  virtual double *condition_buffer(uint_t iChunk) const { return NULL; }
+  virtual double *probability_buffer(uint_t iChunk) const { return NULL; }
+
+  virtual void copy_to_probability_buffer(std::vector<double> &buf, int pos) {}
+
+  // classical register to store measured bits/used for bfunc operations
+  virtual void allocate_creg(uint_t num_mem, uint_t num_reg) {}
+  virtual int measured_cbit(uint_t iChunk, int qubit) { return 0; }
+
+  virtual uint_t *creg_buffer(uint_t iChunk) const { return NULL; }
+  virtual void request_creg_update(void) {}
+
+  // apply matrix
+  virtual void apply_matrix(const uint_t iChunk, const reg_t &qubits,
+                            const int_t control_bits,
+                            const cvector_t<double> &mat, const uint_t gid,
+                            const uint_t count);
+
+  // apply diagonal matrix
+  virtual void apply_diagonal_matrix(const uint_t iChunk, const reg_t &qubits,
+                                     const int_t control_bits,
+                                     const cvector_t<double> &diag,
+                                     const uint_t gid, const uint_t count);
+
+  // apply (controlled) X
+  virtual void apply_X(const uint_t iChunk, const reg_t &qubits,
+                       const uint_t gid, const uint_t count);
+
+  // apply (controlled) Y
+  virtual void apply_Y(const uint_t iChunk, const reg_t &qubits,
+                       const uint_t gid, const uint_t count);
+
+  // apply (controlled) phase
+  virtual void apply_phase(const uint_t iChunk, const reg_t &qubits,
+                           const int_t control_bits,
+                           const std::complex<double> phase, const uint_t gid,
+                           const uint_t count);
+
+  // apply (controlled) swap gate
+  virtual void apply_swap(const uint_t iChunk, const reg_t &qubits,
+                          const int_t control_bits, const uint_t gid,
+                          const uint_t count);
+
+  // apply multiple swap gates
+  virtual void apply_multi_swaps(const uint_t iChunk, const reg_t &qubits,
+                                 const uint_t gid, const uint_t count);
+
+  // apply permutation
+  virtual void
+  apply_permutation(const uint_t iChunk, const reg_t &qubits,
+                    const std::vector<std::pair<uint_t, uint_t>> &pairs,
+                    const uint_t gid, const uint_t count);
+
+  // apply rotation around axis
+  virtual void apply_rotation(const uint_t iChunk, const reg_t &qubits,
+                              const Rotation r, const double theta,
+                              const uint_t gid, const uint_t count);
+
+  // get probabilities of chunk
+  virtual void probabilities(std::vector<double> &probs, const uint_t iChunk,
+                             const reg_t &qubits) const;
+
+  // Pauli expectation values
+  virtual double expval_pauli(const uint_t iChunk, const reg_t &qubits,
+                              const std::string &pauli,
+                              const complex_t initial_phase) const;
 
 protected:
-  int convert_blocked_qubit(int qubit)
-  {
+  int convert_blocked_qubit(int qubit) {
     int i;
-    for(i=0;i<blocked_qubits_.size();i++){
-      if(blocked_qubits_[i] == qubit){
+    for (i = 0; i < blocked_qubits_.size(); i++) {
+      if (blocked_qubits_[i] == qubit) {
         return i;
       }
     }
     return -1;
   }
 
-
-  //allocate storage for chunk classes
+  // allocate storage for chunk classes
   void allocate_chunks(void);
   void deallocate_chunks(void);
 };
 
 template <typename data_t>
-bool ChunkContainer<data_t>::MapChunk(Chunk<data_t>& chunk)
-{
-  uint_t i,idx;
+bool ChunkContainer<data_t>::MapChunk(Chunk<data_t> &chunk) {
+  uint_t i, idx;
 
-  for(i=0;i<num_chunks_;i++){
+  for (i = 0; i < num_chunks_; i++) {
     idx = (num_chunk_mapped_ + i) % num_chunks_;
-    if(!chunks_map_[idx]){
+    if (!chunks_map_[idx]) {
       chunks_map_[idx] = true;
       num_chunk_mapped_++;
-      chunk.map(this->shared_from_this(),idx);
+      chunk.map(this->shared_from_this(), idx);
       break;
     }
   }
@@ -394,114 +341,108 @@ bool ChunkContainer<data_t>::MapChunk(Chunk<data_t>& chunk)
 }
 
 template <typename data_t>
-void ChunkContainer<data_t>::UnmapChunk(Chunk<data_t>& chunk)
-{
+void ChunkContainer<data_t>::UnmapChunk(Chunk<data_t> &chunk) {
   chunks_map_[chunk.pos()] = false;
   chunk.unmap();
 }
 
 template <typename data_t>
-bool ChunkContainer<data_t>::MapBufferChunk(Chunk<data_t>& chunk)
-{
-  chunk.map(this->shared_from_this(),num_chunks_);
+bool ChunkContainer<data_t>::MapBufferChunk(Chunk<data_t> &chunk) {
+  chunk.map(this->shared_from_this(), num_chunks_);
   return chunk.is_mapped();
 }
 
 template <typename data_t>
-void ChunkContainer<data_t>::UnmapBuffer(Chunk<data_t>& buf)
-{
+void ChunkContainer<data_t>::UnmapBuffer(Chunk<data_t> &buf) {
   buf.unmap();
 }
 
-template <typename data_t>
-void ChunkContainer<data_t>::unmap_all(void)
-{
+template <typename data_t> void ChunkContainer<data_t>::unmap_all(void) {
   int_t i;
-  for(i=0;i<chunks_map_.size();i++)
+  for (i = 0; i < chunks_map_.size(); i++)
     chunks_map_[i] = false;
   num_chunk_mapped_ = 0;
 }
 
 template <typename data_t>
 template <typename Function>
-void ChunkContainer<data_t>::Execute(Function func,uint_t iChunk,const uint_t gid, const uint_t count)
-{
+void ChunkContainer<data_t>::Execute(Function func, uint_t iChunk,
+                                     const uint_t gid, const uint_t count) {
   set_device();
 
   func.set_base_index(gid << chunk_bits_);
-  func.set_data( chunk_pointer(iChunk) );
-  func.set_matrix( matrix_pointer(iChunk) );
-  func.set_params( param_pointer(iChunk) );
-  func.set_cregs_(creg_buffer(iChunk),num_creg_bits_);
+  func.set_data(chunk_pointer(iChunk));
+  func.set_matrix(matrix_pointer(iChunk));
+  func.set_params(param_pointer(iChunk));
+  func.set_cregs_(creg_buffer(iChunk), num_creg_bits_);
 
-  if(iChunk == 0 && conditional_bit_ >= 0){
+  if (iChunk == 0 && conditional_bit_ >= 0) {
     func.set_conditional(conditional_bit_);
-    if(!keep_conditional_bit_)
-      conditional_bit_ = -1;  //reset conditional
+    if (!keep_conditional_bit_)
+      conditional_bit_ = -1; // reset conditional
   }
 
 #ifdef AER_THRUST_CUDA
   cudaStream_t strm = stream(iChunk);
-  if(strm){
-    uint_t nt,nb;
+  if (strm) {
+    uint_t nt, nb;
     nb = 1;
 
-    if(func.use_cache()){
+    if (func.use_cache()) {
       func.set_chunk_bits(chunk_bits_);
 
       nt = count << chunk_bits_;
-      if(nt > 0){
+      if (nt > 0) {
         uint_t ntotal = nt;
-        if(nt > QV_CUDA_NUM_THREADS){
+        if (nt > QV_CUDA_NUM_THREADS) {
           nb = (nt + QV_CUDA_NUM_THREADS - 1) / QV_CUDA_NUM_THREADS;
           nt = QV_CUDA_NUM_THREADS;
         }
-        dev_apply_function_with_cache<data_t,Function><<<nb,nt,0,strm>>>(func,ntotal);
+        dev_apply_function_with_cache<data_t, Function>
+            <<<nb, nt, 0, strm>>>(func, ntotal);
       }
-    }
-    else{
+    } else {
       nt = count * func.size(chunk_bits_);
 
-      if(nt > 0){
+      if (nt > 0) {
         uint_t ntotal = nt;
-        if(nt > QV_CUDA_NUM_THREADS){
+        if (nt > QV_CUDA_NUM_THREADS) {
           nb = (nt + QV_CUDA_NUM_THREADS - 1) / QV_CUDA_NUM_THREADS;
           nt = QV_CUDA_NUM_THREADS;
         }
-        dev_apply_function<data_t,Function><<<nb,nt,0,strm>>>(func,ntotal);
+        dev_apply_function<data_t, Function><<<nb, nt, 0, strm>>>(func, ntotal);
       }
     }
     cudaError_t err = cudaGetLastError();
-    if(err != cudaSuccess){
+    if (err != cudaSuccess) {
       std::stringstream str;
-      str << "ChunkContainer::Execute in " << func.name() << " : " << cudaGetErrorName(err);
+      str << "ChunkContainer::Execute in " << func.name() << " : "
+          << cudaGetErrorName(err);
       throw std::runtime_error(str.str());
     }
-  }
-  else{ //if no stream returned, run on host
+  } else { // if no stream returned, run on host
     uint_t size = count * func.size(chunk_bits_);
     auto ci = thrust::counting_iterator<uint_t>(0);
-    thrust::for_each_n(thrust::seq, ci , size, func);
+    thrust::for_each_n(thrust::seq, ci, size, func);
   }
 #else
   uint_t size;
-  if(func.use_cache())
+  if (func.use_cache())
     size = count << (chunk_bits_ - func.qubits_count());
   else
     size = count * func.size(chunk_bits_);
   auto ci = thrust::counting_iterator<uint_t>(0);
-  if(omp_threads_ > 1)
-    thrust::for_each_n(thrust::device, ci , size, func);
+  if (omp_threads_ > 1)
+    thrust::for_each_n(thrust::device, ci, size, func);
   else
-    thrust::for_each_n(thrust::seq, ci , size, func);
+    thrust::for_each_n(thrust::seq, ci, size, func);
 #endif
-
 }
 
 template <typename data_t>
 template <typename Function>
-void ChunkContainer<data_t>::ExecuteSum(double* pSum,Function func,uint_t iChunk,uint_t count) const
-{
+void ChunkContainer<data_t>::ExecuteSum(double *pSum, Function func,
+                                        uint_t iChunk, uint_t count) const {
 
 #ifdef AER_THRUST_CUDA
   uint_t size = count * func.size(chunk_bits_);
@@ -509,173 +450,179 @@ void ChunkContainer<data_t>::ExecuteSum(double* pSum,Function func,uint_t iChunk
   set_device();
 
   func.set_base_index((chunk_index_ + iChunk) << chunk_bits_);
-  func.set_data( chunk_pointer(iChunk) );
-  func.set_matrix( matrix_pointer(iChunk) );
-  func.set_params( param_pointer(iChunk) );
-  func.set_cregs_(creg_buffer(iChunk),num_creg_bits_);
+  func.set_data(chunk_pointer(iChunk));
+  func.set_matrix(matrix_pointer(iChunk));
+  func.set_params(param_pointer(iChunk));
+  func.set_cregs_(creg_buffer(iChunk), num_creg_bits_);
 
   auto ci = thrust::counting_iterator<uint_t>(0);
 
   cudaStream_t strm = stream(iChunk);
-  if(strm){
+  if (strm) {
     uint_t buf_size;
-    double* buf = reduce_buffer(iChunk);
+    double *buf = reduce_buffer(iChunk);
 
-    if(pSum){   //sum for all chunks are gathered and stored to pSum
+    if (pSum) { // sum for all chunks are gathered and stored to pSum
       buf_size = 0;
-      uint_t n,nt,nb;
+      uint_t n, nt, nb;
       nb = 1;
 
-      if(func.use_cache()){
+      if (func.use_cache()) {
         nt = count << chunk_bits_;
-        if(nt > 0){
+        if (nt > 0) {
           uint_t ntotal = nt;
-          if(nt > QV_CUDA_NUM_THREADS){
+          if (nt > QV_CUDA_NUM_THREADS) {
             nb = (nt + QV_CUDA_NUM_THREADS - 1) / QV_CUDA_NUM_THREADS;
             nt = QV_CUDA_NUM_THREADS;
           }
-          dev_apply_function_sum_with_cache<data_t,Function><<<nb,nt,0,strm>>>(buf,func,buf_size,ntotal);
+          dev_apply_function_sum_with_cache<data_t, Function>
+              <<<nb, nt, 0, strm>>>(buf, func, buf_size, ntotal);
         }
-      }
-      else{
+      } else {
         nt = size;
-        if(nt > 0){
+        if (nt > 0) {
           uint_t ntotal = nt;
-          if(nt > QV_CUDA_NUM_THREADS){
+          if (nt > QV_CUDA_NUM_THREADS) {
             nb = (nt + QV_CUDA_NUM_THREADS - 1) / QV_CUDA_NUM_THREADS;
             nt = QV_CUDA_NUM_THREADS;
           }
-          dev_apply_function_sum<data_t,Function><<<nb,nt,0,strm>>>(buf,func,buf_size,ntotal);
+          dev_apply_function_sum<data_t, Function>
+              <<<nb, nt, 0, strm>>>(buf, func, buf_size, ntotal);
         }
       }
       cudaError_t err = cudaGetLastError();
-      if(err != cudaSuccess){
+      if (err != cudaSuccess) {
         std::stringstream str;
-        str << "ChunkContainer::ExecuteSum in " << func.name() << " : " << cudaGetErrorName(err);
+        str << "ChunkContainer::ExecuteSum in " << func.name() << " : "
+            << cudaGetErrorName(err);
         throw std::runtime_error(str.str());
       }
 
-      while(nb > 1){
+      while (nb > 1) {
         n = nb;
         nt = nb;
         nb = 1;
-        if(nt > QV_CUDA_NUM_THREADS){
+        if (nt > QV_CUDA_NUM_THREADS) {
           nb = (nt + QV_CUDA_NUM_THREADS - 1) / QV_CUDA_NUM_THREADS;
           nt = QV_CUDA_NUM_THREADS;
         }
-        dev_reduce_sum<<<nb,nt,0,strm>>>(buf,n,buf_size);
+        dev_reduce_sum<<<nb, nt, 0, strm>>>(buf, n, buf_size);
 
         cudaError_t err = cudaGetLastError();
-        if(err != cudaSuccess){
+        if (err != cudaSuccess) {
           std::stringstream str;
-          str << "ChunkContainer::ExecuteSum in " << func.name() << " :: " << cudaGetErrorName(err);
+          str << "ChunkContainer::ExecuteSum in " << func.name()
+              << " :: " << cudaGetErrorName(err);
           throw std::runtime_error(str.str());
         }
       }
-      cudaMemcpyAsync(pSum,buf,sizeof(double),cudaMemcpyDeviceToHost,strm);
-    }
-    else{
+      cudaMemcpyAsync(pSum, buf, sizeof(double), cudaMemcpyDeviceToHost, strm);
+    } else {
       buf_size = reduce_buffer_size();
 
-      uint_t n,nt,nb;
+      uint_t n, nt, nb;
       nb = 1;
 
-      if(func.use_cache()){
+      if (func.use_cache()) {
         nt = 1ull << chunk_bits_;
-        if(nt > 0){
-          uint_t ntotal = nt*count;
-          if(nt > QV_CUDA_NUM_THREADS){
+        if (nt > 0) {
+          uint_t ntotal = nt * count;
+          if (nt > QV_CUDA_NUM_THREADS) {
             nb = (nt + QV_CUDA_NUM_THREADS - 1) / QV_CUDA_NUM_THREADS;
             nt = QV_CUDA_NUM_THREADS;
           }
-          dim3 grid(nb,count,1);
-          dev_apply_function_sum_with_cache<data_t,Function><<<grid,nt,0,strm>>>(buf,func,buf_size,ntotal);
+          dim3 grid(nb, count, 1);
+          dev_apply_function_sum_with_cache<data_t, Function>
+              <<<grid, nt, 0, strm>>>(buf, func, buf_size, ntotal);
         }
-      }
-      else{
+      } else {
         nt = func.size(chunk_bits_);
-        if(nt > 0){
-          uint_t ntotal = nt*count;
-          if(nt > QV_CUDA_NUM_THREADS){
+        if (nt > 0) {
+          uint_t ntotal = nt * count;
+          if (nt > QV_CUDA_NUM_THREADS) {
             nb = (nt + QV_CUDA_NUM_THREADS - 1) / QV_CUDA_NUM_THREADS;
             nt = QV_CUDA_NUM_THREADS;
           }
-          dim3 grid(nb,count,1);
-          dev_apply_function_sum<data_t,Function><<<grid,nt,0,strm>>>(buf,func,buf_size,ntotal);
+          dim3 grid(nb, count, 1);
+          dev_apply_function_sum<data_t, Function>
+              <<<grid, nt, 0, strm>>>(buf, func, buf_size, ntotal);
         }
       }
       cudaError_t err = cudaGetLastError();
-      if(err != cudaSuccess){
+      if (err != cudaSuccess) {
         std::stringstream str;
-        str << "ChunkContainer::ExecuteSum in " << func.name() << " : " << cudaGetErrorName(err);
+        str << "ChunkContainer::ExecuteSum in " << func.name() << " : "
+            << cudaGetErrorName(err);
         throw std::runtime_error(str.str());
       }
 
-      while(nb > 1){
+      while (nb > 1) {
         n = nb;
         nt = nb;
         nb = 1;
-        if(nt > QV_CUDA_NUM_THREADS){
+        if (nt > QV_CUDA_NUM_THREADS) {
           nb = (nt + QV_CUDA_NUM_THREADS - 1) / QV_CUDA_NUM_THREADS;
           nt = QV_CUDA_NUM_THREADS;
         }
-        dim3 grid(nb,count,1);
-        dev_reduce_sum<<<grid,nt,0,strm>>>(buf,n,buf_size);
+        dim3 grid(nb, count, 1);
+        dev_reduce_sum<<<grid, nt, 0, strm>>>(buf, n, buf_size);
 
         cudaError_t err = cudaGetLastError();
-        if(err != cudaSuccess){
+        if (err != cudaSuccess) {
           std::stringstream str;
-          str << "ChunkContainer::ExecuteSum in " << func.name() << " :: " << cudaGetErrorName(err);
+          str << "ChunkContainer::ExecuteSum in " << func.name()
+              << " :: " << cudaGetErrorName(err);
           throw std::runtime_error(str.str());
         }
       }
     }
-  }
-  else{ //if no stream returned, run on host
-    *pSum = thrust::transform_reduce(thrust::seq, ci, ci + size, func,0.0,thrust::plus<double>());
+  } else { // if no stream returned, run on host
+    *pSum = thrust::transform_reduce(thrust::seq, ci, ci + size, func, 0.0,
+                                     thrust::plus<double>());
   }
 #else
   uint_t size = func.size(chunk_bits_);
 
   func.set_base_index((chunk_index_ + iChunk) << chunk_bits_);
-  func.set_matrix( matrix_pointer(iChunk) );
-  func.set_params( param_pointer(iChunk) );
+  func.set_matrix(matrix_pointer(iChunk));
+  func.set_params(param_pointer(iChunk));
 
   uint_t i;
-  for(i=0;i<count;i++){
+  for (i = 0; i < count; i++) {
 
-    func.set_data( chunk_pointer(iChunk + i) );
+    func.set_data(chunk_pointer(iChunk + i));
     func.set_index_offset(iChunk << chunk_bits_);
 
     auto ci = thrust::counting_iterator<uint_t>(0);
 
     double sum;
-    if(omp_threads_ > 1)
-      sum = thrust::transform_reduce(thrust::device, ci, ci + size, func,0.0,thrust::plus<double>());
+    if (omp_threads_ > 1)
+      sum = thrust::transform_reduce(thrust::device, ci, ci + size, func, 0.0,
+                                     thrust::plus<double>());
     else
-      sum = thrust::transform_reduce(thrust::seq, ci, ci + size, func,0.0,thrust::plus<double>());
-    if(count == 1 && pSum){
+      sum = thrust::transform_reduce(thrust::seq, ci, ci + size, func, 0.0,
+                                     thrust::plus<double>());
+    if (count == 1 && pSum) {
       *pSum = sum;
-    }
-    else{
+    } else {
       *(reduce_buffer(iChunk + i)) = sum;
     }
   }
 #endif
 }
 
-struct complex_sum
-{
-  __host__ __device__ thrust::complex<double> operator()(const thrust::complex<double>& a,const thrust::complex<double>& b)
-  {
-    return a+b;
+struct complex_sum {
+  __host__ __device__ thrust::complex<double>
+  operator()(const thrust::complex<double> &a,
+             const thrust::complex<double> &b) {
+    return a + b;
   }
 };
 
 template <typename data_t>
 template <typename Function>
-void ChunkContainer<data_t>::ExecuteSum2(double* pSum,Function func,uint_t iChunk,uint_t count) const
-{
+void ChunkContainer<data_t>::ExecuteSum2(double *pSum, Function func,
+                                         uint_t iChunk, uint_t count) const {
 
 #ifdef AER_THRUST_CUDA
   uint_t size = count * func.size(chunk_bits_);
@@ -683,152 +630,155 @@ void ChunkContainer<data_t>::ExecuteSum2(double* pSum,Function func,uint_t iChun
   set_device();
 
   func.set_base_index((chunk_index_ + iChunk) << chunk_bits_);
-  func.set_data( chunk_pointer(iChunk) );
-  func.set_matrix( matrix_pointer(iChunk) );
-  func.set_params( param_pointer(iChunk) );
-  func.set_cregs_(creg_buffer(iChunk),num_creg_bits_);
+  func.set_data(chunk_pointer(iChunk));
+  func.set_matrix(matrix_pointer(iChunk));
+  func.set_params(param_pointer(iChunk));
+  func.set_cregs_(creg_buffer(iChunk), num_creg_bits_);
 
   auto ci = thrust::counting_iterator<uint_t>(0);
 
   cudaStream_t strm = stream(iChunk);
-  if(strm){
+  if (strm) {
     uint_t buf_size;
-    uint_t n,nt,nb;
+    uint_t n, nt, nb;
     nb = 1;
     nt = func.size(chunk_bits_);
-    thrust::complex<double>* buf = (thrust::complex<double>*)reduce_buffer(iChunk);
+    thrust::complex<double> *buf =
+        (thrust::complex<double> *)reduce_buffer(iChunk);
 
-    if(pSum){   //sum for all chunks are gathered and stored to pSum
+    if (pSum) { // sum for all chunks are gathered and stored to pSum
       buf_size = 0;
       nt = size;
-      if(nt > 0){
+      if (nt > 0) {
         uint_t ntotal = nt;
-        if(nt > QV_CUDA_NUM_THREADS){
+        if (nt > QV_CUDA_NUM_THREADS) {
           nb = (nt + QV_CUDA_NUM_THREADS - 1) / QV_CUDA_NUM_THREADS;
           nt = QV_CUDA_NUM_THREADS;
         }
-        dev_apply_function_sum_complex<data_t,Function><<<nb,nt,0,strm>>>(buf,func,buf_size,ntotal);
+        dev_apply_function_sum_complex<data_t, Function>
+            <<<nb, nt, 0, strm>>>(buf, func, buf_size, ntotal);
       }
       cudaError_t err = cudaGetLastError();
-      if(err != cudaSuccess){
+      if (err != cudaSuccess) {
         std::stringstream str;
-        str << "ChunkContainer::ExecuteSum2 in " << func.name() << " : " << cudaGetErrorName(err);
+        str << "ChunkContainer::ExecuteSum2 in " << func.name() << " : "
+            << cudaGetErrorName(err);
         throw std::runtime_error(str.str());
       }
 
-      while(nb > 1){
+      while (nb > 1) {
         n = nb;
         nt = nb;
         nb = 1;
-        if(nt > QV_CUDA_NUM_THREADS){
+        if (nt > QV_CUDA_NUM_THREADS) {
           nb = (nt + QV_CUDA_NUM_THREADS - 1) / QV_CUDA_NUM_THREADS;
           nt = QV_CUDA_NUM_THREADS;
         }
-        dev_reduce_sum_complex<<<nb,nt,0,strm>>>(buf,n,buf_size);
+        dev_reduce_sum_complex<<<nb, nt, 0, strm>>>(buf, n, buf_size);
 
         cudaError_t err = cudaGetLastError();
-        if(err != cudaSuccess){
+        if (err != cudaSuccess) {
           std::stringstream str;
-          str << "ChunkContainer::ExecuteSum2 in " << func.name() << " :: " << cudaGetErrorName(err);
+          str << "ChunkContainer::ExecuteSum2 in " << func.name()
+              << " :: " << cudaGetErrorName(err);
           throw std::runtime_error(str.str());
         }
       }
-      cudaMemcpyAsync(pSum,buf,sizeof(double)*2,cudaMemcpyDeviceToHost,strm);
-    }
-    else{
-      buf_size = reduce_buffer_size()/2;
-
-      if(nt > 0){
-        uint_t ntotal = nt*count;
-        if(nt > QV_CUDA_NUM_THREADS){
+      cudaMemcpyAsync(pSum, buf, sizeof(double) * 2, cudaMemcpyDeviceToHost,
+                      strm);
+    } else {
+      buf_size = reduce_buffer_size() / 2;
+
+      if (nt > 0) {
+        uint_t ntotal = nt * count;
+        if (nt > QV_CUDA_NUM_THREADS) {
           nb = (nt + QV_CUDA_NUM_THREADS - 1) / QV_CUDA_NUM_THREADS;
           nt = QV_CUDA_NUM_THREADS;
         }
-        dim3 grid(nb,count,1);
-        dev_apply_function_sum_complex<data_t,Function><<<grid,nt,0,strm>>>(buf,func,buf_size,ntotal);
+        dim3 grid(nb, count, 1);
+        dev_apply_function_sum_complex<data_t, Function>
+            <<<grid, nt, 0, strm>>>(buf, func, buf_size, ntotal);
       }
       cudaError_t err = cudaGetLastError();
-      if(err != cudaSuccess){
+      if (err != cudaSuccess) {
         std::stringstream str;
-        str << "ChunkContainer::ExecuteSum2 in " << func.name() << " : " << cudaGetErrorName(err);
+        str << "ChunkContainer::ExecuteSum2 in " << func.name() << " : "
+            << cudaGetErrorName(err);
         throw std::runtime_error(str.str());
       }
 
-      while(nb > 1){
+      while (nb > 1) {
         n = nb;
         nt = nb;
         nb = 1;
-        if(nt > QV_CUDA_NUM_THREADS){
+        if (nt > QV_CUDA_NUM_THREADS) {
           nb = (nt + QV_CUDA_NUM_THREADS - 1) / QV_CUDA_NUM_THREADS;
           nt = QV_CUDA_NUM_THREADS;
         }
-        dim3 grid(nb,count,1);
-        dev_reduce_sum_complex<<<grid,nt,0,strm>>>(buf,n,buf_size);
+        dim3 grid(nb, count, 1);
+        dev_reduce_sum_complex<<<grid, nt, 0, strm>>>(buf, n, buf_size);
 
         cudaError_t err = cudaGetLastError();
-        if(err != cudaSuccess){
+        if (err != cudaSuccess) {
           std::stringstream str;
-          str << "ChunkContainer::ExecuteSum2 in " << func.name() << " :: " << cudaGetErrorName(err);
+          str << "ChunkContainer::ExecuteSum2 in " << func.name()
+              << " :: " << cudaGetErrorName(err);
           throw std::runtime_error(str.str());
         }
       }
     }
-  }
-  else{ //if no stream returned, run on host
-    thrust::complex<double> ret,zero = 0.0;
-    ret = thrust::transform_reduce(thrust::seq, ci, ci + size, func,zero,complex_sum());
-    *((thrust::complex<double>*)pSum) = ret;
+  } else { // if no stream returned, run on host
+    thrust::complex<double> ret, zero = 0.0;
+    ret = thrust::transform_reduce(thrust::seq, ci, ci + size, func, zero,
+                                   complex_sum());
+    *((thrust::complex<double> *)pSum) = ret;
   }
 #else
   uint_t size = func.size(chunk_bits_);
 
   func.set_base_index((chunk_index_ + iChunk) << chunk_bits_);
-  func.set_matrix( matrix_pointer(iChunk) );
-  func.set_params( param_pointer(iChunk) );
- 
+  func.set_matrix(matrix_pointer(iChunk));
+  func.set_params(param_pointer(iChunk));
+
   uint_t i;
-  for(i=0;i<count;i++){
-    thrust::complex<double> ret,zero = 0.0;
-    func.set_data( chunk_pointer(iChunk + i) );
+  for (i = 0; i < count; i++) {
+    thrust::complex<double> ret, zero = 0.0;
+    func.set_data(chunk_pointer(iChunk + i));
     func.set_index_offset(iChunk << chunk_bits_);
 
     auto ci = thrust::counting_iterator<uint_t>(0);
 
-    if(omp_threads_ > 1)
-      ret = thrust::transform_reduce(thrust::device, ci, ci + size, func,zero,complex_sum());
+    if (omp_threads_ > 1)
+      ret = thrust::transform_reduce(thrust::device, ci, ci + size, func, zero,
+                                     complex_sum());
     else
-      ret = thrust::transform_reduce(thrust::seq, ci, ci + size, func,zero,complex_sum());
+      ret = thrust::transform_reduce(thrust::seq, ci, ci + size, func, zero,
+                                     complex_sum());
 
-    if(count == 1 && pSum){
-      *((thrust::complex<double>*)pSum) = ret;
-    }
-    else{
-      *((thrust::complex<double>*)reduce_buffer(iChunk + i)) = ret;
+    if (count == 1 && pSum) {
+      *((thrust::complex<double> *)pSum) = ret;
+    } else {
+      *((thrust::complex<double> *)reduce_buffer(iChunk + i)) = ret;
     }
   }
 #endif
 }
 
-
-void host_func_launcher(void* pParam)
-{
-  HostFuncBase* func = reinterpret_cast<HostFuncBase*>(pParam);
+void host_func_launcher(void *pParam) {
+  HostFuncBase *func = reinterpret_cast<HostFuncBase *>(pParam);
   func->execute();
 }
 
-template <typename data_t>
-void ChunkContainer<data_t>::allocate_chunks(void)
-{
+template <typename data_t> void ChunkContainer<data_t>::allocate_chunks(void) {
   uint_t i;
-  chunks_map_.resize(num_chunks_,false);
+  chunks_map_.resize(num_chunks_, false);
 
-  reduced_queue_begin_.resize(num_chunks_,0);
-  reduced_queue_end_.resize(num_chunks_,0);
+  reduced_queue_begin_.resize(num_chunks_, 0);
+  reduced_queue_end_.resize(num_chunks_, 0);
 }
 
 template <typename data_t>
-void ChunkContainer<data_t>::deallocate_chunks(void)
-{
+void ChunkContainer<data_t>::deallocate_chunks(void) {
   chunks_map_.clear();
 
   reduced_queue_begin_.clear();
@@ -836,48 +786,46 @@ void ChunkContainer<data_t>::deallocate_chunks(void)
 }
 
 template <typename data_t>
-void ChunkContainer<data_t>::apply_matrix(const uint_t iChunk,const reg_t& qubits,const int_t control_bits,const cvector_t<double> &mat,const uint_t gid, const uint_t count)
-{
+void ChunkContainer<data_t>::apply_matrix(
+    const uint_t iChunk, const reg_t &qubits, const int_t control_bits,
+    const cvector_t<double> &mat, const uint_t gid, const uint_t count) {
   const size_t N = qubits.size() - control_bits;
 
-  if(N == 1){
-    if(control_bits == 0)
-      Execute(MatrixMult2x2<data_t>(mat,qubits[0]), iChunk, gid, count);
-    else  //2x2 matrix with control bits
-      Execute(MatrixMult2x2Controlled<data_t>(mat,qubits), iChunk, gid, count);
-  }
-  else if(N == 2){
-    Execute(MatrixMult4x4<data_t>(mat,qubits[0],qubits[1]), iChunk, gid, count);
-  }
-  else{
+  if (N == 1) {
+    if (control_bits == 0)
+      Execute(MatrixMult2x2<data_t>(mat, qubits[0]), iChunk, gid, count);
+    else // 2x2 matrix with control bits
+      Execute(MatrixMult2x2Controlled<data_t>(mat, qubits), iChunk, gid, count);
+  } else if (N == 2) {
+    Execute(MatrixMult4x4<data_t>(mat, qubits[0], qubits[1]), iChunk, gid,
+            count);
+  } else {
     auto qubits_sorted = qubits;
     std::sort(qubits_sorted.begin(), qubits_sorted.end());
 #ifndef AER_THRUST_CUDA
-    if(N == 3){
+    if (N == 3) {
       StoreMatrix(mat, iChunk);
-      Execute(MatrixMult8x8<data_t>(qubits,qubits_sorted), iChunk, gid, count);
-    }
-    else if(N == 4){
+      Execute(MatrixMult8x8<data_t>(qubits, qubits_sorted), iChunk, gid, count);
+    } else if (N == 4) {
       StoreMatrix(mat, iChunk);
-      Execute(MatrixMult16x16<data_t>(qubits,qubits_sorted), iChunk, gid, count);
-    }
-    else if(N <= 10){
+      Execute(MatrixMult16x16<data_t>(qubits, qubits_sorted), iChunk, gid,
+              count);
+    } else if (N <= 10) {
 #else
-    if(N <= 10){
+    if (N <= 10) {
 #endif
       int i;
-      for(i=0;i<N;i++){
+      for (i = 0; i < N; i++) {
         qubits_sorted.push_back(qubits[i]);
       }
       StoreMatrix(mat, iChunk);
       StoreUintParams(qubits_sorted, iChunk);
 
       Execute(MatrixMultNxN<data_t>(N), iChunk, gid, count);
-    }
-    else{
+    } else {
       cvector_t<double> matLU;
       reg_t params;
-      MatrixMultNxN_LU<data_t> f(mat,qubits_sorted,matLU,params);
+      MatrixMultNxN_LU<data_t> f(mat, qubits_sorted, matLU, params);
 
       StoreMatrix(matLU, iChunk);
       StoreUintParams(params, iChunk);
@@ -888,20 +836,21 @@ void ChunkContainer<data_t>::apply_matrix(const uint_t iChunk,const reg_t& qubit
 }
 
 template <typename data_t>
-void ChunkContainer<data_t>::apply_diagonal_matrix(const uint_t iChunk,const reg_t& qubits,const int_t control_bits,const cvector_t<double> &diag,const uint_t gid, const uint_t count)
-{
+void ChunkContainer<data_t>::apply_diagonal_matrix(
+    const uint_t iChunk, const reg_t &qubits, const int_t control_bits,
+    const cvector_t<double> &diag, const uint_t gid, const uint_t count) {
   const size_t N = qubits.size() - control_bits;
 
-  if(N == 1){
-    if(control_bits == 0)
-      Execute(DiagonalMult2x2<data_t>(diag,qubits[0]), iChunk, gid, count);
+  if (N == 1) {
+    if (control_bits == 0)
+      Execute(DiagonalMult2x2<data_t>(diag, qubits[0]), iChunk, gid, count);
     else
-      Execute(DiagonalMult2x2Controlled<data_t>(diag,qubits), iChunk, gid, count);
-  }
-  else if(N == 2){
-    Execute(DiagonalMult4x4<data_t>(diag,qubits[0],qubits[1]), iChunk, gid, count);
-  }
-  else{
+      Execute(DiagonalMult2x2Controlled<data_t>(diag, qubits), iChunk, gid,
+              count);
+  } else if (N == 2) {
+    Execute(DiagonalMult4x4<data_t>(diag, qubits[0], qubits[1]), iChunk, gid,
+            count);
+  } else {
     StoreMatrix(diag, iChunk);
     StoreUintParams(qubits, iChunk);
 
@@ -910,42 +859,50 @@ void ChunkContainer<data_t>::apply_diagonal_matrix(const uint_t iChunk,const reg
 }
 
 template <typename data_t>
-void ChunkContainer<data_t>::apply_X(const uint_t iChunk,const reg_t& qubits,const uint_t gid, const uint_t count)
-{
+void ChunkContainer<data_t>::apply_X(const uint_t iChunk, const reg_t &qubits,
+                                     const uint_t gid, const uint_t count) {
   Execute(CX_func<data_t>(qubits), iChunk, gid, count);
 }
 
 template <typename data_t>
-void ChunkContainer<data_t>::apply_Y(const uint_t iChunk,const reg_t& qubits,const uint_t gid, const uint_t count)
-{
+void ChunkContainer<data_t>::apply_Y(const uint_t iChunk, const reg_t &qubits,
+                                     const uint_t gid, const uint_t count) {
   Execute(CY_func<data_t>(qubits), iChunk, gid, count);
 }
 
 template <typename data_t>
-void ChunkContainer<data_t>::apply_phase(const uint_t iChunk,const reg_t& qubits,const int_t control_bits,const std::complex<double> phase,const uint_t gid, const uint_t count)
-{
-  Execute(phase_func<data_t>(qubits,*(thrust::complex<double>*)&phase), iChunk, gid, count );
+void ChunkContainer<data_t>::apply_phase(const uint_t iChunk,
+                                         const reg_t &qubits,
+                                         const int_t control_bits,
+                                         const std::complex<double> phase,
+                                         const uint_t gid, const uint_t count) {
+  Execute(phase_func<data_t>(qubits, *(thrust::complex<double> *)&phase),
+          iChunk, gid, count);
 }
 
 template <typename data_t>
-void ChunkContainer<data_t>::apply_swap(const uint_t iChunk,const reg_t& qubits,const int_t control_bits,const uint_t gid, const uint_t count)
-{
+void ChunkContainer<data_t>::apply_swap(const uint_t iChunk,
+                                        const reg_t &qubits,
+                                        const int_t control_bits,
+                                        const uint_t gid, const uint_t count) {
   Execute(CSwap_func<data_t>(qubits), iChunk, gid, count);
 }
 
-
 template <typename data_t>
-void ChunkContainer<data_t>::apply_multi_swaps(const uint_t iChunk,const reg_t& qubits,const uint_t gid,const uint_t count)
-{
-  //max 5 swaps can be applied at once using GPU's shared memory
-  for(int_t i=0;i<qubits.size();i+=10){
+void ChunkContainer<data_t>::apply_multi_swaps(const uint_t iChunk,
+                                               const reg_t &qubits,
+                                               const uint_t gid,
+                                               const uint_t count) {
+  // max 5 swaps can be applied at once using GPU's shared memory
+  for (int_t i = 0; i < qubits.size(); i += 10) {
     int_t n = 10;
-    if(i + n > qubits.size())
+    if (i + n > qubits.size())
       n = qubits.size() - i;
 
-    reg_t qubits_swap(qubits.begin() + i,qubits.begin() + i + n);
+    reg_t qubits_swap(qubits.begin() + i, qubits.begin() + i + n);
     std::sort(qubits_swap.begin(), qubits_swap.end());
-    qubits_swap.insert(qubits_swap.end(), qubits.begin() + i,qubits.begin() + i + n);
+    qubits_swap.insert(qubits_swap.end(), qubits.begin() + i,
+                       qubits.begin() + i + n);
 
     StoreUintParams(qubits_swap, iChunk);
     Execute(MultiSwap_func<data_t>(n), iChunk, gid, count);
@@ -953,14 +910,16 @@ void ChunkContainer<data_t>::apply_multi_swaps(const uint_t iChunk,const reg_t&
 }
 
 template <typename data_t>
-void ChunkContainer<data_t>::apply_permutation(const uint_t iChunk,const reg_t& qubits,const std::vector<std::pair<uint_t, uint_t>> &pairs, const uint_t gid, const uint_t count)
-{
+void ChunkContainer<data_t>::apply_permutation(
+    const uint_t iChunk, const reg_t &qubits,
+    const std::vector<std::pair<uint_t, uint_t>> &pairs, const uint_t gid,
+    const uint_t count) {
   const size_t N = qubits.size();
   auto qubits_sorted = qubits;
   std::sort(qubits_sorted.begin(), qubits_sorted.end());
 
   reg_t params;
-  Permutation<data_t> f(qubits_sorted,qubits,pairs,params);
+  Permutation<data_t> f(qubits_sorted, qubits, pairs, params);
 
   StoreUintParams(params, iChunk);
 
@@ -968,75 +927,84 @@ void ChunkContainer<data_t>::apply_permutation(const uint_t iChunk,const reg_t&
 }
 
 template <typename data_t>
-void ChunkContainer<data_t>::apply_rotation(const uint_t iChunk,const reg_t &qubits, const Rotation r, const double theta, const uint_t gid, const uint_t count)
-{
+void ChunkContainer<data_t>::apply_rotation(
+    const uint_t iChunk, const reg_t &qubits, const Rotation r,
+    const double theta, const uint_t gid, const uint_t count) {
   int control_bits = qubits.size() - 1;
-  switch(r){
-    case Rotation::x:
-      apply_matrix(iChunk, qubits, control_bits, Linalg::VMatrix::rx(theta), gid, count);
-      break;
-    case Rotation::y:
-      apply_matrix(iChunk, qubits, control_bits, Linalg::VMatrix::ry(theta), gid, count);
-      break;
-    case Rotation::z:
-      apply_diagonal_matrix(iChunk, qubits, control_bits, Linalg::VMatrix::rz_diag(theta), gid, count);
-      break;
-    case Rotation::xx:
-      apply_matrix(iChunk, qubits, control_bits-1, Linalg::VMatrix::rxx(theta), gid, count);
-      break;
-    case Rotation::yy:
-      apply_matrix(iChunk, qubits, control_bits-1, Linalg::VMatrix::ryy(theta), gid, count);
-      break;
-    case Rotation::zz:
-      apply_diagonal_matrix(iChunk, qubits, control_bits-1, Linalg::VMatrix::rzz_diag(theta), gid, count);
-      break;
-    case Rotation::zx:
-      apply_matrix(iChunk, qubits, control_bits-1, Linalg::VMatrix::rzx(theta), gid, count);
-      break;
-    default:
-      throw std::invalid_argument(
-          "QubitVectorThrust::invalid rotation axis.");
+  switch (r) {
+  case Rotation::x:
+    apply_matrix(iChunk, qubits, control_bits, Linalg::VMatrix::rx(theta), gid,
+                 count);
+    break;
+  case Rotation::y:
+    apply_matrix(iChunk, qubits, control_bits, Linalg::VMatrix::ry(theta), gid,
+                 count);
+    break;
+  case Rotation::z:
+    apply_diagonal_matrix(iChunk, qubits, control_bits,
+                          Linalg::VMatrix::rz_diag(theta), gid, count);
+    break;
+  case Rotation::xx:
+    apply_matrix(iChunk, qubits, control_bits - 1, Linalg::VMatrix::rxx(theta),
+                 gid, count);
+    break;
+  case Rotation::yy:
+    apply_matrix(iChunk, qubits, control_bits - 1, Linalg::VMatrix::ryy(theta),
+                 gid, count);
+    break;
+  case Rotation::zz:
+    apply_diagonal_matrix(iChunk, qubits, control_bits - 1,
+                          Linalg::VMatrix::rzz_diag(theta), gid, count);
+    break;
+  case Rotation::zx:
+    apply_matrix(iChunk, qubits, control_bits - 1, Linalg::VMatrix::rzx(theta),
+                 gid, count);
+    break;
+  default:
+    throw std::invalid_argument("QubitVectorThrust::invalid rotation axis.");
   }
 }
 
 template <typename data_t>
-void ChunkContainer<data_t>::probabilities(std::vector<double>& probs, const uint_t iChunk, const reg_t& qubits) const
-{
+void ChunkContainer<data_t>::probabilities(std::vector<double> &probs,
+                                           const uint_t iChunk,
+                                           const reg_t &qubits) const {
   const size_t N = qubits.size();
   const int_t DIM = 1 << N;
   probs.resize(DIM);
 
-  if(N == 1){ //special case for 1 qubit (optimized for measure)
-    ExecuteSum2(&probs[0],probability_1qubit_func<data_t>(qubits[0]), iChunk, 1);
-  }
-  else{
-    for(int_t i=0;i<DIM;i++){
-      ExecuteSum(&probs[i],probability_func<data_t>(qubits,i), iChunk, 1);
+  if (N == 1) { // special case for 1 qubit (optimized for measure)
+    ExecuteSum2(&probs[0], probability_1qubit_func<data_t>(qubits[0]), iChunk,
+                1);
+  } else {
+    for (int_t i = 0; i < DIM; i++) {
+      ExecuteSum(&probs[i], probability_func<data_t>(qubits, i), iChunk, 1);
     }
   }
 }
 
 template <typename data_t>
-double ChunkContainer<data_t>::norm(uint_t iChunk,uint_t count) const
-{
+double ChunkContainer<data_t>::norm(uint_t iChunk, uint_t count) const {
   double ret;
-  ExecuteSum(&ret,norm_func<data_t>(), iChunk, count);
+  ExecuteSum(&ret, norm_func<data_t>(), iChunk, count);
 
   return ret;
 }
 
 template <typename data_t>
-double ChunkContainer<data_t>::trace(uint_t iChunk,uint_t row,uint_t count) const
-{
+double ChunkContainer<data_t>::trace(uint_t iChunk, uint_t row,
+                                     uint_t count) const {
   double ret;
-  ExecuteSum(&ret,trace_func<data_t>(row), iChunk, count);
+  ExecuteSum(&ret, trace_func<data_t>(row), iChunk, count);
 
   return ret;
 }
 
 template <typename data_t>
-double ChunkContainer<data_t>::expval_pauli(const uint_t iChunk,const reg_t& qubits,const std::string &pauli,const complex_t initial_phase) const
-{
+double
+ChunkContainer<data_t>::expval_pauli(const uint_t iChunk, const reg_t &qubits,
+                                     const std::string &pauli,
+                                     const complex_t initial_phase) const {
   uint_t x_mask, z_mask, num_y, x_max;
   std::tie(x_mask, z_mask, num_y, x_max) = pauli_masks_and_phase(qubits, pauli);
 
@@ -1047,8 +1015,8 @@ double ChunkContainer<data_t>::expval_pauli(const uint_t iChunk,const reg_t& qub
   }
   double ret;
   // specialize x_max == 0
-  if(x_mask == 0) {
-    ExecuteSum(&ret, expval_pauli_Z_func<data_t>(z_mask), iChunk,  1 );
+  if (x_mask == 0) {
+    ExecuteSum(&ret, expval_pauli_Z_func<data_t>(z_mask), iChunk, 1);
     return ret;
   }
 
@@ -1056,13 +1024,11 @@ double ChunkContainer<data_t>::expval_pauli(const uint_t iChunk,const reg_t& qub
   // This is (-1j) ** number of Y terms modulo 4
   auto phase = std::complex<data_t>(initial_phase);
   add_y_phase(num_y, phase);
-  ExecuteSum(&ret, expval_pauli_XYZ_func<data_t>(x_mask, z_mask, x_max, phase), iChunk, 1 );
+  ExecuteSum(&ret, expval_pauli_XYZ_func<data_t>(x_mask, z_mask, x_max, phase),
+             iChunk, 1);
   return ret;
 }
 
-
-
-
 //------------------------------------------------------------------------------
 } // end namespace Chunk
 } // end namespace QV
diff --git a/src/simulators/statevector/chunk/chunk_manager.hpp b/src/simulators/statevector/chunk/chunk_manager.hpp
index a83520cbde..072efd04bd 100644
--- a/src/simulators/statevector/chunk/chunk_manager.hpp
+++ b/src/simulators/statevector/chunk/chunk_manager.hpp
@@ -12,45 +12,41 @@
  * that they have been altered from the originals.
  */
 
-
 #ifndef _qv_chunk_manager_hpp_
 #define _qv_chunk_manager_hpp_
 
 #include "simulators/statevector/chunk/chunk.hpp"
 
-#include <spdlog/spdlog.h>
 #include <spdlog/async.h>
 #include <spdlog/sinks/basic_file_sink.h>
-
+#include <spdlog/spdlog.h>
 
 namespace AER {
 namespace QV {
 namespace Chunk {
 
-
 //============================================================================
 // chunk manager class
 // this is static class, there is only 1 manager class
 //============================================================================
-template <typename data_t>
-class ChunkManager 
-{
+template <typename data_t> class ChunkManager {
 protected:
-  std::vector<std::shared_ptr<ChunkContainer<data_t>>> chunks_;         //chunk containers for each device and host
+  std::vector<std::shared_ptr<ChunkContainer<data_t>>>
+      chunks_; // chunk containers for each device and host
 
-  int num_devices_;            //number of devices
-  int num_places_;             //number of places (devices + host)
+  int num_devices_; // number of devices
+  int num_places_;  // number of places (devices + host)
 
-  int chunk_bits_;             //number of qubits of chunk
-  int num_qubits_;             //number of global qubits
+  int chunk_bits_; // number of qubits of chunk
+  int num_qubits_; // number of global qubits
 
-  uint_t num_chunks_;          //number of chunks on this process
-  uint_t chunk_index_;         //global chunk index for the first chunk
+  uint_t num_chunks_;  // number of chunks on this process
+  uint_t chunk_index_; // global chunk index for the first chunk
 
-  int i_dev_map_;              //device index chunk to be mapped
-  int idev_buffer_map_;        //device index buffer to be mapped
+  int i_dev_map_;       // device index chunk to be mapped
+  int idev_buffer_map_; // device index buffer to be mapped
 
-  int iplace_host_;            //chunk container for host memory
+  int iplace_host_; // chunk container for host memory
   bool multi_shots_;
 
   bool density_matrix_;
@@ -58,72 +54,49 @@ class ChunkManager
   bool enable_cuStatevec_;
 
   int num_threads_per_group_;
+
 public:
   ChunkManager();
 
   ~ChunkManager();
 
-  std::shared_ptr<ChunkContainer<data_t>> container(uint_t i)
-  {
-    if(i < chunks_.size())
+  std::shared_ptr<ChunkContainer<data_t>> container(uint_t i) {
+    if (i < chunks_.size())
       return chunks_[i];
     return nullptr;
   }
-  uint_t num_containers(void)
-  {
-    return chunks_.size();
-  }
+  uint_t num_containers(void) { return chunks_.size(); }
 
-  uint_t Allocate(int chunk_bits,int nqubits,uint_t nchunks,uint_t chunk_index,int matrix_bit,bool density_mat,bool enable_cuStatevec);
+  uint_t Allocate(int chunk_bits, int nqubits, uint_t nchunks,
+                  uint_t chunk_index, int matrix_bit, bool density_mat,
+                  bool enable_cuStatevec);
   void Free(void);
 
-  int num_devices(void)
-  {
-    return num_devices_;
-  }
-  int num_places(void)
-  {
-    return num_places_;
-  }
-  int place_host(void)
-  {
-    return iplace_host_;
-  }
-  uint_t num_chunks(void)
-  {
-    return num_chunks_;
-  }
-  int chunk_bits(void)
-  {
-    return chunk_bits_;
-  }
-  int num_qubits(void)
-  {
-    return num_qubits_;
-  }
+  int num_devices(void) { return num_devices_; }
+  int num_places(void) { return num_places_; }
+  int place_host(void) { return iplace_host_; }
+  uint_t num_chunks(void) { return num_chunks_; }
+  int chunk_bits(void) { return chunk_bits_; }
+  int num_qubits(void) { return num_qubits_; }
 
-  void set_num_threads_per_group(int n)
-  {
-    num_threads_per_group_ = n;
-  }
+  void set_num_threads_per_group(int n) { num_threads_per_group_ = n; }
 
-  bool MapChunk(Chunk<data_t>& chunk,int iplace = -1);
-  bool MapBufferChunk(Chunk<data_t>& out,int idev);
-  bool MapBufferChunkOnHost(Chunk<data_t>& out);
+  bool MapChunk(Chunk<data_t> &chunk, int iplace = -1);
+  bool MapBufferChunk(Chunk<data_t> &out, int idev);
+  bool MapBufferChunkOnHost(Chunk<data_t> &out);
 
-  void UnmapChunk(Chunk<data_t>& chunk);
-  void UnmapBufferChunk(Chunk<data_t>& buffer);
+  void UnmapChunk(Chunk<data_t> &chunk);
+  void UnmapBufferChunk(Chunk<data_t> &buffer);
 
-  //execute a kernel on all the chunks
+  // execute a kernel on all the chunks
   template <typename Function>
-  void execute_on_device(Function func,const std::vector<std::complex<double>>& mat,const std::vector<uint_t>& prm);
-
+  void execute_on_device(Function func,
+                         const std::vector<std::complex<double>> &mat,
+                         const std::vector<uint_t> &prm);
 };
 
-template <typename data_t>
-ChunkManager<data_t>::ChunkManager()
-{
-  int i,j;
+template <typename data_t> ChunkManager<data_t>::ChunkManager() {
+  int i, j;
   num_places_ = 1;
   chunk_bits_ = 0;
   num_chunks_ = 0;
@@ -144,10 +117,9 @@ ChunkManager<data_t>::ChunkManager()
 #else
 
 #ifdef AER_THRUST_CUDA
-  if(cudaGetDeviceCount(&num_devices_) == cudaSuccess){
+  if (cudaGetDeviceCount(&num_devices_) == cudaSuccess) {
     num_places_ = num_devices_;
-  }
-  else{
+  } else {
     cudaGetLastError();
     num_devices_ = 1;
     num_places_ = 1;
@@ -159,46 +131,45 @@ ChunkManager<data_t>::ChunkManager()
 
 #endif
 
-  iplace_host_ = num_places_ ;
+  iplace_host_ = num_places_;
 
 #ifdef AER_DEBUG
-  //spdlog for Thrust implementation debugging
+  // spdlog for Thrust implementation debugging
   auto logger = spdlog::get("qv_thrust_logger");
-  if(!logger){  //for the first call of this process
+  if (!logger) { // for the first call of this process
     char filename[512];
-    sprintf(filename,"logs/qubitvector_thrust_%d.txt",getpid());
-    auto file_logger = spdlog::basic_logger_mt<spdlog::async_factory>("qv_thrust_logger", filename);
+    sprintf(filename, "logs/qubitvector_thrust_%d.txt", getpid());
+    auto file_logger = spdlog::basic_logger_mt<spdlog::async_factory>(
+        "qv_thrust_logger", filename);
     file_logger->set_level(spdlog::level::debug);
     spdlog::set_default_logger(file_logger);
   }
 #endif
 }
 
-template <typename data_t>
-ChunkManager<data_t>::~ChunkManager()
-{
-  Free();
-}
+template <typename data_t> ChunkManager<data_t>::~ChunkManager() { Free(); }
 
 template <typename data_t>
-uint_t ChunkManager<data_t>::Allocate(int chunk_bits,int nqubits,uint_t nchunks,uint_t chunk_index,int matrix_bit, bool density_mat, bool enable_cuStatevec)
-{
+uint_t ChunkManager<data_t>::Allocate(int chunk_bits, int nqubits,
+                                      uint_t nchunks, uint_t chunk_index,
+                                      int matrix_bit, bool density_mat,
+                                      bool enable_cuStatevec) {
   uint_t num_buffers;
   int iDev;
-  uint_t is,ie,nc;
+  uint_t is, ie, nc;
   int i;
-  char* str;
+  char *str;
   bool multi_gpu = false;
   bool hybrid = false;
 
   //--- for test
   str = getenv("AER_MULTI_GPU");
-  if(str){
+  if (str) {
     multi_gpu = true;
     num_places_ = num_devices_;
   }
   str = getenv("AER_HYBRID");
-  if(str){
+  if (str) {
     hybrid = true;
   }
   //---
@@ -208,8 +179,9 @@ uint_t ChunkManager<data_t>::Allocate(int chunk_bits,int nqubits,uint_t nchunks,
 
   chunk_index_ = chunk_index;
 
-  if(num_qubits_ != nqubits || chunk_bits_ != chunk_bits || nchunks > num_chunks_){
-    //free previous allocation
+  if (num_qubits_ != nqubits || chunk_bits_ != chunk_bits ||
+      nchunks > num_chunks_) {
+    // free previous allocation
     Free();
 
     num_qubits_ = nqubits;
@@ -219,9 +191,9 @@ uint_t ChunkManager<data_t>::Allocate(int chunk_bits,int nqubits,uint_t nchunks,
 
     uint_t idev_start = 0;
 
-    if(chunk_bits == nqubits){
-      if(nchunks > 1){  //multi-shot parallelization
-        //accumulate number of chunks
+    if (chunk_bits == nqubits) {
+      if (nchunks > 1) { // multi-shot parallelization
+        // accumulate number of chunks
         num_chunks_ = nchunks;
 
         num_buffers = 0;
@@ -233,45 +205,45 @@ uint_t ChunkManager<data_t>::Allocate(int chunk_bits,int nqubits,uint_t nchunks,
 #else
         multi_gpu = true;
         num_places_ = num_devices_;
-        if(num_threads_per_group_ > 1)
+        if (num_threads_per_group_ > 1)
           num_places_ *= num_threads_per_group_;
 
-        if(num_places_ > omp_get_max_threads()){
+        if (num_places_ > omp_get_max_threads()) {
           num_places_ = num_devices_;
         }
 #endif
-      }
-      else{    //single chunk
+      } else { // single chunk
         num_buffers = 0;
         multi_gpu = false;
         num_places_ = 1;
         num_chunks_ = nchunks;
         multi_shots_ = false;
 
-        //distribute chunk on multiple GPUs when OMP parallel shots are used
-        if(num_devices_ > 0)
+        // distribute chunk on multiple GPUs when OMP parallel shots are used
+        if (num_devices_ > 0)
           idev_start = omp_get_thread_num() % num_devices_;
       }
-    }
-    else{   //multiple-chunk parallelization
+    } else { // multiple-chunk parallelization
       multi_shots_ = false;
 
       num_buffers = AER_MAX_BUFFERS;
 
 #ifdef AER_THRUST_CUDA
       num_places_ = num_devices_;
-      if(num_threads_per_group_ > 1)
+      if (num_threads_per_group_ > 1)
         num_places_ *= num_threads_per_group_;
 
-      if(num_places_ > omp_get_max_threads()){
+      if (num_places_ > omp_get_max_threads()) {
         num_places_ = num_devices_;
       }
 
-      if(!multi_gpu){
-        size_t freeMem,totalMem;
+      if (!multi_gpu) {
+        size_t freeMem, totalMem;
         cudaSetDevice(0);
-        cudaMemGetInfo(&freeMem,&totalMem);
-        if(freeMem > ( ((uint_t)sizeof(thrust::complex<data_t>) * (nchunks + num_buffers + AER_DUMMY_BUFFERS)) << chunk_bits_)){
+        cudaMemGetInfo(&freeMem, &totalMem);
+        if (freeMem > (((uint_t)sizeof(thrust::complex<data_t>) *
+                        (nchunks + num_buffers + AER_DUMMY_BUFFERS))
+                       << chunk_bits_)) {
           num_places_ = 1;
         }
       }
@@ -281,18 +253,18 @@ uint_t ChunkManager<data_t>::Allocate(int chunk_bits,int nqubits,uint_t nchunks,
 #endif
       num_chunks_ = nchunks;
     }
-    if(num_chunks_ < num_places_){
+    if (num_chunks_ < num_places_) {
       num_places_ = num_chunks_;
     }
 
-    //allocate chunk container before parallel loop using push_back to store shared pointer
-    for(i=0;i<num_places_;i++){
+    // allocate chunk container before parallel loop using push_back to store
+    // shared pointer
+    for (i = 0; i < num_places_; i++) {
 #ifdef AER_CUSTATEVEC
-      if(enable_cuStatevec_){   //allocate cuStateVec chunk
+      if (enable_cuStatevec_) { // allocate cuStateVec chunk
         chunks_.push_back(std::make_shared<cuStateVecChunkContainer<data_t>>());
         continue;
-      }
-      else{
+      } else {
 #endif
         chunks_.push_back(std::make_shared<DeviceChunkContainer<data_t>>());
 #ifdef AER_CUSTATEVEC
@@ -301,52 +273,65 @@ uint_t ChunkManager<data_t>::Allocate(int chunk_bits,int nqubits,uint_t nchunks,
     }
 
     uint_t chunks_allocated = 0;
-//#pragma omp parallel for if(num_places_ == num_devices_) private(is,ie,nc) reduction(+:chunks_allocated)
-    for(iDev=0;iDev<num_places_;iDev++){
+    //#pragma omp parallel for if(num_places_ == num_devices_) private(is,ie,nc)
+    // reduction(+:chunks_allocated)
+    for (iDev = 0; iDev < num_places_; iDev++) {
       is = num_chunks_ * (uint_t)iDev / (uint_t)num_places_;
       ie = num_chunks_ * (uint_t)(iDev + 1) / (uint_t)num_places_;
       nc = ie - is;
-      if(hybrid){
+      if (hybrid) {
         nc /= 2;
-        if(nc < 1)
+        if (nc < 1)
           nc = 1;
       }
-      chunks_[iDev]->set_chunk_index(chunk_index_ + chunks_allocated);  //set first chunk index for the container
-      if(num_devices_ > 0)
-        chunks_allocated += chunks_[iDev]->Allocate((iDev + idev_start)%num_devices_,chunk_bits,nqubits,nc,num_buffers,multi_shots_,matrix_bit,density_matrix_);
+      chunks_[iDev]->set_chunk_index(
+          chunk_index_ +
+          chunks_allocated); // set first chunk index for the container
+      if (num_devices_ > 0)
+        chunks_allocated += chunks_[iDev]->Allocate(
+            (iDev + idev_start) % num_devices_, chunk_bits, nqubits, nc,
+            num_buffers, multi_shots_, matrix_bit, density_matrix_);
       else
-        chunks_allocated += chunks_[iDev]->Allocate(iDev,chunk_bits,nqubits,nc,num_buffers,multi_shots_,matrix_bit,density_matrix_);
+        chunks_allocated +=
+            chunks_[iDev]->Allocate(iDev, chunk_bits, nqubits, nc, num_buffers,
+                                    multi_shots_, matrix_bit, density_matrix_);
     }
-    if(chunks_allocated < num_chunks_){
+    if (chunks_allocated < num_chunks_) {
       int nplaces_add = num_places_;
-      if((num_chunks_ - chunks_allocated) < nplaces_add)
+      if ((num_chunks_ - chunks_allocated) < nplaces_add)
         nplaces_add = (num_chunks_ - chunks_allocated);
-      //rest of chunks are stored on host
-      for(iDev=0;iDev<nplaces_add;iDev++){
-        is = (num_chunks_ - chunks_allocated) * (uint_t)iDev / (uint_t)nplaces_add;
-        ie = (num_chunks_ - chunks_allocated) * (uint_t)(iDev + 1) / (uint_t)nplaces_add;
+      // rest of chunks are stored on host
+      for (iDev = 0; iDev < nplaces_add; iDev++) {
+        is = (num_chunks_ - chunks_allocated) * (uint_t)iDev /
+             (uint_t)nplaces_add;
+        ie = (num_chunks_ - chunks_allocated) * (uint_t)(iDev + 1) /
+             (uint_t)nplaces_add;
         nc = ie - is;
-        if(nc > 0){
+        if (nc > 0) {
           chunks_.push_back(std::make_shared<HostChunkContainer<data_t>>());
-          chunks_[chunks_.size()-1]->set_chunk_index(chunk_index_ + chunks_allocated + is);  //set first chunk index for the container
-          chunks_[chunks_.size()-1]->Allocate(-1,chunk_bits,nqubits,nc,num_buffers,multi_shots_,matrix_bit,density_matrix_);
+          chunks_[chunks_.size() - 1]->set_chunk_index(
+              chunk_index_ + chunks_allocated +
+              is); // set first chunk index for the container
+          chunks_[chunks_.size() - 1]->Allocate(-1, chunk_bits, nqubits, nc,
+                                                num_buffers, multi_shots_,
+                                                matrix_bit, density_matrix_);
         }
       }
       num_places_ += nplaces_add;
     }
 
-    for(iDev=0;iDev<num_places_;iDev++)
-      chunks_[iDev]->set_place(iDev,num_places_);
+    for (iDev = 0; iDev < num_places_; iDev++)
+      chunks_[iDev]->set_place(iDev, num_places_);
 
 #ifdef AER_DISABLE_GDR
-    //additional host buffer
+    // additional host buffer
     iplace_host_ = chunks_.size();
     chunks_.push_back(std::make_shared<HostChunkContainer<data_t>>());
-    chunks_[iplace_host_]->Allocate(-1,chunk_bits,nqubits,0,AER_MAX_BUFFERS,multi_shots_,matrix_bit,density_matrix_);
+    chunks_[iplace_host_]->Allocate(-1, chunk_bits, nqubits, 0, AER_MAX_BUFFERS,
+                                    multi_shots_, matrix_bit, density_matrix_);
 #endif
-  }
-  else{
-    for(iDev=0;iDev<chunks_.size();iDev++){
+  } else {
+    for (iDev = 0; iDev < chunks_.size(); iDev++) {
       chunks_[iDev]->unmap_all();
     }
   }
@@ -354,12 +339,10 @@ uint_t ChunkManager<data_t>::Allocate(int chunk_bits,int nqubits,uint_t nchunks,
   return num_chunks_;
 }
 
-template <typename data_t>
-void ChunkManager<data_t>::Free(void)
-{
+template <typename data_t> void ChunkManager<data_t>::Free(void) {
   int i;
 
-  for(i=0;i<chunks_.size();i++){
+  for (i = 0; i < chunks_.size(); i++) {
     chunks_[i]->Deallocate();
     chunks_[i].reset();
   }
@@ -373,12 +356,11 @@ void ChunkManager<data_t>::Free(void)
 }
 
 template <typename data_t>
-bool ChunkManager<data_t>::MapChunk(Chunk<data_t>& chunk,int iplace)
-{
+bool ChunkManager<data_t>::MapChunk(Chunk<data_t> &chunk, int iplace) {
   int i;
 
-  for(i=0;i<num_places_;i++){
-    if(chunks_[(iplace + i) % num_places_]->MapChunk(chunk)){
+  for (i = 0; i < num_places_; i++) {
+    if (chunks_[(iplace + i) % num_places_]->MapChunk(chunk)) {
       chunk.set_place((iplace + i) % num_places_);
       break;
     }
@@ -387,64 +369,58 @@ bool ChunkManager<data_t>::MapChunk(Chunk<data_t>& chunk,int iplace)
 }
 
 template <typename data_t>
-bool ChunkManager<data_t>::MapBufferChunk(Chunk<data_t>& out,int idev)
-{
-  if(idev < 0){
+bool ChunkManager<data_t>::MapBufferChunk(Chunk<data_t> &out, int idev) {
+  if (idev < 0) {
     int i;
-    for(i=0;i<num_devices_;i++){
-      if(chunks_[i]->MapBufferChunk(out))
+    for (i = 0; i < num_devices_; i++) {
+      if (chunks_[i]->MapBufferChunk(out))
         break;
     }
-  }
-  else{
+  } else {
     chunks_[(idev % num_devices_)]->MapBufferChunk(out);
   }
   return out.is_mapped();
 }
 
 template <typename data_t>
-bool ChunkManager<data_t>::MapBufferChunkOnHost(Chunk<data_t>& out)
-{
+bool ChunkManager<data_t>::MapBufferChunkOnHost(Chunk<data_t> &out) {
   return chunks_[iplace_host_]->MapBufferChunk(out);
 }
 
 template <typename data_t>
-void ChunkManager<data_t>::UnmapChunk(Chunk<data_t>& chunk)
-{
+void ChunkManager<data_t>::UnmapChunk(Chunk<data_t> &chunk) {
   int iPlace = chunk.place();
 
   chunks_[iPlace]->UnmapChunk(chunk);
 }
 
-
 template <typename data_t>
-void ChunkManager<data_t>::UnmapBufferChunk(Chunk<data_t>& buffer)
-{
+void ChunkManager<data_t>::UnmapBufferChunk(Chunk<data_t> &buffer) {
   chunks_[buffer.place()]->UnmapBuffer(buffer);
 }
 
 template <typename data_t>
 template <typename Function>
-void ChunkManager<data_t>::execute_on_device(Function func,const std::vector<std::complex<double>>& mat,const std::vector<uint_t>& prm)
-{
+void ChunkManager<data_t>::execute_on_device(
+    Function func, const std::vector<std::complex<double>> &mat,
+    const std::vector<uint_t> &prm) {
 #pragma omp parallel num_threads(num_places_)
   {
     int_t place = omp_get_thread_num();
 
-    //store matrix and params if exist
-    if(mat.size() > 0)
-      chunks_[place]->StoreMatrix(mat,0);
-    if(prm.size() > 0)
-      chunks_[place]->StoreUintParams(prm,0);
+    // store matrix and params if exist
+    if (mat.size() > 0)
+      chunks_[place]->StoreMatrix(mat, 0);
+    if (prm.size() > 0)
+      chunks_[place]->StoreUintParams(prm, 0);
 
-    //execute a kernel
-    chunks_[place]->Execute(func,0);
+    // execute a kernel
+    chunks_[place]->Execute(func, 0);
   }
 }
 
-
 //------------------------------------------------------------------------------
-} //end namespace Chunk
+} // end namespace Chunk
 } // end namespace QV
 } // end namespace AER
 //------------------------------------------------------------------------------
diff --git a/src/simulators/statevector/chunk/cuStateVec_chunk_container.hpp b/src/simulators/statevector/chunk/cuStateVec_chunk_container.hpp
index e375a56c2f..a55e8a2112 100644
--- a/src/simulators/statevector/chunk/cuStateVec_chunk_container.hpp
+++ b/src/simulators/statevector/chunk/cuStateVec_chunk_container.hpp
@@ -12,7 +12,6 @@
  * that they have been altered from the originals.
  */
 
-
 #ifndef _qv_cuStateVec_chunk_container_hpp_
 #define _qv_cuStateVec_chunk_container_hpp_
 
@@ -24,125 +23,154 @@ namespace AER {
 namespace QV {
 namespace Chunk {
 
-
 //============================================================================
 // cuStateVec chunk container class
 //============================================================================
 template <typename data_t>
-class cuStateVecChunkContainer : public DeviceChunkContainer<data_t>
-{
+class cuStateVecChunkContainer : public DeviceChunkContainer<data_t> {
 protected:
-  custatevecHandle_t custatevec_handle_;                       //cuStatevec handle for this chunk container
-  uint_t             custatevec_chunk_total_qubits_;   //total qubits of statevector passed to ApplyMatrix
-  uint_t                                  custatevec_chunk_count_;          //number of counts for all chunks
+  custatevecHandle_t
+      custatevec_handle_; // cuStatevec handle for this chunk container
+  uint_t custatevec_chunk_total_qubits_; // total qubits of statevector passed
+                                         // to ApplyMatrix
+  uint_t custatevec_chunk_count_;        // number of counts for all chunks
+
+  custatevecDeviceMemHandler_t custatevec_mem_handler_;
+  cudaMemPool_t memory_pool_;
 
-  custatevecDeviceMemHandler_t              custatevec_mem_handler_;
-  cudaMemPool_t                             memory_pool_;
 public:
   using BaseContainer = DeviceChunkContainer<data_t>;
 
-  cuStateVecChunkContainer()
-  {
-  }
+  cuStateVecChunkContainer() {}
   ~cuStateVecChunkContainer();
 
-  uint_t Allocate(int idev,int chunk_bits,int num_qubits,uint_t chunks,uint_t buffers,bool multi_shots,int matrix_bit,bool density_matrix) override;
+  uint_t Allocate(int idev, int chunk_bits, int num_qubits, uint_t chunks,
+                  uint_t buffers, bool multi_shots, int matrix_bit,
+                  bool density_matrix) override;
   void Deallocate(void) override;
 
-  reg_t sample_measure(uint_t iChunk,const std::vector<double> &rnds, uint_t stride = 1, bool dot = true,uint_t count = 1) const override;
-  double norm(uint_t iChunk,uint_t count) const override;
-
-  //apply matrix
-  void apply_matrix(const uint_t iChunk,const reg_t& qubits,const int_t control_bits,const cvector_t<double> &mat,const uint_t gid, const uint_t count) override;
-
-  //apply diagonal matrix
-  void apply_diagonal_matrix(const uint_t iChunk,const reg_t& qubits,const int_t control_bits,const cvector_t<double> &diag,const uint_t gid, const uint_t count) override;
-
-  //apply (controlled) X
-  void apply_X(const uint_t iChunk,const reg_t& qubits,const uint_t gid, const uint_t count) override;
-
-  //apply (controlled) Y
-  void apply_Y(const uint_t iChunk,const reg_t& qubits,const uint_t gid, const uint_t count) override;
-
-  //apply (controlled) phase
-  virtual void apply_phase(const uint_t iChunk,const reg_t& qubits,const int_t control_bits,const std::complex<double> phase,const uint_t gid, const uint_t count) override;
-
-  //apply (controlled) swap gate
-  void apply_swap(const uint_t iChunk,const reg_t& qubits,const int_t control_bits,const uint_t gid, const uint_t count) override;
-
-  //apply permutation
-  void apply_permutation(const uint_t iChunk,const reg_t& qubits,const std::vector<std::pair<uint_t, uint_t>> &pairs, const uint_t gid, const uint_t count) override;
-
-  //apply rotation around axis
-  void apply_rotation(const uint_t iChunk,const reg_t &qubits, const Rotation r, const double theta, const uint_t gid, const uint_t count) override;
-
-  //get probabilities of chunk
-  void probabilities(std::vector<double>& probs, const uint_t iChunk, const reg_t& qubits) const override;
-
-  //Pauli expectation values
-  double expval_pauli(const uint_t iChunk,const reg_t& qubits,const std::string &pauli,const complex_t initial_phase) const override;
+  reg_t sample_measure(uint_t iChunk, const std::vector<double> &rnds,
+                       uint_t stride = 1, bool dot = true,
+                       uint_t count = 1) const override;
+  double norm(uint_t iChunk, uint_t count) const override;
+
+  // apply matrix
+  void apply_matrix(const uint_t iChunk, const reg_t &qubits,
+                    const int_t control_bits, const cvector_t<double> &mat,
+                    const uint_t gid, const uint_t count) override;
+
+  // apply diagonal matrix
+  void apply_diagonal_matrix(const uint_t iChunk, const reg_t &qubits,
+                             const int_t control_bits,
+                             const cvector_t<double> &diag, const uint_t gid,
+                             const uint_t count) override;
+
+  // apply (controlled) X
+  void apply_X(const uint_t iChunk, const reg_t &qubits, const uint_t gid,
+               const uint_t count) override;
+
+  // apply (controlled) Y
+  void apply_Y(const uint_t iChunk, const reg_t &qubits, const uint_t gid,
+               const uint_t count) override;
+
+  // apply (controlled) phase
+  virtual void apply_phase(const uint_t iChunk, const reg_t &qubits,
+                           const int_t control_bits,
+                           const std::complex<double> phase, const uint_t gid,
+                           const uint_t count) override;
+
+  // apply (controlled) swap gate
+  void apply_swap(const uint_t iChunk, const reg_t &qubits,
+                  const int_t control_bits, const uint_t gid,
+                  const uint_t count) override;
+
+  // apply permutation
+  void apply_permutation(const uint_t iChunk, const reg_t &qubits,
+                         const std::vector<std::pair<uint_t, uint_t>> &pairs,
+                         const uint_t gid, const uint_t count) override;
+
+  // apply rotation around axis
+  void apply_rotation(const uint_t iChunk, const reg_t &qubits,
+                      const Rotation r, const double theta, const uint_t gid,
+                      const uint_t count) override;
+
+  // get probabilities of chunk
+  void probabilities(std::vector<double> &probs, const uint_t iChunk,
+                     const reg_t &qubits) const override;
+
+  // Pauli expectation values
+  double expval_pauli(const uint_t iChunk, const reg_t &qubits,
+                      const std::string &pauli,
+                      const complex_t initial_phase) const override;
 };
 
-int cuStateVecChunkContainer_MemPoolAlloc(void* ctx, void** ptr, size_t size, cudaStream_t stream) 
-{
-  cudaMemPool_t& pool = *static_cast<cudaMemPool_t*>(ctx);
+int cuStateVecChunkContainer_MemPoolAlloc(void *ctx, void **ptr, size_t size,
+                                          cudaStream_t stream) {
+  cudaMemPool_t &pool = *static_cast<cudaMemPool_t *>(ctx);
   cudaError_t status = cudaMallocFromPoolAsync(ptr, size, pool, stream);
   return (int)status;
 }
 
 // upon success, this function should return 0, otherwise a nonzero value
-int cuStateVecChunkContainer_MemPoolFree(void* ctx, void* ptr, size_t size, cudaStream_t stream)
-{
+int cuStateVecChunkContainer_MemPoolFree(void *ctx, void *ptr, size_t size,
+                                         cudaStream_t stream) {
   cudaError_t status = cudaFreeAsync(ptr, stream);
   return (int)status;
 }
 
-
 template <typename data_t>
-cuStateVecChunkContainer<data_t>::~cuStateVecChunkContainer(void)
-{
+cuStateVecChunkContainer<data_t>::~cuStateVecChunkContainer(void) {
   Deallocate();
 }
 
 template <typename data_t>
-uint_t cuStateVecChunkContainer<data_t>::Allocate(int idev,int chunk_bits,int num_qubits,uint_t chunks,uint_t buffers,bool multi_shots,int matrix_bit,bool density_matrix)
-{
+uint_t cuStateVecChunkContainer<data_t>::Allocate(
+    int idev, int chunk_bits, int num_qubits, uint_t chunks, uint_t buffers,
+    bool multi_shots, int matrix_bit, bool density_matrix) {
   uint_t nc;
-  nc = BaseContainer::Allocate(idev,chunk_bits,num_qubits,chunks,buffers,multi_shots,matrix_bit,density_matrix);
+  nc = BaseContainer::Allocate(idev, chunk_bits, num_qubits, chunks, buffers,
+                               multi_shots, matrix_bit, density_matrix);
 
-  //initialize custatevevtor handle
+  // initialize custatevevtor handle
   custatevecStatus_t err;
 
   err = custatevecCreate(&custatevec_handle_);
-  if(err != CUSTATEVEC_STATUS_SUCCESS){
+  if (err != CUSTATEVEC_STATUS_SUCCESS) {
     std::stringstream str;
-    str << "cuStateVecChunkContainer::allocate::custatevecCreate : " << custatevecGetErrorString(err);
+    str << "cuStateVecChunkContainer::allocate::custatevecCreate : "
+        << custatevecGetErrorString(err);
     throw std::runtime_error(str.str());
   }
 
-  err = custatevecSetStream(custatevec_handle_,BaseContainer::stream_);
-  if(err != CUSTATEVEC_STATUS_SUCCESS){
+  err = custatevecSetStream(custatevec_handle_, BaseContainer::stream_);
+  if (err != CUSTATEVEC_STATUS_SUCCESS) {
     std::stringstream str;
-    str << "cuStateVecChunkContainer::allocate::custatevecSetStream : " << custatevecGetErrorString(err);
+    str << "cuStateVecChunkContainer::allocate::custatevecSetStream : "
+        << custatevecGetErrorString(err);
     throw std::runtime_error(str.str());
   }
 
-  //setup memory pool
+  // setup memory pool
   cudaError_t status;
   int isMemPoolSupported;
-  status = cudaDeviceGetAttribute(&isMemPoolSupported, cudaDevAttrMemoryPoolsSupported, idev);
-  if(status != cudaSuccess || !isMemPoolSupported){
+  status = cudaDeviceGetAttribute(&isMemPoolSupported,
+                                  cudaDevAttrMemoryPoolsSupported, idev);
+  if (status != cudaSuccess || !isMemPoolSupported) {
     std::stringstream str;
-    str << "cuStateVecChunkContainer : cuStateVec support requires memory pool on GPU device. " << cudaGetErrorString(status);
+    str << "cuStateVecChunkContainer : cuStateVec support requires memory pool "
+           "on GPU device. "
+        << cudaGetErrorString(status);
     throw std::runtime_error(str.str());
   }
 
   cudaDeviceGetDefaultMemPool(&memory_pool_, idev);
   uint64_t threshold = UINT64_MAX;
-  status = cudaMemPoolSetAttribute(memory_pool_, cudaMemPoolAttrReleaseThreshold, &threshold);
-  if(status != cudaSuccess){
+  status = cudaMemPoolSetAttribute(memory_pool_,
+                                   cudaMemPoolAttrReleaseThreshold, &threshold);
+  if (status != cudaSuccess) {
     std::stringstream str;
-    str << "cuStateVecChunkContainer::cudaMemPoolSetAttribute : " << cudaGetErrorString(status);
+    str << "cuStateVecChunkContainer::cudaMemPoolSetAttribute : "
+        << cudaGetErrorString(status);
     throw std::runtime_error(str.str());
   }
 
@@ -150,39 +178,43 @@ uint_t cuStateVecChunkContainer<data_t>::Allocate(int idev,int chunk_bits,int nu
   custatevec_mem_handler_.device_alloc = cuStateVecChunkContainer_MemPoolAlloc;
   custatevec_mem_handler_.device_free = cuStateVecChunkContainer_MemPoolFree;
   strcpy(custatevec_mem_handler_.name, "mempool");
-  err = custatevecSetDeviceMemHandler(custatevec_handle_, &custatevec_mem_handler_);
-  if(err != CUSTATEVEC_STATUS_SUCCESS){
+  err = custatevecSetDeviceMemHandler(custatevec_handle_,
+                                      &custatevec_mem_handler_);
+  if (err != CUSTATEVEC_STATUS_SUCCESS) {
     std::stringstream str;
-    str << "cuStateVecChunkContainer::custatevecSetDeviceMemHandler : " << custatevecGetErrorString(err);
+    str << "cuStateVecChunkContainer::custatevecSetDeviceMemHandler : "
+        << custatevecGetErrorString(err);
     throw std::runtime_error(str.str());
   }
 
-  //count bits for multi-chunks
+  // count bits for multi-chunks
   custatevec_chunk_total_qubits_ = this->num_pow2_qubits_;
-  custatevec_chunk_count_ = this->num_chunks_ >> (this->num_pow2_qubits_ - this->chunk_bits_);
+  custatevec_chunk_count_ =
+      this->num_chunks_ >> (this->num_pow2_qubits_ - this->chunk_bits_);
 
   return nc;
 }
 
 template <typename data_t>
-void cuStateVecChunkContainer<data_t>::Deallocate(void)
-{
+void cuStateVecChunkContainer<data_t>::Deallocate(void) {
   BaseContainer::Deallocate();
 
   custatevecDestroy(custatevec_handle_);
 }
 
 template <typename data_t>
-reg_t cuStateVecChunkContainer<data_t>::sample_measure(uint_t iChunk,const std::vector<double> &rnds, uint_t stride, bool dot,uint_t count) const
-{
-  if(stride == 1 && count == (1ull << (this->num_qubits_ - this->chunk_bits_))){
-    //custatevecSampler_sample only can be applied to whole statevector
-    //also density_matrix is not supported (stride != 1)
+reg_t cuStateVecChunkContainer<data_t>::sample_measure(
+    uint_t iChunk, const std::vector<double> &rnds, uint_t stride, bool dot,
+    uint_t count) const {
+  if (stride == 1 &&
+      count == (1ull << (this->num_qubits_ - this->chunk_bits_))) {
+    // custatevecSampler_sample only can be applied to whole statevector
+    // also density_matrix is not supported (stride != 1)
     const int_t SHOTS = rnds.size();
-    reg_t samples(SHOTS,0);
+    reg_t samples(SHOTS, 0);
 
     BaseContainer::set_device();
-    custatevecSetStream(custatevec_handle_,BaseContainer::stream_);
+    custatevecSetStream(custatevec_handle_, BaseContainer::stream_);
 
     custatevecStatus_t err;
     custatevecSamplerDescriptor_t sampler;
@@ -191,90 +223,100 @@ reg_t cuStateVecChunkContainer<data_t>::sample_measure(uint_t iChunk,const std::
     cudaStreamSynchronize(BaseContainer::stream_);
 
     cudaDataType_t state_type;
-    if(sizeof(data_t) == sizeof(double))
+    if (sizeof(data_t) == sizeof(double))
       state_type = CUDA_C_64F;
     else
       state_type = CUDA_C_32F;
 
-    err = custatevecSamplerCreate(custatevec_handle_, BaseContainer::chunk_pointer(iChunk), state_type, this->num_qubits_, &sampler, SHOTS, &extSize);
-    if(err != CUSTATEVEC_STATUS_SUCCESS){
+    err = custatevecSamplerCreate(
+        custatevec_handle_, BaseContainer::chunk_pointer(iChunk), state_type,
+        this->num_qubits_, &sampler, SHOTS, &extSize);
+    if (err != CUSTATEVEC_STATUS_SUCCESS) {
       std::stringstream str;
-      str << "cuStateVecChunkContainer::sample_measure : custatevecSampler_create " << custatevecGetErrorString(err);
+      str << "cuStateVecChunkContainer::sample_measure : "
+             "custatevecSampler_create "
+          << custatevecGetErrorString(err);
       throw std::runtime_error(str.str());
     }
 
     AERDeviceVector<unsigned char> extBuf;
-    void* pExtBuf = nullptr;
-    if(extSize > 0){
+    void *pExtBuf = nullptr;
+    if (extSize > 0) {
       cudaMalloc(&pExtBuf, extSize);
     }
 
-    err = custatevecSamplerPreprocess(custatevec_handle_,sampler,pExtBuf,extSize);
-    if(err != CUSTATEVEC_STATUS_SUCCESS){
+    err = custatevecSamplerPreprocess(custatevec_handle_, sampler, pExtBuf,
+                                      extSize);
+    if (err != CUSTATEVEC_STATUS_SUCCESS) {
       std::stringstream str;
-      str << "cuStateVecChunkContainer::sample_measure : custatevecSampler_preprocess " << custatevecGetErrorString(err);
+      str << "cuStateVecChunkContainer::sample_measure : "
+             "custatevecSampler_preprocess "
+          << custatevecGetErrorString(err);
       throw std::runtime_error(str.str());
     }
 
     std::vector<custatevecIndex_t> bitStr(SHOTS);
     std::vector<int> bitOrdering(this->num_qubits_);
-    for(int_t i=0;i<this->num_qubits_;i++){
+    for (int_t i = 0; i < this->num_qubits_; i++) {
       bitOrdering[i] = i;
     }
 
-    err = custatevecSamplerSample(custatevec_handle_, sampler, &bitStr[0], &bitOrdering[0], this->num_qubits_, &rnds[0], SHOTS,
-                    CUSTATEVEC_SAMPLER_OUTPUT_RANDNUM_ORDER ) ;
-    if(err != CUSTATEVEC_STATUS_SUCCESS){
+    err =
+        custatevecSamplerSample(custatevec_handle_, sampler, &bitStr[0],
+                                &bitOrdering[0], this->num_qubits_, &rnds[0],
+                                SHOTS, CUSTATEVEC_SAMPLER_OUTPUT_RANDNUM_ORDER);
+    if (err != CUSTATEVEC_STATUS_SUCCESS) {
       std::stringstream str;
-      str << "cuStateVecChunkContainer::sample_measure : custatevecSampler_sample " << custatevecGetErrorString(err);
+      str << "cuStateVecChunkContainer::sample_measure : "
+             "custatevecSampler_sample "
+          << custatevecGetErrorString(err);
       throw std::runtime_error(str.str());
     }
 
-    for(int_t i=0;i<SHOTS;i++){
+    for (int_t i = 0; i < SHOTS; i++) {
       samples[i] = bitStr[i];
     }
 
-    if(pExtBuf){
+    if (pExtBuf) {
       cudaFree(pExtBuf);
     }
 
     custatevecSamplerDestroy(sampler);
     return samples;
-  }
-  else{
+  } else {
     return BaseContainer::sample_measure(iChunk, rnds, stride, dot, count);
   }
 }
 
 template <typename data_t>
-void cuStateVecChunkContainer<data_t>::apply_matrix(const uint_t iChunk,const reg_t& qubits,const int_t control_bits,const cvector_t<double> &mat,const uint_t gid, const uint_t count)
-{
-  thrust::complex<double>* pMat;
-  int_t num_qubits = qubits.size()-control_bits;
+void cuStateVecChunkContainer<data_t>::apply_matrix(
+    const uint_t iChunk, const reg_t &qubits, const int_t control_bits,
+    const cvector_t<double> &mat, const uint_t gid, const uint_t count) {
+  thrust::complex<double> *pMat;
+  int_t num_qubits = qubits.size() - control_bits;
 
-  pMat = (thrust::complex<double>*)&mat[0];
+  pMat = (thrust::complex<double> *)&mat[0];
   BaseContainer::set_device();
 
   std::vector<int32_t> qubits32(qubits.size());
-  for(int_t i=0;i<qubits.size();i++)
+  for (int_t i = 0; i < qubits.size(); i++)
     qubits32[i] = qubits[i];
 
-  int32_t* pQubits = &qubits32[control_bits];
-  int32_t* pControl = nullptr;
-  if(control_bits > 0)
+  int32_t *pQubits = &qubits32[control_bits];
+  int32_t *pControl = nullptr;
+  if (control_bits > 0)
     pControl = &qubits32[0];
 
   uint_t bits;
   uint_t nc;
-  if(count == this->num_chunks_){
+  if (count == this->num_chunks_) {
     bits = custatevec_chunk_total_qubits_;
     nc = custatevec_chunk_count_;
-  }
-  else{
+  } else {
     nc = count;
     bits = this->chunk_bits_;
-    if(nc > 1){
-      while((nc & 1) == 0){
+    if (nc > 1) {
+      while ((nc & 1) == 0) {
         nc >>= 1;
         bits++;
       }
@@ -282,70 +324,72 @@ void cuStateVecChunkContainer<data_t>::apply_matrix(const uint_t iChunk,const re
   }
   cudaDataType_t state_type;
   custatevecComputeType_t comp_type;
-  if(sizeof(data_t) == sizeof(double)){
+  if (sizeof(data_t) == sizeof(double)) {
     state_type = CUDA_C_64F;
     comp_type = CUSTATEVEC_COMPUTE_64F;
-  }
-  else{
+  } else {
     state_type = CUDA_C_32F;
     comp_type = CUSTATEVEC_COMPUTE_32F;
   }
 
   custatevecStatus_t err;
-  for(int_t i=0;i<nc;i++){
-    err = custatevecApplyMatrix(custatevec_handle_, BaseContainer::chunk_pointer(iChunk) + (i << bits), state_type, bits, pMat, CUDA_C_64F,
-                          CUSTATEVEC_MATRIX_LAYOUT_COL, 0, pQubits, num_qubits, pControl, nullptr, control_bits, 
-                          comp_type, nullptr, 0);
-    if(err != CUSTATEVEC_STATUS_SUCCESS){
+  for (int_t i = 0; i < nc; i++) {
+    err = custatevecApplyMatrix(
+        custatevec_handle_, BaseContainer::chunk_pointer(iChunk) + (i << bits),
+        state_type, bits, pMat, CUDA_C_64F, CUSTATEVEC_MATRIX_LAYOUT_COL, 0,
+        pQubits, num_qubits, pControl, nullptr, control_bits, comp_type,
+        nullptr, 0);
+    if (err != CUSTATEVEC_STATUS_SUCCESS) {
       std::stringstream str;
-      str << "cuStateVecChunkContainer::apply_matrix : " << custatevecGetErrorString(err);
+      str << "cuStateVecChunkContainer::apply_matrix : "
+          << custatevecGetErrorString(err);
       throw std::runtime_error(str.str());
     }
   }
 }
 
 template <typename data_t>
-void cuStateVecChunkContainer<data_t>::apply_diagonal_matrix(const uint_t iChunk,const reg_t& qubits,const int_t control_bits,const cvector_t<double> &diag,const uint_t gid, const uint_t count)
-{
-  thrust::complex<double>* pMat;
+void cuStateVecChunkContainer<data_t>::apply_diagonal_matrix(
+    const uint_t iChunk, const reg_t &qubits, const int_t control_bits,
+    const cvector_t<double> &diag, const uint_t gid, const uint_t count) {
+  thrust::complex<double> *pMat;
   int_t num_qubits = qubits.size();
 
-  if(control_bits > 0){
+  if (control_bits > 0) {
     uint_t size = 1ull << num_qubits;
-    cvector_t<double> diag_ctrl(size);    //make diagonal matrix with controls
+    cvector_t<double> diag_ctrl(size); // make diagonal matrix with controls
 
-    for(int_t i=0;i<size;i++)
+    for (int_t i = 0; i < size; i++)
       diag_ctrl[i] = 1.0;
     uint_t offset = (1ull << control_bits) - 1;
-    for(int_t i=0;i<diag.size();i++)
-      diag_ctrl[(i << control_bits)+offset] = diag[i];
+    for (int_t i = 0; i < diag.size(); i++)
+      diag_ctrl[(i << control_bits) + offset] = diag[i];
 
     return apply_diagonal_matrix(iChunk, qubits, 0, diag_ctrl, gid, count);
   }
 
-  pMat = (thrust::complex<double>*)&diag[0];
+  pMat = (thrust::complex<double> *)&diag[0];
   BaseContainer::set_device();
 
   std::vector<int32_t> qubits32(qubits.size());
-  for(int_t i=0;i<qubits.size();i++)
+  for (int_t i = 0; i < qubits.size(); i++)
     qubits32[i] = qubits[i];
 
-  int32_t* pQubits = &qubits32[control_bits];
-  int32_t* pControl = nullptr;
-  if(control_bits > 0)
+  int32_t *pQubits = &qubits32[control_bits];
+  int32_t *pControl = nullptr;
+  if (control_bits > 0)
     pControl = &qubits32[0];
 
   uint_t bits;
   uint_t nc;
-  if(count == this->num_chunks_){
+  if (count == this->num_chunks_) {
     bits = custatevec_chunk_total_qubits_;
     nc = custatevec_chunk_count_;
-  }
-  else{
+  } else {
     nc = count;
     bits = this->chunk_bits_;
-    if(nc > 1){
-      while((nc & 1) == 0){
+    if (nc > 1) {
+      while ((nc & 1) == 0) {
         nc >>= 1;
         bits++;
       }
@@ -353,58 +397,61 @@ void cuStateVecChunkContainer<data_t>::apply_diagonal_matrix(const uint_t iChunk
   }
 
   cudaDataType_t state_type;
-  if(sizeof(data_t) == sizeof(double))
+  if (sizeof(data_t) == sizeof(double))
     state_type = CUDA_C_64F;
   else
     state_type = CUDA_C_32F;
 
   custatevecStatus_t err;
-  for(int_t i=0;i<nc;i++){
-    err = custatevecApplyGeneralizedPermutationMatrix(custatevec_handle_, BaseContainer::chunk_pointer(iChunk) + (i << bits), state_type, bits, 
-                          nullptr, pMat, CUDA_C_64F, 0, pQubits, num_qubits, nullptr, nullptr, 0, 
-                          nullptr, 0);
-    if(err != CUSTATEVEC_STATUS_SUCCESS){
+  for (int_t i = 0; i < nc; i++) {
+    err = custatevecApplyGeneralizedPermutationMatrix(
+        custatevec_handle_, BaseContainer::chunk_pointer(iChunk) + (i << bits),
+        state_type, bits, nullptr, pMat, CUDA_C_64F, 0, pQubits, num_qubits,
+        nullptr, nullptr, 0, nullptr, 0);
+    if (err != CUSTATEVEC_STATUS_SUCCESS) {
       std::stringstream str;
-      str << "cuStateVecChunkContainer::apply_diagonal_matrix : " << custatevecGetErrorString(err);
+      str << "cuStateVecChunkContainer::apply_diagonal_matrix : "
+          << custatevecGetErrorString(err);
       throw std::runtime_error(str.str());
     }
   }
 }
 
 template <typename data_t>
-void cuStateVecChunkContainer<data_t>::apply_X(const uint_t iChunk,const reg_t& qubits,const uint_t gid, const uint_t count)
-{
+void cuStateVecChunkContainer<data_t>::apply_X(const uint_t iChunk,
+                                               const reg_t &qubits,
+                                               const uint_t gid,
+                                               const uint_t count) {
   int_t num_qubits = qubits.size();
 
   BaseContainer::set_device();
 
   uint_t perm_size = 1ull << num_qubits;
   std::vector<custatevecIndex_t> perm(perm_size);
-  for(int_t i=0;i<perm_size;i++)
+  for (int_t i = 0; i < perm_size; i++)
     perm[i] = i;
 
-  //set permutation
+  // set permutation
   uint_t ctrl_offset = (1ull << (num_qubits - 1)) - 1;
   uint_t t_offset = (1ull << (num_qubits - 1)) + ctrl_offset;
   perm[ctrl_offset] = t_offset;
   perm[t_offset] = ctrl_offset;
 
   std::vector<int32_t> qubits32(qubits.size());
-  for(int_t i=0;i<qubits.size();i++)
+  for (int_t i = 0; i < qubits.size(); i++)
     qubits32[i] = qubits[i];
-  int32_t* pQubits = &qubits32[0];
+  int32_t *pQubits = &qubits32[0];
 
   uint_t bits;
   uint_t nc;
-  if(count == this->num_chunks_){
+  if (count == this->num_chunks_) {
     bits = custatevec_chunk_total_qubits_;
     nc = custatevec_chunk_count_;
-  }
-  else{
+  } else {
     nc = count;
     bits = this->chunk_bits_;
-    if(nc > 1){
-      while((nc & 1) == 0){
+    if (nc > 1) {
+      while ((nc & 1) == 0) {
         nc >>= 1;
         bits++;
       }
@@ -412,27 +459,31 @@ void cuStateVecChunkContainer<data_t>::apply_X(const uint_t iChunk,const reg_t&
   }
 
   cudaDataType_t state_type;
-  if(sizeof(data_t) == sizeof(double))
+  if (sizeof(data_t) == sizeof(double))
     state_type = CUDA_C_64F;
   else
     state_type = CUDA_C_32F;
 
   custatevecStatus_t err;
-  for(int_t i=0;i<nc;i++){
-    err = custatevecApplyGeneralizedPermutationMatrix(custatevec_handle_, BaseContainer::chunk_pointer(iChunk) + (i << bits), state_type, bits, 
-                          &perm[0], nullptr, CUDA_C_64F, 0, pQubits, num_qubits, nullptr, nullptr, 0, 
-                          nullptr, 0);
-    if(err != CUSTATEVEC_STATUS_SUCCESS){
+  for (int_t i = 0; i < nc; i++) {
+    err = custatevecApplyGeneralizedPermutationMatrix(
+        custatevec_handle_, BaseContainer::chunk_pointer(iChunk) + (i << bits),
+        state_type, bits, &perm[0], nullptr, CUDA_C_64F, 0, pQubits, num_qubits,
+        nullptr, nullptr, 0, nullptr, 0);
+    if (err != CUSTATEVEC_STATUS_SUCCESS) {
       std::stringstream str;
-      str << "cuStateVecChunkContainer::apply_X : " << custatevecGetErrorString(err);
+      str << "cuStateVecChunkContainer::apply_X : "
+          << custatevecGetErrorString(err);
       throw std::runtime_error(str.str());
     }
   }
 }
 
 template <typename data_t>
-void cuStateVecChunkContainer<data_t>::apply_Y(const uint_t iChunk,const reg_t& qubits,const uint_t gid, const uint_t count)
-{
+void cuStateVecChunkContainer<data_t>::apply_Y(const uint_t iChunk,
+                                               const reg_t &qubits,
+                                               const uint_t gid,
+                                               const uint_t count) {
   int_t num_qubits = qubits.size();
 
   BaseContainer::set_device();
@@ -440,12 +491,12 @@ void cuStateVecChunkContainer<data_t>::apply_Y(const uint_t iChunk,const reg_t&
   uint_t perm_size = 1ull << num_qubits;
   cvector_t<double> diag(perm_size);
   std::vector<custatevecIndex_t> perm(perm_size);
-  for(int_t i=0;i<perm_size;i++){
+  for (int_t i = 0; i < perm_size; i++) {
     perm[i] = i;
     diag[i] = 1.0;
   }
 
-  //set diagonal matrix and permutation matrix
+  // set diagonal matrix and permutation matrix
   uint_t ctrl_offset = (1ull << (num_qubits - 1)) - 1;
   uint_t t_offset = (1ull << (num_qubits - 1)) + ctrl_offset;
   perm[ctrl_offset] = t_offset;
@@ -454,21 +505,20 @@ void cuStateVecChunkContainer<data_t>::apply_Y(const uint_t iChunk,const reg_t&
   diag[t_offset] = {0.0, 1.0};
 
   std::vector<int32_t> qubits32(qubits.size());
-  for(int_t i=0;i<qubits.size();i++)
+  for (int_t i = 0; i < qubits.size(); i++)
     qubits32[i] = qubits[i];
-  int32_t* pQubits = &qubits32[0];
+  int32_t *pQubits = &qubits32[0];
 
   uint_t bits;
   uint_t nc;
-  if(count == this->num_chunks_){
+  if (count == this->num_chunks_) {
     bits = custatevec_chunk_total_qubits_;
     nc = custatevec_chunk_count_;
-  }
-  else{
+  } else {
     nc = count;
     bits = this->chunk_bits_;
-    if(nc > 1){
-      while((nc & 1) == 0){
+    if (nc > 1) {
+      while ((nc & 1) == 0) {
         nc >>= 1;
         bits++;
       }
@@ -476,49 +526,55 @@ void cuStateVecChunkContainer<data_t>::apply_Y(const uint_t iChunk,const reg_t&
   }
 
   cudaDataType_t state_type;
-  if(sizeof(data_t) == sizeof(double))
+  if (sizeof(data_t) == sizeof(double))
     state_type = CUDA_C_64F;
   else
     state_type = CUDA_C_32F;
 
   custatevecStatus_t err;
-  for(int_t i=0;i<nc;i++){
-    err = custatevecApplyGeneralizedPermutationMatrix(custatevec_handle_, BaseContainer::chunk_pointer(iChunk) + (i << bits), state_type, bits, 
-                          &perm[0], &diag[0], CUDA_C_64F, 0, pQubits, num_qubits, nullptr, nullptr, 0, 
-                          nullptr, 0);
-    if(err != CUSTATEVEC_STATUS_SUCCESS){
+  for (int_t i = 0; i < nc; i++) {
+    err = custatevecApplyGeneralizedPermutationMatrix(
+        custatevec_handle_, BaseContainer::chunk_pointer(iChunk) + (i << bits),
+        state_type, bits, &perm[0], &diag[0], CUDA_C_64F, 0, pQubits,
+        num_qubits, nullptr, nullptr, 0, nullptr, 0);
+    if (err != CUSTATEVEC_STATUS_SUCCESS) {
       std::stringstream str;
-      str << "cuStateVecChunkContainer::apply_Y : " << custatevecGetErrorString(err);
+      str << "cuStateVecChunkContainer::apply_Y : "
+          << custatevecGetErrorString(err);
       throw std::runtime_error(str.str());
     }
   }
 }
 
 template <typename data_t>
-void cuStateVecChunkContainer<data_t>::apply_phase(const uint_t iChunk,const reg_t& qubits,const int_t control_bits,const std::complex<double> phase,const uint_t gid, const uint_t count)
-{
+void cuStateVecChunkContainer<data_t>::apply_phase(
+    const uint_t iChunk, const reg_t &qubits, const int_t control_bits,
+    const std::complex<double> phase, const uint_t gid, const uint_t count) {
   uint_t size = 1ull << qubits.size();
   cvector_t<double> diag(size);
-  for(int_t i=0;i<size-1;i++)
+  for (int_t i = 0; i < size - 1; i++)
     diag[i] = 1.0;
-  diag[size-1] = phase;
+  diag[size - 1] = phase;
 
   apply_diagonal_matrix(iChunk, qubits, 0, diag, gid, count);
 }
 
 template <typename data_t>
-void cuStateVecChunkContainer<data_t>::apply_swap(const uint_t iChunk,const reg_t& qubits,const int_t control_bits,const uint_t gid, const uint_t count)
-{
+void cuStateVecChunkContainer<data_t>::apply_swap(const uint_t iChunk,
+                                                  const reg_t &qubits,
+                                                  const int_t control_bits,
+                                                  const uint_t gid,
+                                                  const uint_t count) {
   int_t num_qubits = qubits.size();
 
   BaseContainer::set_device();
 
   uint_t perm_size = 1ull << num_qubits;
   std::vector<custatevecIndex_t> swap(perm_size);
-  for(int_t i=0;i<perm_size;i++)
+  for (int_t i = 0; i < perm_size; i++)
     swap[i] = i;
 
-  //set permutation
+  // set permutation
   uint_t ctrl_offset = (1ull << control_bits) - 1;
   uint_t t1_offset = (1ull << (num_qubits - 2)) + ctrl_offset;
   uint_t t2_offset = (1ull << (num_qubits - 1)) + ctrl_offset;
@@ -526,21 +582,20 @@ void cuStateVecChunkContainer<data_t>::apply_swap(const uint_t iChunk,const reg_
   swap[t2_offset] = t1_offset;
 
   std::vector<int32_t> qubits32(qubits.size());
-  for(int_t i=0;i<qubits.size();i++)
+  for (int_t i = 0; i < qubits.size(); i++)
     qubits32[i] = qubits[i];
-  int32_t* pQubits = &qubits32[0];
+  int32_t *pQubits = &qubits32[0];
 
   uint_t bits;
   uint_t nc;
-  if(count == this->num_chunks_){
+  if (count == this->num_chunks_) {
     bits = custatevec_chunk_total_qubits_;
     nc = custatevec_chunk_count_;
-  }
-  else{
+  } else {
     nc = count;
     bits = this->chunk_bits_;
-    if(nc > 1){
-      while((nc & 1) == 0){
+    if (nc > 1) {
+      while ((nc & 1) == 0) {
         nc >>= 1;
         bits++;
       }
@@ -548,53 +603,56 @@ void cuStateVecChunkContainer<data_t>::apply_swap(const uint_t iChunk,const reg_
   }
 
   cudaDataType_t state_type;
-  if(sizeof(data_t) == sizeof(double))
+  if (sizeof(data_t) == sizeof(double))
     state_type = CUDA_C_64F;
   else
     state_type = CUDA_C_32F;
 
   custatevecStatus_t err;
-  for(int_t i=0;i<nc;i++){
-    err = custatevecApplyGeneralizedPermutationMatrix(custatevec_handle_, BaseContainer::chunk_pointer(iChunk) + (i << bits), state_type, bits, 
-                          &swap[0], nullptr, CUDA_C_64F, 0, pQubits, num_qubits, nullptr, nullptr, 0, 
-                          nullptr, 0);
-    if(err != CUSTATEVEC_STATUS_SUCCESS){
+  for (int_t i = 0; i < nc; i++) {
+    err = custatevecApplyGeneralizedPermutationMatrix(
+        custatevec_handle_, BaseContainer::chunk_pointer(iChunk) + (i << bits),
+        state_type, bits, &swap[0], nullptr, CUDA_C_64F, 0, pQubits, num_qubits,
+        nullptr, nullptr, 0, nullptr, 0);
+    if (err != CUSTATEVEC_STATUS_SUCCESS) {
       std::stringstream str;
-      str << "cuStateVecChunkContainer::apply_swap : " << custatevecGetErrorString(err);
+      str << "cuStateVecChunkContainer::apply_swap : "
+          << custatevecGetErrorString(err);
       throw std::runtime_error(str.str());
     }
   }
 }
 
 template <typename data_t>
-void cuStateVecChunkContainer<data_t>::apply_permutation(const uint_t iChunk,const reg_t& qubits,const std::vector<std::pair<uint_t, uint_t>> &pairs, const uint_t gid, const uint_t count)
-{
+void cuStateVecChunkContainer<data_t>::apply_permutation(
+    const uint_t iChunk, const reg_t &qubits,
+    const std::vector<std::pair<uint_t, uint_t>> &pairs, const uint_t gid,
+    const uint_t count) {
   BaseContainer::set_device();
 
   int_t size = 1ull << qubits.size();
   custatevecIndex_t perm[size];
-  for(int_t i=0;i<size;i++)
+  for (int_t i = 0; i < size; i++)
     perm[i] = i;
-  for(int_t i=0;i<pairs.size();i++)
-    std::swap(perm[pairs[i].first],perm[pairs[i].second]);
+  for (int_t i = 0; i < pairs.size(); i++)
+    std::swap(perm[pairs[i].first], perm[pairs[i].second]);
 
   std::vector<int32_t> qubits32(qubits.size());
-  for(int_t i=0;i<qubits.size();i++)
+  for (int_t i = 0; i < qubits.size(); i++)
     qubits32[i] = qubits[i];
 
-  int32_t* pQubits = &qubits32[0];
+  int32_t *pQubits = &qubits32[0];
 
   uint_t bits;
   uint_t nc;
-  if(count == this->num_chunks_){
+  if (count == this->num_chunks_) {
     bits = custatevec_chunk_total_qubits_;
     nc = custatevec_chunk_count_;
-  }
-  else{
+  } else {
     nc = count;
     bits = this->chunk_bits_;
-    if(nc > 1){
-      while((nc & 1) == 0){
+    if (nc > 1) {
+      while ((nc & 1) == 0) {
         nc >>= 1;
         bits++;
       }
@@ -602,27 +660,30 @@ void cuStateVecChunkContainer<data_t>::apply_permutation(const uint_t iChunk,con
   }
 
   cudaDataType_t state_type;
-  if(sizeof(data_t) == sizeof(double))
+  if (sizeof(data_t) == sizeof(double))
     state_type = CUDA_C_64F;
   else
     state_type = CUDA_C_32F;
 
   custatevecStatus_t err;
-  for(int_t i=0;i<nc;i++){
-    err = custatevecApplyGeneralizedPermutationMatrix(custatevec_handle_, BaseContainer::chunk_pointer(iChunk) + (i << bits), state_type, bits, 
-                          perm, nullptr, CUDA_C_64F, 0, pQubits, qubits.size(), nullptr, nullptr, 0, 
-                          nullptr, 0);
-    if(err != CUSTATEVEC_STATUS_SUCCESS){
+  for (int_t i = 0; i < nc; i++) {
+    err = custatevecApplyGeneralizedPermutationMatrix(
+        custatevec_handle_, BaseContainer::chunk_pointer(iChunk) + (i << bits),
+        state_type, bits, perm, nullptr, CUDA_C_64F, 0, pQubits, qubits.size(),
+        nullptr, nullptr, 0, nullptr, 0);
+    if (err != CUSTATEVEC_STATUS_SUCCESS) {
       std::stringstream str;
-      str << "cuStateVecChunkContainer::apply_permutation : " << custatevecGetErrorString(err);
+      str << "cuStateVecChunkContainer::apply_permutation : "
+          << custatevecGetErrorString(err);
       throw std::runtime_error(str.str());
     }
   }
 }
 
 template <typename data_t>
-void cuStateVecChunkContainer<data_t>::apply_rotation(const uint_t iChunk,const reg_t &qubits, const Rotation r, const double theta, const uint_t gid, const uint_t count)
-{
+void cuStateVecChunkContainer<data_t>::apply_rotation(
+    const uint_t iChunk, const reg_t &qubits, const Rotation r,
+    const double theta, const uint_t gid, const uint_t count) {
   custatevecPauli_t pauli[2];
   int nPauli = 1;
 
@@ -630,65 +691,63 @@ void cuStateVecChunkContainer<data_t>::apply_rotation(const uint_t iChunk,const
 
   int control_bits = qubits.size() - 1;
 
-  switch(r){
-    case Rotation::x:
-      pauli[0] = CUSTATEVEC_PAULI_X;
-      break;
-    case Rotation::y:
-      pauli[0] = CUSTATEVEC_PAULI_Y;
-      break;
-    case Rotation::z:
-      pauli[0] = CUSTATEVEC_PAULI_Z;
-      break;
-    case Rotation::xx:
-      pauli[0] = CUSTATEVEC_PAULI_X;
-      pauli[1] = CUSTATEVEC_PAULI_X;
-      nPauli = 2;
-      control_bits--;
-      break;
-    case Rotation::yy:
-      pauli[0] = CUSTATEVEC_PAULI_Y;
-      pauli[1] = CUSTATEVEC_PAULI_Y;
-      nPauli = 2;
-      control_bits--;
-      break;
-    case Rotation::zz:
-      pauli[0] = CUSTATEVEC_PAULI_Z;
-      pauli[1] = CUSTATEVEC_PAULI_Z;
-      nPauli = 2;
-      control_bits--;
-      break;
-    case Rotation::zx:
-      pauli[0] = CUSTATEVEC_PAULI_Z;
-      pauli[1] = CUSTATEVEC_PAULI_X;
-      nPauli = 2;
-      control_bits--;
-      break;
-    default:
-      throw std::invalid_argument(
-          "QubitVectorThrust::invalid rotation axis.");
+  switch (r) {
+  case Rotation::x:
+    pauli[0] = CUSTATEVEC_PAULI_X;
+    break;
+  case Rotation::y:
+    pauli[0] = CUSTATEVEC_PAULI_Y;
+    break;
+  case Rotation::z:
+    pauli[0] = CUSTATEVEC_PAULI_Z;
+    break;
+  case Rotation::xx:
+    pauli[0] = CUSTATEVEC_PAULI_X;
+    pauli[1] = CUSTATEVEC_PAULI_X;
+    nPauli = 2;
+    control_bits--;
+    break;
+  case Rotation::yy:
+    pauli[0] = CUSTATEVEC_PAULI_Y;
+    pauli[1] = CUSTATEVEC_PAULI_Y;
+    nPauli = 2;
+    control_bits--;
+    break;
+  case Rotation::zz:
+    pauli[0] = CUSTATEVEC_PAULI_Z;
+    pauli[1] = CUSTATEVEC_PAULI_Z;
+    nPauli = 2;
+    control_bits--;
+    break;
+  case Rotation::zx:
+    pauli[0] = CUSTATEVEC_PAULI_Z;
+    pauli[1] = CUSTATEVEC_PAULI_X;
+    nPauli = 2;
+    control_bits--;
+    break;
+  default:
+    throw std::invalid_argument("QubitVectorThrust::invalid rotation axis.");
   }
 
   std::vector<int32_t> qubits32(qubits.size());
-  for(int_t i=0;i<qubits.size();i++)
+  for (int_t i = 0; i < qubits.size(); i++)
     qubits32[i] = qubits[i];
 
-  int32_t* pQubits = &qubits32[control_bits];
-  int32_t* pControl = nullptr;
-  if(control_bits > 0)
+  int32_t *pQubits = &qubits32[control_bits];
+  int32_t *pControl = nullptr;
+  if (control_bits > 0)
     pControl = &qubits32[0];
 
   uint_t bits;
   uint_t nc;
-  if(count == this->num_chunks_){
+  if (count == this->num_chunks_) {
     bits = custatevec_chunk_total_qubits_;
     nc = custatevec_chunk_count_;
-  }
-  else{
+  } else {
     nc = count;
     bits = this->chunk_bits_;
-    if(nc > 1){
-      while((nc & 1) == 0){
+    if (nc > 1) {
+      while ((nc & 1) == 0) {
         nc >>= 1;
         bits++;
       }
@@ -696,42 +755,42 @@ void cuStateVecChunkContainer<data_t>::apply_rotation(const uint_t iChunk,const
   }
 
   cudaDataType_t state_type;
-  if(sizeof(data_t) == sizeof(double))
+  if (sizeof(data_t) == sizeof(double))
     state_type = CUDA_C_64F;
   else
     state_type = CUDA_C_32F;
 
   custatevecStatus_t err;
-  for(int_t i=0;i<nc;i++){
-    err = custatevecApplyPauliRotation(custatevec_handle_, BaseContainer::chunk_pointer(iChunk) + (i << bits) , state_type, bits,
-      -0.5*theta, &pauli[0], pQubits, qubits.size() - control_bits, pControl, nullptr, control_bits);
-    if(err != CUSTATEVEC_STATUS_SUCCESS){
+  for (int_t i = 0; i < nc; i++) {
+    err = custatevecApplyPauliRotation(
+        custatevec_handle_, BaseContainer::chunk_pointer(iChunk) + (i << bits),
+        state_type, bits, -0.5 * theta, &pauli[0], pQubits,
+        qubits.size() - control_bits, pControl, nullptr, control_bits);
+    if (err != CUSTATEVEC_STATUS_SUCCESS) {
       std::stringstream str;
-      str << "cuStateVecChunkContainer::apply_rotation : " << custatevecGetErrorString(err);
+      str << "cuStateVecChunkContainer::apply_rotation : "
+          << custatevecGetErrorString(err);
       throw std::runtime_error(str.str());
     }
   }
-  
-
 }
 
 template <typename data_t>
-double cuStateVecChunkContainer<data_t>::norm(uint_t iChunk,uint_t count) const 
-{
+double cuStateVecChunkContainer<data_t>::norm(uint_t iChunk,
+                                              uint_t count) const {
   BaseContainer::set_device();
 
   double ret = 0.0;
   uint_t bits;
   uint_t nc;
-  if(count == this->num_chunks_){
+  if (count == this->num_chunks_) {
     bits = custatevec_chunk_total_qubits_;
     nc = custatevec_chunk_count_;
-  }
-  else{
+  } else {
     nc = count;
     bits = this->chunk_bits_;
-    if(nc > 1){
-      while((nc & 1) == 0){
+    if (nc > 1) {
+      while ((nc & 1) == 0) {
         nc >>= 1;
         bits++;
       }
@@ -739,19 +798,21 @@ double cuStateVecChunkContainer<data_t>::norm(uint_t iChunk,uint_t count) const
   }
 
   cudaDataType_t state_type;
-  if(sizeof(data_t) == sizeof(double))
+  if (sizeof(data_t) == sizeof(double))
     state_type = CUDA_C_64F;
   else
     state_type = CUDA_C_32F;
 
   custatevecStatus_t err;
-  for(int_t i=0;i<nc;i++){
+  for (int_t i = 0; i < nc; i++) {
     double d;
-    err = custatevecAbs2SumArray(custatevec_handle_, BaseContainer::chunk_pointer(iChunk) + (i << bits), state_type, bits, 
-                           &d, nullptr, 0, nullptr,nullptr,0);
-    if(err != CUSTATEVEC_STATUS_SUCCESS){
+    err = custatevecAbs2SumArray(
+        custatevec_handle_, BaseContainer::chunk_pointer(iChunk) + (i << bits),
+        state_type, bits, &d, nullptr, 0, nullptr, nullptr, 0);
+    if (err != CUSTATEVEC_STATUS_SUCCESS) {
       std::stringstream str;
-      str << "cuStateVecChunkContainer::norm : " << custatevecGetErrorString(err);
+      str << "cuStateVecChunkContainer::norm : "
+          << custatevecGetErrorString(err);
       throw std::runtime_error(str.str());
     }
     ret += d;
@@ -761,106 +822,112 @@ double cuStateVecChunkContainer<data_t>::norm(uint_t iChunk,uint_t count) const
 }
 
 template <typename data_t>
-void cuStateVecChunkContainer<data_t>::probabilities(std::vector<double>& probs, const uint_t iChunk, const reg_t& qubits) const
-{
+void cuStateVecChunkContainer<data_t>::probabilities(
+    std::vector<double> &probs, const uint_t iChunk,
+    const reg_t &qubits) const {
   BaseContainer::set_device();
 
   probs.resize(1ull << qubits.size());
-  for(int_t i=0;i<probs.size();i++)
+  for (int_t i = 0; i < probs.size(); i++)
     probs[i] = 0.0;
-  if(iChunk != 0)
+  if (iChunk != 0)
     return;
 
-  //calculate all chunks at once
+  // calculate all chunks at once
   uint_t bits;
   uint_t nc;
   bits = custatevec_chunk_total_qubits_;
   nc = custatevec_chunk_count_;
 
   cudaDataType_t state_type;
-  if(sizeof(data_t) == sizeof(double))
+  if (sizeof(data_t) == sizeof(double))
     state_type = CUDA_C_64F;
   else
     state_type = CUDA_C_32F;
 
   std::vector<int32_t> qubits32(qubits.size());
-  for(int_t i=0;i<qubits.size();i++)
+  for (int_t i = 0; i < qubits.size(); i++)
     qubits32[i] = qubits[i];
 
   custatevecStatus_t err;
-  for(int_t i=0;i<nc;i++){
-    if(qubits.size() == 1){
-      double p0,p1;
-      err = custatevecAbs2SumOnZBasis(custatevec_handle_, BaseContainer::chunk_pointer(iChunk) + (i << bits), state_type, bits, 
-                                &p0, &p1, &qubits32[0], 1);
+  for (int_t i = 0; i < nc; i++) {
+    if (qubits.size() == 1) {
+      double p0, p1;
+      err = custatevecAbs2SumOnZBasis(
+          custatevec_handle_,
+          BaseContainer::chunk_pointer(iChunk) + (i << bits), state_type, bits,
+          &p0, &p1, &qubits32[0], 1);
       probs[0] += p0;
       probs[1] += p1;
-    }
-    else{
+    } else {
       std::vector<double> tmp((1ull << qubits.size()));
-      err = custatevecAbs2SumArray(custatevec_handle_, BaseContainer::chunk_pointer(iChunk) + (i << bits), state_type, bits, 
-                             &tmp[0], &qubits32[0], qubits.size(), nullptr,nullptr,0);
-      for(int_t j=0;j<probs.size();j++)
+      err = custatevecAbs2SumArray(
+          custatevec_handle_,
+          BaseContainer::chunk_pointer(iChunk) + (i << bits), state_type, bits,
+          &tmp[0], &qubits32[0], qubits.size(), nullptr, nullptr, 0);
+      for (int_t j = 0; j < probs.size(); j++)
         probs[j] += tmp[j];
     }
 
-    if(err != CUSTATEVEC_STATUS_SUCCESS){
+    if (err != CUSTATEVEC_STATUS_SUCCESS) {
       std::stringstream str;
-      str << "cuStateVecChunkContainer::probabilities : " << custatevecGetErrorString(err);
+      str << "cuStateVecChunkContainer::probabilities : "
+          << custatevecGetErrorString(err);
       throw std::runtime_error(str.str());
     }
   }
 }
 
 template <typename data_t>
-double cuStateVecChunkContainer<data_t>::expval_pauli(const uint_t iChunk,const reg_t& qubits,const std::string &pauli,const complex_t initial_phase) const
-{
-  if(initial_phase != 1.0){
+double cuStateVecChunkContainer<data_t>::expval_pauli(
+    const uint_t iChunk, const reg_t &qubits, const std::string &pauli,
+    const complex_t initial_phase) const {
+  if (initial_phase != 1.0) {
     return BaseContainer::expval_pauli(iChunk, qubits, pauli, initial_phase);
   }
   BaseContainer::set_device();
 
   cudaDataType_t state_type;
-  if(sizeof(data_t) == sizeof(double))
+  if (sizeof(data_t) == sizeof(double))
     state_type = CUDA_C_64F;
   else
     state_type = CUDA_C_32F;
 
   custatevecPauli_t pauliOps[pauli.size()];
   int32_t qubits32[qubits.size()];
-  for(int_t i=0;i<qubits.size();i++){
+  for (int_t i = 0; i < qubits.size(); i++) {
     qubits32[i] = qubits[i];
-    if(pauli[pauli.size()-1-i] == 'X')
+    if (pauli[pauli.size() - 1 - i] == 'X')
       pauliOps[i] = CUSTATEVEC_PAULI_X;
-    else if(pauli[pauli.size()-1-i] == 'Y')
+    else if (pauli[pauli.size() - 1 - i] == 'Y')
       pauliOps[i] = CUSTATEVEC_PAULI_Y;
-    else if(pauli[pauli.size()-1-i] == 'Z')
+    else if (pauli[pauli.size() - 1 - i] == 'Z')
       pauliOps[i] = CUSTATEVEC_PAULI_Z;
     else
       pauliOps[i] = CUSTATEVEC_PAULI_I;
   }
 
-  const custatevecPauli_t* pauliOperatorsArray[] = {pauliOps};
-  const int32_t *basisBitsArray[] = { qubits32 };
+  const custatevecPauli_t *pauliOperatorsArray[] = {pauliOps};
+  const int32_t *basisBitsArray[] = {qubits32};
   double ret[1];
   const uint32_t nBasisBitsArray[] = {qubits.size()};
 
   custatevecStatus_t err;
   err = custatevecComputeExpectationsOnPauliBasis(
-                             custatevec_handle_, BaseContainer::chunk_pointer(iChunk), state_type, this->chunk_bits_, 
-                             ret, pauliOperatorsArray, 1, basisBitsArray, nBasisBitsArray);
+      custatevec_handle_, BaseContainer::chunk_pointer(iChunk), state_type,
+      this->chunk_bits_, ret, pauliOperatorsArray, 1, basisBitsArray,
+      nBasisBitsArray);
 
-  if(err != CUSTATEVEC_STATUS_SUCCESS){
+  if (err != CUSTATEVEC_STATUS_SUCCESS) {
     std::stringstream str;
-    str << "cuStateVecChunkContainer::expval_pauli : " << custatevecGetErrorString(err);
+    str << "cuStateVecChunkContainer::expval_pauli : "
+        << custatevecGetErrorString(err);
     throw std::runtime_error(str.str());
   }
 
   return ret[0];
 }
 
-
-
 //------------------------------------------------------------------------------
 } // end namespace Chunk
 } // end namespace QV
diff --git a/src/simulators/statevector/chunk/cuda_kernels.hpp b/src/simulators/statevector/chunk/cuda_kernels.hpp
index a508300152..dc7936fcf1 100644
--- a/src/simulators/statevector/chunk/cuda_kernels.hpp
+++ b/src/simulators/statevector/chunk/cuda_kernels.hpp
@@ -12,7 +12,6 @@
  * that they have been altered from the originals.
  */
 
-
 #ifndef _qv_cuda_kernels_hpp_
 #define _qv_cuda_kernels_hpp_
 
@@ -20,30 +19,27 @@ namespace AER {
 namespace QV {
 namespace Chunk {
 
-
-template <typename data_t,typename kernel_t> __global__
-void dev_apply_function(kernel_t func, uint_t count)
-{
+template <typename data_t, typename kernel_t>
+__global__ void dev_apply_function(kernel_t func, uint_t count) {
   uint_t i;
 
   i = blockIdx.x * blockDim.x + threadIdx.x;
-  if(i < count){
-    if(func.check_conditional(i))
+  if (i < count) {
+    if (func.check_conditional(i))
       func(i);
   }
 }
 
-template <typename data_t,typename kernel_t> __global__
-void dev_apply_function_with_cache(kernel_t func, uint_t count)
-{
+template <typename data_t, typename kernel_t>
+__global__ void dev_apply_function_with_cache(kernel_t func, uint_t count) {
   __shared__ thrust::complex<data_t> cache[1024];
-  uint_t i,idx;
+  uint_t i, idx;
 
   i = blockIdx.x * blockDim.x + threadIdx.x;
-  if(i >= count)
+  if (i >= count)
     return;
 
-  if(!func.check_conditional(i))
+  if (!func.check_conditional(i))
     return;
 
   idx = func.thread_to_index(i);
@@ -51,71 +47,71 @@ void dev_apply_function_with_cache(kernel_t func, uint_t count)
   cache[threadIdx.x] = func.data()[idx];
   __syncthreads();
 
-  func.run_with_cache(i,idx,cache);
+  func.run_with_cache(i, idx, cache);
 }
 
-
-template <typename data_t,typename kernel_t> __global__
-void dev_apply_function_sum(double* pReduceBuffer, kernel_t func,uint_t buf_size, uint_t count)
-{
+template <typename data_t, typename kernel_t>
+__global__ void dev_apply_function_sum(double *pReduceBuffer, kernel_t func,
+                                       uint_t buf_size, uint_t count) {
   __shared__ double cache[32];
   double sum;
-  uint_t i,j,iChunk,nw;
+  uint_t i, j, iChunk, nw;
 
-  iChunk = blockIdx.y + blockIdx.z*gridDim.y;
-  i = threadIdx.x + blockIdx.x * blockDim.x + iChunk*gridDim.x*blockDim.x;
-  if(i >= count)
+  iChunk = blockIdx.y + blockIdx.z * gridDim.y;
+  i = threadIdx.x + blockIdx.x * blockDim.x + iChunk * gridDim.x * blockDim.x;
+  if (i >= count)
     return;
 
-  if(!func.check_conditional(i))
+  if (!func.check_conditional(i))
     return;
 
   sum = func(i);
 
-  //reduce in warp
-  nw = min(blockDim.x,warpSize);
-  for(j=1;j<nw;j*=2){
-    sum += __shfl_xor_sync(0xffffffff,sum,j,32);
+  // reduce in warp
+  nw = min(blockDim.x, warpSize);
+  for (j = 1; j < nw; j *= 2) {
+    sum += __shfl_xor_sync(0xffffffff, sum, j, 32);
   }
 
-  if(blockDim.x > warpSize){
-    //reduce in thread block
-    if((threadIdx.x & 31) == 0){
+  if (blockDim.x > warpSize) {
+    // reduce in thread block
+    if ((threadIdx.x & 31) == 0) {
       cache[(threadIdx.x >> 5)] = sum;
     }
     __syncthreads();
-    if(threadIdx.x < 32){
-      if(threadIdx.x < ((blockDim.x+warpSize-1) >> 5))
+    if (threadIdx.x < 32) {
+      if (threadIdx.x < ((blockDim.x + warpSize - 1) >> 5))
         sum = cache[threadIdx.x];
       else
         sum = 0.0;
 
-      //reduce in warp
+      // reduce in warp
       nw = warpSize;
-      for(j=1;j<nw;j*=2){
-        sum += __shfl_xor_sync(0xffffffff,sum,j,32);
+      for (j = 1; j < nw; j *= 2) {
+        sum += __shfl_xor_sync(0xffffffff, sum, j, 32);
       }
     }
   }
-  if(threadIdx.x == 0){
-    pReduceBuffer[blockIdx.x + buf_size*iChunk] = sum;
+  if (threadIdx.x == 0) {
+    pReduceBuffer[blockIdx.x + buf_size * iChunk] = sum;
   }
 }
 
-template <typename data_t,typename kernel_t> __global__
-void dev_apply_function_sum_with_cache(double* pReduceBuffer, kernel_t func,uint_t buf_size, uint_t count)
-{
+template <typename data_t, typename kernel_t>
+__global__ void
+dev_apply_function_sum_with_cache(double *pReduceBuffer, kernel_t func,
+                                  uint_t buf_size, uint_t count) {
   __shared__ thrust::complex<data_t> cache[1024];
-  uint_t i,idx;
-  uint_t j,iChunk,nw;
+  uint_t i, idx;
+  uint_t j, iChunk, nw;
   double sum;
 
-  iChunk = blockIdx.y + blockIdx.z*gridDim.y;
-  i = threadIdx.x + blockIdx.x * blockDim.x + iChunk*gridDim.x*blockDim.x;
-  if(i >= count)
+  iChunk = blockIdx.y + blockIdx.z * gridDim.y;
+  i = threadIdx.x + blockIdx.x * blockDim.x + iChunk * gridDim.x * blockDim.x;
+  if (i >= count)
     return;
 
-  if(!func.check_conditional(i))
+  if (!func.check_conditional(i))
     return;
 
   idx = func.thread_to_index(i);
@@ -123,231 +119,229 @@ void dev_apply_function_sum_with_cache(double* pReduceBuffer, kernel_t func,uint
   cache[threadIdx.x] = func.data()[idx];
   __syncthreads();
 
-  sum = func.run_with_cache_sum(threadIdx.x,idx,cache);
+  sum = func.run_with_cache_sum(threadIdx.x, idx, cache);
 
-  //reduce in warp
-  nw = min(blockDim.x,warpSize);
-  for(j=1;j<nw;j*=2){
-    sum += __shfl_xor_sync(0xffffffff,sum,j,32);
+  // reduce in warp
+  nw = min(blockDim.x, warpSize);
+  for (j = 1; j < nw; j *= 2) {
+    sum += __shfl_xor_sync(0xffffffff, sum, j, 32);
   }
 
-  if(blockDim.x > warpSize){
-    //reduce in thread block
+  if (blockDim.x > warpSize) {
+    // reduce in thread block
     __syncthreads();
-    if((threadIdx.x & 31) == 0){
-      ((double*)cache)[(threadIdx.x >> 5)] = sum;
+    if ((threadIdx.x & 31) == 0) {
+      ((double *)cache)[(threadIdx.x >> 5)] = sum;
     }
     __syncthreads();
-    if(threadIdx.x < 32){
-      if(threadIdx.x < ((blockDim.x+warpSize-1) >> 5))
-        sum = ((double*)cache)[threadIdx.x];
+    if (threadIdx.x < 32) {
+      if (threadIdx.x < ((blockDim.x + warpSize - 1) >> 5))
+        sum = ((double *)cache)[threadIdx.x];
       else
         sum = 0.0;
 
-      //reduce in warp
+      // reduce in warp
       nw = warpSize;
-      for(j=1;j<nw;j*=2){
-        sum += __shfl_xor_sync(0xffffffff,sum,j,32);
+      for (j = 1; j < nw; j *= 2) {
+        sum += __shfl_xor_sync(0xffffffff, sum, j, 32);
       }
     }
   }
-  if(threadIdx.x == 0){
-    pReduceBuffer[blockIdx.x + buf_size*iChunk] = sum;
+  if (threadIdx.x == 0) {
+    pReduceBuffer[blockIdx.x + buf_size * iChunk] = sum;
   }
 }
 
-  
-__global__ void dev_reduce_sum(double *pReduceBuffer,uint_t n,uint_t buf_size)
-{
+__global__ void dev_reduce_sum(double *pReduceBuffer, uint_t n,
+                               uint_t buf_size) {
   __shared__ double cache[32];
   double sum;
-  uint_t i,j,iChunk,nw;
+  uint_t i, j, iChunk, nw;
 
-  iChunk = blockIdx.y + blockIdx.z*gridDim.y;
+  iChunk = blockIdx.y + blockIdx.z * gridDim.y;
   i = threadIdx.x + blockIdx.x * blockDim.x;
 
-  if(i < n)
-    sum = pReduceBuffer[i + buf_size*iChunk];
+  if (i < n)
+    sum = pReduceBuffer[i + buf_size * iChunk];
   else
     sum = 0.0;
 
-  //reduce in warp
-  nw = min(blockDim.x,warpSize);
-  for(j=1;j<nw;j*=2){
-    sum += __shfl_xor_sync(0xffffffff,sum,j,32);
+  // reduce in warp
+  nw = min(blockDim.x, warpSize);
+  for (j = 1; j < nw; j *= 2) {
+    sum += __shfl_xor_sync(0xffffffff, sum, j, 32);
   }
 
-  if(blockDim.x > warpSize){
-    //reduce in thread block
-    if((threadIdx.x & 31) == 0){
+  if (blockDim.x > warpSize) {
+    // reduce in thread block
+    if ((threadIdx.x & 31) == 0) {
       cache[(threadIdx.x >> 5)] = sum;
     }
     __syncthreads();
-    if(threadIdx.x < 32){
-      if(threadIdx.x < ((blockDim.x+warpSize-1) >> 5))
+    if (threadIdx.x < 32) {
+      if (threadIdx.x < ((blockDim.x + warpSize - 1) >> 5))
         sum = cache[threadIdx.x];
       else
         sum = 0.0;
 
-      //reduce in warp
+      // reduce in warp
       nw = warpSize;
-      for(j=1;j<nw;j*=2){
-        sum += __shfl_xor_sync(0xffffffff,sum,j,32);
+      for (j = 1; j < nw; j *= 2) {
+        sum += __shfl_xor_sync(0xffffffff, sum, j, 32);
       }
     }
   }
-  if(threadIdx.x == 0){
-    pReduceBuffer[blockIdx.x + buf_size*iChunk] = sum;
+  if (threadIdx.x == 0) {
+    pReduceBuffer[blockIdx.x + buf_size * iChunk] = sum;
   }
 }
 
-
-template <typename data_t,typename kernel_t> __global__
-void dev_apply_function_sum_complex(thrust::complex<double>* pReduceBuffer, kernel_t func,uint_t buf_size, uint_t count)
-{
+template <typename data_t, typename kernel_t>
+__global__ void
+dev_apply_function_sum_complex(thrust::complex<double> *pReduceBuffer,
+                               kernel_t func, uint_t buf_size, uint_t count) {
   __shared__ thrust::complex<double> cache[32];
   thrust::complex<double> sum;
-  double tr,ti;
-  uint_t i,j,iChunk,nw;
+  double tr, ti;
+  uint_t i, j, iChunk, nw;
 
-  iChunk = blockIdx.y + blockIdx.z*gridDim.y;
-  i = threadIdx.x + blockIdx.x * blockDim.x + iChunk*gridDim.x*blockDim.x;
-  if(i >= count)
+  iChunk = blockIdx.y + blockIdx.z * gridDim.y;
+  i = threadIdx.x + blockIdx.x * blockDim.x + iChunk * gridDim.x * blockDim.x;
+  if (i >= count)
     return;
 
-  if(!func.check_conditional(i))
+  if (!func.check_conditional(i))
     return;
 
   sum = func(i);
 
-  //reduce in warp
-  nw = min(blockDim.x,warpSize);
-  for(j=1;j<nw;j*=2){
-    tr = __shfl_xor_sync(0xffffffff,sum.real(),j,32);
-    ti = __shfl_xor_sync(0xffffffff,sum.imag(),j,32);
-    sum += thrust::complex<double>(tr,ti);
+  // reduce in warp
+  nw = min(blockDim.x, warpSize);
+  for (j = 1; j < nw; j *= 2) {
+    tr = __shfl_xor_sync(0xffffffff, sum.real(), j, 32);
+    ti = __shfl_xor_sync(0xffffffff, sum.imag(), j, 32);
+    sum += thrust::complex<double>(tr, ti);
   }
 
-  if(blockDim.x > warpSize){
-    //reduce in thread block
-    if((threadIdx.x & 31) == 0){
+  if (blockDim.x > warpSize) {
+    // reduce in thread block
+    if ((threadIdx.x & 31) == 0) {
       cache[(threadIdx.x >> 5)] = sum;
     }
     __syncthreads();
-    if(threadIdx.x < warpSize){
-      if(threadIdx.x < ((blockDim.x+warpSize-1) >> 5))
+    if (threadIdx.x < warpSize) {
+      if (threadIdx.x < ((blockDim.x + warpSize - 1) >> 5))
         sum = cache[threadIdx.x];
       else
         sum = 0.0;
 
-      //reduce in warp
+      // reduce in warp
       nw = warpSize;
-      for(j=1;j<nw;j*=2){
-        tr = __shfl_xor_sync(0xffffffff,sum.real(),j,32);
-        ti = __shfl_xor_sync(0xffffffff,sum.imag(),j,32);
-        sum += thrust::complex<double>(tr,ti);
+      for (j = 1; j < nw; j *= 2) {
+        tr = __shfl_xor_sync(0xffffffff, sum.real(), j, 32);
+        ti = __shfl_xor_sync(0xffffffff, sum.imag(), j, 32);
+        sum += thrust::complex<double>(tr, ti);
       }
     }
   }
-  if(threadIdx.x == 0){
-    pReduceBuffer[blockIdx.x + buf_size*iChunk] = sum;
+  if (threadIdx.x == 0) {
+    pReduceBuffer[blockIdx.x + buf_size * iChunk] = sum;
   }
 }
 
-__global__ void dev_reduce_sum_complex(thrust::complex<double> *pReduceBuffer,uint_t n,uint_t buf_size)
-{
+__global__ void dev_reduce_sum_complex(thrust::complex<double> *pReduceBuffer,
+                                       uint_t n, uint_t buf_size) {
   __shared__ thrust::complex<double> cache[32];
   thrust::complex<double> sum;
-  double tr,ti;
-  uint_t i,j,iChunk,nw;
+  double tr, ti;
+  uint_t i, j, iChunk, nw;
 
-  iChunk = blockIdx.y + blockIdx.z*gridDim.y;
+  iChunk = blockIdx.y + blockIdx.z * gridDim.y;
   i = threadIdx.x + blockIdx.x * blockDim.x;
 
-  if(i < n)
-    sum = pReduceBuffer[i + buf_size*iChunk];
+  if (i < n)
+    sum = pReduceBuffer[i + buf_size * iChunk];
   else
     sum = 0.0;
 
-  //reduce in warp
-  nw = min(blockDim.x,warpSize);
-  for(j=1;j<nw;j*=2){
-    tr = __shfl_xor_sync(0xffffffff,sum.real(),j,32);
-    ti = __shfl_xor_sync(0xffffffff,sum.imag(),j,32);
-    sum += thrust::complex<double>(tr,ti);
+  // reduce in warp
+  nw = min(blockDim.x, warpSize);
+  for (j = 1; j < nw; j *= 2) {
+    tr = __shfl_xor_sync(0xffffffff, sum.real(), j, 32);
+    ti = __shfl_xor_sync(0xffffffff, sum.imag(), j, 32);
+    sum += thrust::complex<double>(tr, ti);
   }
 
-  if(blockDim.x > warpSize){
-    //reduce in thread block
-    if((threadIdx.x & 31) == 0){
+  if (blockDim.x > warpSize) {
+    // reduce in thread block
+    if ((threadIdx.x & 31) == 0) {
       cache[(threadIdx.x >> 5)] = sum;
     }
     __syncthreads();
-    if(threadIdx.x < 32){
-      if(threadIdx.x < ((blockDim.x+warpSize-1) >> 5))
+    if (threadIdx.x < 32) {
+      if (threadIdx.x < ((blockDim.x + warpSize - 1) >> 5))
         sum = cache[threadIdx.x];
       else
         sum = 0.0;
 
-      //reduce in warp
+      // reduce in warp
       nw = warpSize;
-      for(j=1;j<nw;j*=2){
-        tr = __shfl_xor_sync(0xffffffff,sum.real(),j,32);
-        ti = __shfl_xor_sync(0xffffffff,sum.imag(),j,32);
-        sum += thrust::complex<double>(tr,ti);
+      for (j = 1; j < nw; j *= 2) {
+        tr = __shfl_xor_sync(0xffffffff, sum.real(), j, 32);
+        ti = __shfl_xor_sync(0xffffffff, sum.imag(), j, 32);
+        sum += thrust::complex<double>(tr, ti);
       }
     }
   }
-  if(threadIdx.x == 0){
-    pReduceBuffer[blockIdx.x + buf_size*iChunk] = sum;
+  if (threadIdx.x == 0) {
+    pReduceBuffer[blockIdx.x + buf_size * iChunk] = sum;
   }
 }
 
-__global__ void dev_reduce_sum_uint(uint_t *pReduceBuffer,uint_t n,uint_t buf_size)
-{
+__global__ void dev_reduce_sum_uint(uint_t *pReduceBuffer, uint_t n,
+                                    uint_t buf_size) {
   __shared__ uint_t cache[32];
   uint_t sum;
-  uint_t i,j,iChunk,nw;
+  uint_t i, j, iChunk, nw;
 
-  iChunk = blockIdx.y + blockIdx.z*gridDim.y;
+  iChunk = blockIdx.y + blockIdx.z * gridDim.y;
   i = threadIdx.x + blockIdx.x * blockDim.x;
 
-  if(i < n)
-    sum = pReduceBuffer[i + buf_size*iChunk];
+  if (i < n)
+    sum = pReduceBuffer[i + buf_size * iChunk];
   else
     sum = 0;
 
-  //reduce in warp
-  nw = min(blockDim.x,warpSize);
-  for(j=1;j<nw;j*=2){
-    sum += __shfl_xor_sync(0xffffffff,sum,j,warpSize);
+  // reduce in warp
+  nw = min(blockDim.x, warpSize);
+  for (j = 1; j < nw; j *= 2) {
+    sum += __shfl_xor_sync(0xffffffff, sum, j, warpSize);
   }
 
-  if(blockDim.x > warpSize){
-    //reduce in thread block
-    if((threadIdx.x & 31) == 0){
+  if (blockDim.x > warpSize) {
+    // reduce in thread block
+    if ((threadIdx.x & 31) == 0) {
       cache[(threadIdx.x >> 5)] = sum;
     }
     __syncthreads();
-    if(threadIdx.x < warpSize){
-      if(threadIdx.x < ((blockDim.x+warpSize-1) >> 5))
+    if (threadIdx.x < warpSize) {
+      if (threadIdx.x < ((blockDim.x + warpSize - 1) >> 5))
         sum = cache[threadIdx.x];
       else
         sum = 0;
 
-      //reduce in warp
+      // reduce in warp
       nw = warpSize;
-      for(j=1;j<nw;j*=2){
-        sum += __shfl_xor_sync(0xffffffff,sum,j,warpSize);
+      for (j = 1; j < nw; j *= 2) {
+        sum += __shfl_xor_sync(0xffffffff, sum, j, warpSize);
       }
     }
   }
-  if(threadIdx.x == 0){
-    pReduceBuffer[blockIdx.x + buf_size*iChunk] = sum;
+  if (threadIdx.x == 0) {
+    pReduceBuffer[blockIdx.x + buf_size * iChunk] = sum;
   }
 }
 
-
 //------------------------------------------------------------------------------
 } // end namespace Chunk
 } // end namespace QV
@@ -356,5 +350,3 @@ __global__ void dev_reduce_sum_uint(uint_t *pReduceBuffer,uint_t n,uint_t buf_si
 
 //------------------------------------------------------------------------------
 #endif // end module
-
-
diff --git a/src/simulators/statevector/chunk/device_chunk_container.hpp b/src/simulators/statevector/chunk/device_chunk_container.hpp
index 0ce0aeb586..8f6c14bdaa 100644
--- a/src/simulators/statevector/chunk/device_chunk_container.hpp
+++ b/src/simulators/statevector/chunk/device_chunk_container.hpp
@@ -12,7 +12,6 @@
  * that they have been altered from the originals.
  */
 
-
 #ifndef _qv_device_chunk_container_hpp_
 #define _qv_device_chunk_container_hpp_
 
@@ -23,47 +22,47 @@ namespace AER {
 namespace QV {
 namespace Chunk {
 
-
 //============================================================================
 // device chunk container class
 //============================================================================
 template <typename data_t>
-class DeviceChunkContainer : public ChunkContainer<data_t>
-{
+class DeviceChunkContainer : public ChunkContainer<data_t> {
 protected:
-  AERDeviceVector<thrust::complex<data_t>>  data_;    //device vector to chunks and buffers
-  AERDeviceVector<thrust::complex<double>>  matrix_;  //storage for large matrix
-  mutable AERDeviceVector<uint_t>           params_;  //storage for additional parameters
-  AERDeviceVector<double>                   reduce_buffer_; //buffer for reduction
-  AERDeviceVector<double>                   probability_buffer_; //buffer used for measure probability
-  AERDeviceVector<uint_t>                   cregs_;
-  AERHostVector<uint_t>                     cregs_host_;
-  int device_id_;                     //device index
-  std::vector<bool> peer_access_;     //to which device accepts peer access 
-  uint_t matrix_buffer_size_;         //matrix buffer size per chunk
-  uint_t params_buffer_size_;         //params buffer size per chunk
-  uint_t num_matrices_;               //number of matrices for chunks (1 shared matrix for multi-chunk execution)
+  AERDeviceVector<thrust::complex<data_t>>
+      data_; // device vector to chunks and buffers
+  AERDeviceVector<thrust::complex<double>> matrix_; // storage for large matrix
+  mutable AERDeviceVector<uint_t> params_; // storage for additional parameters
+  AERDeviceVector<double> reduce_buffer_;  // buffer for reduction
+  AERDeviceVector<double>
+      probability_buffer_; // buffer used for measure probability
+  AERDeviceVector<uint_t> cregs_;
+  AERHostVector<uint_t> cregs_host_;
+  int device_id_;                 // device index
+  std::vector<bool> peer_access_; // to which device accepts peer access
+  uint_t matrix_buffer_size_;     // matrix buffer size per chunk
+  uint_t params_buffer_size_;     // params buffer size per chunk
+  uint_t num_matrices_; // number of matrices for chunks (1 shared matrix for
+                        // multi-chunk execution)
   uint_t reduce_buffer_size_;
 
-  bool multi_shots_;                  //multi-shot parallelization
+  bool multi_shots_; // multi-shot parallelization
 
   bool creg_host_update_;
 
-  //for register blocking
-  thrust::host_vector<uint_t>               blocked_qubits_holder_;
+  // for register blocking
+  thrust::host_vector<uint_t> blocked_qubits_holder_;
   uint_t max_blocked_gates_;
   reg_t num_blocked_gates_;
   reg_t num_blocked_matrix_;
   reg_t num_blocked_qubits_;
 
 #ifdef AER_THRUST_CUDA
-  cudaStream_t stream_;    //asynchronous execution
-  cudaStream_t stream_cache_;    //asynchronous execution
+  cudaStream_t stream_;       // asynchronous execution
+  cudaStream_t stream_cache_; // asynchronous execution
 #endif
 
 public:
-  DeviceChunkContainer()
-  {
+  DeviceChunkContainer() {
     device_id_ = 0;
     matrix_buffer_size_ = 0;
     params_buffer_size_ = 0;
@@ -77,25 +76,15 @@ class DeviceChunkContainer : public ChunkContainer<data_t>
   }
   ~DeviceChunkContainer();
 
-  uint_t size(void)
-  {
-    return data_.size();
-  }
-  int device(void)
-  {
-    return device_id_;
-  }
+  uint_t size(void) { return data_.size(); }
+  int device(void) { return device_id_; }
 
-  AERDeviceVector<thrust::complex<data_t>>& vector(void)
-  {
-    return data_;
-  }
+  AERDeviceVector<thrust::complex<data_t>> &vector(void) { return data_; }
 
-  bool peer_access(int i_dest)
-  {
-    if(i_dest < 0){
+  bool peer_access(int i_dest) {
+    if (i_dest < 0) {
 #ifdef AER_ATS
-      //for IBM AC922
+      // for IBM AC922
       return true;
 #else
       return false;
@@ -104,168 +93,171 @@ class DeviceChunkContainer : public ChunkContainer<data_t>
     return peer_access_[i_dest];
   }
 
-  thrust::complex<data_t>& operator[](uint_t i)
-  {
+  thrust::complex<data_t> &operator[](uint_t i) {
     return raw_reference_cast(data_[i]);
   }
 
-  uint_t Allocate(int idev,int chunk_bits,int num_qubits,uint_t chunks,uint_t buffers,bool multi_shots,int matrix_bit, bool density_matrix) override;
+  uint_t Allocate(int idev, int chunk_bits, int num_qubits, uint_t chunks,
+                  uint_t buffers, bool multi_shots, int matrix_bit,
+                  bool density_matrix) override;
   void Deallocate(void) override;
 
-  void StoreMatrix(const std::vector<std::complex<double>>& mat,uint_t iChunk) override;
-  void StoreMatrix(const std::complex<double>* mat,uint_t iChunk,uint_t size) override;
-  void StoreUintParams(const std::vector<uint_t>& prm,uint_t iChunk) override;
+  void StoreMatrix(const std::vector<std::complex<double>> &mat,
+                   uint_t iChunk) override;
+  void StoreMatrix(const std::complex<double> *mat, uint_t iChunk,
+                   uint_t size) override;
+  void StoreUintParams(const std::vector<uint_t> &prm, uint_t iChunk) override;
   void ResizeMatrixBuffers(int bits) override;
 
-  void set_device(void) const
-  {
+  void set_device(void) const {
 #ifdef AER_THRUST_CUDA
     cudaSetDevice(device_id_);
 #endif
   }
 
 #ifdef AER_THRUST_CUDA
-  cudaStream_t stream(uint_t iChunk) const
-  {
-    if(iChunk >= this->num_chunks_)
+  cudaStream_t stream(uint_t iChunk) const {
+    if (iChunk >= this->num_chunks_)
       return stream_cache_;
     return stream_;
   }
 #endif
 
-  void Set(uint_t i,const thrust::complex<data_t>& t)
-  {
-    data_[i] = t;
-  }
-  thrust::complex<data_t> Get(uint_t i) const
-  {
-    return data_[i];
-  }
-
-  void CopyIn(Chunk<data_t>& src,uint_t iChunk) override;
-  void CopyOut(Chunk<data_t>& src,uint_t iChunk) override;
-  void CopyIn(thrust::complex<data_t>* src,uint_t iChunk, uint_t size) override;
-  void CopyOut(thrust::complex<data_t>* dest,uint_t iChunk, uint_t size) override;
-  void Swap(Chunk<data_t>& src,uint_t iChunk, uint_t dest_offset = 0, uint_t src_offset = 0, uint_t size = 0, bool write_back = true) override;
-
-  void Zero(uint_t iChunk,uint_t count) override;
-
-  reg_t sample_measure(uint_t iChunk,const std::vector<double> &rnds, uint_t stride = 1, bool dot = true,uint_t count = 1) const override;
-
-  thrust::complex<data_t>* chunk_pointer(uint_t iChunk) const
-  {
-    return (thrust::complex<data_t>*)thrust::raw_pointer_cast(data_.data()) + (iChunk << this->chunk_bits_);
-  }
-  thrust::complex<data_t>* buffer_pointer(void) const
-  {
-    return (thrust::complex<data_t>*)thrust::raw_pointer_cast(data_.data()) + (this->num_chunks_ << this->chunk_bits_);
-  }
-
-  thrust::complex<double>* matrix_pointer(uint_t iChunk) const
-  {
-    if(iChunk >= this->num_chunks_){  //for buffer chunks
-      return ((thrust::complex<double>*)thrust::raw_pointer_cast(matrix_.data())) + ((num_matrices_ + iChunk - this->num_chunks_) * matrix_buffer_size_);
-    }
-    else{
-      if(num_matrices_ == 1)
-        return ((thrust::complex<double>*)thrust::raw_pointer_cast(matrix_.data()));
+  void Set(uint_t i, const thrust::complex<data_t> &t) { data_[i] = t; }
+  thrust::complex<data_t> Get(uint_t i) const { return data_[i]; }
+
+  void CopyIn(Chunk<data_t> &src, uint_t iChunk) override;
+  void CopyOut(Chunk<data_t> &src, uint_t iChunk) override;
+  void CopyIn(thrust::complex<data_t> *src, uint_t iChunk,
+              uint_t size) override;
+  void CopyOut(thrust::complex<data_t> *dest, uint_t iChunk,
+               uint_t size) override;
+  void Swap(Chunk<data_t> &src, uint_t iChunk, uint_t dest_offset = 0,
+            uint_t src_offset = 0, uint_t size = 0,
+            bool write_back = true) override;
+
+  void Zero(uint_t iChunk, uint_t count) override;
+
+  reg_t sample_measure(uint_t iChunk, const std::vector<double> &rnds,
+                       uint_t stride = 1, bool dot = true,
+                       uint_t count = 1) const override;
+
+  thrust::complex<data_t> *chunk_pointer(uint_t iChunk) const {
+    return (thrust::complex<data_t> *)thrust::raw_pointer_cast(data_.data()) +
+           (iChunk << this->chunk_bits_);
+  }
+  thrust::complex<data_t> *buffer_pointer(void) const {
+    return (thrust::complex<data_t> *)thrust::raw_pointer_cast(data_.data()) +
+           (this->num_chunks_ << this->chunk_bits_);
+  }
+
+  thrust::complex<double> *matrix_pointer(uint_t iChunk) const {
+    if (iChunk >= this->num_chunks_) { // for buffer chunks
+      return ((thrust::complex<double> *)thrust::raw_pointer_cast(
+                 matrix_.data())) +
+             ((num_matrices_ + iChunk - this->num_chunks_) *
+              matrix_buffer_size_);
+    } else {
+      if (num_matrices_ == 1)
+        return ((thrust::complex<double> *)thrust::raw_pointer_cast(
+            matrix_.data()));
       else
-        return ((thrust::complex<double>*)thrust::raw_pointer_cast(matrix_.data())) + (iChunk * matrix_buffer_size_);
+        return ((thrust::complex<double> *)thrust::raw_pointer_cast(
+                   matrix_.data())) +
+               (iChunk * matrix_buffer_size_);
     }
   }
 
-  uint_t* param_pointer(uint_t iChunk) const
-  {
-    if(iChunk >= this->num_chunks_){  //for buffer chunks
-      return ((uint_t*)thrust::raw_pointer_cast(params_.data())) + ((num_matrices_ + iChunk - this->num_chunks_) * params_buffer_size_);
-    }
-    else{
-      if(num_matrices_ == 1)
-        return ((uint_t*)thrust::raw_pointer_cast(params_.data()));
+  uint_t *param_pointer(uint_t iChunk) const {
+    if (iChunk >= this->num_chunks_) { // for buffer chunks
+      return ((uint_t *)thrust::raw_pointer_cast(params_.data())) +
+             ((num_matrices_ + iChunk - this->num_chunks_) *
+              params_buffer_size_);
+    } else {
+      if (num_matrices_ == 1)
+        return ((uint_t *)thrust::raw_pointer_cast(params_.data()));
       else
-        return ((uint_t*)thrust::raw_pointer_cast(params_.data())) + (iChunk * params_buffer_size_);
+        return ((uint_t *)thrust::raw_pointer_cast(params_.data())) +
+               (iChunk * params_buffer_size_);
     }
   }
 
-  double* reduce_buffer(uint_t iChunk) const
-  {
-    return ((double*)thrust::raw_pointer_cast(reduce_buffer_.data()) + iChunk * reduce_buffer_size_);
+  double *reduce_buffer(uint_t iChunk) const {
+    return ((double *)thrust::raw_pointer_cast(reduce_buffer_.data()) +
+            iChunk * reduce_buffer_size_);
   }
-  uint_t reduce_buffer_size() const
-  {
-    return reduce_buffer_size_;
-  }
-  double* probability_buffer(uint_t iChunk) const
-  {
-    return ((double*)thrust::raw_pointer_cast(probability_buffer_.data()) + iChunk*QV_PROBABILITY_BUFFER_SIZE);
+  uint_t reduce_buffer_size() const { return reduce_buffer_size_; }
+  double *probability_buffer(uint_t iChunk) const {
+    return ((double *)thrust::raw_pointer_cast(probability_buffer_.data()) +
+            iChunk * QV_PROBABILITY_BUFFER_SIZE);
   }
 
-  void copy_to_probability_buffer(std::vector<double>& buf,int pos);
+  void copy_to_probability_buffer(std::vector<double> &buf, int pos);
 
-  void allocate_creg(uint_t num_mem,uint_t num_reg);
-  int measured_cbit(uint_t iChunk,int qubit)
-  {
-    uint_t n64,i64,ibit;
-    if(qubit >= this->num_creg_bits_)
+  void allocate_creg(uint_t num_mem, uint_t num_reg);
+  int measured_cbit(uint_t iChunk, int qubit) {
+    uint_t n64, i64, ibit;
+    if (qubit >= this->num_creg_bits_)
       return -1;
     n64 = (this->num_creg_bits_ + 63) >> 6;
     i64 = qubit >> 6;
     ibit = qubit & 63;
-    if(iChunk == 0 && creg_host_update_){
+    if (iChunk == 0 && creg_host_update_) {
       creg_host_update_ = false;
 #ifdef AER_THRUST_CUDA
-      cudaMemcpyAsync(thrust::raw_pointer_cast(cregs_host_.data()),thrust::raw_pointer_cast(cregs_.data()),sizeof(uint_t)*this->num_chunks_*n64,cudaMemcpyDeviceToHost,stream_);
+      cudaMemcpyAsync(thrust::raw_pointer_cast(cregs_host_.data()),
+                      thrust::raw_pointer_cast(cregs_.data()),
+                      sizeof(uint_t) * this->num_chunks_ * n64,
+                      cudaMemcpyDeviceToHost, stream_);
       cudaStreamSynchronize(stream_);
 #else
-      thrust::copy_n(cregs_.begin(),this->num_chunks_*n64,cregs_host_.begin());
+      thrust::copy_n(cregs_.begin(), this->num_chunks_ * n64,
+                     cregs_host_.begin());
 #endif
     }
 
-    return (cregs_host_[iChunk*n64 + i64] >> ibit) & 1;
+    return (cregs_host_[iChunk * n64 + i64] >> ibit) & 1;
   }
 
-  uint_t* creg_buffer(uint_t iChunk) const
-  {
+  uint_t *creg_buffer(uint_t iChunk) const {
     uint_t n64;
     n64 = (this->num_creg_bits_ + 63) >> 6;
-    return ((uint_t*)thrust::raw_pointer_cast(cregs_.data()) + iChunk*n64);
-  }
-  void request_creg_update(void)
-  {
-    creg_host_update_ = true;
+    return ((uint_t *)thrust::raw_pointer_cast(cregs_.data()) + iChunk * n64);
   }
+  void request_creg_update(void) { creg_host_update_ = true; }
 
-  void synchronize(uint_t iChunk)
-  {
+  void synchronize(uint_t iChunk) {
 #ifdef AER_THRUST_CUDA
     set_device();
-    if(iChunk >= this->num_chunks_)
+    if (iChunk >= this->num_chunks_)
       cudaStreamSynchronize(stream_cache_);
     else
       cudaStreamSynchronize(stream_);
 #endif
   }
 
-  //set qubits to be blocked
-  void set_blocked_qubits(uint_t iChunk,const reg_t& qubits);
+  // set qubits to be blocked
+  void set_blocked_qubits(uint_t iChunk, const reg_t &qubits);
 
-  //do all gates stored in queue
+  // do all gates stored in queue
   void apply_blocked_gates(uint_t iChunk);
 
-  //queue gate for blocked execution
-  void queue_blocked_gate(uint_t iChunk,char gate,uint_t qubit,uint_t mask,const std::complex<double>* pMat = NULL);
-
+  // queue gate for blocked execution
+  void queue_blocked_gate(uint_t iChunk, char gate, uint_t qubit, uint_t mask,
+                          const std::complex<double> *pMat = NULL);
 };
 
 template <typename data_t>
-DeviceChunkContainer<data_t>::~DeviceChunkContainer(void)
-{
+DeviceChunkContainer<data_t>::~DeviceChunkContainer(void) {
   Deallocate();
 }
 
 template <typename data_t>
-uint_t DeviceChunkContainer<data_t>::Allocate(int idev,int chunk_bits,int num_qubits,uint_t chunks,uint_t buffers,bool multi_shots,int matrix_bit, bool density_matrix)
-{
+uint_t DeviceChunkContainer<data_t>::Allocate(int idev, int chunk_bits,
+                                              int num_qubits, uint_t chunks,
+                                              uint_t buffers, bool multi_shots,
+                                              int matrix_bit,
+                                              bool density_matrix) {
   uint_t nc = chunks;
   uint_t i;
   int mat_bits;
@@ -279,25 +271,23 @@ uint_t DeviceChunkContainer<data_t>::Allocate(int idev,int chunk_bits,int num_qu
   set_device();
 
 #ifdef AER_THRUST_CUDA
-  if(!multi_shots){
-    int ip,nd;
+  if (!multi_shots) {
+    int ip, nd;
     cudaGetDeviceCount(&nd);
     peer_access_.resize(nd);
-    for(i=0;i<nd;i++){
+    for (i = 0; i < nd; i++) {
       ip = 1;
-      if(i != device_id_){
-        cudaDeviceCanAccessPeer(&ip,device_id_,i);
+      if (i != device_id_) {
+        cudaDeviceCanAccessPeer(&ip, device_id_, i);
       }
-      if(ip){
-        if(cudaDeviceEnablePeerAccess(i,0) != cudaSuccess)
+      if (ip) {
+        if (cudaDeviceEnablePeerAccess(i, 0) != cudaSuccess)
           cudaGetLastError();
         peer_access_[i] = true;
-      }
-      else
+      } else
         peer_access_[i] = false;
     }
-  }
-  else{
+  } else {
 #endif
     peer_access_.resize(1);
     peer_access_[0] = true;
@@ -307,13 +297,12 @@ uint_t DeviceChunkContainer<data_t>::Allocate(int idev,int chunk_bits,int num_qu
 
   this->num_buffers_ = buffers;
 
-  if(multi_shots){    //mult-shot parallelization for small qubits
+  if (multi_shots) { // mult-shot parallelization for small qubits
     multi_shots_ = true;
     mat_bits = AER_DEFAULT_MATRIX_BITS;
     nc = chunks;
     num_matrices_ = chunks;
-  }
-  else{
+  } else {
     multi_shots_ = false;
 
     mat_bits = AER_DEFAULT_MATRIX_BITS;
@@ -323,13 +312,16 @@ uint_t DeviceChunkContainer<data_t>::Allocate(int idev,int chunk_bits,int num_qu
 
 #ifdef AER_THRUST_CUDA
   uint_t param_size;
-  param_size = (sizeof(thrust::complex<double>) << (matrix_bit*2)) + (sizeof(uint_t) << (matrix_bit+2));
-
-  size_t freeMem,totalMem;
-  cudaMemGetInfo(&freeMem,&totalMem);
-  while(freeMem < ((((nc+buffers)*(uint_t)sizeof(thrust::complex<data_t>)) << chunk_bits) + param_size* (num_matrices_ + buffers)) ){
+  param_size = (sizeof(thrust::complex<double>) << (matrix_bit * 2)) +
+               (sizeof(uint_t) << (matrix_bit + 2));
+
+  size_t freeMem, totalMem;
+  cudaMemGetInfo(&freeMem, &totalMem);
+  while (freeMem < ((((nc + buffers) * (uint_t)sizeof(thrust::complex<data_t>))
+                     << chunk_bits) +
+                    param_size * (num_matrices_ + buffers))) {
     nc--;
-    if(nc == 0){
+    if (nc == 0) {
       break;
     }
   }
@@ -339,16 +331,16 @@ uint_t DeviceChunkContainer<data_t>::Allocate(int idev,int chunk_bits,int num_qu
 
   matrix_buffer_size_ = 0;
   params_buffer_size_ = 0;
-  if(matrix_bit > 0)
+  if (matrix_bit > 0)
     ResizeMatrixBuffers(matrix_bit);
 
   this->num_chunks_ = nc;
-  data_.resize((nc+buffers) << chunk_bits);
+  data_.resize((nc + buffers) << chunk_bits);
 
-  //init number of bits for chunk count
+  // init number of bits for chunk count
   uint_t nc_tmp = this->num_chunks_;
   this->num_pow2_qubits_ = this->chunk_bits_;
-  while((nc_tmp & 1) == 0){
+  while ((nc_tmp & 1) == 0) {
     this->num_pow2_qubits_++;
     nc_tmp >>= 1;
   }
@@ -357,10 +349,9 @@ uint_t DeviceChunkContainer<data_t>::Allocate(int idev,int chunk_bits,int num_qu
   cudaStreamCreateWithFlags(&stream_, cudaStreamNonBlocking);
   cudaStreamCreateWithFlags(&stream_cache_, cudaStreamNonBlocking);
 
-  if(chunk_bits < 10){
+  if (chunk_bits < 10) {
     reduce_buffer_size_ = 1;
-  }
-  else{
+  } else {
     reduce_buffer_size_ = (1ull << (chunk_bits - 10));
   }
 #else
@@ -368,8 +359,8 @@ uint_t DeviceChunkContainer<data_t>::Allocate(int idev,int chunk_bits,int num_qu
 #endif
 
   reduce_buffer_size_ *= 2;
-  reduce_buffer_.resize(reduce_buffer_size_*nc);
-  probability_buffer_.resize(nc*QV_PROBABILITY_BUFFER_SIZE);
+  reduce_buffer_.resize(reduce_buffer_size_ * nc);
+  probability_buffer_.resize(nc * QV_PROBABILITY_BUFFER_SIZE);
 
   creg_host_update_ = false;
   this->num_creg_bits_ = num_qubits;
@@ -378,34 +369,32 @@ uint_t DeviceChunkContainer<data_t>::Allocate(int idev,int chunk_bits,int num_qu
   num_blocked_gates_.resize(size);
   num_blocked_matrix_.resize(size);
   num_blocked_qubits_.resize(size);
-  for(i=0;i<size;i++){
+  for (i = 0; i < size; i++) {
     num_blocked_gates_[i] = 0;
     num_blocked_matrix_[i] = 0;
   }
-  blocked_qubits_holder_.resize(QV_MAX_REGISTERS*size);
+  blocked_qubits_holder_.resize(QV_MAX_REGISTERS * size);
 
-  //allocate chunk classes
+  // allocate chunk classes
   ChunkContainer<data_t>::allocate_chunks();
 
   return nc;
 }
 
 template <typename data_t>
-void DeviceChunkContainer<data_t>::allocate_creg(uint_t num_mem,uint_t num_reg)
-{
-  //allocate memory + register in the same array (reg first)
+void DeviceChunkContainer<data_t>::allocate_creg(uint_t num_mem,
+                                                 uint_t num_reg) {
+  // allocate memory + register in the same array (reg first)
   this->num_creg_bits_ = num_mem + num_reg + QV_NUM_INTERNAL_REGS;
   this->num_cregisters_ = num_reg;
   this->num_cmemory_ = num_mem;
 
   uint_t n64 = (this->num_creg_bits_ + 63) >> 6;
-  cregs_.resize(num_matrices_*n64);
-  cregs_host_.resize(num_matrices_*n64);
+  cregs_.resize(num_matrices_ * n64);
+  cregs_host_.resize(num_matrices_ * n64);
 }
-  
-template <typename data_t>
-void DeviceChunkContainer<data_t>::Deallocate(void)
-{
+
+template <typename data_t> void DeviceChunkContainer<data_t>::Deallocate(void) {
   set_device();
 
   data_.clear();
@@ -430,11 +419,11 @@ void DeviceChunkContainer<data_t>::Deallocate(void)
   blocked_qubits_holder_.clear();
 
 #ifdef AER_THRUST_CUDA
-  if(stream_){
+  if (stream_) {
     cudaStreamDestroy(stream_);
     stream_ = nullptr;
   }
-  if(stream_cache_){
+  if (stream_cache_) {
     cudaStreamDestroy(stream_cache_);
     stream_cache_ = nullptr;
   }
@@ -443,43 +432,40 @@ void DeviceChunkContainer<data_t>::Deallocate(void)
 }
 
 template <typename data_t>
-void DeviceChunkContainer<data_t>::ResizeMatrixBuffers(int bits)
-{
+void DeviceChunkContainer<data_t>::ResizeMatrixBuffers(int bits) {
   uint_t size;
   uint_t n = num_matrices_ + this->num_buffers_;
 
-  if(bits < 0){
+  if (bits < 0) {
     matrix_.resize(n * matrix_buffer_size_);
-  }
-  else{
+  } else {
     this->matrix_bits_ = bits;
-    size = 1ull << (bits*2);
+    size = 1ull << (bits * 2);
 
-    if(max_blocked_gates_*4 > size){
-      size = max_blocked_gates_*4;
+    if (max_blocked_gates_ * 4 > size) {
+      size = max_blocked_gates_ * 4;
     }
-    if(size > matrix_buffer_size_){
+    if (size > matrix_buffer_size_) {
       matrix_buffer_size_ = size;
       matrix_.resize(n * size);
     }
   }
 
-  if(bits < 0){
+  if (bits < 0) {
     params_.resize(n * params_buffer_size_);
-  }
-  else{
-    size = bits*3;
-    uint_t qb = this->num_qubits_*4;
-    if(this->density_matrix_)
+  } else {
+    size = bits * 3;
+    uint_t qb = this->num_qubits_ * 4;
+    if (this->density_matrix_)
       qb /= 2;
-    if(size < qb)
+    if (size < qb)
       size = qb;
-    if(size < 4)
+    if (size < 4)
       size = 4;
-    if(QV_MAX_REGISTERS + max_blocked_gates_*4 > size){
-      size = QV_MAX_REGISTERS + max_blocked_gates_*4;
+    if (QV_MAX_REGISTERS + max_blocked_gates_ * 4 > size) {
+      size = QV_MAX_REGISTERS + max_blocked_gates_ * 4;
     }
-    if(size > params_buffer_size_){
+    if (size > params_buffer_size_) {
       params_buffer_size_ = size;
       params_.resize(n * size);
     }
@@ -487,306 +473,359 @@ void DeviceChunkContainer<data_t>::ResizeMatrixBuffers(int bits)
 }
 
 template <typename data_t>
-void DeviceChunkContainer<data_t>::StoreMatrix(const std::vector<std::complex<double>>& mat,uint_t iChunk)
-{
+void DeviceChunkContainer<data_t>::StoreMatrix(
+    const std::vector<std::complex<double>> &mat, uint_t iChunk) {
   set_device();
 
 #ifdef AER_THRUST_CUDA
-  cudaMemcpyAsync(matrix_pointer(iChunk),&mat[0],mat.size()*sizeof(thrust::complex<double>),cudaMemcpyHostToDevice,stream(iChunk));
+  cudaMemcpyAsync(matrix_pointer(iChunk), &mat[0],
+                  mat.size() * sizeof(thrust::complex<double>),
+                  cudaMemcpyHostToDevice, stream(iChunk));
 
   cudaError_t err = cudaGetLastError();
-  if(err != cudaSuccess){
+  if (err != cudaSuccess) {
     std::stringstream str;
-    str << "ChunkContainer::StoreMatrix size = " << mat.size() << " iChunk = " << iChunk <<" : " << cudaGetErrorName(err);
+    str << "ChunkContainer::StoreMatrix size = " << mat.size()
+        << " iChunk = " << iChunk << " : " << cudaGetErrorName(err);
     throw std::runtime_error(str.str());
   }
 #else
   uint_t offset;
-  if(iChunk >= this->num_chunks_)
+  if (iChunk >= this->num_chunks_)
     offset = (num_matrices_ + iChunk - this->num_chunks_) * matrix_buffer_size_;
-  else{
-    if(num_matrices_ == 1)
+  else {
+    if (num_matrices_ == 1)
       offset = 0;
     else
       offset = iChunk * matrix_buffer_size_;
   }
-  thrust::copy_n(mat.begin(),mat.size(),matrix_.begin() + offset);
+  thrust::copy_n(mat.begin(), mat.size(), matrix_.begin() + offset);
 #endif
 }
 
-
 template <typename data_t>
-void DeviceChunkContainer<data_t>::StoreMatrix(const std::complex<double>* mat,uint_t iChunk,uint_t size)
-{
+void DeviceChunkContainer<data_t>::StoreMatrix(const std::complex<double> *mat,
+                                               uint_t iChunk, uint_t size) {
   set_device();
 
 #ifdef AER_THRUST_CUDA
-  cudaMemcpyAsync(matrix_pointer(iChunk),mat,size*sizeof(thrust::complex<double>),cudaMemcpyHostToDevice,stream(iChunk));
+  cudaMemcpyAsync(matrix_pointer(iChunk), mat,
+                  size * sizeof(thrust::complex<double>),
+                  cudaMemcpyHostToDevice, stream(iChunk));
 
   cudaError_t err = cudaGetLastError();
-  if(err != cudaSuccess){
+  if (err != cudaSuccess) {
     std::stringstream str;
-    str << "ChunkContainer::StoreMatrix size = " << size << " iChunk = " << iChunk << " : " << cudaGetErrorName(err);
+    str << "ChunkContainer::StoreMatrix size = " << size
+        << " iChunk = " << iChunk << " : " << cudaGetErrorName(err);
     throw std::runtime_error(str.str());
   }
 
 #else
   uint_t offset;
-  if(iChunk >= this->num_chunks_)
+  if (iChunk >= this->num_chunks_)
     offset = (num_matrices_ + iChunk - this->num_chunks_) * matrix_buffer_size_;
-  else{
-    if(num_matrices_ == 1)
+  else {
+    if (num_matrices_ == 1)
       offset = 0;
     else
       offset = iChunk * matrix_buffer_size_;
   }
-  thrust::copy_n(mat,mat+size,matrix_.begin() + offset);
+  thrust::copy_n(mat, mat + size, matrix_.begin() + offset);
 #endif
 }
 
 template <typename data_t>
-void DeviceChunkContainer<data_t>::StoreUintParams(const std::vector<uint_t>& prm,uint_t iChunk)
-{
+void DeviceChunkContainer<data_t>::StoreUintParams(
+    const std::vector<uint_t> &prm, uint_t iChunk) {
   set_device();
 
 #ifdef AER_THRUST_CUDA
-  cudaMemcpyAsync(param_pointer(iChunk),&prm[0],prm.size()*sizeof(uint_t),cudaMemcpyHostToDevice,stream(iChunk));
+  cudaMemcpyAsync(param_pointer(iChunk), &prm[0], prm.size() * sizeof(uint_t),
+                  cudaMemcpyHostToDevice, stream(iChunk));
 
   cudaError_t err = cudaGetLastError();
-  if(err != cudaSuccess){
+  if (err != cudaSuccess) {
     std::stringstream str;
-    str << "ChunkContainer::StoreUintParams size = " << prm.size() << "/" << params_.size() <<" iChunk = " << iChunk << " : " << cudaGetErrorName(err);
+    str << "ChunkContainer::StoreUintParams size = " << prm.size() << "/"
+        << params_.size() << " iChunk = " << iChunk << " : "
+        << cudaGetErrorName(err);
     throw std::runtime_error(str.str());
   }
 #else
   uint_t offset;
-  if(iChunk >= this->num_chunks_)
+  if (iChunk >= this->num_chunks_)
     offset = (num_matrices_ + iChunk - this->num_chunks_) * params_buffer_size_;
-  else{
-    if(num_matrices_ == 1)
+  else {
+    if (num_matrices_ == 1)
       offset = 0;
     else
       offset = iChunk * params_buffer_size_;
   }
-  thrust::copy_n(prm.begin(),prm.size(),params_.begin() + offset);
+  thrust::copy_n(prm.begin(), prm.size(), params_.begin() + offset);
 #endif
 }
 
 template <typename data_t>
-void DeviceChunkContainer<data_t>::CopyIn(Chunk<data_t>& src,uint_t iChunk)
-{
+void DeviceChunkContainer<data_t>::CopyIn(Chunk<data_t> &src, uint_t iChunk) {
   uint_t size = 1ull << this->chunk_bits_;
 #ifdef AER_THRUST_CUDA
-  if(src.device() >= 0){
-    if(peer_access(src.device())){
-      cudaMemcpyAsync(chunk_pointer(iChunk),src.pointer(),size*sizeof(thrust::complex<data_t>),cudaMemcpyDeviceToDevice,stream_);
+  if (src.device() >= 0) {
+    if (peer_access(src.device())) {
+      cudaMemcpyAsync(chunk_pointer(iChunk), src.pointer(),
+                      size * sizeof(thrust::complex<data_t>),
+                      cudaMemcpyDeviceToDevice, stream_);
+    } else {
+      cudaMemcpyPeerAsync(chunk_pointer(iChunk), device_id_, src.pointer(),
+                          src.device(), size, stream_);
     }
-    else{
-      cudaMemcpyPeerAsync(chunk_pointer(iChunk),device_id_,src.pointer(),src.device(),size,stream_);
-    }
-  }
-  else{
-    cudaMemcpyAsync(chunk_pointer(iChunk),src.pointer(),size*sizeof(thrust::complex<data_t>),cudaMemcpyHostToDevice,stream(iChunk));
+  } else {
+    cudaMemcpyAsync(chunk_pointer(iChunk), src.pointer(),
+                    size * sizeof(thrust::complex<data_t>),
+                    cudaMemcpyHostToDevice, stream(iChunk));
   }
   cudaError_t err = cudaGetLastError();
-  if(err != cudaSuccess){
+  if (err != cudaSuccess) {
     std::stringstream str;
     str << "DeviceChunkContainer::CopyIn : " << cudaGetErrorName(err);
     throw std::runtime_error(str.str());
   }
 
 #else
-  thrust::copy_n(src.pointer(),size,data_.begin() + (iChunk << this->chunk_bits_));
+  thrust::copy_n(src.pointer(), size,
+                 data_.begin() + (iChunk << this->chunk_bits_));
 #endif
 }
 
 template <typename data_t>
-void DeviceChunkContainer<data_t>::CopyOut(Chunk<data_t>& dest,uint_t iChunk)
-{
+void DeviceChunkContainer<data_t>::CopyOut(Chunk<data_t> &dest, uint_t iChunk) {
   uint_t size = 1ull << this->chunk_bits_;
 
 #ifdef AER_THRUST_CUDA
-  if(dest.device() >= 0){
-    if(peer_access(dest.device())){
-      cudaMemcpyAsync(dest.pointer(),chunk_pointer(iChunk),size*sizeof(thrust::complex<data_t>),cudaMemcpyDeviceToDevice,stream_);
+  if (dest.device() >= 0) {
+    if (peer_access(dest.device())) {
+      cudaMemcpyAsync(dest.pointer(), chunk_pointer(iChunk),
+                      size * sizeof(thrust::complex<data_t>),
+                      cudaMemcpyDeviceToDevice, stream_);
+    } else {
+      cudaMemcpyPeerAsync(dest.pointer(), dest.device(), chunk_pointer(iChunk),
+                          device_id_, size, stream_);
     }
-    else{
-      cudaMemcpyPeerAsync(dest.pointer(),dest.device(),chunk_pointer(iChunk),device_id_,size,stream_);
-    }
-  }
-  else{
-    cudaMemcpyAsync(dest.pointer(),chunk_pointer(iChunk),size*sizeof(thrust::complex<data_t>),cudaMemcpyDeviceToHost,stream(iChunk));
+  } else {
+    cudaMemcpyAsync(dest.pointer(), chunk_pointer(iChunk),
+                    size * sizeof(thrust::complex<data_t>),
+                    cudaMemcpyDeviceToHost, stream(iChunk));
   }
   cudaError_t err = cudaGetLastError();
-  if(err != cudaSuccess){
+  if (err != cudaSuccess) {
     std::stringstream str;
-    str << "DeviceChunkContainer::CopyOut " << dest.pointer() << "," <<chunk_pointer(iChunk) <<" size = " << size <<" : "<< cudaGetErrorName(err);
+    str << "DeviceChunkContainer::CopyOut " << dest.pointer() << ","
+        << chunk_pointer(iChunk) << " size = " << size << " : "
+        << cudaGetErrorName(err);
     throw std::runtime_error(str.str());
   }
 
 #else
-  thrust::copy_n(data_.begin() + (iChunk << this->chunk_bits_),size,dest.pointer());
+  thrust::copy_n(data_.begin() + (iChunk << this->chunk_bits_), size,
+                 dest.pointer());
 #endif
 }
 
 template <typename data_t>
-void DeviceChunkContainer<data_t>::CopyIn(thrust::complex<data_t>* src,uint_t iChunk, uint_t size)
-{
+void DeviceChunkContainer<data_t>::CopyIn(thrust::complex<data_t> *src,
+                                          uint_t iChunk, uint_t size) {
   uint_t this_size = 1ull << this->chunk_bits_;
-  if(this_size < size) throw std::runtime_error("CopyIn chunk size is less than provided size");
+  if (this_size < size)
+    throw std::runtime_error("CopyIn chunk size is less than provided size");
 
   synchronize(iChunk);
-  thrust::copy_n(src,size,data_.begin() + (iChunk << this->chunk_bits_));
+  thrust::copy_n(src, size, data_.begin() + (iChunk << this->chunk_bits_));
 }
 
 template <typename data_t>
-void DeviceChunkContainer<data_t>::CopyOut(thrust::complex<data_t>* dest,uint_t iChunk, uint_t size)
-{
+void DeviceChunkContainer<data_t>::CopyOut(thrust::complex<data_t> *dest,
+                                           uint_t iChunk, uint_t size) {
   uint_t this_size = 1ull << this->chunk_bits_;
-  if(this_size < size) throw std::runtime_error("CopyOut chunk size is less than provided size");
+  if (this_size < size)
+    throw std::runtime_error("CopyOut chunk size is less than provided size");
 
   synchronize(iChunk);
-  thrust::copy_n(data_.begin() + (iChunk << this->chunk_bits_),size,dest);
+  thrust::copy_n(data_.begin() + (iChunk << this->chunk_bits_), size, dest);
 }
 
 template <typename data_t>
-void DeviceChunkContainer<data_t>::Swap(Chunk<data_t>& src,uint_t iChunk, uint_t dest_offset, uint_t src_offset, uint_t size_in, bool write_back)
-{
+void DeviceChunkContainer<data_t>::Swap(Chunk<data_t> &src, uint_t iChunk,
+                                        uint_t dest_offset, uint_t src_offset,
+                                        uint_t size_in, bool write_back) {
   uint_t size = size_in;
-  if(size == 0)
+  if (size == 0)
     size = 1ull << this->chunk_bits_;
 
   set_device();
 #ifdef AER_THRUST_CUDA
-  if(src.device() >= 0){
-    if(peer_access(src.device())){
-      this->Execute(BufferSwap_func<data_t>(chunk_pointer(iChunk) + dest_offset,src.pointer() + src_offset, size, write_back), iChunk, 0, 1);
+  if (src.device() >= 0) {
+    if (peer_access(src.device())) {
+      this->Execute(BufferSwap_func<data_t>(chunk_pointer(iChunk) + dest_offset,
+                                            src.pointer() + src_offset, size,
+                                            write_back),
+                    iChunk, 0, 1);
+    } else {
+      thrust::complex<data_t> *pBuffer = buffer_pointer();
+      thrust::complex<data_t> *pSrc = src.pointer();
+      cudaMemcpyPeerAsync(pBuffer + dest_offset, device_id_, pSrc + src_offset,
+                          src.device(), size * sizeof(thrust::complex<data_t>),
+                          stream_);
+      this->Execute(BufferSwap_func<data_t>(chunk_pointer(iChunk) + dest_offset,
+                                            pBuffer + dest_offset, size, true),
+                    iChunk, 0, 1);
+      cudaMemcpyPeerAsync(pSrc + src_offset, src.device(),
+                          pBuffer + dest_offset, device_id_,
+                          size * sizeof(thrust::complex<data_t>), stream_);
     }
-    else{
-      thrust::complex<data_t>* pBuffer = buffer_pointer();
-      thrust::complex<data_t>* pSrc = src.pointer();
-      cudaMemcpyPeerAsync(pBuffer + dest_offset,device_id_,pSrc + src_offset,src.device(),size*sizeof(thrust::complex<data_t>),stream_);
-      this->Execute(BufferSwap_func<data_t>(chunk_pointer(iChunk) + dest_offset,pBuffer + dest_offset, size, true), iChunk, 0, 1);
-      cudaMemcpyPeerAsync(pSrc + src_offset,src.device(),pBuffer + dest_offset,device_id_,size*sizeof(thrust::complex<data_t>),stream_);
-    }
-  }
-  else{
-    thrust::complex<data_t>* pBuffer = buffer_pointer();
-    thrust::complex<data_t>* pSrc = src.pointer();
-    cudaMemcpyAsync(pBuffer + dest_offset,pSrc + src_offset,size*sizeof(thrust::complex<data_t>),cudaMemcpyHostToDevice,stream_cache_);
-    this->Execute(BufferSwap_func<data_t>(chunk_pointer(iChunk) + dest_offset,pBuffer + dest_offset, size, true), iChunk, 0, 1);
-    cudaMemcpyAsync(pSrc + src_offset,pBuffer + dest_offset,size*sizeof(thrust::complex<data_t>),cudaMemcpyDeviceToHost,stream_cache_);
+  } else {
+    thrust::complex<data_t> *pBuffer = buffer_pointer();
+    thrust::complex<data_t> *pSrc = src.pointer();
+    cudaMemcpyAsync(pBuffer + dest_offset, pSrc + src_offset,
+                    size * sizeof(thrust::complex<data_t>),
+                    cudaMemcpyHostToDevice, stream_cache_);
+    this->Execute(BufferSwap_func<data_t>(chunk_pointer(iChunk) + dest_offset,
+                                          pBuffer + dest_offset, size, true),
+                  iChunk, 0, 1);
+    cudaMemcpyAsync(pSrc + src_offset, pBuffer + dest_offset,
+                    size * sizeof(thrust::complex<data_t>),
+                    cudaMemcpyDeviceToHost, stream_cache_);
   }
   cudaError_t err = cudaGetLastError();
-  if(err != cudaSuccess){
+  if (err != cudaSuccess) {
     std::stringstream str;
     str << "DeviceChunkContainer::Swap : " << cudaGetErrorName(err);
     throw std::runtime_error(str.str());
   }
 
 #else
-  thrust::swap_ranges(thrust::device,chunk_pointer(iChunk)+dest_offset,chunk_pointer(iChunk) + dest_offset + size,src.pointer() + src_offset);
+  thrust::swap_ranges(thrust::device, chunk_pointer(iChunk) + dest_offset,
+                      chunk_pointer(iChunk) + dest_offset + size,
+                      src.pointer() + src_offset);
 #endif
 }
 
-
-
 template <typename data_t>
-void DeviceChunkContainer<data_t>::Zero(uint_t iChunk,uint_t count)
-{
+void DeviceChunkContainer<data_t>::Zero(uint_t iChunk, uint_t count) {
   set_device();
 #ifdef AER_THRUST_CUDA
-  thrust::fill_n(thrust::cuda::par.on(stream_),data_.begin() + (iChunk << this->chunk_bits_),count,0.0);
+  thrust::fill_n(thrust::cuda::par.on(stream_),
+                 data_.begin() + (iChunk << this->chunk_bits_), count, 0.0);
 #else
-  if(this->omp_threads_ > 1)
-    thrust::fill_n(thrust::device,data_.begin() + (iChunk << this->chunk_bits_),count,0.0);
+  if (this->omp_threads_ > 1)
+    thrust::fill_n(thrust::device,
+                   data_.begin() + (iChunk << this->chunk_bits_), count, 0.0);
   else
-    thrust::fill_n(thrust::seq,data_.begin() + (iChunk << this->chunk_bits_),count,0.0);
+    thrust::fill_n(thrust::seq, data_.begin() + (iChunk << this->chunk_bits_),
+                   count, 0.0);
 #endif
 }
 
-
 template <typename data_t>
-reg_t DeviceChunkContainer<data_t>::sample_measure(uint_t iChunk,const std::vector<double> &rnds, uint_t stride, bool dot,uint_t count) const
-{
+reg_t DeviceChunkContainer<data_t>::sample_measure(
+    uint_t iChunk, const std::vector<double> &rnds, uint_t stride, bool dot,
+    uint_t count) const {
   const int_t SHOTS = rnds.size();
-  reg_t samples(SHOTS,0);
+  reg_t samples(SHOTS, 0);
 
   set_device();
 
-  strided_range<thrust::complex<data_t>*> iter(chunk_pointer(iChunk), chunk_pointer(iChunk+count), stride);
+  strided_range<thrust::complex<data_t> *> iter(
+      chunk_pointer(iChunk), chunk_pointer(iChunk + count), stride);
 
 #ifdef AER_THRUST_CUDA
 
-  if(dot)
-    thrust::transform_inclusive_scan(thrust::cuda::par.on(stream_),iter.begin(),iter.end(),iter.begin(),complex_dot_scan<data_t>(),thrust::plus<thrust::complex<data_t>>());
+  if (dot)
+    thrust::transform_inclusive_scan(
+        thrust::cuda::par.on(stream_), iter.begin(), iter.end(), iter.begin(),
+        complex_dot_scan<data_t>(), thrust::plus<thrust::complex<data_t>>());
   else
-    thrust::inclusive_scan(thrust::cuda::par.on(stream_),iter.begin(),iter.end(),iter.begin(),thrust::plus<thrust::complex<data_t>>());
+    thrust::inclusive_scan(thrust::cuda::par.on(stream_), iter.begin(),
+                           iter.end(), iter.begin(),
+                           thrust::plus<thrust::complex<data_t>>());
 
   uint_t iBuf = 0;
-  if(multi_shots_)
+  if (multi_shots_)
     iBuf = iChunk;
 
-  double* pRnd = (double*)matrix_pointer(iBuf);
-  uint_t* pSmp = param_pointer(iBuf);
+  double *pRnd = (double *)matrix_pointer(iBuf);
+  uint_t *pSmp = param_pointer(iBuf);
   thrust::device_ptr<double> rnd_dev_ptr = thrust::device_pointer_cast(pRnd);
-  uint_t i,nshots,size = matrix_.size()*2;
-  if(size > params_.size())
+  uint_t i, nshots, size = matrix_.size() * 2;
+  if (size > params_.size())
     size = params_.size();
 
-  for(i=0;i<SHOTS;i+=size){
+  for (i = 0; i < SHOTS; i += size) {
     nshots = size;
-    if(i + nshots > SHOTS)
+    if (i + nshots > SHOTS)
       nshots = SHOTS - i;
 
-    cudaMemcpyAsync(pRnd,&rnds[i],nshots*sizeof(double),cudaMemcpyHostToDevice,stream_);
+    cudaMemcpyAsync(pRnd, &rnds[i], nshots * sizeof(double),
+                    cudaMemcpyHostToDevice, stream_);
 
-    thrust::lower_bound(thrust::cuda::par.on(stream_), iter.begin(), iter.end(), rnd_dev_ptr, rnd_dev_ptr + nshots, params_.begin() + (iBuf * params_buffer_size_),complex_less<data_t>());
+    thrust::lower_bound(thrust::cuda::par.on(stream_), iter.begin(), iter.end(),
+                        rnd_dev_ptr, rnd_dev_ptr + nshots,
+                        params_.begin() + (iBuf * params_buffer_size_),
+                        complex_less<data_t>());
 
-    cudaMemcpyAsync(&samples[i],pSmp,nshots*sizeof(uint_t),cudaMemcpyDeviceToHost,stream_);
+    cudaMemcpyAsync(&samples[i], pSmp, nshots * sizeof(uint_t),
+                    cudaMemcpyDeviceToHost, stream_);
   }
   cudaStreamSynchronize(stream_);
 
 #else
-  if(this->omp_threads_ > 1){
-    if(dot)
-      thrust::transform_inclusive_scan(thrust::device,iter.begin(),iter.end(),iter.begin(),complex_dot_scan<data_t>(),thrust::plus<thrust::complex<data_t>>());
+  if (this->omp_threads_ > 1) {
+    if (dot)
+      thrust::transform_inclusive_scan(thrust::device, iter.begin(), iter.end(),
+                                       iter.begin(), complex_dot_scan<data_t>(),
+                                       thrust::plus<thrust::complex<data_t>>());
     else
-      thrust::inclusive_scan(thrust::device,iter.begin(),iter.end(),iter.begin(),thrust::plus<thrust::complex<data_t>>());
-
-    thrust::lower_bound(thrust::device, iter.begin(), iter.end(), rnds.begin(), rnds.begin() + SHOTS, samples.begin() ,complex_less<data_t>());
-  }
-  else{
-    if(dot)
-      thrust::transform_inclusive_scan(thrust::seq,iter.begin(),iter.end(),iter.begin(),complex_dot_scan<data_t>(),thrust::plus<thrust::complex<data_t>>());
+      thrust::inclusive_scan(thrust::device, iter.begin(), iter.end(),
+                             iter.begin(),
+                             thrust::plus<thrust::complex<data_t>>());
+
+    thrust::lower_bound(thrust::device, iter.begin(), iter.end(), rnds.begin(),
+                        rnds.begin() + SHOTS, samples.begin(),
+                        complex_less<data_t>());
+  } else {
+    if (dot)
+      thrust::transform_inclusive_scan(thrust::seq, iter.begin(), iter.end(),
+                                       iter.begin(), complex_dot_scan<data_t>(),
+                                       thrust::plus<thrust::complex<data_t>>());
     else
-      thrust::inclusive_scan(thrust::seq,iter.begin(),iter.end(),iter.begin(),thrust::plus<thrust::complex<data_t>>());
+      thrust::inclusive_scan(thrust::seq, iter.begin(), iter.end(),
+                             iter.begin(),
+                             thrust::plus<thrust::complex<data_t>>());
 
-    thrust::lower_bound(thrust::seq, iter.begin(), iter.end(), rnds.begin(), rnds.begin() + SHOTS, samples.begin() ,complex_less<data_t>());
+    thrust::lower_bound(thrust::seq, iter.begin(), iter.end(), rnds.begin(),
+                        rnds.begin() + SHOTS, samples.begin(),
+                        complex_less<data_t>());
   }
 #endif
 
   return samples;
 }
 
-
-//set qubits to be blocked
+// set qubits to be blocked
 template <typename data_t>
-void DeviceChunkContainer<data_t>::set_blocked_qubits(uint_t iChunk,const reg_t& qubits)
-{
-  if(num_matrices_ == 1 && iChunk > 1 && iChunk < this->num_chunks_){
-    //only the first chunk can store (multi-chunk mode)
+void DeviceChunkContainer<data_t>::set_blocked_qubits(uint_t iChunk,
+                                                      const reg_t &qubits) {
+  if (num_matrices_ == 1 && iChunk > 1 && iChunk < this->num_chunks_) {
+    // only the first chunk can store (multi-chunk mode)
     return;
   }
   uint_t iBlock;
-  if(iChunk >= this->num_chunks_){  //for buffer chunks
+  if (iChunk >= this->num_chunks_) { // for buffer chunks
     iBlock = num_matrices_ + iChunk - this->num_chunks_;
-  }
-  else{
+  } else {
     iBlock = iChunk;
   }
 
-  if(num_blocked_gates_[iBlock] > 0){
+  if (num_blocked_gates_[iBlock] > 0) {
     apply_blocked_gates(iChunk);
   }
 
@@ -794,14 +833,14 @@ void DeviceChunkContainer<data_t>::set_blocked_qubits(uint_t iChunk,const reg_t&
   std::sort(qubits_sorted.begin(), qubits_sorted.end());
 
   int i;
-  for(i=0;i<qubits.size();i++){
-    blocked_qubits_holder_[iBlock*QV_MAX_REGISTERS + i] = qubits_sorted[i];
+  for (i = 0; i < qubits.size(); i++) {
+    blocked_qubits_holder_[iBlock * QV_MAX_REGISTERS + i] = qubits_sorted[i];
   }
 #ifdef AER_THRUST_CUDA
   set_device();
-  cudaMemcpyAsync(param_pointer(iChunk),
-                  (uint_t*)&qubits_sorted[0],
-                  qubits.size()*sizeof(uint_t),cudaMemcpyHostToDevice,stream_);
+  cudaMemcpyAsync(param_pointer(iChunk), (uint_t *)&qubits_sorted[0],
+                  qubits.size() * sizeof(uint_t), cudaMemcpyHostToDevice,
+                  stream_);
 #endif
 
   num_blocked_gates_[iBlock] = 0;
@@ -810,16 +849,14 @@ void DeviceChunkContainer<data_t>::set_blocked_qubits(uint_t iChunk,const reg_t&
 }
 
 template <typename data_t>
-class GeneralMatrixMult2x2 : public GateFuncBase<data_t>
-{
+class GeneralMatrixMult2x2 : public GateFuncBase<data_t> {
 protected:
-  thrust::complex<double> m0_,m1_,m2_,m3_;
+  thrust::complex<double> m0_, m1_, m2_, m3_;
   uint_t mask_;
   uint_t offset_;
 
 public:
-  GeneralMatrixMult2x2(const cvector_t<double>& mat,int q,uint_t mask)
-  {
+  GeneralMatrixMult2x2(const cvector_t<double> &mat, int q, uint_t mask) {
     m0_ = mat[0];
     m1_ = mat[1];
     m2_ = mat[2];
@@ -830,11 +867,10 @@ class GeneralMatrixMult2x2 : public GateFuncBase<data_t>
     offset_ = 1ull << q;
   }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    uint_t i0,i1;
-    thrust::complex<data_t> q0,q1;
-    thrust::complex<data_t>* vec;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    uint_t i0, i1;
+    thrust::complex<data_t> q0, q1;
+    thrust::complex<data_t> *vec;
 
     vec = this->data_;
 
@@ -846,38 +882,34 @@ class GeneralMatrixMult2x2 : public GateFuncBase<data_t>
     q0 = vec[i0];
     q1 = vec[i1];
 
-    if((i0 & mask_) == mask_)
+    if ((i0 & mask_) == mask_)
       vec[i0] = m0_ * q0 + m2_ * q1;
-    if((i1 & mask_) == mask_)
+    if ((i1 & mask_) == mask_)
       vec[i1] = m1_ * q0 + m3_ * q1;
   }
-  const char* name(void)
-  {
-    return "general_mult2x2";
-  }
+  const char *name(void) { return "general_mult2x2"; }
 };
 
-
-//queue gate for blocked execution
+// queue gate for blocked execution
 template <typename data_t>
-void DeviceChunkContainer<data_t>::queue_blocked_gate(uint_t iChunk,char gate,uint_t qubit,uint_t mask,const std::complex<double>* pMat)
-{
-  if(num_matrices_ == 1 && iChunk > 1 && iChunk < this->num_chunks_){
-    //only the first chunk can store (multi-chunk mode)
+void DeviceChunkContainer<data_t>::queue_blocked_gate(
+    uint_t iChunk, char gate, uint_t qubit, uint_t mask,
+    const std::complex<double> *pMat) {
+  if (num_matrices_ == 1 && iChunk > 1 && iChunk < this->num_chunks_) {
+    // only the first chunk can store (multi-chunk mode)
     return;
   }
 
-  cvector_t<double> mat(4,0.0);
+  cvector_t<double> mat(4, 0.0);
   int i;
-  uint_t idx,idxParam,iBlock;
-  if(iChunk >= this->num_chunks_){  //for buffer chunks
+  uint_t idx, idxParam, iBlock;
+  if (iChunk >= this->num_chunks_) { // for buffer chunks
     iBlock = num_matrices_ + iChunk - this->num_chunks_;
-  }
-  else{
+  } else {
     iBlock = iChunk;
   }
 
-  if(num_blocked_gates_[iBlock] >= max_blocked_gates_){
+  if (num_blocked_gates_[iBlock] >= max_blocked_gates_) {
     apply_blocked_gates(iChunk);
   }
 
@@ -887,72 +919,75 @@ void DeviceChunkContainer<data_t>::queue_blocked_gate(uint_t iChunk,char gate,ui
   params.mask_ = mask;
   params.gate_ = gate;
   params.qubit_ = 0;
-  for(i=0;i<num_blocked_qubits_[iBlock];i++){
-    if(blocked_qubits_holder_[iBlock*QV_MAX_REGISTERS + i] == qubit){
+  for (i = 0; i < num_blocked_qubits_[iBlock]; i++) {
+    if (blocked_qubits_holder_[iBlock * QV_MAX_REGISTERS + i] == qubit) {
       params.qubit_ = i;
       break;
     }
   }
   set_device();
-  cudaMemcpyAsync((BlockedGateParams*)(param_pointer(iChunk) + num_blocked_qubits_[iBlock]) + num_blocked_gates_[iBlock],
-                  &params,
-                  sizeof(BlockedGateParams),cudaMemcpyHostToDevice,stream_);
-
-  if(pMat != NULL){
-    if(gate == 'd'){  //diagonal matrix
+  cudaMemcpyAsync((BlockedGateParams *)(param_pointer(iChunk) +
+                                        num_blocked_qubits_[iBlock]) +
+                      num_blocked_gates_[iBlock],
+                  &params, sizeof(BlockedGateParams), cudaMemcpyHostToDevice,
+                  stream_);
+
+  if (pMat != NULL) {
+    if (gate == 'd') { // diagonal matrix
       mat[0] = pMat[0];
       mat[1] = pMat[1];
       cudaMemcpyAsync(matrix_pointer(iChunk) + num_blocked_matrix_[iBlock],
-                      (thrust::complex<double>*)&mat[0],
-                      2*sizeof(thrust::complex<double>),cudaMemcpyHostToDevice,stream_);
+                      (thrust::complex<double> *)&mat[0],
+                      2 * sizeof(thrust::complex<double>),
+                      cudaMemcpyHostToDevice, stream_);
       num_blocked_matrix_[iBlock] += 2;
-    }
-    else if(gate == 'p'){ //phase
-      mat[0]   = pMat[0];
+    } else if (gate == 'p') { // phase
+      mat[0] = pMat[0];
       cudaMemcpyAsync(matrix_pointer(iChunk) + num_blocked_matrix_[iBlock],
-                      (thrust::complex<double>*)&mat[0],
-                      1*sizeof(thrust::complex<double>),cudaMemcpyHostToDevice,stream_);
+                      (thrust::complex<double> *)&mat[0],
+                      1 * sizeof(thrust::complex<double>),
+                      cudaMemcpyHostToDevice, stream_);
       num_blocked_matrix_[iBlock] += 1;
-    }
-    else{ //otherwise, 2x2 matrix
+    } else { // otherwise, 2x2 matrix
       mat[0] = pMat[0];
       mat[1] = pMat[2];
       mat[2] = pMat[3];
       mat[3] = pMat[1];
       cudaMemcpyAsync(matrix_pointer(iChunk) + num_blocked_matrix_[iBlock],
-                      (thrust::complex<double>*)&mat[0],
-                      4*sizeof(thrust::complex<double>),cudaMemcpyHostToDevice,stream_);
+                      (thrust::complex<double> *)&mat[0],
+                      4 * sizeof(thrust::complex<double>),
+                      cudaMemcpyHostToDevice, stream_);
       num_blocked_matrix_[iBlock] += 4;
     }
   }
   num_blocked_gates_[iBlock]++;
 
 #else
-  //for statevector_cpu, apply now
+  // for statevector_cpu, apply now
 
-  switch(gate){
+  switch (gate) {
   case 'x':
     mat[1] = 1.0;
     mat[2] = 1.0;
     break;
   case 'y':
-    mat[1] = std::complex<double>(0.0,-1.0);
-    mat[2] = std::complex<double>(0.0,1.0);
+    mat[1] = std::complex<double>(0.0, -1.0);
+    mat[2] = std::complex<double>(0.0, 1.0);
     break;
   case 'p':
-    if(pMat){
+    if (pMat) {
       mat[0] = pMat[0];
       mat[3] = pMat[0];
     }
     break;
   case 'd':
-    if(pMat){
+    if (pMat) {
       mat[0] = pMat[0];
       mat[3] = pMat[1];
     }
     break;
   default:
-    if(pMat){
+    if (pMat) {
       mat[0] = pMat[0];
       mat[1] = pMat[1];
       mat[2] = pMat[2];
@@ -961,40 +996,43 @@ void DeviceChunkContainer<data_t>::queue_blocked_gate(uint_t iChunk,char gate,ui
     break;
   }
   uint_t count = 1;
-  if(num_matrices_ == 1)
+  if (num_matrices_ == 1)
     count = this->chunk_bits_;
-  this->Execute(GeneralMatrixMult2x2<data_t>(mat,qubit,mask),iChunk,0,count);
+  this->Execute(GeneralMatrixMult2x2<data_t>(mat, qubit, mask), iChunk, 0,
+                count);
 
 #endif
-
 }
 
 #ifdef AER_THRUST_CUDA
 
-template <typename data_t> __global__
-void dev_apply_register_blocked_gates(thrust::complex<data_t>* data,int num_gates,int num_qubits,int num_matrix,uint_t* qubits,BlockedGateParams* params,thrust::complex<double>* matrix)
-{
-  uint_t i,idx,ii,t,offset;
-  uint_t j,laneID,iPair;
-  thrust::complex<data_t> q,qp,qt;
-  thrust::complex<double> m0,m1;
-  data_t qr,qi;
+template <typename data_t>
+__global__ void
+dev_apply_register_blocked_gates(thrust::complex<data_t> *data, int num_gates,
+                                 int num_qubits, int num_matrix, uint_t *qubits,
+                                 BlockedGateParams *params,
+                                 thrust::complex<double> *matrix) {
+  uint_t i, idx, ii, t, offset;
+  uint_t j, laneID, iPair;
+  thrust::complex<data_t> q, qp, qt;
+  thrust::complex<double> m0, m1;
+  data_t qr, qi;
   int nElem;
-  thrust::complex<double>* matrix_load;
+  thrust::complex<double> *matrix_load;
 
   i = blockIdx.x * blockDim.x + threadIdx.x;
   laneID = i & 31;
 
-  //index for this thread
+  // index for this thread
   idx = 0;
   ii = i >> num_qubits;
-  for(j=0;j<num_qubits;j++){
+  for (j = 0; j < num_qubits; j++) {
     offset = (1ull << qubits[j]);
     t = ii & (offset - 1);
     idx += t;
     ii = (ii - t) << 1;
 
-    if(((laneID >> j) & 1) != 0){
+    if (((laneID >> j) & 1) != 0) {
       idx += offset;
     }
   }
@@ -1002,27 +1040,27 @@ void dev_apply_register_blocked_gates(thrust::complex<data_t>* data,int num_gate
 
   q = data[idx];
 
-  //prefetch
-  if(threadIdx.x < num_matrix)
+  // prefetch
+  if (threadIdx.x < num_matrix)
     m0 = matrix[threadIdx.x];
 
-  for(j=0;j<num_gates;j++){
+  for (j = 0; j < num_gates; j++) {
     iPair = laneID ^ (1ull << params[j].qubit_);
 
     matrix_load = matrix;
     nElem = 0;
 
-    switch(params[j].gate_){
+    switch (params[j].gate_) {
     case 'x':
       m0 = 0.0;
       m1 = 1.0;
       break;
     case 'y':
       m0 = 0.0;
-      if(iPair > laneID)
-        m1 = thrust::complex<double>(0.0,-1.0);
+      if (iPair > laneID)
+        m1 = thrust::complex<double>(0.0, -1.0);
       else
-        m1 = thrust::complex<double>(0.0,1.0);
+        m1 = thrust::complex<double>(0.0, 1.0);
       break;
     case 'p':
       nElem = 1;
@@ -1040,21 +1078,21 @@ void dev_apply_register_blocked_gates(thrust::complex<data_t>* data,int num_gate
       break;
     }
 
-    if(iPair < laneID){
+    if (iPair < laneID) {
       matrix_load += (nElem >> 1);
     }
-    if(nElem > 0)
+    if (nElem > 0)
       m0 = *(matrix_load);
-    if(nElem > 2)
+    if (nElem > 2)
       m1 = *(matrix_load + 1);
 
-    //warp shuffle to get pair amplitude
-    qr = __shfl_sync(0xffffffff,q.real(),iPair,32);
-    qi = __shfl_sync(0xffffffff,q.imag(),iPair,32);
-    qp = thrust::complex<data_t>(qr,qi);
-    qt = m0*q + m1* qp;
+    // warp shuffle to get pair amplitude
+    qr = __shfl_sync(0xffffffff, q.real(), iPair, 32);
+    qi = __shfl_sync(0xffffffff, q.imag(), iPair, 32);
+    qp = thrust::complex<data_t>(qr, qi);
+    qt = m0 * q + m1 * qp;
 
-    if((idx & params[j].mask_) == params[j].mask_){   //handling control bits
+    if ((idx & params[j].mask_) == params[j].mask_) { // handling control bits
       q = qt;
     }
   }
@@ -1062,33 +1100,35 @@ void dev_apply_register_blocked_gates(thrust::complex<data_t>* data,int num_gate
   data[idx] = q;
 }
 
-
-template <typename data_t> __global__
-void dev_apply_shared_memory_blocked_gates(thrust::complex<data_t>* data,int num_gates,int num_qubits,uint_t* qubits,BlockedGateParams* params,thrust::complex<double>* matrix)
-{
+template <typename data_t>
+__global__ void
+dev_apply_shared_memory_blocked_gates(thrust::complex<data_t> *data,
+                                      int num_gates, int num_qubits,
+                                      uint_t *qubits, BlockedGateParams *params,
+                                      thrust::complex<double> *matrix) {
   __shared__ thrust::complex<data_t> buf[1024];
-  uint_t i,idx,ii,t,offset;
-  uint_t j,laneID,iPair;
-  thrust::complex<data_t> q,qp;
-  thrust::complex<double> m0,m1;
-  data_t qr,qi;
+  uint_t i, idx, ii, t, offset;
+  uint_t j, laneID, iPair;
+  thrust::complex<data_t> q, qp;
+  thrust::complex<double> m0, m1;
+  data_t qr, qi;
   int nElem;
-  thrust::complex<double>* matrix_load;
+  thrust::complex<double> *matrix_load;
 
   i = blockIdx.x * blockDim.x + threadIdx.x;
 
   laneID = threadIdx.x;
 
-  //index for this thread
+  // index for this thread
   idx = 0;
   ii = i >> num_qubits;
-  for(j=0;j<num_qubits;j++){
+  for (j = 0; j < num_qubits; j++) {
     offset = (1ull << qubits[j]);
     t = ii & (offset - 1);
     idx += t;
     ii = (ii - t) << 1;
 
-    if(((laneID >> j) & 1) != 0){
+    if (((laneID >> j) & 1) != 0) {
       idx += offset;
     }
   }
@@ -1096,18 +1136,17 @@ void dev_apply_shared_memory_blocked_gates(thrust::complex<data_t>* data,int num
 
   q = data[idx];
 
-  for(j=0;j<num_gates;j++){
+  for (j = 0; j < num_gates; j++) {
     iPair = laneID ^ (1ull << params[j].qubit_);
 
-    if(params[j].qubit_ < 5){
-      //warp shuffle to get pair amplitude
+    if (params[j].qubit_ < 5) {
+      // warp shuffle to get pair amplitude
       qr = q.real();
       qi = q.imag();
-      qr = __shfl_sync(0xffffffff,qr,iPair & 31,32);
-      qi = __shfl_sync(0xffffffff,qi,iPair & 31,32);
-      qp = thrust::complex<data_t>(qr,qi);
-    }
-    else{
+      qr = __shfl_sync(0xffffffff, qr, iPair & 31, 32);
+      qi = __shfl_sync(0xffffffff, qi, iPair & 31, 32);
+      qp = thrust::complex<data_t>(qr, qi);
+    } else {
       __syncthreads();
       buf[laneID] = q;
       __syncthreads();
@@ -1117,17 +1156,17 @@ void dev_apply_shared_memory_blocked_gates(thrust::complex<data_t>* data,int num
     matrix_load = matrix;
     nElem = 0;
 
-    switch(params[j].gate_){
+    switch (params[j].gate_) {
     case 'x':
       m0 = 0.0;
       m1 = 1.0;
       break;
     case 'y':
       m0 = 0.0;
-      if(iPair > laneID)
-        m1 = thrust::complex<double>(0.0,-1.0);
+      if (iPair > laneID)
+        m1 = thrust::complex<double>(0.0, -1.0);
       else
-        m1 = thrust::complex<double>(0.0,1.0);
+        m1 = thrust::complex<double>(0.0, 1.0);
       break;
     case 'p':
       nElem = 1;
@@ -1145,16 +1184,16 @@ void dev_apply_shared_memory_blocked_gates(thrust::complex<data_t>* data,int num
       break;
     }
 
-    if(iPair < laneID){
+    if (iPair < laneID) {
       matrix_load += (nElem >> 1);
     }
-    if(nElem > 0)
+    if (nElem > 0)
       m0 = *(matrix_load);
-    if(nElem > 2)
+    if (nElem > 2)
       m1 = *(matrix_load + 1);
 
-    if((idx & params[j].mask_) == params[j].mask_){   //handling control bits
-      q = m0*q + m1* qp;
+    if ((idx & params[j].mask_) == params[j].mask_) { // handling control bits
+      q = m0 * q + m1 * qp;
     }
   }
 
@@ -1163,90 +1202,84 @@ void dev_apply_shared_memory_blocked_gates(thrust::complex<data_t>* data,int num
 
 #endif
 
-//do all gates stored in queue
+// do all gates stored in queue
 template <typename data_t>
-void DeviceChunkContainer<data_t>::apply_blocked_gates(uint_t iChunk)
-{
-  if(num_matrices_ == 1 && iChunk > 1 && iChunk < this->num_chunks_){
-    //only the first chunk can apply
+void DeviceChunkContainer<data_t>::apply_blocked_gates(uint_t iChunk) {
+  if (num_matrices_ == 1 && iChunk > 1 && iChunk < this->num_chunks_) {
+    // only the first chunk can apply
     return;
   }
   uint_t iBlock;
-  if(iChunk >= this->num_chunks_){  //for buffer chunks
+  if (iChunk >= this->num_chunks_) { // for buffer chunks
     iBlock = num_matrices_ + iChunk - this->num_chunks_;
-  }
-  else{
+  } else {
     iBlock = iChunk;
   }
 
-  if(num_blocked_gates_[iBlock] == 0)
+  if (num_blocked_gates_[iBlock] == 0)
     return;
 
 #ifdef AER_THRUST_CUDA
 
   uint_t size;
-  uint_t* pQubits;
-  BlockedGateParams* pParams;
-  thrust::complex<double>* pMatrix;
+  uint_t *pQubits;
+  BlockedGateParams *pParams;
+  thrust::complex<double> *pMatrix;
 
   set_device();
 
   pQubits = param_pointer(iChunk);
-  pParams = (BlockedGateParams*)(param_pointer(iChunk) + num_blocked_qubits_[iBlock]);
+  pParams = (BlockedGateParams *)(param_pointer(iChunk) +
+                                  num_blocked_qubits_[iBlock]);
   pMatrix = matrix_pointer(iChunk);
 
-  if(num_matrices_ == 1){
+  if (num_matrices_ == 1) {
     size = this->num_chunks_ << this->chunk_bits_;
-  }
-  else{
+  } else {
     size = 1ull << this->chunk_bits_;
   }
-  uint_t nt,nb;
+  uint_t nt, nb;
   nt = size;
   nb = 1;
-  if(nt > 1024){
+  if (nt > 1024) {
     nb = (nt + 1024 - 1) / 1024;
     nt = 1024;
   }
 
-  if(num_blocked_qubits_[iBlock] < 6){
-    //using register blocking (<=5 qubits)
-    dev_apply_register_blocked_gates<data_t><<<nb,nt,num_blocked_matrix_[iChunk]*sizeof(thrust::complex<double>),stream_>>>(
-                                                                          chunk_pointer(iChunk),
-                                                                          num_blocked_gates_[iBlock],
-                                                                          num_blocked_qubits_[iBlock],
-                                                                          num_blocked_matrix_[iBlock],
-                                                                          pQubits,pParams,pMatrix);
-  }
-  else{
-    //using shared memory blocking (<=10 qubits)
-    dev_apply_shared_memory_blocked_gates<data_t><<<nb,nt,1024*sizeof(thrust::complex<data_t>),stream_>>>(
-                                                                          chunk_pointer(iChunk),
-                                                                          num_blocked_gates_[iBlock],
-                                                                          num_blocked_qubits_[iBlock],
-                                                                          pQubits,pParams,pMatrix);
+  if (num_blocked_qubits_[iBlock] < 6) {
+    // using register blocking (<=5 qubits)
+    dev_apply_register_blocked_gates<data_t>
+        <<<nb, nt,
+           num_blocked_matrix_[iChunk] * sizeof(thrust::complex<double>),
+           stream_>>>(chunk_pointer(iChunk), num_blocked_gates_[iBlock],
+                      num_blocked_qubits_[iBlock], num_blocked_matrix_[iBlock],
+                      pQubits, pParams, pMatrix);
+  } else {
+    // using shared memory blocking (<=10 qubits)
+    dev_apply_shared_memory_blocked_gates<data_t>
+        <<<nb, nt, 1024 * sizeof(thrust::complex<data_t>), stream_>>>(
+            chunk_pointer(iChunk), num_blocked_gates_[iBlock],
+            num_blocked_qubits_[iBlock], pQubits, pParams, pMatrix);
   }
 
 #endif
 
   num_blocked_gates_[iBlock] = 0;
   num_blocked_matrix_[iBlock] = 0;
-
 }
 
 template <typename data_t>
-void DeviceChunkContainer<data_t>::copy_to_probability_buffer(std::vector<double>& buf,int pos)
-{
+void DeviceChunkContainer<data_t>::copy_to_probability_buffer(
+    std::vector<double> &buf, int pos) {
 #ifdef AER_THRUST_CUDA
   set_device();
-  cudaMemcpyAsync(probability_buffer(0) + pos*this->num_chunks_,&buf[0],buf.size()*sizeof(double),cudaMemcpyHostToDevice,stream_);
+  cudaMemcpyAsync(probability_buffer(0) + pos * this->num_chunks_, &buf[0],
+                  buf.size() * sizeof(double), cudaMemcpyHostToDevice, stream_);
 #else
-  thrust::copy_n(buf.begin(),buf.size(),probability_buffer_.begin());
+  thrust::copy_n(buf.begin(), buf.size(), probability_buffer_.begin());
 #endif
-
 }
 
-
 //------------------------------------------------------------------------------
 } // end namespace Chunk
 } // end namespace QV
diff --git a/src/simulators/statevector/chunk/host_chunk_container.hpp b/src/simulators/statevector/chunk/host_chunk_container.hpp
index eb22a7c038..4dd864d0c2 100644
--- a/src/simulators/statevector/chunk/host_chunk_container.hpp
+++ b/src/simulators/statevector/chunk/host_chunk_container.hpp
@@ -12,124 +12,113 @@
  * that they have been altered from the originals.
  */
 
-
 #ifndef _qv_host_chunk_container_hpp_
 #define _qv_host_chunk_container_hpp_
 
 #include "simulators/statevector/chunk/chunk_container.hpp"
 
-
 namespace AER {
 namespace QV {
 namespace Chunk {
 
-
 //============================================================================
 // host chunk container class
 //============================================================================
 template <typename data_t>
-class HostChunkContainer : public ChunkContainer<data_t>
-{
+class HostChunkContainer : public ChunkContainer<data_t> {
 protected:
-  AERHostVector<thrust::complex<data_t>>  data_;     //host vector for chunks + buffers
-  std::vector<thrust::complex<double>*> matrix_;     //pointer to matrix
-  std::vector<uint_t*> params_;                      //pointer to additional parameters
+  AERHostVector<thrust::complex<data_t>>
+      data_; // host vector for chunks + buffers
+  std::vector<thrust::complex<double> *> matrix_; // pointer to matrix
+  std::vector<uint_t *> params_; // pointer to additional parameters
 public:
-  HostChunkContainer(){}
+  HostChunkContainer() {}
   ~HostChunkContainer();
 
-  uint_t size(void)
-  {
-    return data_.size();
-  }
+  uint_t size(void) { return data_.size(); }
 
-  AERHostVector<thrust::complex<data_t>>& vector(void)
-  {
-    return data_;
-  }
+  AERHostVector<thrust::complex<data_t>> &vector(void) { return data_; }
 
-  thrust::complex<data_t>& operator[](uint_t i)
-  {
-    return data_[i];
-  }
+  thrust::complex<data_t> &operator[](uint_t i) { return data_[i]; }
 
-  uint_t Allocate(int idev,int chunk_bits,int num_qubits,uint_t chunks,uint_t buffers,bool multi_shots,int matrix_bit, bool density_matrix) override;
+  uint_t Allocate(int idev, int chunk_bits, int num_qubits, uint_t chunks,
+                  uint_t buffers, bool multi_shots, int matrix_bit,
+                  bool density_matrix) override;
   void Deallocate(void) override;
 
-  void StoreMatrix(const std::vector<std::complex<double>>& mat,uint_t iChunk) override
-  {
-    matrix_[iChunk] = (thrust::complex<double>*)&mat[0];
+  void StoreMatrix(const std::vector<std::complex<double>> &mat,
+                   uint_t iChunk) override {
+    matrix_[iChunk] = (thrust::complex<double> *)&mat[0];
   }
-  void StoreMatrix(const std::complex<double>* mat,uint_t iChunk,uint_t size) override
-  {
-    matrix_[iChunk] = (thrust::complex<double>*)mat;
+  void StoreMatrix(const std::complex<double> *mat, uint_t iChunk,
+                   uint_t size) override {
+    matrix_[iChunk] = (thrust::complex<double> *)mat;
   }
 
-  void StoreUintParams(const std::vector<uint_t>& prm,uint_t iChunk) override
-  {
-    params_[iChunk] = (uint_t*)&prm[0];
+  void StoreUintParams(const std::vector<uint_t> &prm, uint_t iChunk) override {
+    params_[iChunk] = (uint_t *)&prm[0];
   }
-  void ResizeMatrixBuffers(int bits){}
+  void ResizeMatrixBuffers(int bits) {}
 
-  void Set(uint_t i,const thrust::complex<data_t>& t) override
-  {
+  void Set(uint_t i, const thrust::complex<data_t> &t) override {
     data_[i] = t;
   }
-  thrust::complex<data_t> Get(uint_t i) const override
-  {
-    return data_[i];
-  }
+  thrust::complex<data_t> Get(uint_t i) const override { return data_[i]; }
 
-  thrust::complex<data_t>* chunk_pointer(uint_t iChunk) const override
-  {
-    return (thrust::complex<data_t>*)thrust::raw_pointer_cast(data_.data()) + (iChunk << this->chunk_bits_);
+  thrust::complex<data_t> *chunk_pointer(uint_t iChunk) const override {
+    return (thrust::complex<data_t> *)thrust::raw_pointer_cast(data_.data()) +
+           (iChunk << this->chunk_bits_);
   }
-  thrust::complex<data_t>* buffer_pointer(void) const
-  {
-    return (thrust::complex<data_t>*)thrust::raw_pointer_cast(data_.data()) + (this->num_chunks_ << this->chunk_bits_);
+  thrust::complex<data_t> *buffer_pointer(void) const {
+    return (thrust::complex<data_t> *)thrust::raw_pointer_cast(data_.data()) +
+           (this->num_chunks_ << this->chunk_bits_);
   }
 
-  thrust::complex<double>* matrix_pointer(uint_t iChunk) const override
-  {
+  thrust::complex<double> *matrix_pointer(uint_t iChunk) const override {
     return matrix_[iChunk];
   }
 
-  uint_t* param_pointer(uint_t iChunk) const override
-  {
+  uint_t *param_pointer(uint_t iChunk) const override {
     return params_[iChunk];
   }
 
-  bool peer_access(int i_dest)
-  {
+  bool peer_access(int i_dest) {
 #ifdef AER_ATS
-    //for IBM AC922
+    // for IBM AC922
     return true;
 #else
     return false;
 #endif
   }
 
-  void CopyIn(Chunk<data_t>& src,uint_t iChunk) override;
-  void CopyOut(Chunk<data_t>& src,uint_t iChunk) override;
-  void CopyIn(thrust::complex<data_t>* src,uint_t iChunk, uint_t size) override;
-  void CopyOut(thrust::complex<data_t>* dest,uint_t iChunk, uint_t size) override;
-  void Swap(Chunk<data_t>& src,uint_t iChunk, uint_t dest_offset = 0, uint_t src_offset = 0, uint_t size = 0, bool write_back = true) override;
-
-  void Zero(uint_t iChunk,uint_t count) override;
-
-  reg_t sample_measure(uint_t iChunk,const std::vector<double> &rnds, uint_t stride = 1, bool dot = true,uint_t count = 1) const override;
-
+  void CopyIn(Chunk<data_t> &src, uint_t iChunk) override;
+  void CopyOut(Chunk<data_t> &src, uint_t iChunk) override;
+  void CopyIn(thrust::complex<data_t> *src, uint_t iChunk,
+              uint_t size) override;
+  void CopyOut(thrust::complex<data_t> *dest, uint_t iChunk,
+               uint_t size) override;
+  void Swap(Chunk<data_t> &src, uint_t iChunk, uint_t dest_offset = 0,
+            uint_t src_offset = 0, uint_t size = 0,
+            bool write_back = true) override;
+
+  void Zero(uint_t iChunk, uint_t count) override;
+
+  reg_t sample_measure(uint_t iChunk, const std::vector<double> &rnds,
+                       uint_t stride = 1, bool dot = true,
+                       uint_t count = 1) const override;
 };
 
 template <typename data_t>
-HostChunkContainer<data_t>::~HostChunkContainer(void)
-{
+HostChunkContainer<data_t>::~HostChunkContainer(void) {
   Deallocate();
 }
 
 template <typename data_t>
-uint_t HostChunkContainer<data_t>::Allocate(int idev,int chunk_bits,int num_qubits,uint_t chunks,uint_t buffers,bool multi_shots,int matrix_bit, bool density_matrix)
-{
+uint_t HostChunkContainer<data_t>::Allocate(int idev, int chunk_bits,
+                                            int num_qubits, uint_t chunks,
+                                            uint_t buffers, bool multi_shots,
+                                            int matrix_bit,
+                                            bool density_matrix) {
   uint_t nc = chunks;
   uint_t i;
 
@@ -139,24 +128,21 @@ uint_t HostChunkContainer<data_t>::Allocate(int idev,int chunk_bits,int num_qubi
 
   ChunkContainer<data_t>::num_buffers_ = buffers;
   ChunkContainer<data_t>::num_chunks_ = nc;
-  if(nc + buffers > 0)
+  if (nc + buffers > 0)
     data_.resize((nc + buffers) << chunk_bits);
-  if(nc + buffers > 0){
+  if (nc + buffers > 0) {
     matrix_.resize(nc + buffers);
     params_.resize(nc + buffers);
   }
 
-  //allocate chunk classes
-  if(nc + buffers > 0)
+  // allocate chunk classes
+  if (nc + buffers > 0)
     ChunkContainer<data_t>::allocate_chunks();
 
   return nc;
 }
 
-
-template <typename data_t>
-void HostChunkContainer<data_t>::Deallocate(void)
-{
+template <typename data_t> void HostChunkContainer<data_t>::Deallocate(void) {
   data_.clear();
   data_.shrink_to_fit();
   matrix_.clear();
@@ -167,99 +153,123 @@ void HostChunkContainer<data_t>::Deallocate(void)
   ChunkContainer<data_t>::deallocate_chunks();
 }
 
-
 template <typename data_t>
-void HostChunkContainer<data_t>::CopyIn(Chunk<data_t>& src,uint_t iChunk)
-{
+void HostChunkContainer<data_t>::CopyIn(Chunk<data_t> &src, uint_t iChunk) {
   uint_t size = 1ull << this->chunk_bits_;
 
-  if(src.device() >= 0){
+  if (src.device() >= 0) {
     src.set_device();
-    auto src_cont = std::static_pointer_cast<DeviceChunkContainer<data_t>>(src.container());
-    thrust::copy_n(src_cont->vector().begin() + (src.pos() << this->chunk_bits_),size,data_.begin() + (iChunk << this->chunk_bits_));
-  }
-  else{
-    auto src_cont = std::static_pointer_cast<HostChunkContainer<data_t>>(src.container());
-
-    thrust::copy_n(src_cont->vector().begin() + (src.pos() << this->chunk_bits_),size,data_.begin() + (iChunk << this->chunk_bits_));
+    auto src_cont =
+        std::static_pointer_cast<DeviceChunkContainer<data_t>>(src.container());
+    thrust::copy_n(src_cont->vector().begin() +
+                       (src.pos() << this->chunk_bits_),
+                   size, data_.begin() + (iChunk << this->chunk_bits_));
+  } else {
+    auto src_cont =
+        std::static_pointer_cast<HostChunkContainer<data_t>>(src.container());
+
+    thrust::copy_n(src_cont->vector().begin() +
+                       (src.pos() << this->chunk_bits_),
+                   size, data_.begin() + (iChunk << this->chunk_bits_));
   }
 }
 
 template <typename data_t>
-void HostChunkContainer<data_t>::CopyOut(Chunk<data_t>& dest,uint_t iChunk)
-{
+void HostChunkContainer<data_t>::CopyOut(Chunk<data_t> &dest, uint_t iChunk) {
   uint_t size = 1ull << this->chunk_bits_;
-  if(dest.device() >= 0){
+  if (dest.device() >= 0) {
     dest.set_device();
-    auto dest_cont = std::static_pointer_cast<DeviceChunkContainer<data_t>>(dest.container());
-    thrust::copy_n(data_.begin() + (iChunk << this->chunk_bits_),size,dest_cont->vector().begin() + (dest.pos() << this->chunk_bits_));
-  }
-  else{
-    auto dest_cont = std::static_pointer_cast<HostChunkContainer<data_t>>(dest.container());
-
-    thrust::copy_n(data_.begin() + (iChunk << this->chunk_bits_),size,dest_cont->vector().begin() + (dest.pos() << this->chunk_bits_));
+    auto dest_cont = std::static_pointer_cast<DeviceChunkContainer<data_t>>(
+        dest.container());
+    thrust::copy_n(data_.begin() + (iChunk << this->chunk_bits_), size,
+                   dest_cont->vector().begin() +
+                       (dest.pos() << this->chunk_bits_));
+  } else {
+    auto dest_cont =
+        std::static_pointer_cast<HostChunkContainer<data_t>>(dest.container());
+
+    thrust::copy_n(data_.begin() + (iChunk << this->chunk_bits_), size,
+                   dest_cont->vector().begin() +
+                       (dest.pos() << this->chunk_bits_));
   }
 }
 
 template <typename data_t>
-void HostChunkContainer<data_t>::CopyIn(thrust::complex<data_t>* src,uint_t iChunk, uint_t size)
-{
+void HostChunkContainer<data_t>::CopyIn(thrust::complex<data_t> *src,
+                                        uint_t iChunk, uint_t size) {
   uint_t this_size = 1ull << this->chunk_bits_;
-  if(this_size < size) throw std::runtime_error("CopyIn chunk size is less than provided size");
-  
-  thrust::copy_n(src,size,data_.begin() + (iChunk << this->chunk_bits_));
+  if (this_size < size)
+    throw std::runtime_error("CopyIn chunk size is less than provided size");
+
+  thrust::copy_n(src, size, data_.begin() + (iChunk << this->chunk_bits_));
 }
 
 template <typename data_t>
-void HostChunkContainer<data_t>::CopyOut(thrust::complex<data_t>* dest,uint_t iChunk, uint_t size)
-{
+void HostChunkContainer<data_t>::CopyOut(thrust::complex<data_t> *dest,
+                                         uint_t iChunk, uint_t size) {
   uint_t this_size = 1ull << this->chunk_bits_;
-  if(this_size < size) throw std::runtime_error("CopyIn chunk size is less than provided size");
-  
-  thrust::copy_n(data_.begin() + (iChunk << this->chunk_bits_),size,dest);
+  if (this_size < size)
+    throw std::runtime_error("CopyIn chunk size is less than provided size");
+
+  thrust::copy_n(data_.begin() + (iChunk << this->chunk_bits_), size, dest);
 }
 
 template <typename data_t>
-void HostChunkContainer<data_t>::Swap(Chunk<data_t>& src,uint_t iChunk, uint_t dest_offset, uint_t src_offset, uint_t size_in, bool write_back)
-{
+void HostChunkContainer<data_t>::Swap(Chunk<data_t> &src, uint_t iChunk,
+                                      uint_t dest_offset, uint_t src_offset,
+                                      uint_t size_in, bool write_back) {
   uint_t size = size_in;
-  if(size == 0)
+  if (size == 0)
     size = 1ull << this->chunk_bits_;
-//  if(src.device() >= 0){
-//    src.swap(*this,dest_offset,src_offset,size_in,write_back);
-//  }
-//  else{
-    auto src_cont = std::static_pointer_cast<HostChunkContainer<data_t>>(src.container());
-
-    this->Execute(BufferSwap_func<data_t>(chunk_pointer(iChunk) + dest_offset,src.pointer() + src_offset, size, write_back), iChunk,0, 1);
-//    thrust::swap_ranges(thrust::omp::par,data_.begin() + (iChunk << this->chunk_bits_) + dest_offset,data_.begin() + (iChunk << this->chunk_bits_) + dest_offset + size,src_cont->vector().begin() + (src.pos() << this->chunk_bits_) + src_offset);
-//  }
+  //  if(src.device() >= 0){
+  //    src.swap(*this,dest_offset,src_offset,size_in,write_back);
+  //  }
+  //  else{
+  auto src_cont =
+      std::static_pointer_cast<HostChunkContainer<data_t>>(src.container());
+
+  this->Execute(BufferSwap_func<data_t>(chunk_pointer(iChunk) + dest_offset,
+                                        src.pointer() + src_offset, size,
+                                        write_back),
+                iChunk, 0, 1);
+  //    thrust::swap_ranges(thrust::omp::par,data_.begin() + (iChunk <<
+  //    this->chunk_bits_) + dest_offset,data_.begin() + (iChunk <<
+  //    this->chunk_bits_) + dest_offset + size,src_cont->vector().begin() +
+  //    (src.pos() << this->chunk_bits_) + src_offset);
+  //  }
 }
 
-
 template <typename data_t>
-void HostChunkContainer<data_t>::Zero(uint_t iChunk,uint_t count)
-{
-  thrust::fill_n(thrust::omp::par,data_.begin() + (iChunk << this->chunk_bits_),count,0.0);
+void HostChunkContainer<data_t>::Zero(uint_t iChunk, uint_t count) {
+  thrust::fill_n(thrust::omp::par,
+                 data_.begin() + (iChunk << this->chunk_bits_), count, 0.0);
 }
 
 template <typename data_t>
-reg_t HostChunkContainer<data_t>::sample_measure(uint_t iChunk,const std::vector<double> &rnds, uint_t stride, bool dot,uint_t count) const
-{
+reg_t HostChunkContainer<data_t>::sample_measure(
+    uint_t iChunk, const std::vector<double> &rnds, uint_t stride, bool dot,
+    uint_t count) const {
   const int_t SHOTS = rnds.size();
-  reg_t samples(SHOTS,0);
+  reg_t samples(SHOTS, 0);
   thrust::host_vector<uint_t> vSmp(SHOTS);
   int i;
 
-  strided_range<thrust::complex<data_t>*> iter(chunk_pointer(iChunk), chunk_pointer(iChunk+count), stride);
+  strided_range<thrust::complex<data_t> *> iter(
+      chunk_pointer(iChunk), chunk_pointer(iChunk + count), stride);
 
-  if(dot)
-    thrust::transform_inclusive_scan(thrust::omp::par,iter.begin(),iter.end(),iter.begin(),complex_dot_scan<data_t>(),thrust::plus<thrust::complex<data_t>>());
+  if (dot)
+    thrust::transform_inclusive_scan(thrust::omp::par, iter.begin(), iter.end(),
+                                     iter.begin(), complex_dot_scan<data_t>(),
+                                     thrust::plus<thrust::complex<data_t>>());
   else
-    thrust::inclusive_scan(thrust::omp::par,iter.begin(),iter.end(),iter.begin(),thrust::plus<thrust::complex<data_t>>());
-  thrust::lower_bound(thrust::omp::par, iter.begin(), iter.end(), rnds.begin(), rnds.begin() + SHOTS, vSmp.begin() ,complex_less<data_t>());
-
-  for(i=0;i<SHOTS;i++){
+    thrust::inclusive_scan(thrust::omp::par, iter.begin(), iter.end(),
+                           iter.begin(),
+                           thrust::plus<thrust::complex<data_t>>());
+  thrust::lower_bound(thrust::omp::par, iter.begin(), iter.end(), rnds.begin(),
+                      rnds.begin() + SHOTS, vSmp.begin(),
+                      complex_less<data_t>());
+
+  for (i = 0; i < SHOTS; i++) {
     samples[i] = vSmp[i];
   }
   vSmp.clear();
@@ -267,7 +277,6 @@ reg_t HostChunkContainer<data_t>::sample_measure(uint_t iChunk,const std::vector
   return samples;
 }
 
-
 //------------------------------------------------------------------------------
 } // end namespace Chunk
 } // end namespace QV
diff --git a/src/simulators/statevector/chunk/thrust_kernels.hpp b/src/simulators/statevector/chunk/thrust_kernels.hpp
index ff1f6c86f4..6db5d74791 100644
--- a/src/simulators/statevector/chunk/thrust_kernels.hpp
+++ b/src/simulators/statevector/chunk/thrust_kernels.hpp
@@ -12,7 +12,6 @@
  * that they have been altered from the originals.
  */
 
-
 #ifndef _qv_thrust_kernels_hpp_
 #define _qv_thrust_kernels_hpp_
 
@@ -31,11 +30,11 @@ DISABLE_WARNING_POP
 #include <cmath>
 #include <complex>
 #include <cstdint>
-#include <string>
-#include <vector>
 #include <iostream>
 #include <sstream>
 #include <stdexcept>
+#include <string>
+#include <vector>
 
 #include "framework/utils.hpp"
 
@@ -50,24 +49,21 @@ namespace Chunk {
 //========================================
 //  base class of gate functions
 //========================================
-template <typename data_t>
-class GateFuncBase
-{
+template <typename data_t> class GateFuncBase {
 protected:
-  thrust::complex<data_t>* data_;   //pointer to state vector buffer
-  thrust::complex<double>* matrix_; //storage for matrix on device
-  uint_t* params_;                  //storage for additional parameters on device
-  uint_t base_index_;               //start index of state vector 
+  thrust::complex<data_t> *data_;   // pointer to state vector buffer
+  thrust::complex<double> *matrix_; // storage for matrix on device
+  uint_t *params_;    // storage for additional parameters on device
+  uint_t base_index_; // start index of state vector
   uint_t chunk_bits_;
-  uint_t* cregs_;
+  uint_t *cregs_;
   uint_t num_creg_bits_;
   int_t conditional_bit_;
 #ifndef AER_THRUST_CUDA
   uint_t index_offset_;
 #endif
 public:
-  GateFuncBase()
-  {
+  GateFuncBase() {
     data_ = NULL;
     base_index_ = 0;
     cregs_ = NULL;
@@ -77,154 +73,99 @@ class GateFuncBase
     index_offset_ = 0;
 #endif
   }
-  virtual void set_data(thrust::complex<data_t>* p)
-  {
-    data_ = p;
-  }
-  void set_matrix(thrust::complex<double>* mat)
-  {
-    matrix_ = mat;
-  }
-  void set_params(uint_t* p)
-  {
-    params_ = p;
-  }
-  void set_chunk_bits(uint_t bits)
-  {
-    chunk_bits_ = bits;
-  }
+  virtual void set_data(thrust::complex<data_t> *p) { data_ = p; }
+  void set_matrix(thrust::complex<double> *mat) { matrix_ = mat; }
+  void set_params(uint_t *p) { params_ = p; }
+  void set_chunk_bits(uint_t bits) { chunk_bits_ = bits; }
 
-  void set_base_index(uint_t i)
-  {
-    base_index_ = i;
-  }
-  void set_cregs_(uint_t* cbits,uint_t nreg)
-  {
+  void set_base_index(uint_t i) { base_index_ = i; }
+  void set_cregs_(uint_t *cbits, uint_t nreg) {
     cregs_ = cbits;
     num_creg_bits_ = nreg;
   }
-  void set_conditional(int_t bit)
-  {
-    conditional_bit_ = bit;
-  }
+  void set_conditional(int_t bit) { conditional_bit_ = bit; }
 
 #ifndef AER_THRUST_CUDA
-  void set_index_offset(uint_t i)
-  {
-    index_offset_ = i;
-  }
+  void set_index_offset(uint_t i) { index_offset_ = i; }
 #endif
 
-  __host__ __device__ thrust::complex<data_t>* data(void)
-  {
-    return data_;
-  }
+  __host__ __device__ thrust::complex<data_t> *data(void) { return data_; }
 
-  virtual bool is_diagonal(void)
-  {
-    return false;
-  }
-  virtual int qubits_count(void)
-  {
-    return 1;
-  }
-  virtual int num_control_bits(void)
-  {
-    return 0;
-  }
-  virtual int control_mask(void)
-  {
-    return 1;
-  }
-  virtual bool use_cache(void)
-  {
-    return false;
-  }
-  virtual bool batch_enable(void)
-  {
-    return true;
-  }
+  virtual bool is_diagonal(void) { return false; }
+  virtual int qubits_count(void) { return 1; }
+  virtual int num_control_bits(void) { return 0; }
+  virtual int control_mask(void) { return 1; }
+  virtual bool use_cache(void) { return false; }
+  virtual bool batch_enable(void) { return true; }
 
-  virtual const char* name(void)
-  {
-    return "base function";
-  }
-  virtual uint_t size(int num_qubits)
-  {
-    if(is_diagonal()){
+  virtual const char *name(void) { return "base function"; }
+  virtual uint_t size(int num_qubits) {
+    if (is_diagonal()) {
       chunk_bits_ = num_qubits;
       return (1ull << num_qubits);
-    }
-    else{
+    } else {
       chunk_bits_ = num_qubits - (qubits_count() - num_control_bits());
       return (1ull << (num_qubits - (qubits_count() - num_control_bits())));
     }
   }
 
-  virtual __host__ __device__ uint_t thread_to_index(uint_t _tid) const
-  {
+  virtual __host__ __device__ uint_t thread_to_index(uint_t _tid) const {
     return _tid;
   }
-  virtual __host__ __device__ void run_with_cache(uint_t _tid,uint_t _idx,thrust::complex<data_t>* _cache) const
-  {
-    //implemente this in the kernel class
+  virtual __host__ __device__ void
+  run_with_cache(uint_t _tid, uint_t _idx,
+                 thrust::complex<data_t> *_cache) const {
+    // implemente this in the kernel class
   }
-  virtual __host__ __device__ double run_with_cache_sum(uint_t _tid,uint_t _idx,thrust::complex<data_t>* _cache) const
-  {
-    //implemente this in the kernel class
+  virtual __host__ __device__ double
+  run_with_cache_sum(uint_t _tid, uint_t _idx,
+                     thrust::complex<data_t> *_cache) const {
+    // implemente this in the kernel class
     return 0.0;
   }
 
-  virtual __host__ __device__ bool check_conditional(uint_t i) const
-  {
-    if(conditional_bit_ < 0)
+  virtual __host__ __device__ bool check_conditional(uint_t i) const {
+    if (conditional_bit_ < 0)
       return true;
 
     uint_t iChunk = i >> chunk_bits_;
-    uint_t n64,i64,ibit;
+    uint_t n64, i64, ibit;
     n64 = (num_creg_bits_ + 63) >> 6;
     i64 = conditional_bit_ >> 6;
     ibit = conditional_bit_ & 63;
-    return (((cregs_[iChunk*n64 + i64] >> ibit) & 1) != 0);
+    return (((cregs_[iChunk * n64 + i64] >> ibit) & 1) != 0);
   }
 };
 
 //========================================
-  //  gate functions with cache
+//  gate functions with cache
 //========================================
 template <typename data_t>
-class GateFuncWithCache : public GateFuncBase<data_t>
-{
+class GateFuncWithCache : public GateFuncBase<data_t> {
 protected:
   int nqubits_;
+
 public:
-  GateFuncWithCache(uint_t nq)
-  {
-    nqubits_ = nq;
-  }
+  GateFuncWithCache(uint_t nq) { nqubits_ = nq; }
 
-  bool use_cache(void)
-  {
-    return true;
-  }
+  bool use_cache(void) { return true; }
 
-    __host__ __device__ virtual uint_t thread_to_index(uint_t _tid) const
-  {
-    uint_t idx,ii,t,j;
-    uint_t* qubits;
-    uint_t* qubits_sorted;
+  __host__ __device__ virtual uint_t thread_to_index(uint_t _tid) const {
+    uint_t idx, ii, t, j;
+    uint_t *qubits;
+    uint_t *qubits_sorted;
 
     qubits_sorted = this->params_;
     qubits = qubits_sorted + nqubits_;
 
     idx = 0;
     ii = _tid >> nqubits_;
-    for(j=0;j<nqubits_;j++){
+    for (j = 0; j < nqubits_; j++) {
       t = ii & ((1ull << qubits_sorted[j]) - 1);
       idx += t;
       ii = (ii - t) << 1;
 
-      if(((_tid >> j) & 1) != 0){
+      if (((_tid >> j) & 1) != 0) {
         idx += (1ull << qubits[j]);
       }
     }
@@ -232,75 +173,62 @@ class GateFuncWithCache : public GateFuncBase<data_t>
     return idx;
   }
 
-  __host__ __device__ void sync_threads() const
-  {
+  __host__ __device__ void sync_threads() const {
 #ifdef CUDA_ARCH
     __syncthreads();
 #endif
   }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    if(!this->check_conditional(i))
+  __host__ __device__ void operator()(const uint_t &i) const {
+    if (!this->check_conditional(i))
       return;
 
     thrust::complex<data_t> cache[1024];
-    uint_t j,idx;
+    uint_t j, idx;
     uint_t matSize = 1ull << nqubits_;
 
-    //load data to cache
-    for(j=0;j<matSize;j++){
+    // load data to cache
+    for (j = 0; j < matSize; j++) {
       idx = thread_to_index((i << nqubits_) + j);
       cache[j] = this->data_[idx];
     }
 
-    //execute using cache
-    for(j=0;j<matSize;j++){
+    // execute using cache
+    for (j = 0; j < matSize; j++) {
       idx = thread_to_index((i << nqubits_) + j);
-      this->run_with_cache(j,idx,cache);
+      this->run_with_cache(j, idx, cache);
     }
   }
 
-  virtual int qubits_count(void)
-  {
-    return nqubits_;
-  }
+  virtual int qubits_count(void) { return nqubits_; }
 };
 
 template <typename data_t>
-class GateFuncSumWithCache : public GateFuncBase<data_t>
-{
+class GateFuncSumWithCache : public GateFuncBase<data_t> {
 protected:
   int nqubits_;
-public:
-  GateFuncSumWithCache(uint_t nq)
-  {
-    nqubits_ = nq;
-  }
 
-  bool use_cache(void)
-  {
-    return true;
-  }
+public:
+  GateFuncSumWithCache(uint_t nq) { nqubits_ = nq; }
 
+  bool use_cache(void) { return true; }
 
-  __host__ __device__ virtual uint_t thread_to_index(uint_t _tid) const
-  {
-    uint_t idx,ii,t,j;
-    uint_t* qubits;
-    uint_t* qubits_sorted;
+  __host__ __device__ virtual uint_t thread_to_index(uint_t _tid) const {
+    uint_t idx, ii, t, j;
+    uint_t *qubits;
+    uint_t *qubits_sorted;
 
     qubits_sorted = this->params_;
     qubits = qubits_sorted + nqubits_;
 
     idx = 0;
     ii = _tid >> nqubits_;
-    for(j=0;j<nqubits_;j++){
+    for (j = 0; j < nqubits_; j++) {
       t = ii & ((1ull << qubits_sorted[j]) - 1);
       idx += t;
       ii = (ii - t) << 1;
 
-      if(((_tid >> j) & 1) != 0){
+      if (((_tid >> j) & 1) != 0) {
         idx += (1ull << qubits[j]);
       }
     }
@@ -308,69 +236,61 @@ class GateFuncSumWithCache : public GateFuncBase<data_t>
     return idx;
   }
 
-  __host__ __device__ double operator()(const uint_t &i) const
-  {
-    if(!this->check_conditional(i))
+  __host__ __device__ double operator()(const uint_t &i) const {
+    if (!this->check_conditional(i))
       return 0.0;
 
     thrust::complex<data_t> cache[1024];
-    uint_t j,idx;
+    uint_t j, idx;
     uint_t matSize = 1ull << nqubits_;
     double sum = 0.0;
 
-    //load data to cache
-    for(j=0;j<matSize;j++){
+    // load data to cache
+    for (j = 0; j < matSize; j++) {
       idx = thread_to_index((i << nqubits_) + j);
       cache[j] = this->data_[idx];
     }
 
-    //execute using cache
-    for(j=0;j<matSize;j++){
+    // execute using cache
+    for (j = 0; j < matSize; j++) {
       idx = thread_to_index((i << nqubits_) + j);
-      sum += this->run_with_cache_sum(j,idx,cache);
+      sum += this->run_with_cache_sum(j, idx, cache);
     }
     return sum;
   }
 
-  virtual int qubits_count(void)
-  {
-    return nqubits_;
-  }
-
+  virtual int qubits_count(void) { return nqubits_; }
 };
 
-//stridded iterator to access diagonal probabilities
-template <typename Iterator>
-class strided_range
-{
-  public:
-
+// stridded iterator to access diagonal probabilities
+template <typename Iterator> class strided_range {
+public:
   typedef typename thrust::iterator_difference<Iterator>::type difference_type;
 
-  struct stride_functor : public thrust::unary_function<difference_type,difference_type>
-  {
+  struct stride_functor
+      : public thrust::unary_function<difference_type, difference_type> {
     difference_type stride;
 
-    stride_functor(difference_type stride)
-        : stride(stride) {}
+    stride_functor(difference_type stride) : stride(stride) {}
 
-    __host__ __device__
-    difference_type operator()(const difference_type& i) const
-    {
-      if(stride == 1) //statevector
+    __host__ __device__ difference_type
+    operator()(const difference_type &i) const {
+      if (stride == 1) // statevector
         return i;
 
-      //density matrix
+      // density matrix
       difference_type i_chunk;
       i_chunk = i / (stride - 1);
-      difference_type ret = stride * i - i_chunk*(stride-1);
+      difference_type ret = stride * i - i_chunk * (stride - 1);
       return ret;
     }
   };
 
-  typedef typename thrust::counting_iterator<difference_type>                   CountingIterator;
-  typedef typename thrust::transform_iterator<stride_functor, CountingIterator> TransformIterator;
-  typedef typename thrust::permutation_iterator<Iterator,TransformIterator>     PermutationIterator;
+  typedef typename thrust::counting_iterator<difference_type> CountingIterator;
+  typedef typename thrust::transform_iterator<stride_functor, CountingIterator>
+      TransformIterator;
+  typedef typename thrust::permutation_iterator<Iterator, TransformIterator>
+      PermutationIterator;
 
   // type of the strided_range iterator
   typedef PermutationIterator iterator;
@@ -378,75 +298,79 @@ class strided_range
   // construct strided_range for the range [first,last)
   strided_range(Iterator first, Iterator last, difference_type stride)
       : first(first), last(last), stride(stride) {}
- 
-  iterator begin(void) const
-  {
-    return PermutationIterator(first, TransformIterator(CountingIterator(0), stride_functor(stride)));
+
+  iterator begin(void) const {
+    return PermutationIterator(
+        first, TransformIterator(CountingIterator(0), stride_functor(stride)));
   }
 
-  iterator end(void) const
-  {
-    if(stride == 1) //statevector
+  iterator end(void) const {
+    if (stride == 1) // statevector
       return begin() + (last - first);
 
-    //density matrix
-    return begin() + (last - first) / (stride-1);
+    // density matrix
+    return begin() + (last - first) / (stride - 1);
   }
-  
-  protected:
+
+protected:
   Iterator first;
   Iterator last;
   difference_type stride;
 };
 
 template <typename data_t>
-struct complex_dot_scan : public thrust::unary_function<thrust::complex<data_t>,thrust::complex<data_t>>
-{
-  __host__ __device__
-  thrust::complex<data_t> operator()(thrust::complex<data_t> x) { return thrust::complex<data_t>(x.real()*x.real()+x.imag()*x.imag(),0); }
+struct complex_dot_scan
+    : public thrust::unary_function<thrust::complex<data_t>,
+                                    thrust::complex<data_t>> {
+  __host__ __device__ thrust::complex<data_t>
+  operator()(thrust::complex<data_t> x) {
+    return thrust::complex<data_t>(x.real() * x.real() + x.imag() * x.imag(),
+                                   0);
+  }
 };
 
 template <typename data_t>
-struct complex_norm : public thrust::unary_function<thrust::complex<data_t>,thrust::complex<data_t>>
-{
-  __host__ __device__
-  thrust::complex<double> operator()(thrust::complex<data_t> x) { return thrust::complex<double>((double)x.real()*(double)x.real(),(double)x.imag()*(double)x.imag()); }
+struct complex_norm : public thrust::unary_function<thrust::complex<data_t>,
+                                                    thrust::complex<data_t>> {
+  __host__ __device__ thrust::complex<double>
+  operator()(thrust::complex<data_t> x) {
+    return thrust::complex<double>((double)x.real() * (double)x.real(),
+                                   (double)x.imag() * (double)x.imag());
+  }
 };
 
-template<typename data_t>
-struct complex_less
-{
+template <typename data_t> struct complex_less {
   typedef thrust::complex<data_t> first_argument_type;
   typedef thrust::complex<data_t> second_argument_type;
   typedef bool result_type;
-  __thrust_exec_check_disable__
-    __host__ __device__ bool operator()(const thrust::complex<data_t> &lhs, const thrust::complex<data_t> &rhs) const {return lhs.real() < rhs.real();}
+  __thrust_exec_check_disable__ __host__ __device__ bool
+  operator()(const thrust::complex<data_t> &lhs,
+             const thrust::complex<data_t> &rhs) const {
+    return lhs.real() < rhs.real();
+  }
 }; // end less
 
-
-class HostFuncBase
-{
+class HostFuncBase {
 protected:
 public:
-  HostFuncBase(){}
+  HostFuncBase() {}
 
-  virtual void execute(){}
+  virtual void execute() {}
 };
 
-  
 //------------------------------------------------------------------------------
 // State initialize component
 //------------------------------------------------------------------------------
 template <typename data_t>
-class initialize_component_1qubit_func : public GateFuncBase<data_t>
-{
+class initialize_component_1qubit_func : public GateFuncBase<data_t> {
 protected:
-  thrust::complex<double> s0,s1;
+  thrust::complex<double> s0, s1;
   uint_t mask;
   uint_t offset;
+
 public:
-  initialize_component_1qubit_func(int qubit,thrust::complex<double> state0,thrust::complex<double> state1)
-  {
+  initialize_component_1qubit_func(int qubit, thrust::complex<double> state0,
+                                   thrust::complex<double> state1) {
     s0 = state0;
     s1 = state1;
 
@@ -454,12 +378,11 @@ class initialize_component_1qubit_func : public GateFuncBase<data_t>
     offset = 1ull << qubit;
   }
 
-  virtual __host__ __device__ void operator()(const uint_t &i) const
-  {
-    uint_t i0,i1;
+  virtual __host__ __device__ void operator()(const uint_t &i) const {
+    uint_t i0, i1;
     thrust::complex<data_t> q0;
-    thrust::complex<data_t>* vec0;
-    thrust::complex<data_t>* vec1;
+    thrust::complex<data_t> *vec0;
+    thrust::complex<data_t> *vec1;
 
     vec0 = this->data_;
     vec1 = vec0 + offset;
@@ -470,46 +393,38 @@ class initialize_component_1qubit_func : public GateFuncBase<data_t>
 
     q0 = vec0[i0];
 
-    vec0[i0] = s0*q0;
-    vec1[i0] = s1*q0;
+    vec0[i0] = s0 * q0;
+    vec1[i0] = s1 * q0;
   }
 
-  const char* name(void)
-  {
-    return "initialize_component 1 qubit";
-  }
+  const char *name(void) { return "initialize_component 1 qubit"; }
 };
 
 template <typename data_t>
-class initialize_component_func : public GateFuncBase<data_t>
-{
+class initialize_component_func : public GateFuncBase<data_t> {
 protected:
   int nqubits;
   uint_t matSize;
+
 public:
-  initialize_component_func(const cvector_t<double>& mat,const reg_t &qb)
-  {
+  initialize_component_func(const cvector_t<double> &mat, const reg_t &qb) {
     nqubits = qb.size();
     matSize = 1ull << nqubits;
   }
 
-  int qubits_count(void)
-  {
-    return nqubits;
-  }
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    thrust::complex<data_t>* vec;
+  int qubits_count(void) { return nqubits; }
+  __host__ __device__ void operator()(const uint_t &i) const {
+    thrust::complex<data_t> *vec;
     thrust::complex<double> q0;
     thrust::complex<double> q;
-    thrust::complex<double>* state;
-    uint_t* qubits;
-    uint_t* qubits_sorted;
-    uint_t j,k;
-    uint_t ii,idx,t;
+    thrust::complex<double> *state;
+    uint_t *qubits;
+    uint_t *qubits_sorted;
+    uint_t j, k;
+    uint_t ii, idx, t;
     uint_t mask;
 
-    //get parameters from iterator
+    // get parameters from iterator
     vec = this->data_;
     state = this->matrix_;
     qubits = this->params_;
@@ -517,7 +432,7 @@ class initialize_component_func : public GateFuncBase<data_t>
 
     idx = 0;
     ii = i;
-    for(j=0;j<nqubits;j++){
+    for (j = 0; j < nqubits; j++) {
       mask = (1ull << qubits_sorted[j]) - 1;
 
       t = ii & mask;
@@ -527,10 +442,10 @@ class initialize_component_func : public GateFuncBase<data_t>
     idx += ii;
 
     q0 = vec[idx];
-    for(k=0;k<matSize;k++){
+    for (k = 0; k < matSize; k++) {
       ii = idx;
-      for(j=0;j<nqubits;j++){
-        if(((k >> j) & 1) != 0)
+      for (j = 0; j < nqubits; j++) {
+        if (((k >> j) & 1) != 0)
           ii += (1ull << qubits[j]);
       }
       q = q0 * state[k];
@@ -538,141 +453,109 @@ class initialize_component_func : public GateFuncBase<data_t>
     }
   }
 
-  const char* name(void)
-  {
-    return "initialize_component";
-  }
+  const char *name(void) { return "initialize_component"; }
 };
 
 template <typename data_t>
-class initialize_large_component_func : public GateFuncBase<data_t>
-{
+class initialize_large_component_func : public GateFuncBase<data_t> {
 protected:
   int num_qubits_;
   uint_t mask_;
   uint_t cmask_;
   thrust::complex<double> init_;
+
 public:
-  initialize_large_component_func(thrust::complex<double> m,const reg_t& qubits,int i)
-  {
+  initialize_large_component_func(thrust::complex<double> m,
+                                  const reg_t &qubits, int i) {
     num_qubits_ = qubits.size();
     init_ = m;
 
     mask_ = 0;
     cmask_ = 0;
-    for(int k=0;k<num_qubits_;k++){
+    for (int k = 0; k < num_qubits_; k++) {
       mask_ |= (1ull << qubits[k]);
 
-      if(((i >> k) & 1) != 0){
+      if (((i >> k) & 1) != 0) {
         cmask_ |= (1ull << qubits[k]);
       }
     }
   }
-  bool is_diagonal(void)
-  {
-    return true;
-  }
+  bool is_diagonal(void) { return true; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    thrust::complex<data_t>* vec;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    thrust::complex<data_t> *vec;
     thrust::complex<double> q;
     vec = this->data_;
-    if((i & mask_) == cmask_){
+    if ((i & mask_) == cmask_) {
       q = vec[i];
-      vec[i] = init_*q;
+      vec[i] = init_ * q;
     }
   }
-  const char* name(void)
-  {
-    return "initialize_large_component";
-  }
+  const char *name(void) { return "initialize_large_component"; }
 };
 
 //------------------------------------------------------------------------------
 // Zero clear
 //------------------------------------------------------------------------------
-template <typename data_t>
-class ZeroClear : public GateFuncBase<data_t>
-{
+template <typename data_t> class ZeroClear : public GateFuncBase<data_t> {
 protected:
 public:
   ZeroClear() {}
-  bool is_diagonal(void)
-  {
-    return true;
-  }
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    thrust::complex<data_t>* vec;
+  bool is_diagonal(void) { return true; }
+  __host__ __device__ void operator()(const uint_t &i) const {
+    thrust::complex<data_t> *vec;
     vec = this->data_;
     vec[i] = 0.0;
   }
-  const char* name(void)
-  {
-    return "zero";
-  }
+  const char *name(void) { return "zero"; }
 };
 
-
 //------------------------------------------------------------------------------
 // Initialize state
 //------------------------------------------------------------------------------
 template <typename data_t>
-class initialize_kernel : public GateFuncBase<data_t>
-{
+class initialize_kernel : public GateFuncBase<data_t> {
 protected:
   int num_qubits_state_;
   uint_t offset_;
   thrust::complex<data_t> init_val_;
+
 public:
-  initialize_kernel(thrust::complex<data_t> v,int nqs,uint_t offset)
-  {
+  initialize_kernel(thrust::complex<data_t> v, int nqs, uint_t offset) {
     num_qubits_state_ = nqs;
     offset_ = offset;
     init_val_ = v;
   }
 
-  bool is_diagonal(void)
-  {
-    return true;
-  }
+  bool is_diagonal(void) { return true; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    thrust::complex<data_t>* vec;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    thrust::complex<data_t> *vec;
     uint_t iChunk = (i >> num_qubits_state_);
 
     vec = this->data_;
 
-    if(i == iChunk * offset_){
+    if (i == iChunk * offset_) {
       vec[i] = init_val_;
-    }
-    else{
+    } else {
       vec[i] = 0.0;
     }
   }
-  const char* name(void)
-  {
-    return "initialize";
-  }
+  const char *name(void) { return "initialize"; }
 };
 
 //------------------------------------------------------------------------------
 // Matrix multiplication
 //------------------------------------------------------------------------------
-template <typename data_t>
-class MatrixMult2x2 : public GateFuncBase<data_t>
-{
+template <typename data_t> class MatrixMult2x2 : public GateFuncBase<data_t> {
 protected:
-  thrust::complex<double> m0,m1,m2,m3;
+  thrust::complex<double> m0, m1, m2, m3;
   int qubit;
   uint_t mask;
   uint_t offset0;
 
 public:
-  MatrixMult2x2(const cvector_t<double>& mat,int q)
-  {
+  MatrixMult2x2(const cvector_t<double> &mat, int q) {
     qubit = q;
     m0 = mat[0];
     m1 = mat[1];
@@ -684,12 +567,11 @@ class MatrixMult2x2 : public GateFuncBase<data_t>
     offset0 = 1ull << qubit;
   }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    uint_t i0,i1;
-    thrust::complex<data_t> q0,q1;
-    thrust::complex<data_t>* vec0;
-    thrust::complex<data_t>* vec1;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    uint_t i0, i1;
+    thrust::complex<data_t> q0, q1;
+    thrust::complex<data_t> *vec0;
+    thrust::complex<data_t> *vec1;
 
     vec0 = this->data_;
     vec1 = vec0 + offset0;
@@ -704,29 +586,22 @@ class MatrixMult2x2 : public GateFuncBase<data_t>
     vec0[i0] = m0 * q0 + m2 * q1;
     vec1[i0] = m1 * q0 + m3 * q1;
   }
-  const char* name(void)
-  {
-    return "mult2x2";
-  }
+  const char *name(void) { return "mult2x2"; }
 };
 
-
-template <typename data_t>
-class MatrixMult4x4 : public GateFuncBase<data_t>
-{
+template <typename data_t> class MatrixMult4x4 : public GateFuncBase<data_t> {
 protected:
-  thrust::complex<double> m00,m10,m20,m30;
-  thrust::complex<double> m01,m11,m21,m31;
-  thrust::complex<double> m02,m12,m22,m32;
-  thrust::complex<double> m03,m13,m23,m33;
+  thrust::complex<double> m00, m10, m20, m30;
+  thrust::complex<double> m01, m11, m21, m31;
+  thrust::complex<double> m02, m12, m22, m32;
+  thrust::complex<double> m03, m13, m23, m33;
   uint_t mask0;
   uint_t mask1;
   uint_t offset0;
   uint_t offset1;
 
 public:
-  MatrixMult4x4(const cvector_t<double>& mat,int qubit0,int qubit1)
-  {
+  MatrixMult4x4(const cvector_t<double> &mat, int qubit0, int qubit1) {
     m00 = mat[0];
     m01 = mat[1];
     m02 = mat[2];
@@ -749,28 +624,23 @@ class MatrixMult4x4 : public GateFuncBase<data_t>
 
     offset0 = 1ull << qubit0;
     offset1 = 1ull << qubit1;
-    if(qubit0 < qubit1){
+    if (qubit0 < qubit1) {
       mask0 = offset0 - 1;
       mask1 = offset1 - 1;
-    }
-    else{
+    } else {
       mask0 = offset1 - 1;
       mask1 = offset0 - 1;
     }
   }
 
-  int qubits_count(void)
-  {
-    return 2;
-  }
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    uint_t i0,i1,i2;
-    thrust::complex<data_t>* vec0;
-    thrust::complex<data_t>* vec1;
-    thrust::complex<data_t>* vec2;
-    thrust::complex<data_t>* vec3;
-    thrust::complex<data_t> q0,q1,q2,q3;
+  int qubits_count(void) { return 2; }
+  __host__ __device__ void operator()(const uint_t &i) const {
+    uint_t i0, i1, i2;
+    thrust::complex<data_t> *vec0;
+    thrust::complex<data_t> *vec1;
+    thrust::complex<data_t> *vec2;
+    thrust::complex<data_t> *vec3;
+    thrust::complex<data_t> q0, q1, q2, q3;
 
     vec0 = this->data_;
 
@@ -795,15 +665,10 @@ class MatrixMult4x4 : public GateFuncBase<data_t>
     vec2[i0] = m02 * q0 + m12 * q1 + m22 * q2 + m32 * q3;
     vec3[i0] = m03 * q0 + m13 * q1 + m23 * q2 + m33 * q3;
   }
-  const char* name(void)
-  {
-    return "mult4x4";
-  }
+  const char *name(void) { return "mult4x4"; }
 };
 
-template <typename data_t>
-class MatrixMult8x8 : public GateFuncBase<data_t>
-{
+template <typename data_t> class MatrixMult8x8 : public GateFuncBase<data_t> {
 protected:
   uint_t offset0;
   uint_t offset1;
@@ -813,8 +678,7 @@ class MatrixMult8x8 : public GateFuncBase<data_t>
   uint_t mask2;
 
 public:
-  MatrixMult8x8(const reg_t &qubit,const reg_t &qubit_ordered)
-  {
+  MatrixMult8x8(const reg_t &qubit, const reg_t &qubit_ordered) {
     offset0 = (1ull << qubit[0]);
     offset1 = (1ull << qubit[1]);
     offset2 = (1ull << qubit[2]);
@@ -824,18 +688,14 @@ class MatrixMult8x8 : public GateFuncBase<data_t>
     mask2 = (1ull << qubit_ordered[2]) - 1;
   }
 
-  int qubits_count(void)
-  {
-    return 3;
-  }
+  int qubits_count(void) { return 3; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    uint_t i0,i1,i2,i3;
-    thrust::complex<data_t>* vec;
-    thrust::complex<data_t> q0,q1,q2,q3,q4,q5,q6,q7;
-    thrust::complex<double> m0,m1,m2,m3,m4,m5,m6,m7;
-    thrust::complex<double>* pMat;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    uint_t i0, i1, i2, i3;
+    thrust::complex<data_t> *vec;
+    thrust::complex<data_t> q0, q1, q2, q3, q4, q5, q6, q7;
+    thrust::complex<double> m0, m1, m2, m3, m4, m5, m6, m7;
+    thrust::complex<double> *pMat;
 
     vec = this->data_;
     pMat = this->matrix_;
@@ -867,7 +727,8 @@ class MatrixMult8x8 : public GateFuncBase<data_t>
     m6 = pMat[48];
     m7 = pMat[56];
 
-    vec[i0] = m0 * q0 + m1 * q1 + m2 * q2 + m3 * q3 + m4 * q4 + m5 * q5 + m6 * q6 + m7 * q7;
+    vec[i0] = m0 * q0 + m1 * q1 + m2 * q2 + m3 * q3 + m4 * q4 + m5 * q5 +
+              m6 * q6 + m7 * q7;
 
     m0 = pMat[1];
     m1 = pMat[9];
@@ -878,7 +739,8 @@ class MatrixMult8x8 : public GateFuncBase<data_t>
     m6 = pMat[49];
     m7 = pMat[57];
 
-    vec[i0 + offset0] = m0 * q0 + m1 * q1 + m2 * q2 + m3 * q3 + m4 * q4 + m5 * q5 + m6 * q6 + m7 * q7;
+    vec[i0 + offset0] = m0 * q0 + m1 * q1 + m2 * q2 + m3 * q3 + m4 * q4 +
+                        m5 * q5 + m6 * q6 + m7 * q7;
 
     m0 = pMat[2];
     m1 = pMat[10];
@@ -889,7 +751,8 @@ class MatrixMult8x8 : public GateFuncBase<data_t>
     m6 = pMat[50];
     m7 = pMat[58];
 
-    vec[i0 + offset1] = m0 * q0 + m1 * q1 + m2 * q2 + m3 * q3 + m4 * q4 + m5 * q5 + m6 * q6 + m7 * q7;
+    vec[i0 + offset1] = m0 * q0 + m1 * q1 + m2 * q2 + m3 * q3 + m4 * q4 +
+                        m5 * q5 + m6 * q6 + m7 * q7;
 
     m0 = pMat[3];
     m1 = pMat[11];
@@ -900,7 +763,8 @@ class MatrixMult8x8 : public GateFuncBase<data_t>
     m6 = pMat[51];
     m7 = pMat[59];
 
-    vec[i0 + offset1 + offset0] = m0 * q0 + m1 * q1 + m2 * q2 + m3 * q3 + m4 * q4 + m5 * q5 + m6 * q6 + m7 * q7;
+    vec[i0 + offset1 + offset0] = m0 * q0 + m1 * q1 + m2 * q2 + m3 * q3 +
+                                  m4 * q4 + m5 * q5 + m6 * q6 + m7 * q7;
 
     m0 = pMat[4];
     m1 = pMat[12];
@@ -911,7 +775,8 @@ class MatrixMult8x8 : public GateFuncBase<data_t>
     m6 = pMat[52];
     m7 = pMat[60];
 
-    vec[i0 + offset2] = m0 * q0 + m1 * q1 + m2 * q2 + m3 * q3 + m4 * q4 + m5 * q5 + m6 * q6 + m7 * q7;
+    vec[i0 + offset2] = m0 * q0 + m1 * q1 + m2 * q2 + m3 * q3 + m4 * q4 +
+                        m5 * q5 + m6 * q6 + m7 * q7;
 
     m0 = pMat[5];
     m1 = pMat[13];
@@ -922,7 +787,8 @@ class MatrixMult8x8 : public GateFuncBase<data_t>
     m6 = pMat[53];
     m7 = pMat[61];
 
-    vec[i0 + offset2 + offset0] = m0 * q0 + m1 * q1 + m2 * q2 + m3 * q3 + m4 * q4 + m5 * q5 + m6 * q6 + m7 * q7;
+    vec[i0 + offset2 + offset0] = m0 * q0 + m1 * q1 + m2 * q2 + m3 * q3 +
+                                  m4 * q4 + m5 * q5 + m6 * q6 + m7 * q7;
 
     m0 = pMat[6];
     m1 = pMat[14];
@@ -933,7 +799,8 @@ class MatrixMult8x8 : public GateFuncBase<data_t>
     m6 = pMat[54];
     m7 = pMat[62];
 
-    vec[i0 + offset2 + offset1] = m0 * q0 + m1 * q1 + m2 * q2 + m3 * q3 + m4 * q4 + m5 * q5 + m6 * q6 + m7 * q7;
+    vec[i0 + offset2 + offset1] = m0 * q0 + m1 * q1 + m2 * q2 + m3 * q3 +
+                                  m4 * q4 + m5 * q5 + m6 * q6 + m7 * q7;
 
     m0 = pMat[7];
     m1 = pMat[15];
@@ -944,17 +811,14 @@ class MatrixMult8x8 : public GateFuncBase<data_t>
     m6 = pMat[55];
     m7 = pMat[63];
 
-    vec[i0 + offset2 + offset1 + offset0] = m0 * q0 + m1 * q1 + m2 * q2 + m3 * q3 + m4 * q4 + m5 * q5 + m6 * q6 + m7 * q7;
-  }
-  const char* name(void)
-  {
-    return "mult8x8";
+    vec[i0 + offset2 + offset1 + offset0] = m0 * q0 + m1 * q1 + m2 * q2 +
+                                            m3 * q3 + m4 * q4 + m5 * q5 +
+                                            m6 * q6 + m7 * q7;
   }
+  const char *name(void) { return "mult8x8"; }
 };
 
-template <typename data_t>
-class MatrixMult16x16 : public GateFuncBase<data_t>
-{
+template <typename data_t> class MatrixMult16x16 : public GateFuncBase<data_t> {
 protected:
   uint_t offset0;
   uint_t offset1;
@@ -964,9 +828,9 @@ class MatrixMult16x16 : public GateFuncBase<data_t>
   uint_t mask1;
   uint_t mask2;
   uint_t mask3;
+
 public:
-  MatrixMult16x16(const reg_t &qubit,const reg_t &qubit_ordered)
-  {
+  MatrixMult16x16(const reg_t &qubit, const reg_t &qubit_ordered) {
     offset0 = (1ull << qubit[0]);
     offset1 = (1ull << qubit[1]);
     offset2 = (1ull << qubit[2]);
@@ -978,19 +842,15 @@ class MatrixMult16x16 : public GateFuncBase<data_t>
     mask3 = (1ull << qubit_ordered[3]) - 1;
   }
 
-  int qubits_count(void)
-  {
-    return 4;
-  }
+  int qubits_count(void) { return 4; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    uint_t i0,i1,i2,i3,i4,offset,f0,f1,f2;
-    thrust::complex<data_t>* vec;
-    thrust::complex<data_t> q0,q1,q2,q3,q4,q5,q6,q7;
-    thrust::complex<data_t> q8,q9,q10,q11,q12,q13,q14,q15;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    uint_t i0, i1, i2, i3, i4, offset, f0, f1, f2;
+    thrust::complex<data_t> *vec;
+    thrust::complex<data_t> q0, q1, q2, q3, q4, q5, q6, q7;
+    thrust::complex<data_t> q8, q9, q10, q11, q12, q13, q14, q15;
     thrust::complex<double> r;
-    thrust::complex<double>* pMat;
+    thrust::complex<double> *pMat;
     int j;
 
     vec = this->data_;
@@ -1028,56 +888,49 @@ class MatrixMult16x16 : public GateFuncBase<data_t>
     f0 = 0;
     f1 = 0;
     f2 = 0;
-    for(j=0;j<16;j++){
-      r = pMat[0+j]*q0;
-      r += pMat[16+j]*q1;
-      r += pMat[32+j]*q2;
-      r += pMat[48+j]*q3;
-      r += pMat[64+j]*q4;
-      r += pMat[80+j]*q5;
-      r += pMat[96+j]*q6;
-      r += pMat[112+j]*q7;
-      r += pMat[128+j]*q8;
-      r += pMat[144+j]*q9;
-      r += pMat[160+j]*q10;
-      r += pMat[176+j]*q11;
-      r += pMat[192+j]*q12;
-      r += pMat[208+j]*q13;
-      r += pMat[224+j]*q14;
-      r += pMat[240+j]*q15;
-
-      offset = offset3 * (((uint_t)j >> 3) & 1) + 
-               offset2 * (((uint_t)j >> 2) & 1) + 
-               offset1 * (((uint_t)j >> 1) & 1) + 
-               offset0 *  ((uint_t)j & 1);
+    for (j = 0; j < 16; j++) {
+      r = pMat[0 + j] * q0;
+      r += pMat[16 + j] * q1;
+      r += pMat[32 + j] * q2;
+      r += pMat[48 + j] * q3;
+      r += pMat[64 + j] * q4;
+      r += pMat[80 + j] * q5;
+      r += pMat[96 + j] * q6;
+      r += pMat[112 + j] * q7;
+      r += pMat[128 + j] * q8;
+      r += pMat[144 + j] * q9;
+      r += pMat[160 + j] * q10;
+      r += pMat[176 + j] * q11;
+      r += pMat[192 + j] * q12;
+      r += pMat[208 + j] * q13;
+      r += pMat[224 + j] * q14;
+      r += pMat[240 + j] * q15;
+
+      offset = offset3 * (((uint_t)j >> 3) & 1) +
+               offset2 * (((uint_t)j >> 2) & 1) +
+               offset1 * (((uint_t)j >> 1) & 1) + offset0 * ((uint_t)j & 1);
 
       vec[i0 + offset] = r;
     }
   }
-  const char* name(void)
-  {
-    return "mult16x16";
-  }
+  const char *name(void) { return "mult16x16"; }
 };
 
 template <typename data_t>
-class MatrixMultNxN : public GateFuncWithCache<data_t>
-{
+class MatrixMultNxN : public GateFuncWithCache<data_t> {
 protected:
 public:
-  MatrixMultNxN(uint_t nq) : GateFuncWithCache<data_t>(nq)
-  {
-    ;
-  }
+  MatrixMultNxN(uint_t nq) : GateFuncWithCache<data_t>(nq) { ; }
 
-  __host__ __device__ void run_with_cache(uint_t _tid,uint_t _idx,thrust::complex<data_t>* _cache) const
-  {
-    uint_t j,threadID;
-    thrust::complex<data_t> q,r;
+  __host__ __device__ void
+  run_with_cache(uint_t _tid, uint_t _idx,
+                 thrust::complex<data_t> *_cache) const {
+    uint_t j, threadID;
+    thrust::complex<data_t> q, r;
     thrust::complex<double> m;
-    uint_t mat_size,irow;
-    thrust::complex<data_t>* vec;
-    thrust::complex<double>* pMat;
+    uint_t mat_size, irow;
+    thrust::complex<data_t> *vec;
+    thrust::complex<double> *pMat;
 
     vec = this->data_;
     pMat = this->matrix_;
@@ -1086,98 +939,95 @@ class MatrixMultNxN : public GateFuncWithCache<data_t>
     irow = _tid & (mat_size - 1);
 
     r = 0.0;
-    for(j=0;j<mat_size;j++){
-      m = pMat[irow + mat_size*j];
+    for (j = 0; j < mat_size; j++) {
+      m = pMat[irow + mat_size * j];
       q = _cache[(_tid & 1023) - irow + j];
 
-      r += m*q;
+      r += m * q;
     }
 
     vec[_idx] = r;
   }
 
-  const char* name(void)
-  {
-    return "multNxN";
-  }
-
+  const char *name(void) { return "multNxN"; }
 };
 
-//in-place NxN matrix multiplication using LU factorization
+// in-place NxN matrix multiplication using LU factorization
 template <typename data_t>
-class MatrixMultNxN_LU : public GateFuncBase<data_t>
-{
+class MatrixMultNxN_LU : public GateFuncBase<data_t> {
 protected:
   int nqubits;
   uint_t matSize;
   int nswap;
+
 public:
-  MatrixMultNxN_LU(const cvector_t<double>& mat,const reg_t &qb,cvector_t<double>& matLU,reg_t& params)
-  {
-    uint_t i,j,k,imax;
-    std::complex<double> c0,c1;
-    double d,dmax;
-    uint_t* pSwap;
+  MatrixMultNxN_LU(const cvector_t<double> &mat, const reg_t &qb,
+                   cvector_t<double> &matLU, reg_t &params) {
+    uint_t i, j, k, imax;
+    std::complex<double> c0, c1;
+    double d, dmax;
+    uint_t *pSwap;
 
     nqubits = qb.size();
     matSize = 1ull << nqubits;
 
     matLU = mat;
-    params.resize(nqubits + matSize*2);
+    params.resize(nqubits + matSize * 2);
 
-    for(k=0;k<nqubits;k++){
+    for (k = 0; k < nqubits; k++) {
       params[k] = qb[k];
     }
 
-    //LU factorization of input matrix
-    for(i=0;i<matSize;i++){
-      params[nqubits + i] = i;  //init pivot
+    // LU factorization of input matrix
+    for (i = 0; i < matSize; i++) {
+      params[nqubits + i] = i; // init pivot
     }
-    for(i=0;i<matSize;i++){
+    for (i = 0; i < matSize; i++) {
       imax = i;
       dmax = std::abs(matLU[(i << nqubits) + params[nqubits + i]]);
-      for(j=i+1;j<matSize;j++){
+      for (j = i + 1; j < matSize; j++) {
         d = std::abs(matLU[(i << nqubits) + params[nqubits + j]]);
-        if(d > dmax){
+        if (d > dmax) {
           dmax = d;
           imax = j;
         }
       }
-      if(imax != i){
+      if (imax != i) {
         j = params[nqubits + imax];
         params[nqubits + imax] = params[nqubits + i];
         params[nqubits + i] = j;
       }
 
-      if(dmax != 0){
+      if (dmax != 0) {
         c0 = matLU[(i << nqubits) + params[nqubits + i]];
 
-        for(j=i+1;j<matSize;j++){
-          c1 = matLU[(i << nqubits) + params[nqubits + j]]/c0;
+        for (j = i + 1; j < matSize; j++) {
+          c1 = matLU[(i << nqubits) + params[nqubits + j]] / c0;
 
-          for(k=i+1;k<matSize;k++){
-            matLU[(k << nqubits) + params[nqubits + j]] -= c1*matLU[(k << nqubits) + params[nqubits + i]];
+          for (k = i + 1; k < matSize; k++) {
+            matLU[(k << nqubits) + params[nqubits + j]] -=
+                c1 * matLU[(k << nqubits) + params[nqubits + i]];
           }
           matLU[(i << nqubits) + params[nqubits + j]] = c1;
         }
       }
     }
 
-    //making table for swapping pivotted result
+    // making table for swapping pivotted result
     pSwap = new uint_t[matSize];
     nswap = 0;
-    for(i=0;i<matSize;i++){
+    for (i = 0; i < matSize; i++) {
       pSwap[i] = params[nqubits + i];
     }
     i = 0;
-    while(i<matSize){
-      if(pSwap[i] != i){
+    while (i < matSize) {
+      if (pSwap[i] != i) {
         params[nqubits + matSize + nswap++] = i;
         j = pSwap[i];
         params[nqubits + matSize + nswap++] = j;
         k = pSwap[j];
         pSwap[j] = j;
-        while(i != k){
+        while (i != k) {
           j = k;
           params[nqubits + matSize + nswap++] = k;
           k = pSwap[j];
@@ -1190,24 +1040,20 @@ class MatrixMultNxN_LU : public GateFuncBase<data_t>
     delete[] pSwap;
   }
 
-  int qubits_count(void)
-  {
-    return nqubits;
-  }
+  int qubits_count(void) { return nqubits; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    thrust::complex<data_t> q,qt;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    thrust::complex<data_t> q, qt;
     thrust::complex<double> m;
     thrust::complex<double> r;
-    uint_t j,k,l,iq;
-    uint_t ii,idx,t;
-    uint_t mask,offset_j,offset_k;
-    thrust::complex<data_t>* vec;
-    thrust::complex<double>* pMat;
-    uint_t* qubits;
-    uint_t* pivot;
-    uint_t* table;
+    uint_t j, k, l, iq;
+    uint_t ii, idx, t;
+    uint_t mask, offset_j, offset_k;
+    thrust::complex<data_t> *vec;
+    thrust::complex<double> *pMat;
+    uint_t *qubits;
+    uint_t *pivot;
+    uint_t *table;
 
     vec = this->data_;
     pMat = this->matrix_;
@@ -1218,7 +1064,7 @@ class MatrixMultNxN_LU : public GateFuncBase<data_t>
 
     idx = 0;
     ii = i;
-    for(j=0;j<nqubits;j++){
+    for (j = 0; j < nqubits; j++) {
       mask = (1ull << qubits[j]) - 1;
 
       t = ii & mask;
@@ -1227,112 +1073,108 @@ class MatrixMultNxN_LU : public GateFuncBase<data_t>
     }
     idx += ii;
 
-    //mult U
-    for(j=0;j<matSize;j++){
+    // mult U
+    for (j = 0; j < matSize; j++) {
       r = 0.0;
-      for(k=j;k<matSize;k++){
+      for (k = j; k < matSize; k++) {
         l = (pivot[j] + (k << nqubits));
         m = pMat[l];
 
         offset_k = 0;
-        for(iq=0;iq<nqubits;iq++){
-          if(((k >> iq) & 1) != 0)
+        for (iq = 0; iq < nqubits; iq++) {
+          if (((k >> iq) & 1) != 0)
             offset_k += (1ull << qubits[iq]);
         }
-        q = vec[offset_k+idx];
+        q = vec[offset_k + idx];
 
-        r += m*q;
+        r += m * q;
       }
       offset_j = 0;
-      for(iq=0;iq<nqubits;iq++){
-        if(((j >> iq) & 1) != 0)
+      for (iq = 0; iq < nqubits; iq++) {
+        if (((j >> iq) & 1) != 0)
           offset_j += (1ull << qubits[iq]);
       }
-      vec[offset_j+idx] = r;
+      vec[offset_j + idx] = r;
     }
 
-    //mult L
-    for(j=matSize-1;j>0;j--){
+    // mult L
+    for (j = matSize - 1; j > 0; j--) {
       offset_j = 0;
-      for(iq=0;iq<nqubits;iq++){
-        if(((j >> iq) & 1) != 0)
+      for (iq = 0; iq < nqubits; iq++) {
+        if (((j >> iq) & 1) != 0)
           offset_j += (1ull << qubits[iq]);
       }
-      r = vec[offset_j+idx];
+      r = vec[offset_j + idx];
 
-      for(k=0;k<j;k++){
+      for (k = 0; k < j; k++) {
         l = (pivot[j] + (k << nqubits));
         m = pMat[l];
 
         offset_k = 0;
-        for(iq=0;iq<nqubits;iq++){
-          if(((k >> iq) & 1) != 0)
+        for (iq = 0; iq < nqubits; iq++) {
+          if (((k >> iq) & 1) != 0)
             offset_k += (1ull << qubits[iq]);
         }
-        q = vec[offset_k+idx];
+        q = vec[offset_k + idx];
 
-        r += m*q;
+        r += m * q;
       }
       offset_j = 0;
-      for(iq=0;iq<nqubits;iq++){
-        if(((j >> iq) & 1) != 0)
+      for (iq = 0; iq < nqubits; iq++) {
+        if (((j >> iq) & 1) != 0)
           offset_j += (1ull << qubits[iq]);
       }
-      vec[offset_j+idx] = r;
+      vec[offset_j + idx] = r;
     }
 
-    //swap results
-    if(nswap > 0){
+    // swap results
+    if (nswap > 0) {
       offset_j = 0;
-      for(iq=0;iq<nqubits;iq++){
-        if(((table[0] >> iq) & 1) != 0)
+      for (iq = 0; iq < nqubits; iq++) {
+        if (((table[0] >> iq) & 1) != 0)
           offset_j += (1ull << qubits[iq]);
       }
-      q = vec[offset_j+idx];
+      q = vec[offset_j + idx];
       k = pivot[table[0]];
-      for(j=1;j<nswap;j++){
+      for (j = 1; j < nswap; j++) {
         offset_j = 0;
-        for(iq=0;iq<nqubits;iq++){
-          if(((table[j] >> iq) & 1) != 0)
+        for (iq = 0; iq < nqubits; iq++) {
+          if (((table[j] >> iq) & 1) != 0)
             offset_j += (1ull << qubits[iq]);
         }
-        qt = vec[offset_j+idx];
+        qt = vec[offset_j + idx];
 
         offset_k = 0;
-        for(iq=0;iq<nqubits;iq++){
-          if(((k >> iq) & 1) != 0)
+        for (iq = 0; iq < nqubits; iq++) {
+          if (((k >> iq) & 1) != 0)
             offset_k += (1ull << qubits[iq]);
         }
-        vec[offset_k+idx] = q;
+        vec[offset_k + idx] = q;
         q = qt;
         k = pivot[table[j]];
       }
       offset_k = 0;
-      for(iq=0;iq<nqubits;iq++){
-        if(((k >> iq) & 1) != 0)
+      for (iq = 0; iq < nqubits; iq++) {
+        if (((k >> iq) & 1) != 0)
           offset_k += (1ull << qubits[iq]);
       }
-      vec[offset_k+idx] = q;
+      vec[offset_k + idx] = q;
     }
   }
-  const char* name(void)
-  {
-    return "multNxN";
-  }
+  const char *name(void) { return "multNxN"; }
 };
 
 template <typename data_t>
-class MatrixMult2x2Controlled : public GateFuncBase<data_t> 
-{
+class MatrixMult2x2Controlled : public GateFuncBase<data_t> {
 protected:
-  thrust::complex<double> m0,m1,m2,m3;
+  thrust::complex<double> m0, m1, m2, m3;
   uint_t mask;
   uint_t cmask;
   uint_t offset;
   int nqubits;
+
 public:
-  MatrixMult2x2Controlled(const cvector_t<double>& mat,const reg_t &qubits)
-  {
+  MatrixMult2x2Controlled(const cvector_t<double> &mat, const reg_t &qubits) {
     int i;
     m0 = mat[0];
     m1 = mat[1];
@@ -1340,29 +1182,22 @@ class MatrixMult2x2Controlled : public GateFuncBase<data_t>
     m3 = mat[3];
     nqubits = qubits.size();
 
-    offset = 1ull << qubits[nqubits-1];
-    mask = (1ull << qubits[nqubits-1]) - 1;
+    offset = 1ull << qubits[nqubits - 1];
+    mask = (1ull << qubits[nqubits - 1]) - 1;
     cmask = 0;
-    for(i=0;i<nqubits-1;i++){
+    for (i = 0; i < nqubits - 1; i++) {
       cmask |= (1ull << qubits[i]);
     }
   }
 
-  int qubits_count(void)
-  {
-    return nqubits;
-  }
-  int num_control_bits(void)
-  {
-    return nqubits - 1;
-  }
+  int qubits_count(void) { return nqubits; }
+  int num_control_bits(void) { return nqubits - 1; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    uint_t i0,i1;
-    thrust::complex<data_t> q0,q1;
-    thrust::complex<data_t>* vec0;
-    thrust::complex<data_t>* vec1;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    uint_t i0, i1;
+    thrust::complex<data_t> q0, q1;
+    thrust::complex<data_t> *vec0;
+    thrust::complex<data_t> *vec1;
 
     vec0 = this->data_;
 
@@ -1372,7 +1207,7 @@ class MatrixMult2x2Controlled : public GateFuncBase<data_t>
     i0 = (i - i1) << 1;
     i0 += i1;
 
-    if(((i0 + this->base_index_) & cmask) == cmask){
+    if (((i0 + this->base_index_) & cmask) == cmask) {
       q0 = vec0[i0];
       q1 = vec1[i0];
 
@@ -1380,39 +1215,29 @@ class MatrixMult2x2Controlled : public GateFuncBase<data_t>
       vec1[i0] = m1 * q0 + m3 * q1;
     }
   }
-  const char* name(void)
-  {
-    return "matrix_Cmult2x2";
-  }
+  const char *name(void) { return "matrix_Cmult2x2"; }
 };
 
 //------------------------------------------------------------------------------
 // Diagonal matrix multiplication
 //------------------------------------------------------------------------------
-template <typename data_t>
-class DiagonalMult2x2 : public GateFuncBase<data_t>
-{
+template <typename data_t> class DiagonalMult2x2 : public GateFuncBase<data_t> {
 protected:
-  thrust::complex<double> m0,m1;
+  thrust::complex<double> m0, m1;
   int qubit;
-public:
 
-  DiagonalMult2x2(const cvector_t<double>& mat,int q)
-  {
+public:
+  DiagonalMult2x2(const cvector_t<double> &mat, int q) {
     qubit = q;
     m0 = mat[0];
     m1 = mat[1];
   }
 
-  bool is_diagonal(void)
-  {
-    return true;
-  }
+  bool is_diagonal(void) { return true; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
+  __host__ __device__ void operator()(const uint_t &i) const {
     thrust::complex<data_t> q;
-    thrust::complex<data_t>* vec;
+    thrust::complex<data_t> *vec;
     thrust::complex<double> m;
     uint_t gid;
 
@@ -1420,32 +1245,25 @@ class DiagonalMult2x2 : public GateFuncBase<data_t>
     gid = this->base_index_;
 
     q = vec[i];
-    if((((i + gid) >> qubit) & 1) == 0){
+    if ((((i + gid) >> qubit) & 1) == 0) {
       m = m0;
-    }
-    else{
+    } else {
       m = m1;
     }
 
     vec[i] = m * q;
   }
-  const char* name(void)
-  {
-    return "diagonal_mult2x2";
-  }
+  const char *name(void) { return "diagonal_mult2x2"; }
 };
 
-template <typename data_t>
-class DiagonalMult4x4 : public GateFuncBase<data_t>
-{
+template <typename data_t> class DiagonalMult4x4 : public GateFuncBase<data_t> {
 protected:
-  thrust::complex<double> m0,m1,m2,m3;
+  thrust::complex<double> m0, m1, m2, m3;
   int qubit0;
   int qubit1;
-public:
 
-  DiagonalMult4x4(const cvector_t<double>& mat,int q0,int q1)
-  {
+public:
+  DiagonalMult4x4(const cvector_t<double> &mat, int q0, int q1) {
     qubit0 = q0;
     qubit1 = q1;
     m0 = mat[0];
@@ -1454,19 +1272,12 @@ class DiagonalMult4x4 : public GateFuncBase<data_t>
     m3 = mat[3];
   }
 
-  bool is_diagonal(void)
-  {
-    return true;
-  }
-  int qubits_count(void)
-  {
-    return 2;
-  }
+  bool is_diagonal(void) { return true; }
+  int qubits_count(void) { return 2; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
+  __host__ __device__ void operator()(const uint_t &i) const {
     thrust::complex<data_t> q;
-    thrust::complex<data_t>* vec;
+    thrust::complex<data_t> *vec;
     thrust::complex<double> m;
     uint_t gid;
 
@@ -1474,59 +1285,42 @@ class DiagonalMult4x4 : public GateFuncBase<data_t>
     gid = this->base_index_;
 
     q = vec[i];
-    if((((i+gid) >> qubit1) & 1) == 0){
-      if((((i+gid) >> qubit0) & 1) == 0){
+    if ((((i + gid) >> qubit1) & 1) == 0) {
+      if ((((i + gid) >> qubit0) & 1) == 0) {
         m = m0;
-      }
-      else{
+      } else {
         m = m1;
       }
-    }
-    else{
-      if((((i+gid) >> qubit0) & 1) == 0){
+    } else {
+      if ((((i + gid) >> qubit0) & 1) == 0) {
         m = m2;
-      }
-      else{
+      } else {
         m = m3;
       }
     }
 
     vec[i] = m * q;
   }
-  const char* name(void)
-  {
-    return "diagonal_mult4x4";
-  }
+  const char *name(void) { return "diagonal_mult4x4"; }
 };
 
-template <typename data_t>
-class DiagonalMultNxN : public GateFuncBase<data_t>
-{
+template <typename data_t> class DiagonalMultNxN : public GateFuncBase<data_t> {
 protected:
   int nqubits;
+
 public:
-  DiagonalMultNxN(const reg_t &qb)
-  {
-    nqubits = qb.size();
-  }
+  DiagonalMultNxN(const reg_t &qb) { nqubits = qb.size(); }
 
-  bool is_diagonal(void)
-  {
-    return true;
-  }
-  int qubits_count(void)
-  {
-    return nqubits;
-  }
+  bool is_diagonal(void) { return true; }
+  int qubits_count(void) { return nqubits; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    uint_t j,im;
-    thrust::complex<data_t>* vec;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    uint_t j, im;
+    thrust::complex<data_t> *vec;
     thrust::complex<data_t> q;
     thrust::complex<double> m;
-    thrust::complex<double>* pMat;
-    uint_t* qubits;
+    thrust::complex<double> *pMat;
+    uint_t *qubits;
     uint_t gid;
 
     vec = this->data_;
@@ -1536,8 +1330,8 @@ class DiagonalMultNxN : public GateFuncBase<data_t>
     qubits = this->params_;
 
     im = 0;
-    for(j=0;j<nqubits;j++){
-      if((((i + gid) >> qubits[j]) & 1) != 0){
+    for (j = 0; j < nqubits; j++) {
+      if ((((i + gid) >> qubits[j]) & 1) != 0) {
         im += (1 << j);
       }
     }
@@ -1547,132 +1341,109 @@ class DiagonalMultNxN : public GateFuncBase<data_t>
 
     vec[i] = m * q;
   }
-  const char* name(void)
-  {
-    return "diagonal_multNxN";
-  }
+  const char *name(void) { return "diagonal_multNxN"; }
 };
 
 template <typename data_t>
-class DiagonalMult2x2Controlled : public GateFuncBase<data_t> 
-{
+class DiagonalMult2x2Controlled : public GateFuncBase<data_t> {
 protected:
-  thrust::complex<double> m0,m1;
+  thrust::complex<double> m0, m1;
   uint_t mask;
   uint_t cmask;
   int nqubits;
+
 public:
-  DiagonalMult2x2Controlled(const cvector_t<double>& mat,const reg_t &qubits)
-  {
+  DiagonalMult2x2Controlled(const cvector_t<double> &mat, const reg_t &qubits) {
     int i;
     nqubits = qubits.size();
 
     m0 = mat[0];
     m1 = mat[1];
 
-    mask = (1ull << qubits[nqubits-1]) - 1;
+    mask = (1ull << qubits[nqubits - 1]) - 1;
     cmask = 0;
-    for(i=0;i<nqubits-1;i++){
+    for (i = 0; i < nqubits - 1; i++) {
       cmask |= (1ull << qubits[i]);
     }
   }
 
-  int qubits_count(void)
-  {
-    return nqubits;
-  }
-  int num_control_bits(void)
-  {
-    return nqubits - 1;
-  }
+  int qubits_count(void) { return nqubits; }
+  int num_control_bits(void) { return nqubits - 1; }
 
-  bool is_diagonal(void)
-  {
-    return true;
-  }
+  bool is_diagonal(void) { return true; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
+  __host__ __device__ void operator()(const uint_t &i) const {
     uint_t gid;
-    thrust::complex<data_t>* vec;
+    thrust::complex<data_t> *vec;
     thrust::complex<data_t> q0;
     thrust::complex<double> m;
 
     vec = this->data_;
     gid = this->base_index_;
 
-    if(((i + gid) & cmask) == cmask){
-      if((i + gid) & mask){
+    if (((i + gid) & cmask) == cmask) {
+      if ((i + gid) & mask) {
         m = m1;
-      }
-      else{
+      } else {
         m = m0;
       }
 
       q0 = vec[i];
-      vec[i] = m*q0;
+      vec[i] = m * q0;
     }
   }
-  const char* name(void)
-  {
-    return "diagonal_Cmult2x2";
-  }
+  const char *name(void) { return "diagonal_Cmult2x2"; }
 };
 
 //------------------------------------------------------------------------------
 // Permutation
 //------------------------------------------------------------------------------
-template <typename data_t>
-class Permutation : public GateFuncBase<data_t>
-{
+template <typename data_t> class Permutation : public GateFuncBase<data_t> {
 protected:
   uint_t nqubits;
   uint_t npairs;
 
 public:
-  Permutation(const reg_t& qubits_sorted,const reg_t& qubits,const std::vector<std::pair<uint_t, uint_t>> &pairs,reg_t& params)
-  {
-    uint_t j,k;
-    uint_t offset0,offset1;
+  Permutation(const reg_t &qubits_sorted, const reg_t &qubits,
+              const std::vector<std::pair<uint_t, uint_t>> &pairs,
+              reg_t &params) {
+    uint_t j, k;
+    uint_t offset0, offset1;
 
     nqubits = qubits.size();
     npairs = pairs.size();
 
-    params.resize(nqubits + npairs*2);
+    params.resize(nqubits + npairs * 2);
 
-    for(j=0;j<nqubits;j++){ //save masks
+    for (j = 0; j < nqubits; j++) { // save masks
       params[j] = (1ull << qubits_sorted[j]) - 1;
     }
-    //make offset for pairs
-    for(j=0;j<npairs;j++){
+    // make offset for pairs
+    for (j = 0; j < npairs; j++) {
       offset0 = 0;
       offset1 = 0;
-      for(k=0;k<nqubits;k++){
-        if(((pairs[j].first >> k) & 1) != 0){
+      for (k = 0; k < nqubits; k++) {
+        if (((pairs[j].first >> k) & 1) != 0) {
           offset0 += (1ull << qubits[k]);
         }
-        if(((pairs[j].second >> k) & 1) != 0){
+        if (((pairs[j].second >> k) & 1) != 0) {
           offset1 += (1ull << qubits[k]);
         }
       }
-      params[nqubits + j*2  ] = offset0;
-      params[nqubits + j*2+1] = offset1;
+      params[nqubits + j * 2] = offset0;
+      params[nqubits + j * 2 + 1] = offset1;
     }
   }
-  int qubits_count(void)
-  {
-    return nqubits;
-  }
+  int qubits_count(void) { return nqubits; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    thrust::complex<data_t>* vec;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    thrust::complex<data_t> *vec;
     thrust::complex<data_t> q0;
     thrust::complex<data_t> q1;
     uint_t j;
-    uint_t ii,idx,t;
-    uint_t* mask;
-    uint_t* pairs;
+    uint_t ii, idx, t;
+    uint_t *mask;
+    uint_t *pairs;
 
     vec = this->data_;
     mask = this->params_;
@@ -1680,71 +1451,58 @@ class Permutation : public GateFuncBase<data_t>
 
     idx = 0;
     ii = i;
-    for(j=0;j<nqubits;j++){
+    for (j = 0; j < nqubits; j++) {
       t = ii & mask[j];
       idx += t;
       ii = (ii - t) << 1;
     }
     idx += ii;
 
-    for(j=0;j<npairs;j++){
-      q0 = vec[idx + pairs[j*2]];
-      q1 = vec[idx + pairs[j*2+1]];
+    for (j = 0; j < npairs; j++) {
+      q0 = vec[idx + pairs[j * 2]];
+      q1 = vec[idx + pairs[j * 2 + 1]];
 
-      vec[idx + pairs[j*2]]   = q1;
-      vec[idx + pairs[j*2+1]] = q0;
+      vec[idx + pairs[j * 2]] = q1;
+      vec[idx + pairs[j * 2 + 1]] = q0;
     }
   }
-  const char* name(void)
-  {
-    return "Permutation";
-  }
+  const char *name(void) { return "Permutation"; }
 };
 
 //------------------------------------------------------------------------------
 // X gate
 //------------------------------------------------------------------------------
-template <typename data_t>
-class CX_func : public GateFuncBase<data_t>
-{
+template <typename data_t> class CX_func : public GateFuncBase<data_t> {
 protected:
   uint_t offset;
   uint_t mask;
   uint_t cmask;
   int nqubits;
   int qubit_t;
-public:
 
-  CX_func(const reg_t &qubits)
-  {
+public:
+  CX_func(const reg_t &qubits) {
     int i;
     nqubits = qubits.size();
 
-    qubit_t = qubits[nqubits-1];
+    qubit_t = qubits[nqubits - 1];
     offset = 1ull << qubit_t;
     mask = offset - 1;
 
     cmask = 0;
-    for(i=0;i<nqubits-1;i++){
+    for (i = 0; i < nqubits - 1; i++) {
       cmask |= (1ull << qubits[i]);
     }
   }
 
-  int qubits_count(void)
-  {
-    return nqubits;
-  }
-  int num_control_bits(void)
-  {
-    return nqubits - 1;
-  }
+  int qubits_count(void) { return nqubits; }
+  int num_control_bits(void) { return nqubits - 1; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    uint_t i0,i1;
-    thrust::complex<data_t> q0,q1;
-    thrust::complex<data_t>* vec0;
-    thrust::complex<data_t>* vec1;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    uint_t i0, i1;
+    thrust::complex<data_t> q0, q1;
+    thrust::complex<data_t> *vec0;
+    thrust::complex<data_t> *vec1;
 
     vec0 = this->data_;
     vec1 = vec0 + offset;
@@ -1753,7 +1511,7 @@ class CX_func : public GateFuncBase<data_t>
     i0 = (i - i1) << 1;
     i0 += i1;
 
-    if(((i0 + this->base_index_) & cmask) == cmask){
+    if (((i0 + this->base_index_) & cmask) == cmask) {
       q0 = vec0[i0];
       q1 = vec1[i0];
 
@@ -1761,55 +1519,43 @@ class CX_func : public GateFuncBase<data_t>
       vec1[i0] = q0;
     }
   }
-  const char* name(void)
-  {
-    return "CX";
-  }
+  const char *name(void) { return "CX"; }
 };
 
 //------------------------------------------------------------------------------
 // Y gate
 //------------------------------------------------------------------------------
-template <typename data_t>
-class CY_func : public GateFuncBase<data_t>
-{
+template <typename data_t> class CY_func : public GateFuncBase<data_t> {
 protected:
   uint_t mask;
   uint_t cmask;
   uint_t offset;
   int nqubits;
   int qubit_t;
+
 public:
-  CY_func(const reg_t &qubits)
-  {
+  CY_func(const reg_t &qubits) {
     int i;
     nqubits = qubits.size();
 
-    qubit_t = qubits[nqubits-1];
+    qubit_t = qubits[nqubits - 1];
     offset = (1ull << qubit_t);
     mask = (1ull << qubit_t) - 1;
 
     cmask = 0;
-    for(i=0;i<nqubits-1;i++){
+    for (i = 0; i < nqubits - 1; i++) {
       cmask |= (1ull << qubits[i]);
     }
   }
 
-  int qubits_count(void)
-  {
-    return nqubits;
-  }
-  int num_control_bits(void)
-  {
-    return nqubits - 1;
-  }
+  int qubits_count(void) { return nqubits; }
+  int num_control_bits(void) { return nqubits - 1; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    uint_t i0,i1;
-    thrust::complex<data_t> q0,q1;
-    thrust::complex<data_t>* vec0;
-    thrust::complex<data_t>* vec1;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    uint_t i0, i1;
+    thrust::complex<data_t> q0, q1;
+    thrust::complex<data_t> *vec0;
+    thrust::complex<data_t> *vec1;
 
     vec0 = this->data_;
 
@@ -1819,26 +1565,21 @@ class CY_func : public GateFuncBase<data_t>
     i0 = (i - i1) << 1;
     i0 += i1;
 
-    if(((i0 + this->base_index_) & cmask) == cmask){
+    if (((i0 + this->base_index_) & cmask) == cmask) {
       q0 = vec0[i0];
       q1 = vec1[i0];
 
-      vec0[i0] = thrust::complex<data_t>(q1.imag(),-q1.real());
-      vec1[i0] = thrust::complex<data_t>(-q0.imag(),q0.real());
+      vec0[i0] = thrust::complex<data_t>(q1.imag(), -q1.real());
+      vec1[i0] = thrust::complex<data_t>(-q0.imag(), q0.real());
     }
   }
-  const char* name(void)
-  {
-    return "CY";
-  }
+  const char *name(void) { return "CY"; }
 };
 
 //------------------------------------------------------------------------------
 // Swap gate
 //------------------------------------------------------------------------------
-template <typename data_t>
-class CSwap_func : public GateFuncBase<data_t>
-{
+template <typename data_t> class CSwap_func : public GateFuncBase<data_t> {
 protected:
   uint_t mask0;
   uint_t mask1;
@@ -1848,20 +1589,18 @@ class CSwap_func : public GateFuncBase<data_t>
   int qubit_t1;
   uint_t offset1;
   uint_t offset2;
-public:
 
-  CSwap_func(const reg_t &qubits)
-  {
+public:
+  CSwap_func(const reg_t &qubits) {
     int i;
     nqubits = qubits.size();
 
-    if(qubits[nqubits-2] < qubits[nqubits-1]){
-      qubit_t0 = qubits[nqubits-2];
-      qubit_t1 = qubits[nqubits-1];
-    }
-    else{
-      qubit_t1 = qubits[nqubits-2];
-      qubit_t0 = qubits[nqubits-1];
+    if (qubits[nqubits - 2] < qubits[nqubits - 1]) {
+      qubit_t0 = qubits[nqubits - 2];
+      qubit_t1 = qubits[nqubits - 1];
+    } else {
+      qubit_t1 = qubits[nqubits - 2];
+      qubit_t0 = qubits[nqubits - 1];
     }
     mask0 = (1ull << qubit_t0) - 1;
     mask1 = (1ull << qubit_t1) - 1;
@@ -1870,26 +1609,19 @@ class CSwap_func : public GateFuncBase<data_t>
     offset2 = 1ull << qubit_t1;
 
     cmask = 0;
-    for(i=0;i<nqubits-2;i++){
+    for (i = 0; i < nqubits - 2; i++) {
       cmask |= (1ull << qubits[i]);
     }
   }
 
-  int qubits_count(void)
-  {
-    return nqubits;
-  }
-  int num_control_bits(void)
-  {
-    return nqubits - 2;
-  }
+  int qubits_count(void) { return nqubits; }
+  int num_control_bits(void) { return nqubits - 2; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    uint_t i0,i1,i2;
-    thrust::complex<data_t> q1,q2;
-    thrust::complex<data_t>* vec1;
-    thrust::complex<data_t>* vec2;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    uint_t i0, i1, i2;
+    thrust::complex<data_t> q1, q2;
+    thrust::complex<data_t> *vec1;
+    thrust::complex<data_t> *vec2;
 
     vec1 = this->data_;
 
@@ -1903,75 +1635,63 @@ class CSwap_func : public GateFuncBase<data_t>
 
     i0 = i0 + i1 + i2;
 
-    if(((i0 + this->base_index_) & cmask) == cmask){
+    if (((i0 + this->base_index_) & cmask) == cmask) {
       q1 = vec1[i0];
       q2 = vec2[i0];
       vec1[i0] = q2;
       vec2[i0] = q1;
     }
   }
-  const char* name(void)
-  {
-    return "CSWAP";
-  }
+  const char *name(void) { return "CSWAP"; }
 };
 
 template <typename data_t>
-class MultiSwap_func : public GateFuncWithCache<data_t>
-{
+class MultiSwap_func : public GateFuncWithCache<data_t> {
 protected:
-  
 public:
+  MultiSwap_func(uint_t nq) : GateFuncWithCache<data_t>(nq) {}
 
-  MultiSwap_func(uint_t nq) : GateFuncWithCache<data_t>(nq)
-  {
-  }
-
-  __host__ __device__ void run_with_cache(uint_t _tid,uint_t _idx,thrust::complex<data_t>* _cache) const
-  {
-    thrust::complex<data_t>* vec;
+  __host__ __device__ void
+  run_with_cache(uint_t _tid, uint_t _idx,
+                 thrust::complex<data_t> *_cache) const {
+    thrust::complex<data_t> *vec;
     uint_t pos = _tid & 1023;
     uint_t j;
 
     vec = this->data_;
 
-    for(j=0;j<this->nqubits_;j+=2){
-      if((((pos >> j) & 1) ^ ((pos >> (j+1)) & 1)) != 0){
-        pos ^= ((1ull << j) | (1ull << (j+1)));
+    for (j = 0; j < this->nqubits_; j += 2) {
+      if ((((pos >> j) & 1) ^ ((pos >> (j + 1)) & 1)) != 0) {
+        pos ^= ((1ull << j) | (1ull << (j + 1)));
       }
     }
     vec[_idx] = _cache[pos];
   }
-  const char* name(void)
-  {
-    return "MultiSWAP";
-  }
+  const char *name(void) { return "MultiSWAP"; }
 };
 
-//swap operator between chunks
-template <typename data_t>
-class CSwapChunk_func : public GateFuncBase<data_t>
-{
+// swap operator between chunks
+template <typename data_t> class CSwapChunk_func : public GateFuncBase<data_t> {
 protected:
   uint_t mask;
-  thrust::complex<data_t>* vec0;
-  thrust::complex<data_t>* vec1;
+  thrust::complex<data_t> *vec0;
+  thrust::complex<data_t> *vec1;
   bool write_back_;
   bool swap_all_;
-public:
 
-  CSwapChunk_func(const reg_t &qubits,uint_t block_bits,thrust::complex<data_t>* pVec0,thrust::complex<data_t>* pVec1,bool wb)
-  {
+public:
+  CSwapChunk_func(const reg_t &qubits, uint_t block_bits,
+                  thrust::complex<data_t> *pVec0,
+                  thrust::complex<data_t> *pVec1, bool wb) {
     int i;
     int nqubits;
     int qubit_t;
     nqubits = qubits.size();
 
-    if(qubits[nqubits-2] < qubits[nqubits-1]){
-      qubit_t = qubits[nqubits-2];
-    }
-    else{
-      qubit_t = qubits[nqubits-1];
+    if (qubits[nqubits - 2] < qubits[nqubits - 1]) {
+      qubit_t = qubits[nqubits - 2];
+    } else {
+      qubit_t = qubits[nqubits - 1];
     }
     mask = (1ull << qubit_t) - 1;
 
@@ -1979,25 +1699,18 @@ class CSwapChunk_func : public GateFuncBase<data_t>
     vec1 = pVec1;
 
     write_back_ = wb;
-    if(qubit_t >= block_bits)
+    if (qubit_t >= block_bits)
       swap_all_ = true;
     else
       swap_all_ = false;
   }
 
-  bool batch_enable(void)
-  {
-    return false;
-  }
-  bool is_diagonal(void)
-  {
-    return swap_all_;
-  }
+  bool batch_enable(void) { return false; }
+  bool is_diagonal(void) { return swap_all_; }
 
-  __host__ __device__  void operator()(const uint_t &i) const
-  {
-    uint_t i0,i1;
-    thrust::complex<data_t> q0,q1;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    uint_t i0, i1;
+    thrust::complex<data_t> q0, q1;
 
     i0 = i & mask;
     i1 = (i - i0) << 1;
@@ -2006,201 +1719,151 @@ class CSwapChunk_func : public GateFuncBase<data_t>
     q0 = vec0[i0];
     q1 = vec1[i0];
     vec0[i0] = q1;
-    if(write_back_)
+    if (write_back_)
       vec1[i0] = q0;
   }
-  const char* name(void)
-  {
-    return "Chunk SWAP";
-  }
+  const char *name(void) { return "Chunk SWAP"; }
 };
 
-
-//buffer swap
-template <typename data_t>
-class BufferSwap_func : public GateFuncBase<data_t>
-{
+// buffer swap
+template <typename data_t> class BufferSwap_func : public GateFuncBase<data_t> {
 protected:
   uint_t mask;
-  thrust::complex<data_t>* vec0_;
-  thrust::complex<data_t>* vec1_;
+  thrust::complex<data_t> *vec0_;
+  thrust::complex<data_t> *vec1_;
   uint_t size_;
   bool write_back_;
-public:
 
-  BufferSwap_func(thrust::complex<data_t>* pVec0,thrust::complex<data_t>* pVec1,uint_t size,bool wb)
-  {
+public:
+  BufferSwap_func(thrust::complex<data_t> *pVec0,
+                  thrust::complex<data_t> *pVec1, uint_t size, bool wb) {
     vec0_ = pVec0;
     vec1_ = pVec1;
     size_ = size;
     write_back_ = wb;
   }
 
-  bool is_diagonal(void)
-  {
-    return true;
-  }
+  bool is_diagonal(void) { return true; }
 
-  __host__ __device__  void operator()(const uint_t &i) const
-  {
-    thrust::complex<data_t> q0,q1;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    thrust::complex<data_t> q0, q1;
 
-    if(i < size_){
+    if (i < size_) {
       q1 = vec1_[i];
-      if(write_back_){
+      if (write_back_) {
         q0 = vec0_[i];
         vec1_[i] = q0;
       }
       vec0_[i] = q1;
     }
   }
-  const char* name(void)
-  {
-    return "buffer swap";
-  }
+  const char *name(void) { return "buffer swap"; }
 };
 
-
 //------------------------------------------------------------------------------
 // Phase gate
 //------------------------------------------------------------------------------
-template <typename data_t>
-class phase_func : public GateFuncBase<data_t> 
-{
+template <typename data_t> class phase_func : public GateFuncBase<data_t> {
 protected:
   thrust::complex<double> phase;
   uint_t mask;
   int nqubits;
+
 public:
-  phase_func(const reg_t &qubits,thrust::complex<double> p)
-  {
+  phase_func(const reg_t &qubits, thrust::complex<double> p) {
     int i;
     nqubits = qubits.size();
     phase = p;
 
     mask = 0;
-    for(i=0;i<nqubits;i++){
+    for (i = 0; i < nqubits; i++) {
       mask |= (1ull << qubits[i]);
     }
   }
-  bool is_diagonal(void)
-  {
-    return true;
-  }
+  bool is_diagonal(void) { return true; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
+  __host__ __device__ void operator()(const uint_t &i) const {
     uint_t gid;
-    thrust::complex<data_t>* vec;
+    thrust::complex<data_t> *vec;
     thrust::complex<data_t> q0;
 
     vec = this->data_;
     gid = this->base_index_;
 
-    if(((i+gid) & mask) == mask){
+    if (((i + gid) & mask) == mask) {
       q0 = vec[i];
       vec[i] = q0 * phase;
     }
   }
-  const char* name(void)
-  {
-    return "phase";
-  }
+  const char *name(void) { return "phase"; }
 };
 
 //------------------------------------------------------------------------------
 // Norm functions
 //------------------------------------------------------------------------------
-template <typename data_t>
-class norm_func : public GateFuncBase<data_t>
-{
+template <typename data_t> class norm_func : public GateFuncBase<data_t> {
 protected:
 public:
-  norm_func(void)
-  {
+  norm_func(void) {}
+  bool is_diagonal(void) { return true; }
 
-  }
-  bool is_diagonal(void)
-  {
-    return true;
-  }
-
-  __host__ __device__ double operator()(const uint_t &i) const
-  {
+  __host__ __device__ double operator()(const uint_t &i) const {
     thrust::complex<data_t> q;
-    thrust::complex<data_t>* vec;
+    thrust::complex<data_t> *vec;
     double d;
 
     vec = this->data_;
     q = vec[i];
-    d = (double)(q.real()*q.real() + q.imag()*q.imag());
+    d = (double)(q.real() * q.real() + q.imag() * q.imag());
     return d;
   }
 
-  const char* name(void)
-  {
-    return "norm";
-  }
+  const char *name(void) { return "norm"; }
 };
 
-template <typename data_t>
-class trace_func : public GateFuncBase<data_t>
-{
+template <typename data_t> class trace_func : public GateFuncBase<data_t> {
 protected:
   uint_t rows_;
+
 public:
-  trace_func(uint_t nrow)
-  {
-    rows_ = nrow;
-  }
-  bool is_diagonal(void)
-  {
-    return true;
-  }
-  uint_t size(int num_qubits)
-  {
+  trace_func(uint_t nrow) { rows_ = nrow; }
+  bool is_diagonal(void) { return true; }
+  uint_t size(int num_qubits) {
     this->chunk_bits_ = num_qubits;
     return rows_;
   }
 
-  __host__ __device__ double operator()(const uint_t &i) const
-  {
+  __host__ __device__ double operator()(const uint_t &i) const {
     thrust::complex<data_t> q;
-    thrust::complex<data_t>* vec;
+    thrust::complex<data_t> *vec;
 
     uint_t iChunk = (i / rows_);
     uint_t lid = i - (iChunk * rows_);
-    uint_t idx = (iChunk << this->chunk_bits_) + lid*(rows_ + 1);
+    uint_t idx = (iChunk << this->chunk_bits_) + lid * (rows_ + 1);
 
     vec = this->data_;
     q = vec[idx];
     return q.real();
   }
 
-  const char* name(void)
-  {
-    return "trace";
-  }
+  const char *name(void) { return "trace"; }
 };
 
 template <typename data_t>
-class NormMatrixMultNxN : public GateFuncSumWithCache<data_t>
-{
+class NormMatrixMultNxN : public GateFuncSumWithCache<data_t> {
 protected:
 public:
-  NormMatrixMultNxN(uint_t nq) : GateFuncSumWithCache<data_t>(nq)
-  {
-    ;
-  }
+  NormMatrixMultNxN(uint_t nq) : GateFuncSumWithCache<data_t>(nq) { ; }
 
-  __host__ __device__ double run_with_cache_sum(uint_t _tid,uint_t _idx,thrust::complex<data_t>* _cache) const
-  {
+  __host__ __device__ double
+  run_with_cache_sum(uint_t _tid, uint_t _idx,
+                     thrust::complex<data_t> *_cache) const {
     uint_t j;
-    thrust::complex<data_t> q,r;
+    thrust::complex<data_t> q, r;
     thrust::complex<double> m;
-    uint_t mat_size,irow;
-    thrust::complex<data_t>* vec;
-    thrust::complex<double>* pMat;
+    uint_t mat_size, irow;
+    thrust::complex<data_t> *vec;
+    thrust::complex<double> *pMat;
 
     vec = this->data_;
     pMat = this->matrix_;
@@ -2209,51 +1872,37 @@ class NormMatrixMultNxN : public GateFuncSumWithCache<data_t>
     irow = _tid & (mat_size - 1);
 
     r = 0.0;
-    for(j=0;j<mat_size;j++){
-      m = pMat[irow + mat_size*j];
+    for (j = 0; j < mat_size; j++) {
+      m = pMat[irow + mat_size * j];
       q = _cache[_tid - irow + j];
 
-      r += m*q;
+      r += m * q;
     }
 
-    return (r.real()*r.real() + r.imag()*r.imag());
-  }
-
-  const char* name(void)
-  {
-    return "NormmultNxN";
+    return (r.real() * r.real() + r.imag() * r.imag());
   }
 
+  const char *name(void) { return "NormmultNxN"; }
 };
 
 template <typename data_t>
-class NormDiagonalMultNxN : public GateFuncBase<data_t>
-{
+class NormDiagonalMultNxN : public GateFuncBase<data_t> {
 protected:
   int nqubits;
+
 public:
-  NormDiagonalMultNxN(const reg_t &qb)
-  {
-    nqubits = qb.size();
-  }
+  NormDiagonalMultNxN(const reg_t &qb) { nqubits = qb.size(); }
 
-  bool is_diagonal(void)
-  {
-    return true;
-  }
-  int qubits_count(void)
-  {
-    return nqubits;
-  }
+  bool is_diagonal(void) { return true; }
+  int qubits_count(void) { return nqubits; }
 
-  __host__ __device__ double operator()(const uint_t &i) const
-  {
-    uint_t im,j,gid;
+  __host__ __device__ double operator()(const uint_t &i) const {
+    uint_t im, j, gid;
     thrust::complex<data_t> q;
-    thrust::complex<double> m,r;
-    thrust::complex<double>* pMat;
-    thrust::complex<data_t>* vec;
-    uint_t* qubits;
+    thrust::complex<double> m, r;
+    thrust::complex<double> *pMat;
+    thrust::complex<data_t> *vec;
+    uint_t *qubits;
 
     vec = this->data_;
     pMat = this->matrix_;
@@ -2261,8 +1910,8 @@ class NormDiagonalMultNxN : public GateFuncBase<data_t>
     gid = this->base_index_;
 
     im = 0;
-    for(j=0;j<nqubits;j++){
-      if(((i+gid) & (1ull << qubits[j])) != 0){
+    for (j = 0; j < nqubits; j++) {
+      if (((i + gid) & (1ull << qubits[j])) != 0) {
         im += (1 << j);
       }
     }
@@ -2271,25 +1920,21 @@ class NormDiagonalMultNxN : public GateFuncBase<data_t>
     m = pMat[im];
 
     r = m * q;
-    return (r.real()*r.real() + r.imag()*r.imag());
-  }
-  const char* name(void)
-  {
-    return "Norm_diagonal_multNxN";
+    return (r.real() * r.real() + r.imag() * r.imag());
   }
+  const char *name(void) { return "Norm_diagonal_multNxN"; }
 };
 
 template <typename data_t>
-class NormMatrixMult2x2 : public GateFuncBase<data_t>
-{
+class NormMatrixMult2x2 : public GateFuncBase<data_t> {
 protected:
-  thrust::complex<double> m0,m1,m2,m3;
+  thrust::complex<double> m0, m1, m2, m3;
   int qubit;
   uint_t mask;
   uint_t offset;
+
 public:
-  NormMatrixMult2x2(const cvector_t<double> &mat,int q)
-  {
+  NormMatrixMult2x2(const cvector_t<double> &mat, int q) {
     qubit = q;
     m0 = mat[0];
     m1 = mat[1];
@@ -2300,12 +1945,11 @@ class NormMatrixMult2x2 : public GateFuncBase<data_t>
     mask = (1ull << qubit) - 1;
   }
 
-  __host__ __device__ double operator()(const uint_t &i) const
-  {
-    uint_t i0,i1;
-    thrust::complex<data_t>* vec;
-    thrust::complex<data_t> q0,q1;
-    thrust::complex<double> r0,r1;
+  __host__ __device__ double operator()(const uint_t &i) const {
+    uint_t i0, i1;
+    thrust::complex<data_t> *vec;
+    thrust::complex<data_t> q0, q1;
+    thrust::complex<double> r0, r1;
     double sum = 0.0;
 
     vec = this->data_;
@@ -2315,140 +1959,117 @@ class NormMatrixMult2x2 : public GateFuncBase<data_t>
     i0 += i1;
 
     q0 = vec[i0];
-    q1 = vec[offset+i0];
+    q1 = vec[offset + i0];
 
     r0 = m0 * q0 + m2 * q1;
-    sum += r0.real()*r0.real() + r0.imag()*r0.imag();
+    sum += r0.real() * r0.real() + r0.imag() * r0.imag();
     r1 = m1 * q0 + m3 * q1;
-    sum += r1.real()*r1.real() + r1.imag()*r1.imag();
+    sum += r1.real() * r1.real() + r1.imag() * r1.imag();
     return sum;
   }
-  const char* name(void)
-  {
-    return "Norm_mult2x2";
-  }
+  const char *name(void) { return "Norm_mult2x2"; }
 };
 
 template <typename data_t>
-class NormDiagonalMult2x2 : public GateFuncBase<data_t>
-{
+class NormDiagonalMult2x2 : public GateFuncBase<data_t> {
 protected:
-  thrust::complex<double> m0,m1;
+  thrust::complex<double> m0, m1;
   int qubit;
+
 public:
-  NormDiagonalMult2x2(cvector_t<double> &mat,int q)
-  {
+  NormDiagonalMult2x2(cvector_t<double> &mat, int q) {
     qubit = q;
     m0 = mat[0];
     m1 = mat[1];
   }
 
-  bool is_diagonal(void)
-  {
-    return true;
-  }
+  bool is_diagonal(void) { return true; }
 
-  __host__ __device__ double operator()(const uint_t &i) const
-  {
+  __host__ __device__ double operator()(const uint_t &i) const {
     uint_t gid;
-    thrust::complex<data_t>* vec;
+    thrust::complex<data_t> *vec;
     thrust::complex<data_t> q;
-    thrust::complex<double> m,r;
+    thrust::complex<double> m, r;
 
     vec = this->data_;
     gid = this->base_index_;
 
     q = vec[i];
-    if((((i+gid) >> qubit) & 1) == 0){
+    if ((((i + gid) >> qubit) & 1) == 0) {
       m = m0;
-    }
-    else{
+    } else {
       m = m1;
     }
 
     r = m * q;
 
-    return (r.real()*r.real() + r.imag()*r.imag());
-  }
-  const char* name(void)
-  {
-    return "Norm_diagonal_mult2x2";
+    return (r.real() * r.real() + r.imag() * r.imag());
   }
+  const char *name(void) { return "Norm_diagonal_mult2x2"; }
 };
 
 //------------------------------------------------------------------------------
 // Probabilities
 //------------------------------------------------------------------------------
 template <typename data_t>
-class probability_func : public GateFuncBase<data_t>
-{
+class probability_func : public GateFuncBase<data_t> {
 protected:
   uint_t mask;
   uint_t cmask;
+
 public:
-  probability_func(const reg_t &qubits,int i)
-  {
+  probability_func(const reg_t &qubits, int i) {
     int k;
     int nq = qubits.size();
 
     mask = 0;
     cmask = 0;
-    for(k=0;k<nq;k++){
+    for (k = 0; k < nq; k++) {
       mask |= (1ull << qubits[k]);
 
-      if(((i >> k) & 1) != 0){
+      if (((i >> k) & 1) != 0) {
         cmask |= (1ull << qubits[k]);
       }
     }
   }
 
-  bool is_diagonal(void)
-  {
-    return true;
-  }
+  bool is_diagonal(void) { return true; }
 
-  __host__ __device__ double operator()(const uint_t &i) const
-  {
+  __host__ __device__ double operator()(const uint_t &i) const {
     thrust::complex<data_t> q;
-    thrust::complex<data_t>* vec;
+    thrust::complex<data_t> *vec;
     double ret;
 
     vec = this->data_;
 
     ret = 0.0;
 
-    if((i & mask) == cmask){
+    if ((i & mask) == cmask) {
       q = vec[i];
-      ret = q.real()*q.real() + q.imag()*q.imag();
+      ret = q.real() * q.real() + q.imag() * q.imag();
     }
     return ret;
   }
 
-  const char* name(void)
-  {
-    return "probabilities";
-  }
+  const char *name(void) { return "probabilities"; }
 };
 
 template <typename data_t>
-class probability_1qubit_func : public GateFuncBase<data_t>
-{
+class probability_1qubit_func : public GateFuncBase<data_t> {
 protected:
   uint_t offset;
-public:
-  probability_1qubit_func(const uint_t qubit)
-  {
-    offset = 1ull << qubit;
-  }
 
-  __host__ __device__ thrust::complex<double> operator()(const uint_t &i) const
-  {
-    uint_t i0,i1;
-    thrust::complex<data_t> q0,q1;
-    thrust::complex<data_t>* vec0;
-    thrust::complex<data_t>* vec1;
+public:
+  probability_1qubit_func(const uint_t qubit) { offset = 1ull << qubit; }
+
+  __host__ __device__ thrust::complex<double>
+  operator()(const uint_t &i) const {
+    uint_t i0, i1;
+    thrust::complex<data_t> q0, q1;
+    thrust::complex<data_t> *vec0;
+    thrust::complex<data_t> *vec1;
     thrust::complex<double> ret;
-    double d0,d1;
+    double d0, d1;
 
     vec0 = this->data_;
     vec1 = vec0 + offset;
@@ -2460,24 +2081,20 @@ class probability_1qubit_func : public GateFuncBase<data_t>
     q0 = vec0[i0];
     q1 = vec1[i0];
 
-    d0 = (double)(q0.real()*q0.real() + q0.imag()*q0.imag());
-    d1 = (double)(q1.real()*q1.real() + q1.imag()*q1.imag());
+    d0 = (double)(q0.real() * q0.real() + q0.imag() * q0.imag());
+    d1 = (double)(q1.real() * q1.real() + q1.imag() * q1.imag());
 
-    ret = thrust::complex<double>(d0,d1);
+    ret = thrust::complex<double>(d0, d1);
     return ret;
   }
 
-  const char* name(void)
-  {
-    return "probabilities_1qubit";
-  }
+  const char *name(void) { return "probabilities_1qubit"; }
 };
 
 //------------------------------------------------------------------------------
 // Expectation values
 //------------------------------------------------------------------------------
-inline __host__ __device__ uint_t pop_count_kernel(uint_t val)
-{
+inline __host__ __device__ uint_t pop_count_kernel(uint_t val) {
   uint_t count = val;
   count = (count & 0x5555555555555555) + ((count >> 1) & 0x5555555555555555);
   count = (count & 0x3333333333333333) + ((count >> 2) & 0x3333333333333333);
@@ -2488,85 +2105,67 @@ inline __host__ __device__ uint_t pop_count_kernel(uint_t val)
   return count;
 }
 
-//special case Z only
+// special case Z only
 template <typename data_t>
-class expval_pauli_Z_func : public GateFuncBase<data_t>
-{
+class expval_pauli_Z_func : public GateFuncBase<data_t> {
 protected:
   uint_t z_mask_;
 
 public:
-  expval_pauli_Z_func(uint_t z)
-  {
-    z_mask_ = z;
-  }
+  expval_pauli_Z_func(uint_t z) { z_mask_ = z; }
 
-  bool is_diagonal(void)
-  {
-    return true;
-  }
-  bool batch_enable(void)
-  {
-    return false;
-  }
+  bool is_diagonal(void) { return true; }
+  bool batch_enable(void) { return false; }
 
-  __host__ __device__ double operator()(const uint_t &i) const
-  {
-    thrust::complex<data_t>* vec;
+  __host__ __device__ double operator()(const uint_t &i) const {
+    thrust::complex<data_t> *vec;
     thrust::complex<data_t> q0;
     double ret = 0.0;
 
     vec = this->data_;
 
     q0 = vec[i];
-    ret = q0.real()*q0.real() + q0.imag()*q0.imag();
+    ret = q0.real() * q0.real() + q0.imag() * q0.imag();
 
-    if(z_mask_ != 0){
-      if(pop_count_kernel(i & z_mask_) & 1)
+    if (z_mask_ != 0) {
+      if (pop_count_kernel(i & z_mask_) & 1)
         ret = -ret;
     }
 
     return ret;
   }
-  const char* name(void)
-  {
-    return "expval_pauli_Z";
-  }
+  const char *name(void) { return "expval_pauli_Z"; }
 };
 
 template <typename data_t>
-class expval_pauli_XYZ_func : public GateFuncBase<data_t>
-{
+class expval_pauli_XYZ_func : public GateFuncBase<data_t> {
 protected:
   uint_t x_mask_;
   uint_t z_mask_;
   uint_t mask_l_;
   uint_t mask_u_;
   thrust::complex<data_t> phase_;
+
 public:
-  expval_pauli_XYZ_func(uint_t x,uint_t z,uint_t x_max,std::complex<data_t> p)
-  {
+  expval_pauli_XYZ_func(uint_t x, uint_t z, uint_t x_max,
+                        std::complex<data_t> p) {
     x_mask_ = x;
     z_mask_ = z;
     phase_ = p;
 
-    mask_u_ = ~((1ull << (x_max+1)) - 1);
+    mask_u_ = ~((1ull << (x_max + 1)) - 1);
     mask_l_ = (1ull << x_max) - 1;
   }
-  bool batch_enable(void)
-  {
-    return false;
-  }
+  bool batch_enable(void) { return false; }
 
-  __host__ __device__ double operator()(const uint_t &i) const
-  {
-    thrust::complex<data_t>* vec;
+  __host__ __device__ double operator()(const uint_t &i) const {
+    thrust::complex<data_t> *vec;
     thrust::complex<data_t> q0;
     thrust::complex<data_t> q1;
     thrust::complex<data_t> q0p;
     thrust::complex<data_t> q1p;
-    double d0,d1,ret = 0.0;
-    uint_t idx0,idx1;
+    double d0, d1, ret = 0.0;
+    uint_t idx0, idx1;
 
     vec = this->data_;
 
@@ -2577,44 +2176,41 @@ class expval_pauli_XYZ_func : public GateFuncBase<data_t>
     q1 = vec[idx1];
     q0p = q1 * phase_;
     q1p = q0 * phase_;
-    d0 = q0.real()*q0p.real() + q0.imag()*q0p.imag();
-    d1 = q1.real()*q1p.real() + q1.imag()*q1p.imag();
+    d0 = q0.real() * q0p.real() + q0.imag() * q0p.imag();
+    d1 = q1.real() * q1p.real() + q1.imag() * q1p.imag();
 
-    if(z_mask_ != 0){
-      if(pop_count_kernel(idx0 & z_mask_) & 1)
+    if (z_mask_ != 0) {
+      if (pop_count_kernel(idx0 & z_mask_) & 1)
         ret = -d0;
       else
         ret = d0;
-      if(pop_count_kernel(idx1 & z_mask_) & 1)
+      if (pop_count_kernel(idx1 & z_mask_) & 1)
         ret -= d1;
       else
         ret += d1;
-    }
-    else{
+    } else {
       ret = d0 + d1;
     }
 
     return ret;
   }
-  const char* name(void)
-  {
-    return "expval_pauli_XYZ";
-  }
+  const char *name(void) { return "expval_pauli_XYZ"; }
 };
 
 template <typename data_t>
-class expval_pauli_inter_chunk_func : public GateFuncBase<data_t>
-{
+class expval_pauli_inter_chunk_func : public GateFuncBase<data_t> {
 protected:
   uint_t x_mask_;
   uint_t z_mask_;
   thrust::complex<data_t> phase_;
-  thrust::complex<data_t>* pair_chunk_;
+  thrust::complex<data_t> *pair_chunk_;
   uint_t z_count_;
   uint_t z_count_pair_;
+
 public:
-  expval_pauli_inter_chunk_func(uint_t x,uint_t z,std::complex<data_t> p,thrust::complex<data_t>* pair_chunk,uint_t zc,uint_t zcp)
-  {
+  expval_pauli_inter_chunk_func(uint_t x, uint_t z, std::complex<data_t> p,
+                                thrust::complex<data_t> *pair_chunk, uint_t zc,
+                                uint_t zcp) {
     x_mask_ = x;
     z_mask_ = z;
     phase_ = p;
@@ -2624,23 +2220,16 @@ class expval_pauli_inter_chunk_func : public GateFuncBase<data_t>
     z_count_pair_ = zcp;
   }
 
-  bool is_diagonal(void)
-  {
-    return true;
-  }
-  bool batch_enable(void)
-  {
-    return false;
-  }
+  bool is_diagonal(void) { return true; }
+  bool batch_enable(void) { return false; }
 
-  __host__ __device__ double operator()(const uint_t &i) const
-  {
-    thrust::complex<data_t>* vec;
+  __host__ __device__ double operator()(const uint_t &i) const {
+    thrust::complex<data_t> *vec;
     thrust::complex<data_t> q0;
     thrust::complex<data_t> q1;
     thrust::complex<data_t> q0p;
     thrust::complex<data_t> q1p;
-    double d0,d1,ret = 0.0;
+    double d0, d1, ret = 0.0;
     uint_t ip;
 
     vec = this->data_;
@@ -2650,32 +2239,28 @@ class expval_pauli_inter_chunk_func : public GateFuncBase<data_t>
     q1 = pair_chunk_[ip];
     q0p = q1 * phase_;
     q1p = q0 * phase_;
-    d0 = q0.real()*q0p.real() + q0.imag()*q0p.imag();
-    d1 = q1.real()*q1p.real() + q1.imag()*q1p.imag();
+    d0 = q0.real() * q0p.real() + q0.imag() * q0p.imag();
+    d1 = q1.real() * q1p.real() + q1.imag() * q1p.imag();
 
-    if((pop_count_kernel(i & z_mask_) + z_count_) & 1)
+    if ((pop_count_kernel(i & z_mask_) + z_count_) & 1)
       ret = -d0;
     else
       ret = d0;
-    if((pop_count_kernel(ip & z_mask_) + z_count_pair_) & 1)
+    if ((pop_count_kernel(ip & z_mask_) + z_count_pair_) & 1)
       ret -= d1;
     else
       ret += d1;
 
     return ret;
   }
-  const char* name(void)
-  {
-    return "expval_pauli_inter_chunk";
-  }
+  const char *name(void) { return "expval_pauli_inter_chunk"; }
 };
 
 //------------------------------------------------------------------------------
 // Pauli application
 //------------------------------------------------------------------------------
 template <typename data_t>
-class multi_pauli_func : public GateFuncBase<data_t>
-{
+class multi_pauli_func : public GateFuncBase<data_t> {
 protected:
   uint_t x_mask_;
   uint_t z_mask_;
@@ -2683,23 +2268,22 @@ class multi_pauli_func : public GateFuncBase<data_t>
   uint_t mask_u_;
   thrust::complex<data_t> phase_;
   uint_t nqubits_;
+
 public:
-  multi_pauli_func(uint_t x,uint_t z,uint_t x_max,std::complex<data_t> p)
-  {
+  multi_pauli_func(uint_t x, uint_t z, uint_t x_max, std::complex<data_t> p) {
     x_mask_ = x;
     z_mask_ = z;
     phase_ = p;
 
-    mask_u_ = ~((1ull << (x_max+1)) - 1);
+    mask_u_ = ~((1ull << (x_max + 1)) - 1);
     mask_l_ = (1ull << x_max) - 1;
   }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    thrust::complex<data_t>* vec;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    thrust::complex<data_t> *vec;
     thrust::complex<data_t> q0;
     thrust::complex<data_t> q1;
-    uint_t idx0,idx1;
+    uint_t idx0, idx1;
 
     vec = this->data_;
 
@@ -2709,63 +2293,51 @@ class multi_pauli_func : public GateFuncBase<data_t>
     q0 = vec[idx0];
     q1 = vec[idx1];
 
-    if(z_mask_ != 0){
-      if(pop_count_kernel(idx0 & z_mask_) & 1)
+    if (z_mask_ != 0) {
+      if (pop_count_kernel(idx0 & z_mask_) & 1)
         q0 *= -1;
 
-      if(pop_count_kernel(idx1 & z_mask_) & 1)
+      if (pop_count_kernel(idx1 & z_mask_) & 1)
         q1 *= -1;
     }
     vec[idx0] = q1 * phase_;
     vec[idx1] = q0 * phase_;
   }
-  const char* name(void)
-  {
-    return "multi_pauli";
-  }
+  const char *name(void) { return "multi_pauli"; }
 };
 
-//special case Z only
+// special case Z only
 template <typename data_t>
-class multi_pauli_Z_func : public GateFuncBase<data_t>
-{
+class multi_pauli_Z_func : public GateFuncBase<data_t> {
 protected:
   uint_t z_mask_;
   thrust::complex<data_t> phase_;
+
 public:
-  multi_pauli_Z_func(uint_t z,std::complex<data_t> p)
-  {
+  multi_pauli_Z_func(uint_t z, std::complex<data_t> p) {
     z_mask_ = z;
     phase_ = p;
   }
 
-  bool is_diagonal(void)
-  {
-    return true;
-  }
+  bool is_diagonal(void) { return true; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    thrust::complex<data_t>* vec;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    thrust::complex<data_t> *vec;
     thrust::complex<data_t> q0;
 
     vec = this->data_;
 
     q0 = vec[i];
 
-    if(z_mask_ != 0){
-      if(pop_count_kernel(i & z_mask_) & 1)
+    if (z_mask_ != 0) {
+      if (pop_count_kernel(i & z_mask_) & 1)
         q0 = -q0;
     }
     vec[i] = q0 * phase_;
   }
-  const char* name(void)
-  {
-    return "multi_pauli_Z";
-  }
+  const char *name(void) { return "multi_pauli_Z"; }
 };
 
-
 //------------------------------------------------------------------------------
 } // end namespace Chunk
 } // end namespace QV
diff --git a/src/simulators/statevector/indexes.hpp b/src/simulators/statevector/indexes.hpp
index 0df6a69ce9..b947220eb3 100644
--- a/src/simulators/statevector/indexes.hpp
+++ b/src/simulators/statevector/indexes.hpp
@@ -12,15 +12,13 @@
  * that they have been altered from the originals.
  */
 
-
-
 #ifndef _qv_indexes_hpp_
 #define _qv_indexes_hpp_
 
 #include <array>
 #include <cstdint>
-#include <vector>
 #include <memory>
+#include <vector>
 
 namespace AER {
 namespace QV {
@@ -36,44 +34,135 @@ template <size_t N> using areg_t = std::array<uint_t, N>;
 // BIT MASKS and indexing
 //============================================================================
 
-const std::array<uint_t, 64> BITS {{
-  1ULL, 2ULL, 4ULL, 8ULL,
-  16ULL, 32ULL, 64ULL, 128ULL,
-  256ULL, 512ULL, 1024ULL, 2048ULL,
-  4096ULL, 8192ULL, 16384ULL, 32768ULL,
-  65536ULL, 131072ULL, 262144ULL, 524288ULL,
-  1048576ULL, 2097152ULL, 4194304ULL, 8388608ULL,
-  16777216ULL, 33554432ULL, 67108864ULL, 134217728ULL,
-  268435456ULL, 536870912ULL, 1073741824ULL, 2147483648ULL,
-  4294967296ULL, 8589934592ULL, 17179869184ULL, 34359738368ULL,
-  68719476736ULL, 137438953472ULL, 274877906944ULL, 549755813888ULL,
-  1099511627776ULL, 2199023255552ULL, 4398046511104ULL, 8796093022208ULL,
-  17592186044416ULL, 35184372088832ULL, 70368744177664ULL, 140737488355328ULL,
-  281474976710656ULL, 562949953421312ULL, 1125899906842624ULL, 2251799813685248ULL,
-  4503599627370496ULL, 9007199254740992ULL, 18014398509481984ULL, 36028797018963968ULL,
-  72057594037927936ULL, 144115188075855872ULL, 288230376151711744ULL, 576460752303423488ULL,
-  1152921504606846976ULL, 2305843009213693952ULL, 4611686018427387904ULL, 9223372036854775808ULL
-}};
-
-
-const std::array<uint_t, 64> MASKS {{
-  0ULL, 1ULL, 3ULL, 7ULL,
-  15ULL, 31ULL, 63ULL, 127ULL,
-  255ULL, 511ULL, 1023ULL, 2047ULL,
-  4095ULL, 8191ULL, 16383ULL, 32767ULL,
-  65535ULL, 131071ULL, 262143ULL, 524287ULL,
-  1048575ULL, 2097151ULL, 4194303ULL, 8388607ULL,
-  16777215ULL, 33554431ULL, 67108863ULL, 134217727ULL,
-  268435455ULL, 536870911ULL, 1073741823ULL, 2147483647ULL,
-  4294967295ULL, 8589934591ULL, 17179869183ULL, 34359738367ULL,
-  68719476735ULL, 137438953471ULL, 274877906943ULL, 549755813887ULL,
-  1099511627775ULL, 2199023255551ULL, 4398046511103ULL, 8796093022207ULL,
-  17592186044415ULL, 35184372088831ULL, 70368744177663ULL, 140737488355327ULL,
-  281474976710655ULL, 562949953421311ULL, 1125899906842623ULL, 2251799813685247ULL,
-  4503599627370495ULL, 9007199254740991ULL, 18014398509481983ULL, 36028797018963967ULL,
-  72057594037927935ULL, 144115188075855871ULL, 288230376151711743ULL, 576460752303423487ULL,
-  1152921504606846975ULL, 2305843009213693951ULL, 4611686018427387903ULL, 9223372036854775807ULL
-}};
+const std::array<uint_t, 64> BITS{{1ULL,
+                                   2ULL,
+                                   4ULL,
+                                   8ULL,
+                                   16ULL,
+                                   32ULL,
+                                   64ULL,
+                                   128ULL,
+                                   256ULL,
+                                   512ULL,
+                                   1024ULL,
+                                   2048ULL,
+                                   4096ULL,
+                                   8192ULL,
+                                   16384ULL,
+                                   32768ULL,
+                                   65536ULL,
+                                   131072ULL,
+                                   262144ULL,
+                                   524288ULL,
+                                   1048576ULL,
+                                   2097152ULL,
+                                   4194304ULL,
+                                   8388608ULL,
+                                   16777216ULL,
+                                   33554432ULL,
+                                   67108864ULL,
+                                   134217728ULL,
+                                   268435456ULL,
+                                   536870912ULL,
+                                   1073741824ULL,
+                                   2147483648ULL,
+                                   4294967296ULL,
+                                   8589934592ULL,
+                                   17179869184ULL,
+                                   34359738368ULL,
+                                   68719476736ULL,
+                                   137438953472ULL,
+                                   274877906944ULL,
+                                   549755813888ULL,
+                                   1099511627776ULL,
+                                   2199023255552ULL,
+                                   4398046511104ULL,
+                                   8796093022208ULL,
+                                   17592186044416ULL,
+                                   35184372088832ULL,
+                                   70368744177664ULL,
+                                   140737488355328ULL,
+                                   281474976710656ULL,
+                                   562949953421312ULL,
+                                   1125899906842624ULL,
+                                   2251799813685248ULL,
+                                   4503599627370496ULL,
+                                   9007199254740992ULL,
+                                   18014398509481984ULL,
+                                   36028797018963968ULL,
+                                   72057594037927936ULL,
+                                   144115188075855872ULL,
+                                   288230376151711744ULL,
+                                   576460752303423488ULL,
+                                   1152921504606846976ULL,
+                                   2305843009213693952ULL,
+                                   4611686018427387904ULL,
+                                   9223372036854775808ULL}};
+
+const std::array<uint_t, 64> MASKS{{0ULL,
+                                    1ULL,
+                                    3ULL,
+                                    7ULL,
+                                    15ULL,
+                                    31ULL,
+                                    63ULL,
+                                    127ULL,
+                                    255ULL,
+                                    511ULL,
+                                    1023ULL,
+                                    2047ULL,
+                                    4095ULL,
+                                    8191ULL,
+                                    16383ULL,
+                                    32767ULL,
+                                    65535ULL,
+                                    131071ULL,
+                                    262143ULL,
+                                    524287ULL,
+                                    1048575ULL,
+                                    2097151ULL,
+                                    4194303ULL,
+                                    8388607ULL,
+                                    16777215ULL,
+                                    33554431ULL,
+                                    67108863ULL,
+                                    134217727ULL,
+                                    268435455ULL,
+                                    536870911ULL,
+                                    1073741823ULL,
+                                    2147483647ULL,
+                                    4294967295ULL,
+                                    8589934591ULL,
+                                    17179869183ULL,
+                                    34359738367ULL,
+                                    68719476735ULL,
+                                    137438953471ULL,
+                                    274877906943ULL,
+                                    549755813887ULL,
+                                    1099511627775ULL,
+                                    2199023255551ULL,
+                                    4398046511103ULL,
+                                    8796093022207ULL,
+                                    17592186044415ULL,
+                                    35184372088831ULL,
+                                    70368744177663ULL,
+                                    140737488355327ULL,
+                                    281474976710655ULL,
+                                    562949953421311ULL,
+                                    1125899906842623ULL,
+                                    2251799813685247ULL,
+                                    4503599627370495ULL,
+                                    9007199254740991ULL,
+                                    18014398509481983ULL,
+                                    36028797018963967ULL,
+                                    72057594037927935ULL,
+                                    144115188075855871ULL,
+                                    288230376151711743ULL,
+                                    576460752303423487ULL,
+                                    1152921504606846975ULL,
+                                    2305843009213693951ULL,
+                                    4611686018427387903ULL,
+                                    9223372036854775807ULL}};
 
 // index0 returns the integer representation of a number of bits set
 // to zero inserted into an arbitrary bit string.
@@ -82,7 +171,7 @@ const std::array<uint_t, 64> MASKS {{
 // indexes0([1,3], k) -> int(0b0a)
 // Example: k = 77  = 1001101 , qubits_sorted = [1,4]
 // ==> output = 297 = 100101001 (with 0's put into places 1 and 4).
-template<typename list_t>
+template <typename list_t>
 uint_t index0(const list_t &qubits_sorted, const uint_t k);
 
 // Return a std::unique_ptr to an array of of 2^N in ints
@@ -96,20 +185,21 @@ uint_t index0(const list_t &qubits_sorted, const uint_t k);
 // indexes([1], [1], k) = [int(b0a), int(b1a)],
 // if it were two qubits inserted say at 1,3 it would be:
 // indexes([1,3], [1,3], k) -> [int(0b0a), int(0b1a), int(1b0a), (1b1a)]
-// If the qubits were passed in reverse order it would swap qubit position in the list:
-// indexes([3,1], [1,3], k) -> [int(0b0a), int(1b0a), int(0b1a), (1b1a)]
-// Example: k=77, qubits=qubits_sorted=[1,4] ==> output=[297,299,313,315]
-// input: k = 77  = 1001101
-// output[0]: 297 = 100101001 (with 0's put into places 1 and 4).
-// output[1]: 299 = 100101011 (with 0 put into place 1, and 1 put into place 4).
-// output[2]: 313 = 100111001 (with 1 put into place 1, and 0 put into place 4).
-// output[3]: 313 = 100111011 (with 1's put into places 1 and 4).
-indexes_t indexes(const reg_t &qubits, const reg_t &qubits_sorted, const uint_t k);
+// If the qubits were passed in reverse order it would swap qubit position in
+// the list: indexes([3,1], [1,3], k) -> [int(0b0a), int(1b0a), int(0b1a),
+// (1b1a)] Example: k=77, qubits=qubits_sorted=[1,4] ==>
+// output=[297,299,313,315] input: k = 77  = 1001101 output[0]: 297 = 100101001
+// (with 0's put into places 1 and 4). output[1]: 299 = 100101011 (with 0 put
+// into place 1, and 1 put into place 4). output[2]: 313 = 100111001 (with 1 put
+// into place 1, and 0 put into place 4). output[3]: 313 = 100111011 (with 1's
+// put into places 1 and 4).
+indexes_t indexes(const reg_t &qubits, const reg_t &qubits_sorted,
+                  const uint_t k);
 
 // As above but returns a fixed sized array of of 2^N in ints
-template<size_t N>
-areg_t<1ULL << N> indexes(const areg_t<N> &qs, const areg_t<N> &qubits_sorted, const uint_t k);
-
+template <size_t N>
+areg_t<1ULL << N> indexes(const areg_t<N> &qs, const areg_t<N> &qubits_sorted,
+                          const uint_t k);
 
 /*******************************************************************************
  *
@@ -130,8 +220,7 @@ uint_t index0(const list_t &qubits_sorted, const uint_t k) {
 }
 
 template <size_t N>
-areg_t<1ULL << N> indexes(const areg_t<N> &qs,
-                          const areg_t<N> &qubits_sorted,
+areg_t<1ULL << N> indexes(const areg_t<N> &qs, const areg_t<N> &qubits_sorted,
                           const uint_t k) {
   areg_t<1ULL << N> ret;
   ret[0] = index0(qubits_sorted, k);
@@ -144,9 +233,8 @@ areg_t<1ULL << N> indexes(const areg_t<N> &qs,
   return ret;
 }
 
-inline indexes_t indexes(const reg_t& qubits,
-                  const reg_t& qubits_sorted,
-                  const uint_t k) {
+inline indexes_t indexes(const reg_t &qubits, const reg_t &qubits_sorted,
+                         const uint_t k) {
   const auto N = qubits_sorted.size();
   indexes_t ret(new uint_t[BITS[N]]);
   // Get index0
@@ -166,16 +254,13 @@ inline indexes_t indexes(const reg_t& qubits,
  *
  ******************************************************************************/
 
-
 //------------------------------------------------------------------------------
 // State update
 //------------------------------------------------------------------------------
 
-template<typename Lambda>
-inline void apply_lambda(const size_t start,
-                         const size_t stop,
-                         const uint_t omp_threads,
-                         Lambda&& func) {
+template <typename Lambda>
+inline void apply_lambda(const size_t start, const size_t stop,
+                         const uint_t omp_threads, Lambda &&func) {
 
 #pragma omp parallel if (omp_threads > 1) num_threads(omp_threads)
   {
@@ -186,11 +271,9 @@ inline void apply_lambda(const size_t start,
   }
 }
 
-template<typename Lambda, typename list_t>
-inline void apply_lambda(const size_t start,
-                         const size_t stop,
-                         const uint_t omp_threads,
-                         Lambda&& func,
+template <typename Lambda, typename list_t>
+inline void apply_lambda(const size_t start, const size_t stop,
+                         const uint_t omp_threads, Lambda &&func,
                          const list_t &qubits) {
 
   const auto NUM_QUBITS = qubits.size();
@@ -208,13 +291,10 @@ inline void apply_lambda(const size_t start,
   }
 }
 
-template<typename Lambda, typename list_t, typename param_t>
-inline void apply_lambda(const size_t start,
-                         const size_t stop,
-                         const size_t gap,
-                         const uint_t omp_threads,
-                         Lambda&& func,
-                         const list_t &qubits,
+template <typename Lambda, typename list_t, typename param_t>
+inline void apply_lambda(const size_t start, const size_t stop,
+                         const size_t gap, const uint_t omp_threads,
+                         Lambda &&func, const list_t &qubits,
                          const param_t &params) {
 
   const auto NUM_QUBITS = qubits.size();
@@ -225,20 +305,17 @@ inline void apply_lambda(const size_t start,
 #pragma omp parallel if (omp_threads > 1) num_threads(omp_threads)
   {
 #pragma omp for
-    for (int_t k = int_t(start); k < END; k+=gap) {
+    for (int_t k = int_t(start); k < END; k += gap) {
       const auto inds = indexes(qubits, qubits_sorted, k);
       std::forward<Lambda>(func)(inds, params);
     }
   }
 }
 
-template<typename Lambda, typename list_t, typename param_t>
-inline void apply_lambda(const size_t start,
-                         const size_t stop,
-                         const uint_t omp_threads,
-                         Lambda&& func,
-                         const list_t &qubits,
-                         const param_t &params) {
+template <typename Lambda, typename list_t, typename param_t>
+inline void apply_lambda(const size_t start, const size_t stop,
+                         const uint_t omp_threads, Lambda &&func,
+                         const list_t &qubits, const param_t &params) {
   apply_lambda(start, stop, 1, omp_threads, func, qubits, params);
 }
 
@@ -246,11 +323,10 @@ inline void apply_lambda(const size_t start,
 // Reduction Lambda
 //------------------------------------------------------------------------------
 
-template<typename Lambda>
-inline std::complex<double> apply_reduction_lambda(const size_t start,
-                                                   const size_t stop,
-                                                   const uint_t omp_threads,
-                                                   Lambda &&func) {
+template <typename Lambda>
+inline std::complex<double>
+apply_reduction_lambda(const size_t start, const size_t stop,
+                       const uint_t omp_threads, Lambda &&func) {
   // Reduction variables
   double val_re = 0.;
   double val_im = 0.;
@@ -258,20 +334,19 @@ inline std::complex<double> apply_reduction_lambda(const size_t start,
   {
 #pragma omp for
     for (int_t k = int_t(start); k < int_t(stop); k++) {
-        std::forward<Lambda>(func)(k, val_re, val_im);
-      }
+      std::forward<Lambda>(func)(k, val_re, val_im);
+    }
   } // end omp parallel
   return std::complex<double>(val_re, val_im);
 }
 
-template<typename Lambda, typename list_t>
-std::complex<double> apply_reduction_lambda(const size_t start,
-                                            const size_t stop,
-                                            const uint_t omp_threads,
-                                            Lambda&& func,
-                                            const list_t &qubits) {
+template <typename Lambda, typename list_t>
+std::complex<double>
+apply_reduction_lambda(const size_t start, const size_t stop,
+                       const uint_t omp_threads, Lambda &&func,
+                       const list_t &qubits) {
 
-  const size_t NUM_QUBITS =  qubits.size();
+  const size_t NUM_QUBITS = qubits.size();
   const int_t END = stop >> NUM_QUBITS;
   auto qubits_sorted = qubits;
   std::sort(qubits_sorted.begin(), qubits_sorted.end());
@@ -290,14 +365,11 @@ std::complex<double> apply_reduction_lambda(const size_t start,
   return std::complex<double>(val_re, val_im);
 }
 
-
-template<typename Lambda, typename list_t, typename param_t>
-std::complex<double> apply_reduction_lambda(const size_t start,
-                                            const size_t stop,
-                                            const uint_t omp_threads,
-                                            Lambda&& func,
-                                            const list_t &qubits,
-                                            const param_t &params) {
+template <typename Lambda, typename list_t, typename param_t>
+std::complex<double>
+apply_reduction_lambda(const size_t start, const size_t stop,
+                       const uint_t omp_threads, Lambda &&func,
+                       const list_t &qubits, const param_t &params) {
 
   const auto NUM_QUBITS = qubits.size();
 
@@ -322,7 +394,7 @@ std::complex<double> apply_reduction_lambda(const size_t start,
 //------------------------------------------------------------------------------
 } // end namespace QV
 //------------------------------------------------------------------------------
-}
+} // namespace AER
 
 //------------------------------------------------------------------------------
 #endif // end module
diff --git a/src/simulators/statevector/qubitvector.hpp b/src/simulators/statevector/qubitvector.hpp
old mode 100755
new mode 100644
index d4a8146cd3..9b0e3e7336
--- a/src/simulators/statevector/qubitvector.hpp
+++ b/src/simulators/statevector/qubitvector.hpp
@@ -12,8 +12,6 @@
  * that they have been altered from the originals.
  */
 
-
-
 #ifndef _qv_qubit_vector_hpp_
 #define _qv_qubit_vector_hpp_
 
@@ -22,22 +20,22 @@
 #include <cmath>
 #include <complex>
 #include <cstdint>
-#include <string>
-#include <vector>
-#include <tuple>
 #include <sstream>
 #include <stdexcept>
+#include <string>
+#include <tuple>
+#include <vector>
 
-#include "simulators/statevector/indexes.hpp"
-#include "simulators/statevector/transformer.hpp"
-#include "simulators/statevector/transformer_avx2.hpp"
-#include "framework/operations.hpp"
-#include "framework/rng.hpp"
 #include "framework/avx2_detect.hpp"
 #include "framework/json.hpp"
-#include "framework/utils.hpp"
 #include "framework/linalg/matrix_utils/vmatrix_defs.hpp"
 #include "framework/linalg/vector.hpp"
+#include "framework/operations.hpp"
+#include "framework/rng.hpp"
+#include "framework/utils.hpp"
+#include "simulators/statevector/indexes.hpp"
+#include "simulators/statevector/transformer.hpp"
+#include "simulators/statevector/transformer_avx2.hpp"
 
 namespace AER {
 namespace QV {
@@ -45,8 +43,12 @@ template <typename T> using cvector_t = std::vector<std::complex<T>>;
 template <typename T> using cdict_t = std::map<std::string, std::complex<T>>;
 
 enum class Rotation {
-  x, y, z,
-  xx, yy, zz,
+  x,
+  y,
+  z,
+  xx,
+  yy,
+  zz,
   zx,
 };
 
@@ -54,12 +56,10 @@ enum class Rotation {
 // QubitVector class
 //============================================================================
 
-template <typename data_t = double>
-class QubitVector {
-    std::unique_ptr<Transformer<std::complex<data_t>*, data_t>> transformer_;
+template <typename data_t = double> class QubitVector {
+  std::unique_ptr<Transformer<std::complex<data_t> *, data_t>> transformer_;
 
 public:
-
   //-----------------------------------------------------------------------
   // Constructors and Destructor
   //-----------------------------------------------------------------------
@@ -67,9 +67,9 @@ class QubitVector {
   QubitVector();
   explicit QubitVector(size_t num_qubits);
   virtual ~QubitVector();
-  QubitVector(size_t num_qubits, std::complex<data_t>* data, bool copy=false);
-  QubitVector(const QubitVector& obj) {};
-  QubitVector &operator=(QubitVector&& obj) {
+  QubitVector(size_t num_qubits, std::complex<data_t> *data, bool copy = false);
+  QubitVector(const QubitVector &obj){};
+  QubitVector &operator=(QubitVector &&obj) {
     num_qubits_ = obj.num_qubits_;
     data_size_ = obj.data_size_;
     data_ = obj.data_;
@@ -85,7 +85,7 @@ class QubitVector {
     obj.checkpoint_ = nullptr;
     return *this;
   };
-  QubitVector& operator= (const QubitVector&) = delete;
+  QubitVector &operator=(const QubitVector &) = delete;
 
   //-----------------------------------------------------------------------
   // Data access
@@ -95,41 +95,41 @@ class QubitVector {
   std::complex<data_t> &operator[](uint_t element);
   std::complex<data_t> operator[](uint_t element) const;
 
-  void set_state(uint_t pos, std::complex<data_t>& val);
+  void set_state(uint_t pos, std::complex<data_t> &val);
   std::complex<data_t> get_state(uint_t pos) const;
 
   // Returns a reference to the underlying data_t data class
-  std::complex<data_t>* &data() {return data_;}
+  std::complex<data_t> *&data() { return data_; }
 
   // Returns a copy of the underlying data_t data class
-  std::complex<data_t>* data() const {return data_;}
+  std::complex<data_t> *data() const { return data_; }
 
   //-----------------------------------------------------------------------
   // Utility functions
   //-----------------------------------------------------------------------
 
   // Return the string name of the QUbitVector class
-  static std::string name() {return "statevector";}
+  static std::string name() { return "statevector"; }
 
   // Set the size of the vector in terms of qubit number
   void set_num_qubits(size_t num_qubits);
 
   // Returns the number of qubits for the current vector
-  virtual uint_t num_qubits() const {return num_qubits_;}
+  virtual uint_t num_qubits() const { return num_qubits_; }
 
   // Returns the size of the underlying n-qubit vector
-  uint_t size() const {return data_size_;}
+  uint_t size() const { return data_size_; }
 
   // Returns required memory
   size_t required_memory_mb(uint_t num_qubits) const;
 
-  //check if this register is on the top of array (always true if array is allocated independently)
-  bool top_of_group(){ return true;}
+  // check if this register is on the top of array (always true if array is
+  // allocated independently)
+  bool top_of_group() { return true; }
 
   // Returns a copy of the underlying data_t data as a complex vector
   cvector_t<data_t> vector() const;
 
-
   // Returns a copy of the underlying data_t data as a complex ket dictionary
   cdict_t<data_t> vector_ket(double epsilon = 0) const;
 
@@ -139,7 +139,6 @@ class QubitVector {
   // Moves the data to a complex vector
   AER::Vector<std::complex<data_t>> move_to_vector();
 
-
   // Return JSON serialization of QubitVector;
   json_t json() const;
 
@@ -147,45 +146,38 @@ class QubitVector {
   void zero();
 
   // convert vector type to data type of this qubit vector
-  cvector_t<data_t> convert(const cvector_t<double>& v) const;
+  cvector_t<data_t> convert(const cvector_t<double> &v) const;
 
   // State initialization of a component
   // Initialize the specified qubits to a desired statevector
   // (leaving the other qubits in their current state)
-  // assuming the qubits being initialized have already been reset to the zero state
-  // (using apply_reset)
-  void initialize_component(const reg_t &qubits, const cvector_t<double> &state);
-
-  //setup chunk
-  bool chunk_setup(int chunk_bits,int num_qubits,uint_t chunk_index,uint_t num_local_chunks);
-  bool chunk_setup(QubitVector<data_t>& base,const uint_t chunk_index);
-
-  //cache control for chunks on host
-  bool fetch_chunk(void) const
-  {
-    return true;
-  }
-  void release_chunk(bool write_back = true) const
-  {
-  }
-
-  //blocking
-  void enter_register_blocking(const reg_t& qubits)
-  {
-  }
-  void leave_register_blocking(void)
-  {
-  }
-
-  //prepare buffer for MPI send/recv
-  std::complex<data_t>* send_buffer(uint_t& size_in_byte);
-  std::complex<data_t>* recv_buffer(uint_t& size_in_byte);
+  // assuming the qubits being initialized have already been reset to the zero
+  // state (using apply_reset)
+  void initialize_component(const reg_t &qubits,
+                            const cvector_t<double> &state);
+
+  // setup chunk
+  bool chunk_setup(int chunk_bits, int num_qubits, uint_t chunk_index,
+                   uint_t num_local_chunks);
+  bool chunk_setup(QubitVector<data_t> &base, const uint_t chunk_index);
+
+  // cache control for chunks on host
+  bool fetch_chunk(void) const { return true; }
+  void release_chunk(bool write_back = true) const {}
+
+  // blocking
+  void enter_register_blocking(const reg_t &qubits) {}
+  void leave_register_blocking(void) {}
+
+  // prepare buffer for MPI send/recv
+  std::complex<data_t> *send_buffer(uint_t &size_in_byte);
+  std::complex<data_t> *recv_buffer(uint_t &size_in_byte);
   void release_send_buffer(void) const;
   void release_recv_buffer(void) const;
 
-  void set_max_matrix_bits(int_t bits){}
+  void set_max_matrix_bits(int_t bits) {}
 
-  void synchronize(void){}
+  void synchronize(void) {}
 
   //-----------------------------------------------------------------------
   // Check point operations
@@ -210,44 +202,48 @@ class QubitVector {
   // Initializes the vector to a custom initial state.
   // If the length of the data vector does not match the number of qubits
   // an exception is raised.
-  template <typename list_t>
-  void initialize_from_vector(const list_t &vec);
+  template <typename list_t> void initialize_from_vector(const list_t &vec);
   // Move semantic initialization
   void initialize_from_vector(std::vector<std::complex<data_t>> &&vec);
   void initialize_from_vector(AER::Vector<std::complex<data_t>> &&vec);
 
   // Initializes the vector to a custom initial state.
   // If num_states does not match the number of qubits an exception is raised.
-  void initialize_from_data(const std::complex<data_t>* data, const size_t num_states);
+  void initialize_from_data(const std::complex<data_t> *data,
+                            const size_t num_states);
 
   // Initialize classical memory and register to default value (all-0)
   virtual void initialize_creg(uint_t num_memory, uint_t num_register) {}
 
   // Initialize classical memory and register to specific values
-  virtual void initialize_creg(uint_t num_memory,
-                       uint_t num_register,
-                       const std::string &memory_hex,
-                       const std::string &register_hex) {}
+  virtual void initialize_creg(uint_t num_memory, uint_t num_register,
+                               const std::string &memory_hex,
+                               const std::string &register_hex) {}
 
   //-----------------------------------------------------------------------
   // Apply Matrices
   //-----------------------------------------------------------------------
 
   // Apply a N-qubit matrix to the state vector.
-  // The matrix is input as vector of the column-major vectorized N-qubit matrix.
+  // The matrix is input as vector of the column-major vectorized N-qubit
+  // matrix.
   void apply_matrix(const reg_t &qubits, const cvector_t<double> &mat);
 
-  // Apply a stacked set of 2^control_count target_count--qubit matrix to the state vector.
-  // The matrix is input as vector of the column-major vectorized N-qubit matrix.
-  void apply_multiplexer(const reg_t &control_qubits, const reg_t &target_qubits, const cvector_t<double> &mat);
+  // Apply a stacked set of 2^control_count target_count--qubit matrix to the
+  // state vector. The matrix is input as vector of the column-major vectorized
+  // N-qubit matrix.
+  void apply_multiplexer(const reg_t &control_qubits,
+                         const reg_t &target_qubits,
+                         const cvector_t<double> &mat);
 
   // Apply a N-qubit diagonal matrix to the state vector.
   // The matrix is input as vector of the matrix diagonal.
   void apply_diagonal_matrix(const reg_t &qubits, const cvector_t<double> &mat);
 
   // Swap pairs of indicies in the underlying vector
-  void apply_permutation_matrix(const reg_t &qubits,
-                                const std::vector<std::pair<uint_t, uint_t>> &pairs);
+  void
+  apply_permutation_matrix(const reg_t &qubits,
+                           const std::vector<std::pair<uint_t, uint_t>> &pairs);
 
   //-----------------------------------------------------------------------
   // Apply Specialized Gates
@@ -284,17 +280,20 @@ class QubitVector {
   // If N=3 this implements an optimized Fredkin gate
   void apply_mcswap(const reg_t &qubits);
 
-  //apply multiple swap gates
-  // qubits is a list of pair of swaps
+  // apply multiple swap gates
+  //  qubits is a list of pair of swaps
   void apply_multi_swaps(const reg_t &qubits);
 
-  //apply rotation around axis
-  void apply_rotation(const reg_t &qubits, const Rotation r, const double theta);
+  // apply rotation around axis
+  void apply_rotation(const reg_t &qubits, const Rotation r,
+                      const double theta);
 
-  //swap between chunk
-  void apply_chunk_swap(const reg_t &qubits, QubitVector<data_t> &chunk, bool write_back = true);
+  // swap between chunk
+  void apply_chunk_swap(const reg_t &qubits, QubitVector<data_t> &chunk,
+                        bool write_back = true);
   void apply_chunk_swap(const reg_t &qubits, uint_t remote_chunk_index);
-  void apply_chunk_swap(QubitVector<data_t> &chunk, uint_t dest_offset, uint_t src_offset, uint_t size);
+  void apply_chunk_swap(QubitVector<data_t> &chunk, uint_t dest_offset,
+                        uint_t src_offset, uint_t size);
 
   void apply_pauli(const reg_t &qubits, const std::string &pauli,
                    const complex_t &coeff = 1);
@@ -321,35 +320,39 @@ class QubitVector {
   // generating samples.
   virtual reg_t sample_measure(const std::vector<double> &rnds) const;
 
-
   //-----------------------------------------------------------------------
-  // for batched optimization (Implement them if CPU simulator supports multi-shots)
+  // for batched optimization (Implement them if CPU simulator supports
+  // multi-shots)
   //-----------------------------------------------------------------------
-  virtual bool batched_optimization_supported(void)
-  {
-    return false;
+  virtual bool batched_optimization_supported(void) { return false; }
+  virtual void apply_bfunc(const Operations::Op &op) {}
+  virtual void set_conditional(int_t reg) {}
+  virtual void apply_roerror(const Operations::Op &op,
+                             std::vector<RngEngine> &rng) {}
+
+  // optimized batched measure/reset
+  virtual void apply_batched_measure(const reg_t &qubits,
+                                     std::vector<RngEngine> &rng,
+                                     const reg_t &cmemory, const reg_t &cregs) {
   }
-  virtual void apply_bfunc(const Operations::Op &op){}
-  virtual void set_conditional(int_t reg){}
-  virtual void apply_roerror(const Operations::Op &op, std::vector<RngEngine> &rng){}
+  virtual void apply_batched_reset(const reg_t &qubits,
+                                   std::vector<RngEngine> &rng) {}
 
-  //optimized batched measure/reset
-  virtual void apply_batched_measure(const reg_t& qubits,std::vector<RngEngine>& rng,const reg_t& cmemory,const reg_t& cregs){}
-  virtual void apply_batched_reset(const reg_t& qubits,std::vector<RngEngine>& rng){}
+  // copy classical register stored on qreg
+  template <typename storage_t> void read_measured_data(storage_t &creg) {}
 
-  //copy classical register stored on qreg 
-  template <typename storage_t>
-  void read_measured_data(storage_t& creg){}
-
-  virtual int_t set_batched_system_conditional(int_t src_reg, reg_t& mask){return -1;}
+  virtual int_t set_batched_system_conditional(int_t src_reg, reg_t &mask) {
+    return -1;
+  }
 
-  //apply Pauli ops to multiple-shots (apply sampled Pauli noises)
-  virtual void apply_batched_pauli_ops(const std::vector<std::vector<Operations::Op>> &op){}
+  // apply Pauli ops to multiple-shots (apply sampled Pauli noises)
+  virtual void
+  apply_batched_pauli_ops(const std::vector<std::vector<Operations::Op>> &op) {}
 
-  //Apply Kraus to multiple-shots
+  // Apply Kraus to multiple-shots
   void apply_batched_kraus(const reg_t &qubits,
-                   const std::vector<cmatrix_t> &kmats,
-                   std::vector<RngEngine>& rng){}
+                           const std::vector<cmatrix_t> &kmats,
+                           std::vector<RngEngine> &rng) {}
 
   //-----------------------------------------------------------------------
   // Norms
@@ -365,12 +368,14 @@ class QubitVector {
 
   // Return the norm for of the vector obtained after apply the 1-qubit
   // matrix mat to the vector.
-  // The matrix is input as vector of the column-major vectorized 1-qubit matrix.
+  // The matrix is input as vector of the column-major vectorized 1-qubit
+  // matrix.
   double norm(const uint_t qubit, const cvector_t<double> &mat) const;
 
   // Return the norm for of the vector obtained after apply the N-qubit
   // matrix mat to the vector.
-  // The matrix is input as vector of the column-major vectorized N-qubit matrix.
+  // The matrix is input as vector of the column-major vectorized N-qubit
+  // matrix.
   double norm(const reg_t &qubits, const cvector_t<double> &mat) const;
 
   // Return the norm for of the vector obtained after apply the 1-qubit
@@ -393,12 +398,13 @@ class QubitVector {
 
   // Return the expectation value of an N-qubit Pauli matrix.
   // The Pauli is input as a length N string of I,X,Y,Z characters.
-  double expval_pauli(const reg_t &qubits, const std::string &pauli,const complex_t initial_phase=1.0) const;
-  //for multi-chunk inter chunk expectation
   double expval_pauli(const reg_t &qubits, const std::string &pauli,
-                      const QubitVector<data_t>& pair_chunk, 
-                      const uint_t z_count,
-                      const uint_t z_count_pair,const complex_t initial_phase=1.0) const;
+                      const complex_t initial_phase = 1.0) const;
+  // for multi-chunk inter chunk expectation
+  double expval_pauli(const reg_t &qubits, const std::string &pauli,
+                      const QubitVector<data_t> &pair_chunk,
+                      const uint_t z_count, const uint_t z_count_pair,
+                      const complex_t initial_phase = 1.0) const;
 
   //-----------------------------------------------------------------------
   // JSON configuration settings
@@ -408,7 +414,7 @@ class QubitVector {
   void set_json_chop_threshold(double threshold);
 
   // Set the threshold for chopping values to 0 in JSON
-  double get_json_chop_threshold() {return json_chop_threshold_;}
+  double get_json_chop_threshold() { return json_chop_threshold_; }
 
   //-----------------------------------------------------------------------
   // OpenMP configuration settings
@@ -418,74 +424,73 @@ class QubitVector {
   void set_omp_threads(int n);
 
   // Get the maximum number of OpenMP thread for operations.
-  uint_t get_omp_threads() {return omp_threads_;}
+  uint_t get_omp_threads() { return omp_threads_; }
 
   // Set the qubit threshold for activating OpenMP.
   // If self.qubits() > threshold OpenMP will be activated.
   void set_omp_threshold(int n);
 
   // Get the qubit threshold for activating OpenMP.
-  uint_t get_omp_threshold() {return omp_threshold_;}
+  uint_t get_omp_threshold() { return omp_threshold_; }
 
-  //set number of threads per group(GPU)
-  void set_num_threads_per_group(int n){}
+  // set number of threads per group(GPU)
+  void set_num_threads_per_group(int n) {}
 
-  //cuStateVec
-  void cuStateVec_enable(bool flg)
-  {
-  }
+  // cuStateVec
+  void cuStateVec_enable(bool flg) {}
 
   //-----------------------------------------------------------------------
   // Optimization configuration settings
   //-----------------------------------------------------------------------
 
   // Set the sample_measure index size
-  void set_sample_measure_index_size(int n) {sample_measure_index_size_ = n;}
+  void set_sample_measure_index_size(int n) { sample_measure_index_size_ = n; }
 
   // Get the sample_measure index size
-  int get_sample_measure_index_size() {return sample_measure_index_size_;}
+  int get_sample_measure_index_size() { return sample_measure_index_size_; }
 
-  virtual bool enable_batch(bool flg) const
-  {
-    return false;
-  }
+  virtual bool enable_batch(bool flg) const { return false; }
 
 protected:
-
   //-----------------------------------------------------------------------
   // Protected data members
   //-----------------------------------------------------------------------
   size_t num_qubits_;
   size_t data_size_;
-  std::complex<data_t>* data_;
+  std::complex<data_t> *data_;
   bool unmanaged_data_;
-  std::complex<data_t>* checkpoint_;
+  std::complex<data_t> *checkpoint_;
 
-  uint_t chunk_index_;      //global chunk index
-  mutable cvector_t<data_t> recv_buffer_;   //receive buffer for MPI
+  uint_t chunk_index_;                    // global chunk index
+  mutable cvector_t<data_t> recv_buffer_; // receive buffer for MPI
 
   //-----------------------------------------------------------------------
   // Config settings
   //-----------------------------------------------------------------------
-  uint_t omp_threads_ = 1;     // Disable multithreading by default
-  uint_t omp_threshold_ = 14;  // Qubit threshold for multithreading when enabled
+  uint_t omp_threads_ = 1;    // Disable multithreading by default
+  uint_t omp_threshold_ = 14; // Qubit threshold for multithreading when enabled
   int sample_measure_index_size_ = 10; // Sample measure indexing qubit size
-  double json_chop_threshold_ = 0;  // Threshold for choping small values
-                                    // in JSON serialization
+  double json_chop_threshold_ = 0;     // Threshold for choping small values
+                                       // in JSON serialization
   inline uint_t omp_threads_managed() const {
-    return (num_qubits_ > omp_threshold_ && omp_threads_ > 1) ? omp_threads_: 1;
+    return (num_qubits_ > omp_threshold_ && omp_threads_ > 1) ? omp_threads_
+                                                              : 1;
   }
 
-  void set_transformer_method(){
+  void set_transformer_method() {
 #if defined(GNUC_AVX2) || defined(_MSC_VER)
-    transformer_ = is_avx2_supported() ? std::make_unique<TransformerAVX2<std::complex<data_t>*, data_t>>()
-                                       : std::make_unique<Transformer<std::complex<data_t>*, data_t>>();
+    transformer_ =
+        is_avx2_supported()
+            ? std::make_unique<
+                  TransformerAVX2<std::complex<data_t> *, data_t>>()
+            : std::make_unique<Transformer<std::complex<data_t> *, data_t>>();
 #else
-    transformer_ = std::make_unique<Transformer<std::complex<data_t>*, data_t>>();
+    transformer_ =
+        std::make_unique<Transformer<std::complex<data_t> *, data_t>>();
 #endif
   }
 
-    //-----------------------------------------------------------------------
+  //-----------------------------------------------------------------------
   // Error Messages
   //-----------------------------------------------------------------------
 
@@ -504,8 +509,7 @@ class QubitVector {
   // [&](const int_t k)->void
   //
   // where k is the index of the vector
-  template <typename Lambda>
-  void apply_lambda(Lambda&& func);
+  template <typename Lambda> void apply_lambda(Lambda &&func);
 
   //-----------------------------------------------------------------------
   // Statevector update with Lambda function on a range of entries
@@ -518,7 +522,7 @@ class QubitVector {
   //
   // where k is the index of the vector
   template <typename Lambda>
-  void apply_lambda(Lambda&& func, size_t start, size_t stop);
+  void apply_lambda(Lambda &&func, size_t start, size_t stop);
 
   //-----------------------------------------------------------------------
   // Statevector block update with Lambda function
@@ -539,7 +543,7 @@ class QubitVector {
   // where `inds` are the 2 ** N indexes for each N-qubit block returned by
   // the `indexes` function.
   template <typename Lambda, typename list_t>
-  void apply_lambda(Lambda&& func, const list_t &qubits);
+  void apply_lambda(Lambda &&func, const list_t &qubits);
 
   // Apply an N-qubit parameterized lambda function to all blocks of the
   // statevector for the given qubits. The function signature should be:
@@ -551,7 +555,7 @@ class QubitVector {
   // the `indexes` function and `param` is a templated parameter class.
   // (typically a complex vector).
   template <typename Lambda, typename list_t, typename param_t>
-  void apply_lambda(Lambda&& func, const list_t &qubits, const param_t &par);
+  void apply_lambda(Lambda &&func, const list_t &qubits, const param_t &par);
 
   //-----------------------------------------------------------------------
   // State reduction with Lambda functions
@@ -565,10 +569,11 @@ class QubitVector {
   // to store the reduction.
   // Returns std::complex<double>(val_re, val_im)
   template <typename Lambda>
-  std::complex<double> apply_reduction_lambda(Lambda&& func, size_t start, size_t stop) const;
+  std::complex<double> apply_reduction_lambda(Lambda &&func, size_t start,
+                                              size_t stop) const;
 
   template <typename Lambda>
-  std::complex<double> apply_reduction_lambda(Lambda&& func) const;
+  std::complex<double> apply_reduction_lambda(Lambda &&func) const;
 
   //-----------------------------------------------------------------------
   // Statevector block reduction with Lambda function
@@ -576,7 +581,8 @@ class QubitVector {
   // These functions loop through the indexes of the qubitvector data and
   // apply a reduction lambda function to each block specified by the qubits
   // argument. The reduction lambda stores the reduction in two doubles
-  // (val_re, val_im) and returns the complex result std::complex<double>(val_re, val_im)
+  // (val_re, val_im) and returns the complex result
+  // std::complex<double>(val_re, val_im)
   //
   // NOTE: The lambda functions can use the dynamic or static indexes
   // signature however if N is known at compile time the static case should
@@ -595,7 +601,7 @@ class QubitVector {
   // the `indexes` function, `val_re` and `val_im` are the doubles to
   // store the reduction returned as std::complex<double>(val_re, val_im).
   template <typename Lambda, typename list_t>
-  std::complex<double> apply_reduction_lambda(Lambda&& func,
+  std::complex<double> apply_reduction_lambda(Lambda &&func,
                                               const list_t &qubits) const;
 
   // Apply a N-qubit complex matrix reduction lambda function to all blocks
@@ -612,7 +618,7 @@ class QubitVector {
   // (typically a complex vector), `val_re` and `val_im` are the doubles to
   // store the reduction returned as std::complex<double>(val_re, val_im).
   template <typename Lambda, typename list_t, typename param_t>
-  std::complex<double> apply_reduction_lambda(Lambda&& func,
+  std::complex<double> apply_reduction_lambda(Lambda &&func,
                                               const list_t &qubits,
                                               const param_t &params) const;
 
@@ -644,23 +650,24 @@ inline void to_json(json_t &js, const QubitVector<data_t> &qv) {
   js = qv.json();
 }
 
-template <typename data_t>
-json_t QubitVector<data_t>::json() const {
+template <typename data_t> json_t QubitVector<data_t>::json() const {
   const int_t END = data_size_;
   const json_t ZERO = std::complex<data_t>(0.0, 0.0);
   json_t js = json_t(data_size_, ZERO);
 
   if (json_chop_threshold_ > 0) {
-    #pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
-    for (int_t j=0; j < END; j++) {
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
+    for (int_t j = 0; j < END; j++) {
       if (std::abs(data_[j].real()) > json_chop_threshold_)
         js[j][0] = data_[j].real();
       if (std::abs(data_[j].imag()) > json_chop_threshold_)
         js[j][1] = data_[j].imag();
     }
   } else {
-    #pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
-    for (int_t j=0; j < END; j++) {
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
+    for (int_t j = 0; j < END; j++) {
       js[j][0] = data_[j].real();
       js[j][1] = data_[j].imag();
     }
@@ -682,7 +689,8 @@ void QubitVector<data_t>::check_qubit(const uint_t qubit) const {
 }
 
 template <typename data_t>
-void QubitVector<data_t>::check_matrix(const cvector_t<data_t> &vec, uint_t nqubits) const {
+void QubitVector<data_t>::check_matrix(const cvector_t<data_t> &vec,
+                                       uint_t nqubits) const {
   const size_t DIM = BITS[nqubits];
   const auto SIZE = vec.size();
   if (SIZE != DIM * DIM) {
@@ -693,7 +701,8 @@ void QubitVector<data_t>::check_matrix(const cvector_t<data_t> &vec, uint_t nqub
 }
 
 template <typename data_t>
-void QubitVector<data_t>::check_vector(const cvector_t<data_t> &vec, uint_t nqubits) const {
+void QubitVector<data_t>::check_vector(const cvector_t<data_t> &vec,
+                                       uint_t nqubits) const {
   const size_t DIM = BITS[nqubits];
   const auto SIZE = vec.size();
   if (SIZE != DIM) {
@@ -707,16 +716,16 @@ template <typename data_t>
 void QubitVector<data_t>::check_dimension(const QubitVector &qv) const {
   if (data_size_ != qv.size_) {
     std::string error = "QubitVector: vectors are different shape " +
-                         std::to_string(data_size_) + " != " +
-                         std::to_string(qv.num_states_);
+                        std::to_string(data_size_) +
+                        " != " + std::to_string(qv.num_states_);
     throw std::runtime_error(error);
   }
 }
 
-template <typename data_t>
-void QubitVector<data_t>::check_checkpoint() const {
+template <typename data_t> void QubitVector<data_t>::check_checkpoint() const {
   if (!checkpoint_) {
-    throw std::runtime_error("QubitVector: checkpoint must exist for inner_product() or revert()");
+    throw std::runtime_error(
+        "QubitVector: checkpoint must exist for inner_product() or revert()");
   }
 }
 
@@ -725,31 +734,32 @@ void QubitVector<data_t>::check_checkpoint() const {
 //------------------------------------------------------------------------------
 
 template <typename data_t>
-QubitVector<data_t>::QubitVector(size_t num_qubits, std::complex<data_t>* data, bool copy)
-  : num_qubits_(num_qubits), data_size_(BITS[num_qubits]), data_(data), unmanaged_data_(true), checkpoint_(0) {
-    set_transformer_method();
-    if (!data)
-      unmanaged_data_ = false;
-    if (copy) {
-      checkpoint();
-      data_ = checkpoint_;
-      checkpoint_ = 0;
-      unmanaged_data_ = false;
-    }
+QubitVector<data_t>::QubitVector(size_t num_qubits, std::complex<data_t> *data,
+                                 bool copy)
+    : num_qubits_(num_qubits), data_size_(BITS[num_qubits]), data_(data),
+      unmanaged_data_(true), checkpoint_(0) {
+  set_transformer_method();
+  if (!data)
+    unmanaged_data_ = false;
+  if (copy) {
+    checkpoint();
+    data_ = checkpoint_;
+    checkpoint_ = 0;
+    unmanaged_data_ = false;
+  }
 }
 
 template <typename data_t>
 QubitVector<data_t>::QubitVector(size_t num_qubits)
-  : num_qubits_(0), data_(nullptr), unmanaged_data_(false), checkpoint_(0) {
-    set_num_qubits(num_qubits);
-    set_transformer_method();
+    : num_qubits_(0), data_(nullptr), unmanaged_data_(false), checkpoint_(0) {
+  set_num_qubits(num_qubits);
+  set_transformer_method();
 }
 
 template <typename data_t>
 QubitVector<data_t>::QubitVector() : QubitVector(0) {}
 
-template <typename data_t>
-QubitVector<data_t>::~QubitVector() {
+template <typename data_t> QubitVector<data_t>::~QubitVector() {
   free_mem();
   free_checkpoint();
 }
@@ -760,32 +770,34 @@ QubitVector<data_t>::~QubitVector() {
 
 template <typename data_t>
 std::complex<data_t> &QubitVector<data_t>::operator[](uint_t element) {
-  // Error checking
-  #ifdef DEBUG
+// Error checking
+#ifdef DEBUG
   if (element > data_size_) {
-    std::string error = "QubitVector(" << std::hex << this << "): vector index " + std::to_string(element) +
-                        " > " + std::to_string(data_size_);
+    std::string error = "QubitVector("
+                        << std::hex << this
+                        << "): vector index " + std::to_string(element) +
+                               " > " + std::to_string(data_size_);
     throw std::runtime_error(error);
   }
-  #endif
+#endif
   return data_[element];
 }
 
 template <typename data_t>
 std::complex<data_t> QubitVector<data_t>::operator[](uint_t element) const {
-  // Error checking
-  #ifdef DEBUG
+// Error checking
+#ifdef DEBUG
   if (element > data_size_) {
     std::string error = "QubitVector: vector index " + std::to_string(element) +
                         " > " + std::to_string(data_size_);
     throw std::runtime_error(error);
   }
-  #endif
+#endif
   return data_[element];
 }
 
 template <typename data_t>
-void QubitVector<data_t>::set_state(uint_t pos, std::complex<data_t>& val) {
+void QubitVector<data_t>::set_state(uint_t pos, std::complex<data_t> &val) {
   data_[pos] = val;
 }
 
@@ -794,22 +806,21 @@ std::complex<data_t> QubitVector<data_t>::get_state(uint_t pos) const {
   return data_[pos];
 }
 
-
 template <typename data_t>
 cvector_t<data_t> QubitVector<data_t>::vector() const {
   cvector_t<data_t> ret(data_size_, 0.);
   const int_t END = data_size_;
-  #pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
-  for (int_t j=0; j < END; j++) {
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
+  for (int_t j = 0; j < END; j++) {
     ret[j] = data_[j];
   }
   return ret;
 }
 
-
 template <typename data_t>
 cdict_t<data_t> QubitVector<data_t>::vector_ket(double epsilon) const {
-    return AER::Utils::vec2ket(data_, size(), epsilon, 16);
+  return AER::Utils::vec2ket(data_, size(), epsilon, 16);
 }
 
 template <typename data_t>
@@ -831,18 +842,21 @@ AER::Vector<std::complex<data_t>> QubitVector<data_t>::move_to_vector() {
 // State initialize component
 //------------------------------------------------------------------------------
 template <typename data_t>
-void QubitVector<data_t>::initialize_component(const reg_t &qubits, const cvector_t<double> &state0) {
+void QubitVector<data_t>::initialize_component(
+    const reg_t &qubits, const cvector_t<double> &state0) {
 
   cvector_t<data_t> state = convert(state0);
 
   // Lambda function for initializing component
-  auto lambda = [&](const indexes_t &inds, const cvector_t<data_t> &_state)->void {
+  auto lambda = [&](const indexes_t &inds,
+                    const cvector_t<data_t> &_state) -> void {
     const uint_t DIM = 1ULL << qubits.size();
-    std::complex<data_t> cache = data_[inds[0]];  // the k-th component of non-initialized vector
+    std::complex<data_t> cache =
+        data_[inds[0]]; // the k-th component of non-initialized vector
     for (size_t i = 0; i < DIM; i++) {
-      data_[inds[i]] = cache * _state[i];  // set component to psi[k] * state[i]
-    }    // (where psi is is the post-reset state of the non-initialized qubits)
-   };
+      data_[inds[i]] = cache * _state[i]; // set component to psi[k] * state[i]
+    } // (where psi is is the post-reset state of the non-initialized qubits)
+  };
   // Use the lambda function
   apply_lambda(lambda, qubits, state);
 }
@@ -851,30 +865,30 @@ void QubitVector<data_t>::initialize_component(const reg_t &qubits, const cvecto
 // Utility
 //------------------------------------------------------------------------------
 
-template <typename data_t>
-void QubitVector<data_t>::zero() {
-  const int_t END = data_size_;    // end for k loop
+template <typename data_t> void QubitVector<data_t>::zero() {
+  const int_t END = data_size_; // end for k loop
 
-#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
   for (int_t k = 0; k < END; ++k) {
     data_[k] = 0.0;
   }
 }
 
 template <typename data_t>
-cvector_t<data_t> QubitVector<data_t>::convert(const cvector_t<double>& v) const {
+cvector_t<data_t>
+QubitVector<data_t>::convert(const cvector_t<double> &v) const {
   cvector_t<data_t> ret(v.size());
   for (size_t i = 0; i < v.size(); ++i)
     ret[i] = v[i];
   return ret;
 }
 
-
 template <typename data_t>
 void QubitVector<data_t>::set_num_qubits(size_t num_qubits) {
 
   free_checkpoint();
-  if(num_qubits != num_qubits_){
+  if (num_qubits != num_qubits_) {
     free_mem();
   }
   data_size_ = BITS[num_qubits];
@@ -883,8 +897,7 @@ void QubitVector<data_t>::set_num_qubits(size_t num_qubits) {
   num_qubits_ = num_qubits;
 }
 
-template <typename data_t>
-void QubitVector<data_t>::free_mem(){
+template <typename data_t> void QubitVector<data_t>::free_mem() {
   if (data_) {
     if (!unmanaged_data_)
       free(data_);
@@ -893,8 +906,7 @@ void QubitVector<data_t>::free_mem(){
   }
 }
 
-template<typename data_t>
-void QubitVector<data_t>::free_checkpoint(){
+template <typename data_t> void QubitVector<data_t>::free_checkpoint() {
   if (checkpoint_) {
     free(checkpoint_);
     checkpoint_ = nullptr;
@@ -902,32 +914,33 @@ void QubitVector<data_t>::free_checkpoint(){
 }
 
 template <typename data_t>
-void QubitVector<data_t>::allocate_mem(size_t data_size){
+void QubitVector<data_t>::allocate_mem(size_t data_size) {
   // Free any currently assigned memory
   free_mem();
   // Allocate memory for new vector
   if (data_ == nullptr) {
 #if !defined(_WIN64) && !defined(_WIN32)
-    void* data = nullptr;
+    void *data = nullptr;
     posix_memalign(&data, 64, sizeof(std::complex<data_t>) * data_size);
-    data_ = reinterpret_cast<std::complex<data_t>*>(data);
+    data_ = reinterpret_cast<std::complex<data_t> *>(data);
 #else
-    data_ = reinterpret_cast<std::complex<data_t>*>(malloc(sizeof(std::complex<data_t>) * data_size));
+    data_ = reinterpret_cast<std::complex<data_t> *>(
+        malloc(sizeof(std::complex<data_t>) * data_size));
 #endif
   }
 }
 
 template <typename data_t>
-void QubitVector<data_t>::allocate_checkpoint(size_t data_size){
+void QubitVector<data_t>::allocate_checkpoint(size_t data_size) {
   free_checkpoint();
 #if !defined(_WIN64) && !defined(_WIN32)
-  void* data = nullptr;
+  void *data = nullptr;
   posix_memalign(&data, 64, sizeof(std::complex<data_t>) * data_size);
-  checkpoint_ = reinterpret_cast<std::complex<data_t>*>(data);
+  checkpoint_ = reinterpret_cast<std::complex<data_t> *>(data);
 #else
-  checkpoint_ = reinterpret_cast<std::complex<data_t>*>(malloc(sizeof(std::complex<data_t>) * data_size));
+  checkpoint_ = reinterpret_cast<std::complex<data_t> *>(
+      malloc(sizeof(std::complex<data_t>) * data_size));
 #endif
-
 }
 
 template <typename data_t>
@@ -939,24 +952,21 @@ size_t QubitVector<data_t>::required_memory_mb(uint_t num_qubits) const {
   return mem_mb;
 }
 
-
-template <typename data_t>
-void QubitVector<data_t>::checkpoint() {
+template <typename data_t> void QubitVector<data_t>::checkpoint() {
 
   allocate_checkpoint(data_size_);
-  const int_t END = data_size_;    // end for k loop
-  #pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+  const int_t END = data_size_; // end for k loop
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
   for (int_t k = 0; k < END; ++k)
     checkpoint_[k] = data_[k];
-
 }
 
-template <typename data_t>
-void QubitVector<data_t>::revert(bool keep) {
+template <typename data_t> void QubitVector<data_t>::revert(bool keep) {
 
-  #ifdef DEBUG
+#ifdef DEBUG
   check_checkpoint();
-  #endif
+#endif
 
   // If we aren't keeping checkpoint we don't need to copy memory
   // we can simply swap the pointers and free discarded memory
@@ -967,21 +977,21 @@ void QubitVector<data_t>::revert(bool keep) {
     return;
   }
   // Otherwise we need to copy data
-  const int_t END = data_size_;    // end for k loop
-  #pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+  const int_t END = data_size_; // end for k loop
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
   for (int_t k = 0; k < END; ++k)
     data_[k] = checkpoint_[k];
-
 }
 
 template <typename data_t>
 std::complex<double> QubitVector<data_t>::inner_product() const {
 
-  #ifdef DEBUG
+#ifdef DEBUG
   check_checkpoint();
-  #endif
+#endif
   // Lambda function for inner product with checkpoint state
-  auto lambda = [&](int_t k, double &val_re, double &val_im)->void {
+  auto lambda = [&](int_t k, double &val_re, double &val_im) -> void {
     const std::complex<double> z = data_[k] * std::conj(checkpoint_[k]);
     val_re += std::real(z);
     val_im += std::imag(z);
@@ -989,48 +999,43 @@ std::complex<double> QubitVector<data_t>::inner_product() const {
   return apply_reduction_lambda(lambda);
 }
 
-//setup chunk
+// setup chunk
 template <typename data_t>
-bool QubitVector<data_t>::chunk_setup(int chunk_bits,int num_qubits,uint_t chunk_index,uint_t num_local_chunks)
-{
+bool QubitVector<data_t>::chunk_setup(int chunk_bits, int num_qubits,
+                                      uint_t chunk_index,
+                                      uint_t num_local_chunks) {
   chunk_index_ = chunk_index;
   return true;
 }
 
 template <typename data_t>
-bool QubitVector<data_t>::chunk_setup(QubitVector<data_t>& base,const uint_t chunk_index)
-{
+bool QubitVector<data_t>::chunk_setup(QubitVector<data_t> &base,
+                                      const uint_t chunk_index) {
   chunk_index_ = chunk_index;
   return true;
 }
 
-//prepare buffer for MPI send/recv
+// prepare buffer for MPI send/recv
 template <typename data_t>
-std::complex<data_t>* QubitVector<data_t>::send_buffer(uint_t& size_in_byte)
-{
+std::complex<data_t> *QubitVector<data_t>::send_buffer(uint_t &size_in_byte) {
   size_in_byte = sizeof(std::complex<data_t>) * data_size_;
   return data_;
 }
 
 template <typename data_t>
-std::complex<data_t>* QubitVector<data_t>::recv_buffer(uint_t& size_in_byte)
-{
+std::complex<data_t> *QubitVector<data_t>::recv_buffer(uint_t &size_in_byte) {
   size_in_byte = sizeof(std::complex<data_t>) * data_size_;
-  if(recv_buffer_.size() < data_size_){
+  if (recv_buffer_.size() < data_size_) {
     recv_buffer_.resize(data_size_);
   }
   return &recv_buffer_[0];
 }
 
 template <typename data_t>
-void QubitVector<data_t>::release_send_buffer(void) const
-{
-
-}
+void QubitVector<data_t>::release_send_buffer(void) const {}
 
 template <typename data_t>
-void QubitVector<data_t>::release_recv_buffer(void) const
-{
+void QubitVector<data_t>::release_recv_buffer(void) const {
   recv_buffer_.clear();
 }
 
@@ -1038,8 +1043,7 @@ void QubitVector<data_t>::release_recv_buffer(void) const
 // Initialization
 //------------------------------------------------------------------------------
 
-template <typename data_t>
-void QubitVector<data_t>::initialize() {
+template <typename data_t> void QubitVector<data_t>::initialize() {
   zero();
   data_[0] = 1.;
 }
@@ -1048,36 +1052,39 @@ template <typename data_t>
 template <typename list_t>
 void QubitVector<data_t>::initialize_from_vector(const list_t &vec) {
   if (data_size_ != vec.size()) {
-    std::string error = "QubitVector::initialize input vector is incorrect length (" +
-                        std::to_string(data_size_) + "!=" +
-                        std::to_string(vec.size()) + ")";
+    std::string error =
+        "QubitVector::initialize input vector is incorrect length (" +
+        std::to_string(data_size_) + "!=" + std::to_string(vec.size()) + ")";
     throw std::runtime_error(error);
   }
 
-  const int_t END = data_size_;    // end for k loop
+  const int_t END = data_size_; // end for k loop
 
-#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
   for (int_t k = 0; k < END; ++k)
     data_[k] = vec[k];
 }
 
 template <typename data_t>
-void QubitVector<data_t>::initialize_from_vector(std::vector<std::complex<data_t>> &&vec) {
+void QubitVector<data_t>::initialize_from_vector(
+    std::vector<std::complex<data_t>> &&vec) {
   if (data_size_ != vec.size()) {
-    std::string error = "QubitVector::initialize input vector is incorrect length (" +
-                        std::to_string(data_size_) + "!=" +
-                        std::to_string(vec.size()) + ")";
+    std::string error =
+        "QubitVector::initialize input vector is incorrect length (" +
+        std::to_string(data_size_) + "!=" + std::to_string(vec.size()) + ")";
     throw std::runtime_error(error);
   }
   std::move(vec.begin(), vec.end(), data_);
 }
 
 template <typename data_t>
-void QubitVector<data_t>::initialize_from_vector(AER::Vector<std::complex<data_t>> &&vec) {
+void QubitVector<data_t>::initialize_from_vector(
+    AER::Vector<std::complex<data_t>> &&vec) {
   if (data_size_ != vec.size()) {
-    std::string error = "QubitVector::initialize input vector is incorrect length (" +
-                        std::to_string(data_size_) + "!=" +
-                        std::to_string(vec.size()) + ")";
+    std::string error =
+        "QubitVector::initialize input vector is incorrect length (" +
+        std::to_string(data_size_) + "!=" + std::to_string(vec.size()) + ")";
     throw std::runtime_error(error);
   }
   free_mem();
@@ -1085,35 +1092,35 @@ void QubitVector<data_t>::initialize_from_vector(AER::Vector<std::complex<data_t
 }
 
 template <typename data_t>
-void QubitVector<data_t>::initialize_from_data(const std::complex<data_t>* vec, const size_t num_states) {
+void QubitVector<data_t>::initialize_from_data(const std::complex<data_t> *vec,
+                                               const size_t num_states) {
   if (data_size_ != num_states) {
-    std::string error = "QubitVector::initialize input vector is incorrect length (" +
-                        std::to_string(data_size_) + "!=" + std::to_string(num_states) + ")";
+    std::string error =
+        "QubitVector::initialize input vector is incorrect length (" +
+        std::to_string(data_size_) + "!=" + std::to_string(num_states) + ")";
     throw std::runtime_error(error);
   }
 
-  const int_t END = data_size_;    // end for k loop
+  const int_t END = data_size_; // end for k loop
 
-#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
   for (int_t k = 0; k < END; ++k)
     data_[k] = vec[k];
 }
 
-
 /*******************************************************************************
  *
  * CONFIG SETTINGS
  *
  ******************************************************************************/
 
-template <typename data_t>
-void QubitVector<data_t>::set_omp_threads(int n) {
+template <typename data_t> void QubitVector<data_t>::set_omp_threads(int n) {
   if (n > 0)
     omp_threads_ = n;
 }
 
-template <typename data_t>
-void QubitVector<data_t>::set_omp_threshold(int n) {
+template <typename data_t> void QubitVector<data_t>::set_omp_threshold(int n) {
   if (n > 0)
     omp_threshold_ = n;
 }
@@ -1129,102 +1136,101 @@ void QubitVector<data_t>::set_json_chop_threshold(double threshold) {
  *
  ******************************************************************************/
 
-
 //------------------------------------------------------------------------------
 // State update
 //------------------------------------------------------------------------------
 
 template <typename data_t>
-template<typename Lambda>
-void QubitVector<data_t>::apply_lambda(Lambda&& func) {
+template <typename Lambda>
+void QubitVector<data_t>::apply_lambda(Lambda &&func) {
   QV::apply_lambda(0, data_size_, omp_threads_managed(), func);
 }
 
 template <typename data_t>
-template<typename Lambda, typename list_t>
-void QubitVector<data_t>::apply_lambda(Lambda&& func, const list_t &qubits) {
+template <typename Lambda, typename list_t>
+void QubitVector<data_t>::apply_lambda(Lambda &&func, const list_t &qubits) {
 
-  // Error checking
-  #ifdef DEBUG
+// Error checking
+#ifdef DEBUG
   for (const auto &qubit : qubits)
     check_qubit(qubit);
-  #endif
+#endif
 
   QV::apply_lambda(0, data_size_, omp_threads_managed(), func, qubits);
 }
 
 template <typename data_t>
-template<typename Lambda, typename list_t, typename param_t>
-void QubitVector<data_t>::apply_lambda(Lambda&& func,
-                                       const list_t &qubits,
+template <typename Lambda, typename list_t, typename param_t>
+void QubitVector<data_t>::apply_lambda(Lambda &&func, const list_t &qubits,
                                        const param_t &params) {
 
-  // Error checking
-  #ifdef DEBUG
+// Error checking
+#ifdef DEBUG
   for (const auto &qubit : qubits)
     check_qubit(qubit);
-  #endif
+#endif
 
   QV::apply_lambda(0, data_size_, omp_threads_managed(), func, qubits, params);
 }
 
 template <typename data_t>
-template<typename Lambda>
-void QubitVector<data_t>::apply_lambda(Lambda&& func, size_t start, size_t stop){
-    QV::apply_lambda(start, stop, omp_threads_managed(), func);
+template <typename Lambda>
+void QubitVector<data_t>::apply_lambda(Lambda &&func, size_t start,
+                                       size_t stop) {
+  QV::apply_lambda(start, stop, omp_threads_managed(), func);
 }
 
-
 //------------------------------------------------------------------------------
 // Reduction Lambda
 //------------------------------------------------------------------------------
 
 template <typename data_t>
-template<typename Lambda>
+template <typename Lambda>
 std::complex<double>
-QubitVector<data_t>::apply_reduction_lambda(Lambda &&func, size_t start, size_t stop) const {
+QubitVector<data_t>::apply_reduction_lambda(Lambda &&func, size_t start,
+                                            size_t stop) const {
   return QV::apply_reduction_lambda(start, stop, omp_threads_managed(), func);
 }
 
 template <typename data_t>
-template<typename Lambda>
-std::complex<double> QubitVector<data_t>::apply_reduction_lambda(Lambda &&func) const {
+template <typename Lambda>
+std::complex<double>
+QubitVector<data_t>::apply_reduction_lambda(Lambda &&func) const {
   return apply_reduction_lambda(std::move(func), size_t(0), data_size_);
 }
 
 template <typename data_t>
-template<typename Lambda, typename list_t>
+template <typename Lambda, typename list_t>
 std::complex<double>
-QubitVector<data_t>::apply_reduction_lambda(Lambda&& func,
+QubitVector<data_t>::apply_reduction_lambda(Lambda &&func,
                                             const list_t &qubits) const {
 
-  // Error checking
-  #ifdef DEBUG
+// Error checking
+#ifdef DEBUG
   for (const auto &qubit : qubits)
     check_qubit(qubit);
-  #endif
+#endif
 
-  return QV::apply_reduction_lambda(0, data_size_, omp_threads_managed(), func, qubits);
+  return QV::apply_reduction_lambda(0, data_size_, omp_threads_managed(), func,
+                                    qubits);
 }
 
-
 template <typename data_t>
-template<typename Lambda, typename list_t, typename param_t>
+template <typename Lambda, typename list_t, typename param_t>
 std::complex<double>
-QubitVector<data_t>::apply_reduction_lambda(Lambda&& func,
-                                            const list_t &qubits,
+QubitVector<data_t>::apply_reduction_lambda(Lambda &&func, const list_t &qubits,
                                             const param_t &params) const {
 
-  // Error checking
-  #ifdef DEBUG
+// Error checking
+#ifdef DEBUG
   for (const auto &qubit : qubits)
     check_qubit(qubit);
-  #endif
+#endif
 
-  return QV::apply_reduction_lambda(0, data_size_, omp_threads_managed(), func, qubits, params);
+  return QV::apply_reduction_lambda(0, data_size_, omp_threads_managed(), func,
+                                    qubits, params);
 }
 
-
 /*******************************************************************************
  *
  * MATRIX MULTIPLICATION
@@ -1233,19 +1239,21 @@ QubitVector<data_t>::apply_reduction_lambda(Lambda&& func,
 template <typename data_t>
 void QubitVector<data_t>::apply_matrix(const reg_t &qubits,
                                        const cvector_t<double> &mat) {
-    transformer_->apply_matrix(data_, data_size_, omp_threads_managed(), qubits, mat);
+  transformer_->apply_matrix(data_, data_size_, omp_threads_managed(), qubits,
+                             mat);
 }
 
 template <typename data_t>
 void QubitVector<data_t>::apply_multiplexer(const reg_t &control_qubits,
                                             const reg_t &target_qubits,
-                                            const cvector_t<double>  &mat) {
+                                            const cvector_t<double> &mat) {
 
-  auto lambda = [&](const indexes_t &inds, const cvector_t<data_t> &_mat)->void {
+  auto lambda = [&](const indexes_t &inds,
+                    const cvector_t<data_t> &_mat) -> void {
     // General implementation
     const size_t control_count = control_qubits.size();
-    const size_t target_count  = target_qubits.size();
-    const uint_t DIM = BITS[(target_count+control_count)];
+    const size_t target_count = target_qubits.size();
+    const uint_t DIM = BITS[(target_count + control_count)];
     const uint_t columns = BITS[target_count];
     const uint_t blocks = BITS[control_count];
     // Lambda function for stacked matrix multiplication
@@ -1258,15 +1266,17 @@ void QubitVector<data_t>::apply_multiplexer(const reg_t &control_qubits,
     // update state vector
     for (uint_t b = 0; b < blocks; b++)
       for (uint_t i = 0; i < columns; i++)
-        for (uint_t j = 0; j < columns; j++)
-	{
-	  data_[inds[i+b*columns]] += _mat[i+b*columns + DIM * j] * cache[b*columns+j];
-	}
+        for (uint_t j = 0; j < columns; j++) {
+          data_[inds[i + b * columns]] +=
+              _mat[i + b * columns + DIM * j] * cache[b * columns + j];
+        }
   };
-  
+
   // Use the lambda function
   auto qubits = target_qubits;
-  for (const auto &q : control_qubits) {qubits.push_back(q);}
+  for (const auto &q : control_qubits) {
+    qubits.push_back(q);
+  }
   apply_lambda(lambda, qubits, convert(mat));
 }
 
@@ -1274,92 +1284,94 @@ template <typename data_t>
 void QubitVector<data_t>::apply_diagonal_matrix(const reg_t &qubits,
                                                 const cvector_t<double> &diag) {
 
-  transformer_->apply_diagonal_matrix(data_, data_size_, omp_threads_managed(), qubits, diag);
+  transformer_->apply_diagonal_matrix(data_, data_size_, omp_threads_managed(),
+                                      qubits, diag);
 }
 
 template <typename data_t>
-void QubitVector<data_t>::apply_permutation_matrix(const reg_t& qubits,
-                                                   const std::vector<std::pair<uint_t, uint_t>> &pairs) {
+void QubitVector<data_t>::apply_permutation_matrix(
+    const reg_t &qubits, const std::vector<std::pair<uint_t, uint_t>> &pairs) {
   const size_t N = qubits.size();
 
-  // Error checking
-  #ifdef DEBUG
+// Error checking
+#ifdef DEBUG
   check_vector(diag, N);
-  #endif
+#endif
 
   switch (N) {
-    case 1: {
-      // Lambda function for permutation matrix
-      auto lambda = [&](const areg_t<2> &inds)->void {
-        for (const auto &p : pairs) {
-          std::swap(data_[inds[p.first]], data_[inds[p.second]]);
-        }
-      };
-      apply_lambda(lambda, areg_t<1>({{qubits[0]}}));
-      return;
-    }
-    case 2: {
-      // Lambda function for permutation matrix
-      auto lambda = [&](const areg_t<4> &inds)->void {
-        for (const auto &p : pairs) {
-          std::swap(data_[inds[p.first]], data_[inds[p.second]]);
-        }
-      };
-      apply_lambda(lambda, areg_t<2>({{qubits[0], qubits[1]}}));
-      return;
-    }
-    case 3: {
-      // Lambda function for permutation matrix
-      auto lambda = [&](const areg_t<8> &inds)->void {
-        for (const auto &p : pairs) {
-          std::swap(data_[inds[p.first]], data_[inds[p.second]]);
-        }
-      };
-      apply_lambda(lambda, areg_t<3>({{qubits[0], qubits[1], qubits[2]}}));
-      return;
-    }
-    case 4: {
-      // Lambda function for permutation matrix
-      auto lambda = [&](const areg_t<16> &inds)->void {
-        for (const auto &p : pairs) {
-          std::swap(data_[inds[p.first]], data_[inds[p.second]]);
-        }
-      };
-      apply_lambda(lambda, areg_t<4>({{qubits[0], qubits[1], qubits[2], qubits[3]}}));
-      return;
-    }
-    case 5: {
-      // Lambda function for permutation matrix
-      auto lambda = [&](const areg_t<32> &inds)->void {
-        for (const auto &p : pairs) {
-          std::swap(data_[inds[p.first]], data_[inds[p.second]]);
-        }
-      };
-      apply_lambda(lambda, areg_t<5>({{qubits[0], qubits[1], qubits[2],
-                                       qubits[3], qubits[4]}}));
-      return;
-    }
-    case 6: {
-      // Lambda function for permutation matrix
-      auto lambda = [&](const areg_t<64> &inds)->void {
-        for (const auto &p : pairs) {
-          std::swap(data_[inds[p.first]], data_[inds[p.second]]);
-        }
-      };
-      apply_lambda(lambda, areg_t<6>({{qubits[0], qubits[1], qubits[2],
-                                       qubits[3], qubits[4], qubits[5]}}));
-      return;
-    }
-    default: {
-      // Lambda function for permutation matrix
-      auto lambda = [&](const indexes_t &inds)->void {
-        for (const auto &p : pairs) {
-          std::swap(data_[inds[p.first]], data_[inds[p.second]]);
-        }
-      };
-      // Use the lambda function
-      apply_lambda(lambda, qubits);
-    }
+  case 1: {
+    // Lambda function for permutation matrix
+    auto lambda = [&](const areg_t<2> &inds) -> void {
+      for (const auto &p : pairs) {
+        std::swap(data_[inds[p.first]], data_[inds[p.second]]);
+      }
+    };
+    apply_lambda(lambda, areg_t<1>({{qubits[0]}}));
+    return;
+  }
+  case 2: {
+    // Lambda function for permutation matrix
+    auto lambda = [&](const areg_t<4> &inds) -> void {
+      for (const auto &p : pairs) {
+        std::swap(data_[inds[p.first]], data_[inds[p.second]]);
+      }
+    };
+    apply_lambda(lambda, areg_t<2>({{qubits[0], qubits[1]}}));
+    return;
+  }
+  case 3: {
+    // Lambda function for permutation matrix
+    auto lambda = [&](const areg_t<8> &inds) -> void {
+      for (const auto &p : pairs) {
+        std::swap(data_[inds[p.first]], data_[inds[p.second]]);
+      }
+    };
+    apply_lambda(lambda, areg_t<3>({{qubits[0], qubits[1], qubits[2]}}));
+    return;
+  }
+  case 4: {
+    // Lambda function for permutation matrix
+    auto lambda = [&](const areg_t<16> &inds) -> void {
+      for (const auto &p : pairs) {
+        std::swap(data_[inds[p.first]], data_[inds[p.second]]);
+      }
+    };
+    apply_lambda(lambda,
+                 areg_t<4>({{qubits[0], qubits[1], qubits[2], qubits[3]}}));
+    return;
+  }
+  case 5: {
+    // Lambda function for permutation matrix
+    auto lambda = [&](const areg_t<32> &inds) -> void {
+      for (const auto &p : pairs) {
+        std::swap(data_[inds[p.first]], data_[inds[p.second]]);
+      }
+    };
+    apply_lambda(lambda, areg_t<5>({{qubits[0], qubits[1], qubits[2], qubits[3],
+                                     qubits[4]}}));
+    return;
+  }
+  case 6: {
+    // Lambda function for permutation matrix
+    auto lambda = [&](const areg_t<64> &inds) -> void {
+      for (const auto &p : pairs) {
+        std::swap(data_[inds[p.first]], data_[inds[p.second]]);
+      }
+    };
+    apply_lambda(lambda, areg_t<6>({{qubits[0], qubits[1], qubits[2], qubits[3],
+                                     qubits[4], qubits[5]}}));
+    return;
+  }
+  default: {
+    // Lambda function for permutation matrix
+    auto lambda = [&](const indexes_t &inds) -> void {
+      for (const auto &p : pairs) {
+        std::swap(data_[inds[p.first]], data_[inds[p.second]]);
+      }
+    };
+    // Use the lambda function
+    apply_lambda(lambda, qubits);
+  }
   } // end switch
 }
 
@@ -1381,37 +1393,37 @@ void QubitVector<data_t>::apply_mcx(const reg_t &qubits) {
   const size_t pos1 = MASKS[N];
 
   switch (N) {
-    case 1: {
-      // Lambda function for X gate
-      auto lambda = [&](const areg_t<2> &inds)->void {
-        std::swap(data_[inds[pos0]], data_[inds[pos1]]);
-      };
-      apply_lambda(lambda, areg_t<1>({{qubits[0]}}));
-      return;
-    }
-    case 2: {
-      // Lambda function for CX gate
-      auto lambda = [&](const areg_t<4> &inds)->void {
-        std::swap(data_[inds[pos0]], data_[inds[pos1]]);
-      };
-      apply_lambda(lambda, areg_t<2>({{qubits[0], qubits[1]}}));
-      return;
-    }
-    case 3: {
-      // Lambda function for Toffli gate
-      auto lambda = [&](const areg_t<8> &inds)->void {
-        std::swap(data_[inds[pos0]], data_[inds[pos1]]);
-      };
-      apply_lambda(lambda, areg_t<3>({{qubits[0], qubits[1], qubits[2]}}));
-      return;
-    }
-    default: {
-      // Lambda function for general multi-controlled X gate
-      auto lambda = [&](const indexes_t &inds)->void {
-        std::swap(data_[inds[pos0]], data_[inds[pos1]]);
-      };
-      apply_lambda(lambda, qubits);
-    }
+  case 1: {
+    // Lambda function for X gate
+    auto lambda = [&](const areg_t<2> &inds) -> void {
+      std::swap(data_[inds[pos0]], data_[inds[pos1]]);
+    };
+    apply_lambda(lambda, areg_t<1>({{qubits[0]}}));
+    return;
+  }
+  case 2: {
+    // Lambda function for CX gate
+    auto lambda = [&](const areg_t<4> &inds) -> void {
+      std::swap(data_[inds[pos0]], data_[inds[pos1]]);
+    };
+    apply_lambda(lambda, areg_t<2>({{qubits[0], qubits[1]}}));
+    return;
+  }
+  case 3: {
+    // Lambda function for Toffli gate
+    auto lambda = [&](const areg_t<8> &inds) -> void {
+      std::swap(data_[inds[pos0]], data_[inds[pos1]]);
+    };
+    apply_lambda(lambda, areg_t<3>({{qubits[0], qubits[1], qubits[2]}}));
+    return;
+  }
+  default: {
+    // Lambda function for general multi-controlled X gate
+    auto lambda = [&](const indexes_t &inds) -> void {
+      std::swap(data_[inds[pos0]], data_[inds[pos1]]);
+    };
+    apply_lambda(lambda, qubits);
+  }
   } // end switch
 }
 
@@ -1424,118 +1436,120 @@ void QubitVector<data_t>::apply_mcy(const reg_t &qubits) {
   const std::complex<data_t> I(0., 1.);
 
   switch (N) {
-    case 1: {
-      // Lambda function for Y gate
-      auto lambda = [&](const areg_t<2> &inds)->void {
-        const std::complex<data_t> cache = data_[inds[pos0]];
-        data_[inds[pos0]] = -I * data_[inds[pos1]];
-        data_[inds[pos1]] = I * cache;
-      };
-      apply_lambda(lambda, areg_t<1>({{qubits[0]}}));
-      return;
-    }
-    case 2: {
-      // Lambda function for CY gate
-      auto lambda = [&](const areg_t<4> &inds)->void {
-        const std::complex<data_t> cache = data_[inds[pos0]];
-        data_[inds[pos0]] = -I * data_[inds[pos1]];
-        data_[inds[pos1]] = I * cache;
-      };
-      apply_lambda(lambda, areg_t<2>({{qubits[0], qubits[1]}}));
-      return;
-    }
-    case 3: {
-      // Lambda function for CCY gate
-      auto lambda = [&](const areg_t<8> &inds)->void {
-        const std::complex<data_t> cache = data_[inds[pos0]];
-        data_[inds[pos0]] = -I * data_[inds[pos1]];
-        data_[inds[pos1]] = I * cache;
-      };
-      apply_lambda(lambda, areg_t<3>({{qubits[0], qubits[1], qubits[2]}}));
-      return;
-    }
-    default: {
-      // Lambda function for general multi-controlled Y gate
-      auto lambda = [&](const indexes_t &inds)->void {
-        const std::complex<data_t> cache = data_[inds[pos0]];
-        data_[inds[pos0]] = -I * data_[inds[pos1]];
-        data_[inds[pos1]] = I * cache;
-      };
-      apply_lambda(lambda, qubits);
-    }
+  case 1: {
+    // Lambda function for Y gate
+    auto lambda = [&](const areg_t<2> &inds) -> void {
+      const std::complex<data_t> cache = data_[inds[pos0]];
+      data_[inds[pos0]] = -I * data_[inds[pos1]];
+      data_[inds[pos1]] = I * cache;
+    };
+    apply_lambda(lambda, areg_t<1>({{qubits[0]}}));
+    return;
+  }
+  case 2: {
+    // Lambda function for CY gate
+    auto lambda = [&](const areg_t<4> &inds) -> void {
+      const std::complex<data_t> cache = data_[inds[pos0]];
+      data_[inds[pos0]] = -I * data_[inds[pos1]];
+      data_[inds[pos1]] = I * cache;
+    };
+    apply_lambda(lambda, areg_t<2>({{qubits[0], qubits[1]}}));
+    return;
+  }
+  case 3: {
+    // Lambda function for CCY gate
+    auto lambda = [&](const areg_t<8> &inds) -> void {
+      const std::complex<data_t> cache = data_[inds[pos0]];
+      data_[inds[pos0]] = -I * data_[inds[pos1]];
+      data_[inds[pos1]] = I * cache;
+    };
+    apply_lambda(lambda, areg_t<3>({{qubits[0], qubits[1], qubits[2]}}));
+    return;
+  }
+  default: {
+    // Lambda function for general multi-controlled Y gate
+    auto lambda = [&](const indexes_t &inds) -> void {
+      const std::complex<data_t> cache = data_[inds[pos0]];
+      data_[inds[pos0]] = -I * data_[inds[pos1]];
+      data_[inds[pos1]] = I * cache;
+    };
+    apply_lambda(lambda, qubits);
+  }
   } // end switch
 }
 
 template <typename data_t>
 void QubitVector<data_t>::apply_mcswap(const reg_t &qubits) {
   // Calculate the swap positions for the last two qubits.
-  // If N = 2 this is just a regular SWAP gate rather than a controlled-SWAP gate.
+  // If N = 2 this is just a regular SWAP gate rather than a controlled-SWAP
+  // gate.
   const size_t N = qubits.size();
   const size_t pos0 = MASKS[N - 1];
   const size_t pos1 = pos0 + BITS[N - 2];
 
   switch (N) {
-    case 2: {
-      // Lambda function for SWAP gate
-      auto lambda = [&](const areg_t<4> &inds)->void {
-        std::swap(data_[inds[pos0]], data_[inds[pos1]]);
-      };
-      apply_lambda(lambda, areg_t<2>({{qubits[0], qubits[1]}}));
-      return;
-    }
-    case 3: {
-      // Lambda function for C-SWAP gate
-      auto lambda = [&](const areg_t<8> &inds)->void {
-        std::swap(data_[inds[pos0]], data_[inds[pos1]]);
-      };
-      apply_lambda(lambda, areg_t<3>({{qubits[0], qubits[1], qubits[2]}}));
-      return;
-    }
-    default: {
-      // Lambda function for general multi-controlled SWAP gate
-      auto lambda = [&](const indexes_t &inds)->void {
-        std::swap(data_[inds[pos0]], data_[inds[pos1]]);
-      };
-      apply_lambda(lambda, qubits);
-    }
+  case 2: {
+    // Lambda function for SWAP gate
+    auto lambda = [&](const areg_t<4> &inds) -> void {
+      std::swap(data_[inds[pos0]], data_[inds[pos1]]);
+    };
+    apply_lambda(lambda, areg_t<2>({{qubits[0], qubits[1]}}));
+    return;
+  }
+  case 3: {
+    // Lambda function for C-SWAP gate
+    auto lambda = [&](const areg_t<8> &inds) -> void {
+      std::swap(data_[inds[pos0]], data_[inds[pos1]]);
+    };
+    apply_lambda(lambda, areg_t<3>({{qubits[0], qubits[1], qubits[2]}}));
+    return;
+  }
+  default: {
+    // Lambda function for general multi-controlled SWAP gate
+    auto lambda = [&](const indexes_t &inds) -> void {
+      std::swap(data_[inds[pos0]], data_[inds[pos1]]);
+    };
+    apply_lambda(lambda, qubits);
+  }
   } // end switch
 }
 
 template <typename data_t>
-void QubitVector<data_t>::apply_mcphase(const reg_t &qubits, const std::complex<double> phase) {
+void QubitVector<data_t>::apply_mcphase(const reg_t &qubits,
+                                        const std::complex<double> phase) {
   const size_t N = qubits.size();
   switch (N) {
-    case 1: {
-      // Lambda function for arbitrary Phase gate with diagonal [1, phase]
-      auto lambda = [&](const areg_t<2> &inds)->void {
-        data_[inds[1]] *= phase;
-      };
-      apply_lambda(lambda, areg_t<1>({{qubits[0]}}));
-      return;
-    }
-    case 2: {
-      // Lambda function for CPhase gate with diagonal [1, 1, 1, phase]
-      auto lambda = [&](const areg_t<4> &inds)->void {
-        data_[inds[3]] *= phase;
-      };
-      apply_lambda(lambda, areg_t<2>({{qubits[0], qubits[1]}}));
-      return;
-    }
-    case 3: {
-      auto lambda = [&](const areg_t<8> &inds)->void {
-         data_[inds[7]] *= phase;
-      };
-      apply_lambda(lambda, areg_t<3>({{qubits[0], qubits[1], qubits[2]}}));
-      return;
-    }
-    default: {
-      // Lambda function for general multi-controlled Phase gate
-      // with diagonal [1, ..., 1, phase]
-      auto lambda = [&](const indexes_t &inds)->void {
-         data_[inds[MASKS[N]]] *= phase;
-      };
-      apply_lambda(lambda, qubits);
-    }
+  case 1: {
+    // Lambda function for arbitrary Phase gate with diagonal [1, phase]
+    auto lambda = [&](const areg_t<2> &inds) -> void {
+      data_[inds[1]] *= phase;
+    };
+    apply_lambda(lambda, areg_t<1>({{qubits[0]}}));
+    return;
+  }
+  case 2: {
+    // Lambda function for CPhase gate with diagonal [1, 1, 1, phase]
+    auto lambda = [&](const areg_t<4> &inds) -> void {
+      data_[inds[3]] *= phase;
+    };
+    apply_lambda(lambda, areg_t<2>({{qubits[0], qubits[1]}}));
+    return;
+  }
+  case 3: {
+    auto lambda = [&](const areg_t<8> &inds) -> void {
+      data_[inds[7]] *= phase;
+    };
+    apply_lambda(lambda, areg_t<3>({{qubits[0], qubits[1], qubits[2]}}));
+    return;
+  }
+  default: {
+    // Lambda function for general multi-controlled Phase gate
+    // with diagonal [1, ..., 1, phase]
+    auto lambda = [&](const indexes_t &inds) -> void {
+      data_[inds[MASKS[N]]] *= phase;
+    };
+    apply_lambda(lambda, qubits);
+  }
   } // end switch
 }
 
@@ -1561,151 +1575,156 @@ void QubitVector<data_t>::apply_mcu(const reg_t &qubits,
     const cvector_t<double> diag = {{mat[0], mat[3]}};
     // Diagonal version
     switch (N) {
-      case 1: {
-        // If N=1 this is just a single-qubit matrix
-        apply_diagonal_matrix(qubits, diag);
-        return;
-      }
-      case 2: {
-        // Lambda function for CU gate
-        auto lambda = [&](const areg_t<4> &inds,
-                          const cvector_t<data_t> &_diag)->void {
-          data_[inds[pos0]] = _diag[0] * data_[inds[pos0]];
-          data_[inds[pos1]] = _diag[1] * data_[inds[pos1]];
-        };
-        apply_lambda(lambda, areg_t<2>({{qubits[0], qubits[1]}}), convert(diag));
-        return;
-      }
-      case 3: {
-        // Lambda function for CCU gate
-        auto lambda = [&](const areg_t<8> &inds,
-                          const cvector_t<data_t> &_diag)->void {
-          data_[inds[pos0]] = _diag[0] * data_[inds[pos0]];
-          data_[inds[pos1]] = _diag[1] * data_[inds[pos1]];
-        };
-        apply_lambda(lambda, areg_t<3>({{qubits[0], qubits[1], qubits[2]}}), convert(diag));
-        return;
-      }
-      default: {
-        // Lambda function for general multi-controlled U gate
-        auto lambda = [&](const indexes_t &inds,
-                          const cvector_t<data_t> &_diag)->void {
-          data_[inds[pos0]] = _diag[0] * data_[inds[pos0]];
-          data_[inds[pos1]] = _diag[1] * data_[inds[pos1]];
-        };
-        apply_lambda(lambda, qubits, convert(diag));
-        return;
-      }
-    } // end switch
-  }
-
-  // Non-diagonal version
-  switch (N) {
     case 1: {
       // If N=1 this is just a single-qubit matrix
-      apply_matrix(qubits, mat);
+      apply_diagonal_matrix(qubits, diag);
       return;
     }
     case 2: {
       // Lambda function for CU gate
       auto lambda = [&](const areg_t<4> &inds,
-                        const cvector_t<data_t> &_mat)->void {
-      const auto cache = data_[inds[pos0]];
-      data_[inds[pos0]] = _mat[0] * data_[inds[pos0]] + _mat[2] * data_[inds[pos1]];
-      data_[inds[pos1]] = _mat[1] * cache + _mat[3] * data_[inds[pos1]];
+                        const cvector_t<data_t> &_diag) -> void {
+        data_[inds[pos0]] = _diag[0] * data_[inds[pos0]];
+        data_[inds[pos1]] = _diag[1] * data_[inds[pos1]];
       };
-      apply_lambda(lambda, areg_t<2>({{qubits[0], qubits[1]}}), convert(mat));
+      apply_lambda(lambda, areg_t<2>({{qubits[0], qubits[1]}}), convert(diag));
       return;
     }
     case 3: {
       // Lambda function for CCU gate
       auto lambda = [&](const areg_t<8> &inds,
-                        const cvector_t<data_t> &_mat)->void {
-      const auto cache = data_[inds[pos0]];
-      data_[inds[pos0]] = _mat[0] * data_[inds[pos0]] + _mat[2] * data_[inds[pos1]];
-      data_[inds[pos1]] = _mat[1] * cache + _mat[3] * data_[inds[pos1]];
+                        const cvector_t<data_t> &_diag) -> void {
+        data_[inds[pos0]] = _diag[0] * data_[inds[pos0]];
+        data_[inds[pos1]] = _diag[1] * data_[inds[pos1]];
       };
-      apply_lambda(lambda, areg_t<3>({{qubits[0], qubits[1], qubits[2]}}), convert(mat));
+      apply_lambda(lambda, areg_t<3>({{qubits[0], qubits[1], qubits[2]}}),
+                   convert(diag));
       return;
     }
     default: {
       // Lambda function for general multi-controlled U gate
       auto lambda = [&](const indexes_t &inds,
-                        const cvector_t<data_t> &_mat)->void {
-      const auto cache = data_[inds[pos0]];
-      data_[inds[pos0]] = _mat[0] * data_[inds[pos0]] + _mat[2] * data_[inds[pos1]];
-      data_[inds[pos1]] = _mat[1] * cache + _mat[3] * data_[inds[pos1]];
+                        const cvector_t<data_t> &_diag) -> void {
+        data_[inds[pos0]] = _diag[0] * data_[inds[pos0]];
+        data_[inds[pos1]] = _diag[1] * data_[inds[pos1]];
       };
-      apply_lambda(lambda, qubits, convert(mat));
+      apply_lambda(lambda, qubits, convert(diag));
       return;
     }
+    } // end switch
+  }
+
+  // Non-diagonal version
+  switch (N) {
+  case 1: {
+    // If N=1 this is just a single-qubit matrix
+    apply_matrix(qubits, mat);
+    return;
+  }
+  case 2: {
+    // Lambda function for CU gate
+    auto lambda = [&](const areg_t<4> &inds,
+                      const cvector_t<data_t> &_mat) -> void {
+      const auto cache = data_[inds[pos0]];
+      data_[inds[pos0]] =
+          _mat[0] * data_[inds[pos0]] + _mat[2] * data_[inds[pos1]];
+      data_[inds[pos1]] = _mat[1] * cache + _mat[3] * data_[inds[pos1]];
+    };
+    apply_lambda(lambda, areg_t<2>({{qubits[0], qubits[1]}}), convert(mat));
+    return;
+  }
+  case 3: {
+    // Lambda function for CCU gate
+    auto lambda = [&](const areg_t<8> &inds,
+                      const cvector_t<data_t> &_mat) -> void {
+      const auto cache = data_[inds[pos0]];
+      data_[inds[pos0]] =
+          _mat[0] * data_[inds[pos0]] + _mat[2] * data_[inds[pos1]];
+      data_[inds[pos1]] = _mat[1] * cache + _mat[3] * data_[inds[pos1]];
+    };
+    apply_lambda(lambda, areg_t<3>({{qubits[0], qubits[1], qubits[2]}}),
+                 convert(mat));
+    return;
+  }
+  default: {
+    // Lambda function for general multi-controlled U gate
+    auto lambda = [&](const indexes_t &inds,
+                      const cvector_t<data_t> &_mat) -> void {
+      const auto cache = data_[inds[pos0]];
+      data_[inds[pos0]] =
+          _mat[0] * data_[inds[pos0]] + _mat[2] * data_[inds[pos1]];
+      data_[inds[pos1]] = _mat[1] * cache + _mat[3] * data_[inds[pos1]];
+    };
+    apply_lambda(lambda, qubits, convert(mat));
+    return;
+  }
   } // end switch
 }
 
 template <typename data_t>
-void QubitVector<data_t>::apply_rotation(const reg_t &qubits, const Rotation r, const double theta)
-{
-  switch(r){
-    case Rotation::x:
-      apply_mcu(qubits, Linalg::VMatrix::rx(theta));
-      break;
-    case Rotation::y:
-      apply_mcu(qubits, Linalg::VMatrix::ry(theta));
-      break;
-    case Rotation::z:
-      apply_mcu(qubits, Linalg::VMatrix::rz(theta));
-      break;
-    case Rotation::xx:
-      apply_matrix(qubits, Linalg::VMatrix::rxx(theta));
-      break;
-    case Rotation::yy:
-      apply_matrix(qubits, Linalg::VMatrix::ryy(theta));
-      break;
-    case Rotation::zz:
-      apply_diagonal_matrix(qubits, Linalg::VMatrix::rzz_diag(theta));
-      break;
-    case Rotation::zx:
-      apply_matrix(qubits, Linalg::VMatrix::rzx(theta));
-      break;
-    default:
-      throw std::invalid_argument(
-          "QubitVector::invalid rotation axis.");
+void QubitVector<data_t>::apply_rotation(const reg_t &qubits, const Rotation r,
+                                         const double theta) {
+  switch (r) {
+  case Rotation::x:
+    apply_mcu(qubits, Linalg::VMatrix::rx(theta));
+    break;
+  case Rotation::y:
+    apply_mcu(qubits, Linalg::VMatrix::ry(theta));
+    break;
+  case Rotation::z:
+    apply_mcu(qubits, Linalg::VMatrix::rz(theta));
+    break;
+  case Rotation::xx:
+    apply_matrix(qubits, Linalg::VMatrix::rxx(theta));
+    break;
+  case Rotation::yy:
+    apply_matrix(qubits, Linalg::VMatrix::ryy(theta));
+    break;
+  case Rotation::zz:
+    apply_diagonal_matrix(qubits, Linalg::VMatrix::rzz_diag(theta));
+    break;
+  case Rotation::zx:
+    apply_matrix(qubits, Linalg::VMatrix::rzx(theta));
+    break;
+  default:
+    throw std::invalid_argument("QubitVector::invalid rotation axis.");
   }
 }
 
 template <typename data_t>
-void QubitVector<data_t>::apply_chunk_swap(const reg_t &qubits, QubitVector<data_t> &src, bool write_back)
-{
-  uint_t q0,q1,t;
+void QubitVector<data_t>::apply_chunk_swap(const reg_t &qubits,
+                                           QubitVector<data_t> &src,
+                                           bool write_back) {
+  uint_t q0, q1, t;
 
   q0 = qubits[qubits.size() - 2];
   q1 = qubits[qubits.size() - 1];
 
-  if(q0 > q1){
+  if (q0 > q1) {
     t = q0;
     q0 = q1;
     q1 = t;
   }
 
-  if(q0 >= num_qubits_){  //exchange whole of chunk each other
-    if(write_back){
-#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+  if (q0 >= num_qubits_) { // exchange whole of chunk each other
+    if (write_back) {
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
       for (int_t k = 0; k < data_size_; ++k) {
-        std::swap(data_[k],src.data_[k]);
+        std::swap(data_[k], src.data_[k]);
       }
-    }
-    else{
-#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+    } else {
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
       for (int_t k = 0; k < data_size_; ++k) {
         data_[k] = src.data_[k];
       }
     }
-  }
-  else{
-    bool src_lower =  chunk_index_ < src.chunk_index_;
-    auto first_idx =  src_lower ? 1 : 0;
-    auto second_idx  = src_lower ? 0 : 1;
-    auto lambda = [&](const areg_t<2> &inds)->void {
+  } else {
+    bool src_lower = chunk_index_ < src.chunk_index_;
+    auto first_idx = src_lower ? 1 : 0;
+    auto second_idx = src_lower ? 0 : 1;
+    auto lambda = [&](const areg_t<2> &inds) -> void {
       std::swap(data_[inds[first_idx]], src.data_[inds[second_idx]]);
     };
     apply_lambda(lambda, areg_t<1>({{q0}}));
@@ -1713,30 +1732,30 @@ void QubitVector<data_t>::apply_chunk_swap(const reg_t &qubits, QubitVector<data
 }
 
 template <typename data_t>
-void QubitVector<data_t>::apply_chunk_swap(const reg_t &qubits, uint_t remote_chunk_index)
-{
-  uint_t q0,q1,t;
+void QubitVector<data_t>::apply_chunk_swap(const reg_t &qubits,
+                                           uint_t remote_chunk_index) {
+  uint_t q0, q1, t;
 
   q0 = qubits[qubits.size() - 2];
   q1 = qubits[qubits.size() - 1];
 
-  if(q0 > q1){
+  if (q0 > q1) {
     t = q0;
     q0 = q1;
     q1 = t;
   }
 
-  if(q0 >= num_qubits_){  //exchange whole of chunk each other
-#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+  if (q0 >= num_qubits_) { // exchange whole of chunk each other
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
     for (int_t k = 0; k < data_size_; ++k) {
       data_[k] = recv_buffer_[k];
     }
-  }
-  else{
-    bool src_lower =  chunk_index_ < remote_chunk_index;
-    auto first_idx =  src_lower ? 1 : 0;
-    auto second_idx  = src_lower ? 0 : 1;
-    auto lambda = [&](const areg_t<2> &inds)->void {
+  } else {
+    bool src_lower = chunk_index_ < remote_chunk_index;
+    auto first_idx = src_lower ? 1 : 0;
+    auto second_idx = src_lower ? 0 : 1;
+    auto lambda = [&](const areg_t<2> &inds) -> void {
       std::swap(data_[inds[first_idx]], recv_buffer_[inds[second_idx]]);
     };
     apply_lambda(lambda, areg_t<1>({{q0}}));
@@ -1744,16 +1763,18 @@ void QubitVector<data_t>::apply_chunk_swap(const reg_t &qubits, uint_t remote_ch
 }
 
 template <typename data_t>
-void QubitVector<data_t>::apply_chunk_swap(QubitVector<data_t> &src, uint_t dest_offset, uint_t src_offset, uint_t size)
-{
-  if(src.chunk_index_ == chunk_index_){
-#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+void QubitVector<data_t>::apply_chunk_swap(QubitVector<data_t> &src,
+                                           uint_t dest_offset,
+                                           uint_t src_offset, uint_t size) {
+  if (src.chunk_index_ == chunk_index_) {
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
     for (int_t k = 0; k < size; ++k) {
       data_[dest_offset + k] = src.recv_buffer_[src_offset + k];
     }
-  }
-  else{
-#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+  } else {
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
     for (int_t k = 0; k < size; ++k) {
       std::swap(data_[dest_offset + k], src.data_[src_offset + k]);
     }
@@ -1761,29 +1782,27 @@ void QubitVector<data_t>::apply_chunk_swap(QubitVector<data_t> &src, uint_t dest
 }
 
 template <typename data_t>
-void QubitVector<data_t>::apply_multi_swaps(const reg_t &qubits)
-{
-  for(int_t i=0;i<qubits.size();i+=10){
+void QubitVector<data_t>::apply_multi_swaps(const reg_t &qubits) {
+  for (int_t i = 0; i < qubits.size(); i += 10) {
     int_t n = 10;
-    if(i + n > qubits.size())
+    if (i + n > qubits.size())
       n = qubits.size() - i;
 
-    reg_t qubits_swap(qubits.begin() + i,qubits.begin() + i + n);
+    reg_t qubits_swap(qubits.begin() + i, qubits.begin() + i + n);
 
     uint_t nq = qubits_swap.size();
     uint_t size = 1ull << nq;
 
-    auto lambda = [&](const indexes_t &inds)->void 
-    {
+    auto lambda = [&](const indexes_t &inds) -> void {
       cvector_t<data_t> cache(size);
-      for(int_t i=0;i<size;i++)
+      for (int_t i = 0; i < size; i++)
         cache[i] = data_[inds[i]];
 
-      for(int_t i=0;i<size;i++){
+      for (int_t i = 0; i < size; i++) {
         uint_t pos = i;
-        for(int_t j=0;j<nq;j+=2){
-          if((((pos >> j) & 1) ^ ((pos >> (j+1)) & 1)) != 0){
-            pos ^= ((1ull << j) | (1ull << (j+1)));
+        for (int_t j = 0; j < nq; j += 2) {
+          if ((((pos >> j) & 1) ^ ((pos >> (j + 1)) & 1)) != 0) {
+            pos ^= ((1ull << j) | (1ull << (j + 1)));
           }
         }
         data_[inds[i]] = cache[pos];
@@ -1798,10 +1817,9 @@ void QubitVector<data_t>::apply_multi_swaps(const reg_t &qubits)
  * NORMS
  *
  ******************************************************************************/
-template <typename data_t>
-double QubitVector<data_t>::norm() const {
+template <typename data_t> double QubitVector<data_t>::norm() const {
   // Lambda function for norm
-  auto lambda = [&](int_t k, double &val_re, double &val_im)->void {
+  auto lambda = [&](int_t k, double &val_re, double &val_im) -> void {
     (void)val_im; // unused
     val_re += std::real(data_[k] * std::conj(data_[k]));
   };
@@ -1809,148 +1827,150 @@ double QubitVector<data_t>::norm() const {
 }
 
 template <typename data_t>
-double QubitVector<data_t>::norm(const reg_t &qubits, const cvector_t<double> &mat) const {
+double QubitVector<data_t>::norm(const reg_t &qubits,
+                                 const cvector_t<double> &mat) const {
 
-  // Error checking
-  #ifdef DEBUG
+// Error checking
+#ifdef DEBUG
   check_vector(mat, 2 * qubits.size());
-  #endif
+#endif
 
   // Static array optimized lambda functions
   switch (qubits.size()) {
-    case 1:
-      return norm(qubits[0], mat);
-    case 2: {
-      // Lambda function for 2-qubit matrix norm
-      auto lambda = [&](const areg_t<4> &inds, const cvector_t<data_t> &_mat,
-                        double &val_re, double &val_im)->void {
-        (void)val_im; // unused
-        for (size_t i = 0; i < 4; i++) {
-          std::complex<data_t> vi = 0;
-          for (size_t j = 0; j < 4; j++)
-            vi += _mat[i + 4 * j] * data_[inds[j]];
-          val_re += std::real(vi * std::conj(vi));
-        }
-      };
-      areg_t<2> qubits_arr = {{qubits[0], qubits[1]}};
-      return std::real(apply_reduction_lambda(lambda, qubits_arr, convert(mat)));
-    }
-    case 3: {
-      // Lambda function for 3-qubit matrix norm
-      auto lambda = [&](const areg_t<8> &inds, const cvector_t<data_t> &_mat,
-                        double &val_re, double &val_im)->void {
-        (void)val_im; // unused
-        for (size_t i = 0; i < 8; i++) {
-          std::complex<data_t> vi = 0;
-          for (size_t j = 0; j < 8; j++)
-            vi += _mat[i + 8 * j] * data_[inds[j]];
-          val_re += std::real(vi * std::conj(vi));
-        }
-      };
-      areg_t<3> qubits_arr = {{qubits[0], qubits[1], qubits[2]}};
-      return std::real(apply_reduction_lambda(lambda, qubits_arr, convert(mat)));
-    }
-    case 4: {
-      // Lambda function for 4-qubit matrix norm
-      auto lambda = [&](const areg_t<16> &inds, const cvector_t<data_t> &_mat,
-                        double &val_re, double &val_im)->void {
-        (void)val_im; // unused
-        for (size_t i = 0; i < 16; i++) {
-          std::complex<data_t> vi = 0;
-          for (size_t j = 0; j < 16; j++)
-            vi += _mat[i + 16 * j] * data_[inds[j]];
-          val_re += std::real(vi * std::conj(vi));
-        }
-      };
-      areg_t<4> qubits_arr = {{qubits[0], qubits[1], qubits[2], qubits[3]}};
-      return std::real(apply_reduction_lambda(lambda, qubits_arr, convert(mat)));
-    }
-    default: {
-      // Lambda function for N-qubit matrix norm
-      auto lambda = [&](const indexes_t &inds, const cvector_t<data_t> &_mat,
-                        double &val_re, double &val_im)->void {
-        (void)val_im; // unused
-        const uint_t DIM = BITS[qubits.size()];
-        for (size_t i = 0; i < DIM; i++) {
-          std::complex<data_t> vi = 0;
-          for (size_t j = 0; j < DIM; j++)
-            vi += _mat[i + DIM * j] * data_[inds[j]];
-          val_re += std::real(vi * std::conj(vi));
-        }
-      };
-      // Use the lambda function
-      return std::real(apply_reduction_lambda(lambda, qubits, convert(mat)));
-    }
+  case 1:
+    return norm(qubits[0], mat);
+  case 2: {
+    // Lambda function for 2-qubit matrix norm
+    auto lambda = [&](const areg_t<4> &inds, const cvector_t<data_t> &_mat,
+                      double &val_re, double &val_im) -> void {
+      (void)val_im; // unused
+      for (size_t i = 0; i < 4; i++) {
+        std::complex<data_t> vi = 0;
+        for (size_t j = 0; j < 4; j++)
+          vi += _mat[i + 4 * j] * data_[inds[j]];
+        val_re += std::real(vi * std::conj(vi));
+      }
+    };
+    areg_t<2> qubits_arr = {{qubits[0], qubits[1]}};
+    return std::real(apply_reduction_lambda(lambda, qubits_arr, convert(mat)));
+  }
+  case 3: {
+    // Lambda function for 3-qubit matrix norm
+    auto lambda = [&](const areg_t<8> &inds, const cvector_t<data_t> &_mat,
+                      double &val_re, double &val_im) -> void {
+      (void)val_im; // unused
+      for (size_t i = 0; i < 8; i++) {
+        std::complex<data_t> vi = 0;
+        for (size_t j = 0; j < 8; j++)
+          vi += _mat[i + 8 * j] * data_[inds[j]];
+        val_re += std::real(vi * std::conj(vi));
+      }
+    };
+    areg_t<3> qubits_arr = {{qubits[0], qubits[1], qubits[2]}};
+    return std::real(apply_reduction_lambda(lambda, qubits_arr, convert(mat)));
+  }
+  case 4: {
+    // Lambda function for 4-qubit matrix norm
+    auto lambda = [&](const areg_t<16> &inds, const cvector_t<data_t> &_mat,
+                      double &val_re, double &val_im) -> void {
+      (void)val_im; // unused
+      for (size_t i = 0; i < 16; i++) {
+        std::complex<data_t> vi = 0;
+        for (size_t j = 0; j < 16; j++)
+          vi += _mat[i + 16 * j] * data_[inds[j]];
+        val_re += std::real(vi * std::conj(vi));
+      }
+    };
+    areg_t<4> qubits_arr = {{qubits[0], qubits[1], qubits[2], qubits[3]}};
+    return std::real(apply_reduction_lambda(lambda, qubits_arr, convert(mat)));
+  }
+  default: {
+    // Lambda function for N-qubit matrix norm
+    auto lambda = [&](const indexes_t &inds, const cvector_t<data_t> &_mat,
+                      double &val_re, double &val_im) -> void {
+      (void)val_im; // unused
+      const uint_t DIM = BITS[qubits.size()];
+      for (size_t i = 0; i < DIM; i++) {
+        std::complex<data_t> vi = 0;
+        for (size_t j = 0; j < DIM; j++)
+          vi += _mat[i + DIM * j] * data_[inds[j]];
+        val_re += std::real(vi * std::conj(vi));
+      }
+    };
+    // Use the lambda function
+    return std::real(apply_reduction_lambda(lambda, qubits, convert(mat)));
+  }
   } // end switch
 }
 
 template <typename data_t>
-double QubitVector<data_t>::norm_diagonal(const reg_t &qubits, const cvector_t<double> &mat) const {
+double QubitVector<data_t>::norm_diagonal(const reg_t &qubits,
+                                          const cvector_t<double> &mat) const {
 
   const uint_t N = qubits.size();
 
-  // Error checking
-  #ifdef DEBUG
+// Error checking
+#ifdef DEBUG
   check_vector(mat, N);
-  #endif
+#endif
 
   // Static array optimized lambda functions
   switch (N) {
-    case 1:
-      return norm_diagonal(qubits[0], mat);
-    case 2: {
-      // Lambda function for 2-qubit matrix norm
-      auto lambda = [&](const areg_t<4> &inds, const cvector_t<data_t> &_mat,
-                        double &val_re, double &val_im)->void {
-        (void)val_im; // unused
-        for (size_t i = 0; i < 4; i++) {
-          const auto vi = _mat[i] * data_[inds[i]];
-          val_re += std::real(vi * std::conj(vi));
-        }
-      };
-      areg_t<2> qubits_arr = {{qubits[0], qubits[1]}};
-      return std::real(apply_reduction_lambda(lambda, qubits_arr, convert(mat)));
-    }
-    case 3: {
-      // Lambda function for 3-qubit matrix norm
-      auto lambda = [&](const areg_t<8> &inds, const cvector_t<data_t> &_mat,
-                        double &val_re, double &val_im)->void {
-        (void)val_im; // unused
-        for (size_t i = 0; i < 8; i++) {
-          const auto vi = _mat[i] * data_[inds[i]];
-          val_re += std::real(vi * std::conj(vi));
-        }
-      };
-      areg_t<3> qubits_arr = {{qubits[0], qubits[1], qubits[2]}};
-      return std::real(apply_reduction_lambda(lambda, qubits_arr, convert(mat)));
-    }
-    case 4: {
-      // Lambda function for 4-qubit matrix norm
-      auto lambda = [&](const areg_t<16> &inds, const cvector_t<data_t> &_mat,
-                        double &val_re, double &val_im)->void {
-        (void)val_im; // unused
-        for (size_t i = 0; i < 16; i++) {
-          const auto vi = _mat[i] * data_[inds[i]];
-          val_re += std::real(vi * std::conj(vi));
-        }
-      };
-      areg_t<4> qubits_arr = {{qubits[0], qubits[1], qubits[2], qubits[3]}};
-      return std::real(apply_reduction_lambda(lambda, qubits_arr, convert(mat)));
-    }
-    default: {
-      // Lambda function for N-qubit matrix norm
-      const uint_t DIM = BITS[N];
-      auto lambda = [&](const indexes_t &inds, const cvector_t<data_t> &_mat,
-                        double &val_re, double &val_im)->void {
-        (void)val_im; // unused
-        for (size_t i = 0; i < DIM; i++) {
-          const auto vi = _mat[i] * data_[inds[i]];
-          val_re += std::real(vi * std::conj(vi));
-        }
-      };
-      // Use the lambda function
-      return std::real(apply_reduction_lambda(lambda, qubits, convert(mat)));
-    }
+  case 1:
+    return norm_diagonal(qubits[0], mat);
+  case 2: {
+    // Lambda function for 2-qubit matrix norm
+    auto lambda = [&](const areg_t<4> &inds, const cvector_t<data_t> &_mat,
+                      double &val_re, double &val_im) -> void {
+      (void)val_im; // unused
+      for (size_t i = 0; i < 4; i++) {
+        const auto vi = _mat[i] * data_[inds[i]];
+        val_re += std::real(vi * std::conj(vi));
+      }
+    };
+    areg_t<2> qubits_arr = {{qubits[0], qubits[1]}};
+    return std::real(apply_reduction_lambda(lambda, qubits_arr, convert(mat)));
+  }
+  case 3: {
+    // Lambda function for 3-qubit matrix norm
+    auto lambda = [&](const areg_t<8> &inds, const cvector_t<data_t> &_mat,
+                      double &val_re, double &val_im) -> void {
+      (void)val_im; // unused
+      for (size_t i = 0; i < 8; i++) {
+        const auto vi = _mat[i] * data_[inds[i]];
+        val_re += std::real(vi * std::conj(vi));
+      }
+    };
+    areg_t<3> qubits_arr = {{qubits[0], qubits[1], qubits[2]}};
+    return std::real(apply_reduction_lambda(lambda, qubits_arr, convert(mat)));
+  }
+  case 4: {
+    // Lambda function for 4-qubit matrix norm
+    auto lambda = [&](const areg_t<16> &inds, const cvector_t<data_t> &_mat,
+                      double &val_re, double &val_im) -> void {
+      (void)val_im; // unused
+      for (size_t i = 0; i < 16; i++) {
+        const auto vi = _mat[i] * data_[inds[i]];
+        val_re += std::real(vi * std::conj(vi));
+      }
+    };
+    areg_t<4> qubits_arr = {{qubits[0], qubits[1], qubits[2], qubits[3]}};
+    return std::real(apply_reduction_lambda(lambda, qubits_arr, convert(mat)));
+  }
+  default: {
+    // Lambda function for N-qubit matrix norm
+    const uint_t DIM = BITS[N];
+    auto lambda = [&](const indexes_t &inds, const cvector_t<data_t> &_mat,
+                      double &val_re, double &val_im) -> void {
+      (void)val_im; // unused
+      for (size_t i = 0; i < DIM; i++) {
+        const auto vi = _mat[i] * data_[inds[i]];
+        val_re += std::real(vi * std::conj(vi));
+      }
+    };
+    // Use the lambda function
+    return std::real(apply_reduction_lambda(lambda, qubits, convert(mat)));
+  }
   } // end switch
 }
 
@@ -1958,11 +1978,12 @@ double QubitVector<data_t>::norm_diagonal(const reg_t &qubits, const cvector_t<d
 // Single-qubit specialization
 //------------------------------------------------------------------------------
 template <typename data_t>
-double QubitVector<data_t>::norm(const uint_t qubit, const cvector_t<double> &mat) const {
-  // Error handling
-  #ifdef DEBUG
+double QubitVector<data_t>::norm(const uint_t qubit,
+                                 const cvector_t<double> &mat) const {
+// Error handling
+#ifdef DEBUG
   check_vector(mat, 2);
-  #endif
+#endif
 
   // Check if input matrix is diagonal, and if so use diagonal function.
   if (mat[1] == 0.0 && mat[2] == 0.0) {
@@ -1971,38 +1992,36 @@ double QubitVector<data_t>::norm(const uint_t qubit, const cvector_t<double> &ma
   }
 
   // Lambda function for norm reduction to real value.
-  auto lambda = [&](const areg_t<2> &inds,
-                    const cvector_t<data_t> &_mat,
-                    double &val_re,
-                    double &val_im)->void {
+  auto lambda = [&](const areg_t<2> &inds, const cvector_t<data_t> &_mat,
+                    double &val_re, double &val_im) -> void {
     (void)val_im; // unused
     const auto v0 = _mat[0] * data_[inds[0]] + _mat[2] * data_[inds[1]];
     const auto v1 = _mat[1] * data_[inds[0]] + _mat[3] * data_[inds[1]];
     val_re += std::real(v0 * std::conj(v0)) + std::real(v1 * std::conj(v1));
   };
-  return std::real(apply_reduction_lambda(lambda, areg_t<1>({{qubit}}), convert(mat)));
+  return std::real(
+      apply_reduction_lambda(lambda, areg_t<1>({{qubit}}), convert(mat)));
 }
 
 template <typename data_t>
-double QubitVector<data_t>::norm_diagonal(const uint_t qubit, const cvector_t<double> &mat) const {
-  // Error handling
-  #ifdef DEBUG
+double QubitVector<data_t>::norm_diagonal(const uint_t qubit,
+                                          const cvector_t<double> &mat) const {
+// Error handling
+#ifdef DEBUG
   check_vector(mat, 1);
-  #endif
+#endif
   // Lambda function for norm reduction to real value.
-  auto lambda = [&](const areg_t<2> &inds,
-                    const cvector_t<data_t> &_mat,
-                    double &val_re,
-                    double &val_im)->void {
+  auto lambda = [&](const areg_t<2> &inds, const cvector_t<data_t> &_mat,
+                    double &val_re, double &val_im) -> void {
     (void)val_im; // unused
     const auto v0 = _mat[0] * data_[inds[0]];
     const auto v1 = _mat[1] * data_[inds[1]];
     val_re += std::real(v0 * std::conj(v0)) + std::real(v1 * std::conj(v1));
   };
-  return std::real(apply_reduction_lambda(lambda, areg_t<1>({{qubit}}), convert(mat)));
+  return std::real(
+      apply_reduction_lambda(lambda, areg_t<1>({{qubit}}), convert(mat)));
 }
 
-
 /*******************************************************************************
  *
  * Probabilities
@@ -2017,25 +2036,27 @@ template <typename data_t>
 std::vector<double> QubitVector<data_t>::probabilities() const {
   const int_t END = 1LL << num_qubits();
   std::vector<double> probs(END, 0.);
-#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
-  for (int_t j=0; j < END; j++) {
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
+  for (int_t j = 0; j < END; j++) {
     probs[j] = probability(j);
   }
   return probs;
 }
 
 template <typename data_t>
-std::vector<double> QubitVector<data_t>::probabilities(const reg_t &qubits) const {
+std::vector<double>
+QubitVector<data_t>::probabilities(const reg_t &qubits) const {
 
   const size_t N = qubits.size();
   const int_t DIM = BITS[N];
   const int_t END = BITS[num_qubits() - N];
 
-  // Error checking
-  #ifdef DEBUG
+// Error checking
+#ifdef DEBUG
   for (const auto &qubit : qubits)
     check_qubit(qubit);
-  #endif
+#endif
 
   auto qubits_sorted = qubits;
   std::sort(qubits_sorted.begin(), qubits_sorted.end());
@@ -2043,17 +2064,18 @@ std::vector<double> QubitVector<data_t>::probabilities(const reg_t &qubits) cons
     return probabilities();
 
   std::vector<double> probs(DIM, 0.);
-  #pragma omp parallel if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+#pragma omp parallel if (num_qubits_ > omp_threshold_ && omp_threads_ > 1)     \
+    num_threads(omp_threads_)
   {
     std::vector<data_t> probs_private(DIM, 0.);
-    #pragma omp for
-      for (int_t k = 0; k < END; k++) {
-        auto idx = indexes(qubits, qubits_sorted, k);
-        for (int_t m = 0; m < DIM; ++m) {
-          probs_private[m] += probability(idx[m]);
-        }
+#pragma omp for
+    for (int_t k = 0; k < END; k++) {
+      auto idx = indexes(qubits, qubits_sorted, k);
+      for (int_t m = 0; m < DIM; ++m) {
+        probs_private[m] += probability(idx[m]);
       }
-    #pragma omp critical
+    }
+#pragma omp critical
     for (int_t m = 0; m < DIM; ++m) {
       probs[m] += probs_private[m];
     }
@@ -2061,12 +2083,12 @@ std::vector<double> QubitVector<data_t>::probabilities(const reg_t &qubits) cons
   return probs;
 }
 
-
 //------------------------------------------------------------------------------
 // Sample measure outcomes
 //------------------------------------------------------------------------------
 template <typename data_t>
-reg_t QubitVector<data_t>::sample_measure(const std::vector<double> &rnds) const {
+reg_t QubitVector<data_t>::sample_measure(
+    const std::vector<double> &rnds) const {
 
   const int_t END = 1LL << num_qubits();
   const int_t SHOTS = rnds.size();
@@ -2077,9 +2099,10 @@ reg_t QubitVector<data_t>::sample_measure(const std::vector<double> &rnds) const
   const int_t INDEX_END = BITS[INDEX_SIZE];
   // Qubit number is below index size, loop over shots
   if (END < INDEX_END) {
-    #pragma omp parallel if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+#pragma omp parallel if (num_qubits_ > omp_threshold_ && omp_threads_ > 1)     \
+    num_threads(omp_threads_)
     {
-      #pragma omp for
+#pragma omp for
       for (int_t i = 0; i < SHOTS; ++i) {
         double rnd = rnds[i];
         double p = .0;
@@ -2099,9 +2122,10 @@ reg_t QubitVector<data_t>::sample_measure(const std::vector<double> &rnds) const
     std::vector<double> idxs;
     idxs.assign(INDEX_END, 0.0);
     uint_t loop = (END >> INDEX_SIZE);
-    #pragma omp parallel if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+#pragma omp parallel if (num_qubits_ > omp_threshold_ && omp_threads_ > 1)     \
+    num_threads(omp_threads_)
     {
-      #pragma omp for
+#pragma omp for
       for (int_t i = 0; i < INDEX_END; ++i) {
         uint_t base = loop * i;
         double total = .0;
@@ -2115,9 +2139,10 @@ reg_t QubitVector<data_t>::sample_measure(const std::vector<double> &rnds) const
       }
     } // end omp parallel
 
-    #pragma omp parallel if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
+#pragma omp parallel if (num_qubits_ > omp_threshold_ && omp_threads_ > 1)     \
+    num_threads(omp_threads_)
     {
-      #pragma omp for
+#pragma omp for
       for (int_t i = 0; i < SHOTS; ++i) {
         double rnd = rnds[i];
         double p = .0;
@@ -2132,7 +2157,7 @@ reg_t QubitVector<data_t>::sample_measure(const std::vector<double> &rnds) const
 
         for (; sample < END - 1; ++sample) {
           p += probability(sample);
-          if (rnd < p){
+          if (rnd < p) {
             break;
           }
         }
@@ -2149,9 +2174,10 @@ reg_t QubitVector<data_t>::sample_measure(const std::vector<double> &rnds) const
  *
  ******************************************************************************/
 using pauli_mask_data = std::tuple<uint_t, uint_t, uint_t, uint_t>;
-inline pauli_mask_data pauli_masks_and_phase(const reg_t &qubits, const std::string &pauli){
- // Break string up into Z and X
- // With Y being both Z and X (plus a phase)
+inline pauli_mask_data pauli_masks_and_phase(const reg_t &qubits,
+                                             const std::string &pauli) {
+  // Break string up into Z and X
+  // With Y being both Z and X (plus a phase)
   const size_t N = qubits.size();
   uint_t x_mask = 0;
   uint_t z_mask = 0;
@@ -2160,59 +2186,61 @@ inline pauli_mask_data pauli_masks_and_phase(const reg_t &qubits, const std::str
   for (size_t i = 0; i < N; ++i) {
     const auto bit = BITS[qubits[i]];
     switch (pauli[N - 1 - i]) {
-      case 'I':
-        break;
-      case 'X': {
-        x_mask += bit;
-        x_max = std::max(x_max, (qubits[i]));
-        break;
-      }
-      case 'Z': {
-        z_mask += bit;
-        break;
-      }
-      case 'Y': {
-        x_mask += bit;
-        x_max = std::max(x_max, (qubits[i]));
-        z_mask += bit;
-        num_y++;
-        break;
-      }
-      default:
-        throw std::invalid_argument("Invalid Pauli \"" + std::to_string(pauli[N - 1 - i]) + "\".");
+    case 'I':
+      break;
+    case 'X': {
+      x_mask += bit;
+      x_max = std::max(x_max, (qubits[i]));
+      break;
+    }
+    case 'Z': {
+      z_mask += bit;
+      break;
+    }
+    case 'Y': {
+      x_mask += bit;
+      x_max = std::max(x_max, (qubits[i]));
+      z_mask += bit;
+      num_y++;
+      break;
+    }
+    default:
+      throw std::invalid_argument("Invalid Pauli \"" +
+                                  std::to_string(pauli[N - 1 - i]) + "\".");
     }
   }
   return std::make_tuple(x_mask, z_mask, num_y, x_max);
 }
 
 template <typename data_t>
-void add_y_phase(uint_t num_y, std::complex<data_t>& coeff){
+void add_y_phase(uint_t num_y, std::complex<data_t> &coeff) {
   // Add overall phase to the input coefficient
 
   // Compute the overall phase of the operator.
   // This is (-1j) ** number of Y terms modulo 4
   switch (num_y & 3) {
-    case 0:
-      // phase = 1
-      break;
-    case 1:
-      // phase = -1j
-      coeff = std::complex<data_t>(coeff.imag(), -coeff.real());
-      break;
-    case 2:
-      // phase = -1
-      coeff = std::complex<data_t>(-coeff.real(), -coeff.imag());
-      break;
-    case 3:
-      // phase = 1j
-      coeff = std::complex<data_t>(-coeff.imag(), coeff.real());
-      break;
+  case 0:
+    // phase = 1
+    break;
+  case 1:
+    // phase = -1j
+    coeff = std::complex<data_t>(coeff.imag(), -coeff.real());
+    break;
+  case 2:
+    // phase = -1
+    coeff = std::complex<data_t>(-coeff.real(), -coeff.imag());
+    break;
+  case 3:
+    // phase = 1j
+    coeff = std::complex<data_t>(-coeff.imag(), coeff.real());
+    break;
   }
 }
 
 template <typename data_t>
 double QubitVector<data_t>::expval_pauli(const reg_t &qubits,
-                                         const std::string &pauli,const complex_t initial_phase) const {
+                                         const std::string &pauli,
+                                         const complex_t initial_phase) const {
 
   uint_t x_mask, z_mask, num_y, x_max;
   std::tie(x_mask, z_mask, num_y, x_max) = pauli_masks_and_phase(qubits, pauli);
@@ -2226,7 +2254,7 @@ double QubitVector<data_t>::expval_pauli(const reg_t &qubits,
 
   // specialize x_max == 0
   if (!x_mask) {
-    auto lambda = [&](const int_t i, double &val_re, double &val_im)->void {
+    auto lambda = [&](const int_t i, double &val_re, double &val_im) -> void {
       (void)val_im; // unused
       auto val = std::real(phase * data_[i] * std::conj(data_[i]));
       if (z_mask && (AER::Utils::popcount(i & z_mask) & 1)) {
@@ -2239,7 +2267,7 @@ double QubitVector<data_t>::expval_pauli(const reg_t &qubits,
 
   const uint_t mask_u = ~MASKS[x_max + 1];
   const uint_t mask_l = MASKS[x_max];
-  auto lambda = [&](const int_t i, double &val_re, double &val_im)->void {
+  auto lambda = [&](const int_t i, double &val_re, double &val_im) -> void {
     (void)val_im; // unused
     int_t idxs[2];
     idxs[0] = ((i << 1) & mask_u) | (i & mask_l);
@@ -2255,16 +2283,17 @@ double QubitVector<data_t>::expval_pauli(const reg_t &qubits,
       }
     }
   };
-  return std::real(apply_reduction_lambda(std::move(lambda), (size_t) 0, (data_size_ >> 1)));
+  return std::real(
+      apply_reduction_lambda(std::move(lambda), (size_t)0, (data_size_ >> 1)));
 }
 
-
 template <typename data_t>
 double QubitVector<data_t>::expval_pauli(const reg_t &qubits,
                                          const std::string &pauli,
-                                         const QubitVector<data_t>& pair_chunk,
-                                         const uint_t z_count,const uint_t z_count_pair,const complex_t initial_phase) const 
-{
+                                         const QubitVector<data_t> &pair_chunk,
+                                         const uint_t z_count,
+                                         const uint_t z_count_pair,
+                                         const complex_t initial_phase) const {
 
   uint_t x_mask, z_mask, num_y, x_max;
   std::tie(x_mask, z_mask, num_y, x_max) = pauli_masks_and_phase(qubits, pauli);
@@ -2272,12 +2301,13 @@ double QubitVector<data_t>::expval_pauli(const reg_t &qubits,
   auto phase = std::complex<data_t>(initial_phase);
   add_y_phase(num_y, phase);
 
-  std::complex<data_t>* pair_ptr = pair_chunk.data();
-  if(pair_ptr == this->data()){
-    pair_ptr = (std::complex<data_t>*)&recv_buffer_[0];    //use receive buffer for pair
+  std::complex<data_t> *pair_ptr = pair_chunk.data();
+  if (pair_ptr == this->data()) {
+    pair_ptr =
+        (std::complex<data_t> *)&recv_buffer_[0]; // use receive buffer for pair
   }
 
-  auto lambda = [&](const int_t i, double &val_re, double &val_im)->void {
+  auto lambda = [&](const int_t i, double &val_re, double &val_im) -> void {
     (void)val_im; // unused
     uint_t idxs[2];
     idxs[0] = i;
@@ -2285,13 +2315,14 @@ double QubitVector<data_t>::expval_pauli(const reg_t &qubits,
     double vals[2];
     vals[0] = std::real(phase * pair_ptr[idxs[1]] * std::conj(data_[idxs[0]]));
     vals[1] = std::real(phase * data_[idxs[0]] * std::conj(pair_ptr[idxs[1]]));
-    if( (AER::Utils::popcount(idxs[0] & z_mask)+z_count) & 1)
+    if ((AER::Utils::popcount(idxs[0] & z_mask) + z_count) & 1)
       vals[0] = -vals[0];
-    if( (AER::Utils::popcount(idxs[1] & z_mask)+z_count_pair) & 1)
+    if ((AER::Utils::popcount(idxs[1] & z_mask) + z_count_pair) & 1)
       vals[1] = -vals[1];
     val_re += vals[0] + vals[1];
   };
-  return std::real(apply_reduction_lambda(std::move(lambda), (size_t) 0, data_size_));
+  return std::real(
+      apply_reduction_lambda(std::move(lambda), (size_t)0, data_size_));
 }
 
 /*******************************************************************************
@@ -2300,8 +2331,9 @@ double QubitVector<data_t>::expval_pauli(const reg_t &qubits,
  *
  ******************************************************************************/
 template <typename data_t>
-void QubitVector<data_t>::apply_pauli(const reg_t &qubits, const std::string &pauli,
-                                      const complex_t &coeff){
+void QubitVector<data_t>::apply_pauli(const reg_t &qubits,
+                                      const std::string &pauli,
+                                      const complex_t &coeff) {
   uint_t x_mask, z_mask, num_y, x_max;
   std::tie(x_mask, z_mask, num_y, x_max) = pauli_masks_and_phase(qubits, pauli);
 
@@ -2314,11 +2346,11 @@ void QubitVector<data_t>::apply_pauli(const reg_t &qubits, const std::string &pa
 
   // specialize x_max == 0
   if (!x_mask) {
-    auto lambda = [&](const int_t i)->void {
-        if (z_mask && (AER::Utils::popcount(i & z_mask) & 1)) {
-             data_[i] *= -1;
-        }
-        data_[i] *= phase;
+    auto lambda = [&](const int_t i) -> void {
+      if (z_mask && (AER::Utils::popcount(i & z_mask) & 1)) {
+        data_[i] *= -1;
+      }
+      data_[i] *= phase;
     };
     apply_lambda(lambda);
     return;
@@ -2326,7 +2358,7 @@ void QubitVector<data_t>::apply_pauli(const reg_t &qubits, const std::string &pa
 
   const uint_t mask_u = ~MASKS[x_max + 1];
   const uint_t mask_l = MASKS[x_max];
-  auto lambda = [&](const int_t i)->void {
+  auto lambda = [&](const int_t i) -> void {
     int_t idxs[2];
     idxs[0] = ((i << 1) & mask_u) | (i & mask_l);
     idxs[1] = idxs[0] ^ x_mask;
@@ -2338,10 +2370,9 @@ void QubitVector<data_t>::apply_pauli(const reg_t &qubits, const std::string &pa
       data_[idxs[j]] *= phase;
     }
   };
-  apply_lambda(lambda, (size_t) 0, (data_size_ >> 1));
+  apply_lambda(lambda, (size_t)0, (data_size_ >> 1));
 }
 
-
 //------------------------------------------------------------------------------
 } // end namespace QV
 } // end namespace AER
@@ -2349,7 +2380,8 @@ void QubitVector<data_t>::apply_pauli(const reg_t &qubits, const std::string &pa
 
 // ostream overload for templated qubitvector
 template <typename data_t>
-inline std::ostream &operator<<(std::ostream &out, const AER::QV::QubitVector<data_t>&qv) {
+inline std::ostream &operator<<(std::ostream &out,
+                                const AER::QV::QubitVector<data_t> &qv) {
 
   out << "[";
   size_t last = qv.size() - 1;
diff --git a/src/simulators/statevector/qubitvector_thrust.hpp b/src/simulators/statevector/qubitvector_thrust.hpp
index e35bec2d2c..e80beb739f 100644
--- a/src/simulators/statevector/qubitvector_thrust.hpp
+++ b/src/simulators/statevector/qubitvector_thrust.hpp
@@ -12,7 +12,6 @@
  * that they have been altered from the originals.
  */
 
-
 #ifndef _qv_qubit_vector_thrust_hpp_
 #define _qv_qubit_vector_thrust_hpp_
 
@@ -21,12 +20,12 @@
 #include <cmath>
 #include <complex>
 #include <cstdint>
-#include <string>
-#include <vector>
 #include <iostream>
+#include <spdlog/spdlog.h>
 #include <sstream>
 #include <stdexcept>
-#include <spdlog/spdlog.h>
+#include <string>
+#include <vector>
 
 #include "framework/json.hpp"
 
@@ -38,7 +37,6 @@
 #include <omp.h>
 #endif
 
-
 namespace AER {
 namespace QV {
 
@@ -54,11 +52,9 @@ template <typename T> using cvector_t = std::vector<std::complex<T>>;
 // QubitVectorThrust class
 //============================================================================
 
-template <typename data_t = double>
-class QubitVectorThrust {
+template <typename data_t = double> class QubitVectorThrust {
 
 public:
-
   //-----------------------------------------------------------------------
   // Constructors and Destructor
   //-----------------------------------------------------------------------
@@ -67,11 +63,8 @@ class QubitVectorThrust {
   explicit QubitVectorThrust(size_t num_qubits);
   virtual ~QubitVectorThrust();
 
-  //copy constructor for std::vector
-  QubitVectorThrust(const QubitVectorThrust<data_t>& qv)
-  {
-    
-  }
+  // copy constructor for std::vector
+  QubitVectorThrust(const QubitVectorThrust<data_t> &qv) {}
 
   //-----------------------------------------------------------------------
   // Data access
@@ -81,14 +74,16 @@ class QubitVectorThrust {
   thrust::complex<data_t> &operator[](uint_t element);
   thrust::complex<data_t> operator[](uint_t element) const;
 
-  void set_state(uint_t pos,std::complex<data_t>& c);
+  void set_state(uint_t pos, std::complex<data_t> &c);
   std::complex<data_t> get_state(uint_t pos) const;
 
   // Returns a reference to the underlying data_t data class
   //  std::complex<data_t>* &data() {return data_;}
 
   // Returns a copy of the underlying data_t data class
-  std::complex<data_t>* data() const {return (std::complex<data_t>*)chunk_.pointer();}
+  std::complex<data_t> *data() const {
+    return (std::complex<data_t> *)chunk_.pointer();
+  }
 
   //-----------------------------------------------------------------------
   // Utility functions
@@ -96,29 +91,26 @@ class QubitVectorThrust {
 
   // Return the string name of the QubitVector class
 #ifdef AER_THRUST_CUDA
-  static std::string name() {return "statevector_gpu";}
+  static std::string name() { return "statevector_gpu"; }
 #else
-  static std::string name() {return "statevector_thrust";}
+  static std::string name() { return "statevector_thrust"; }
 #endif
-  virtual bool is_density_matrix(void) {return false;}
+  virtual bool is_density_matrix(void) { return false; }
 
   // Set the size of the vector in terms of qubit number
   virtual void set_num_qubits(size_t num_qubits);
 
   // Returns the number of qubits for the current vector
-  virtual uint_t num_qubits() const {return num_qubits_;}
+  virtual uint_t num_qubits() const { return num_qubits_; }
 
   // Returns the size of the underlying n-qubit vector
-  uint_t size() const {return data_size_;}
+  uint_t size() const { return data_size_; }
 
   // Returns required memory
   size_t required_memory_mb(uint_t num_qubits) const;
 
-  //check if this register is on the top of array on device
-  bool top_of_group()
-  {
-    return (chunk_.pos() == 0);
-  }
+  // check if this register is on the top of array on device
+  bool top_of_group() { return (chunk_.pos() == 0); }
 
   // Returns a copy of the underlying data_t data as a complex vector
   cvector_t<data_t> vector() const;
@@ -138,39 +130,37 @@ class QubitVectorThrust {
   // Set all entries in the vector to 0.
   void zero();
 
-
   // State initialization of a component
   // Initialize the specified qubits to a desired statevector
   // (leaving the other qubits in their current state)
-  // assuming the qubits being initialized have already been reset to the zero state
-  // (using apply_reset)
-  void initialize_component(const reg_t &qubits, const cvector_t<double> &state);
+  // assuming the qubits being initialized have already been reset to the zero
+  // state (using apply_reset)
+  void initialize_component(const reg_t &qubits,
+                            const cvector_t<double> &state);
 
-  //chunk setup
-  bool chunk_setup(int chunk_bits,int num_qubits,uint_t chunk_index,uint_t num_local_chunks);
-  bool chunk_setup(QubitVectorThrust<data_t>& base,const uint_t chunk_index);
+  // chunk setup
+  bool chunk_setup(int chunk_bits, int num_qubits, uint_t chunk_index,
+                   uint_t num_local_chunks);
+  bool chunk_setup(QubitVectorThrust<data_t> &base, const uint_t chunk_index);
 
-  //cache control for chunks on host
+  // cache control for chunks on host
   bool fetch_chunk(void) const;
   void release_chunk(bool write_back = true) const;
 
-  //blocking
-  void enter_register_blocking(const reg_t& qubits);
+  // blocking
+  void enter_register_blocking(const reg_t &qubits);
   void leave_register_blocking(void);
 
-  //prepare buffer for MPI send/recv
-  thrust::complex<data_t>* send_buffer(uint_t& size_in_byte);
-  thrust::complex<data_t>* recv_buffer(uint_t& size_in_byte);
+  // prepare buffer for MPI send/recv
+  thrust::complex<data_t> *send_buffer(uint_t &size_in_byte);
+  thrust::complex<data_t> *recv_buffer(uint_t &size_in_byte);
 
   void release_send_buffer(void) const;
   void release_recv_buffer(void) const;
 
   void set_max_matrix_bits(int_t bits);
 
-  void synchronize(void)
-  {
-    chunk_.synchronize();
-  }
+  void synchronize(void) { chunk_.synchronize(); }
 
   //-----------------------------------------------------------------------
   // Check point operations
@@ -195,39 +185,43 @@ class QubitVectorThrust {
   // Initializes the vector to a custom initial state.
   // If the length of the data vector does not match the number of qubits
   // an exception is raised.
-  template <typename list_t>
-  void initialize_from_vector(const list_t &vec);
-  void initialize_from_vector(const std::vector<std::complex<data_t>>& vec);
-  void initialize_from_vector(const AER::Vector<std::complex<data_t>>& vec);
+  template <typename list_t> void initialize_from_vector(const list_t &vec);
+  void initialize_from_vector(const std::vector<std::complex<data_t>> &vec);
+  void initialize_from_vector(const AER::Vector<std::complex<data_t>> &vec);
 
   // Initializes the vector to a custom initial state.
   // If num_states does not match the number of qubits an exception is raised.
-  void initialize_from_data(const std::complex<data_t>* data, const size_t num_states);
+  void initialize_from_data(const std::complex<data_t> *data,
+                            const size_t num_states);
 
   // Initialize classical memory and register to default value (all-0)
   virtual void initialize_creg(uint_t num_memory, uint_t num_register);
 
   // Initialize classical memory and register to specific values
-  virtual void initialize_creg(uint_t num_memory,
-                       uint_t num_register,
-                       const std::string &memory_hex,
-                       const std::string &register_hex);
+  virtual void initialize_creg(uint_t num_memory, uint_t num_register,
+                               const std::string &memory_hex,
+                               const std::string &register_hex);
 
   //-----------------------------------------------------------------------
   // Apply Matrices
   //-----------------------------------------------------------------------
 
   // Apply a 1-qubit matrix to the state vector.
-  // The matrix is input as vector of the column-major vectorized 1-qubit matrix.
+  // The matrix is input as vector of the column-major vectorized 1-qubit
+  // matrix.
   void apply_matrix(const uint_t qubit, const cvector_t<double> &mat);
 
   // Apply a N-qubit matrix to the state vector.
-  // The matrix is input as vector of the column-major vectorized N-qubit matrix.
+  // The matrix is input as vector of the column-major vectorized N-qubit
+  // matrix.
   void apply_matrix(const reg_t &qubits, const cvector_t<double> &mat);
 
-  // Apply a stacked set of 2^control_count target_count--qubit matrix to the state vector.
-  // The matrix is input as vector of the column-major vectorized N-qubit matrix.
-  void apply_multiplexer(const reg_t &control_qubits, const reg_t &target_qubits, const cvector_t<double> &mat);
+  // Apply a stacked set of 2^control_count target_count--qubit matrix to the
+  // state vector. The matrix is input as vector of the column-major vectorized
+  // N-qubit matrix.
+  void apply_multiplexer(const reg_t &control_qubits,
+                         const reg_t &target_qubits,
+                         const cvector_t<double> &mat);
 
   // Apply a 1-qubit diagonal matrix to the state vector.
   // The matrix is input as vector of the matrix diagonal.
@@ -236,11 +230,11 @@ class QubitVectorThrust {
   // Apply a N-qubit diagonal matrix to the state vector.
   // The matrix is input as vector of the matrix diagonal.
   void apply_diagonal_matrix(const reg_t &qubits, const cvector_t<double> &mat);
-  
-  // Swap pairs of indicies in the underlying vector
-  void apply_permutation_matrix(const reg_t &qubits,
-                                const std::vector<std::pair<uint_t, uint_t>> &pairs);
 
+  // Swap pairs of indicies in the underlying vector
+  void
+  apply_permutation_matrix(const reg_t &qubits,
+                           const std::vector<std::pair<uint_t, uint_t>> &pairs);
 
   //-----------------------------------------------------------------------
   // Apply Specialized Gates
@@ -257,7 +251,7 @@ class QubitVectorThrust {
   // If N=2 this implements an optimized CY gate
   // If N=3 this implements an optimized CCY gate
   void apply_mcy(const reg_t &qubits);
-  
+
   // Apply a general multi-controlled single-qubit phase gate
   // with diagonal [1, ..., 1, phase]
   // If N=1 this implements an optimized single-qubit phase gate
@@ -277,18 +271,21 @@ class QubitVectorThrust {
   // If N=3 this implements an optimized Fredkin gate
   void apply_mcswap(const reg_t &qubits);
 
-  //apply multiple swap gates
-  // qubits is a list of pair of swaps
+  // apply multiple swap gates
+  //  qubits is a list of pair of swaps
   void apply_multi_swaps(const reg_t &qubits);
 
-  //apply rotation around axis
-  void apply_rotation(const reg_t &qubits, const Rotation r, const double theta);
+  // apply rotation around axis
+  void apply_rotation(const reg_t &qubits, const Rotation r,
+                      const double theta);
 
-  //swap between chunk
-  void apply_chunk_swap(const reg_t &qubits, QubitVectorThrust<data_t> &chunk, bool write_back = true);
+  // swap between chunk
+  void apply_chunk_swap(const reg_t &qubits, QubitVectorThrust<data_t> &chunk,
+                        bool write_back = true);
   void apply_chunk_swap(const reg_t &qubits, uint_t remote_chunk_index);
 
-  void apply_chunk_swap(QubitVectorThrust<data_t> &chunk, uint_t dest_offset, uint_t src_offset, uint_t size);
+  void apply_chunk_swap(QubitVectorThrust<data_t> &chunk, uint_t dest_offset,
+                        uint_t src_offset, uint_t size);
 
   void apply_pauli(const reg_t &qubits, const std::string &pauli,
                    const complex_t &coeff = 1);
@@ -315,14 +312,12 @@ class QubitVectorThrust {
   // generating samples.
   virtual reg_t sample_measure(const std::vector<double> &rnds) const;
 
-
   //-----------------------------------------------------------------------
   // for batched optimization
   //-----------------------------------------------------------------------
-  virtual bool batched_optimization_supported(void)
-  {
+  virtual bool batched_optimization_supported(void) {
 #ifdef AER_THRUST_CUDA
-    if(multi_shots_ && enable_batch_)
+    if (multi_shots_ && enable_batch_)
       return true;
     else
       return false;
@@ -336,37 +331,42 @@ class QubitVectorThrust {
   virtual void apply_bfunc(const Operations::Op &op);
   virtual void set_conditional(int_t reg);
 
-  virtual void apply_roerror(const Operations::Op &op, std::vector<RngEngine> &rng);
+  virtual void apply_roerror(const Operations::Op &op,
+                             std::vector<RngEngine> &rng);
 
-  //optimized measure (async)
-  virtual void apply_batched_measure(const reg_t& qubits,std::vector<RngEngine>& rng,const reg_t& cmemory,const reg_t& cregs);
-  virtual void apply_batched_reset(const reg_t& qubits,std::vector<RngEngine>& rng);
+  // optimized measure (async)
+  virtual void apply_batched_measure(const reg_t &qubits,
+                                     std::vector<RngEngine> &rng,
+                                     const reg_t &cmemory, const reg_t &cregs);
+  virtual void apply_batched_reset(const reg_t &qubits,
+                                   std::vector<RngEngine> &rng);
 
-  //return measured cbit (for asynchronous measure)
+  // return measured cbit (for asynchronous measure)
   virtual int measured_cregister(uint_t qubit);
   virtual int measured_cmemory(uint_t qubit);
 
-  virtual int_t set_batched_system_conditional(int_t src_reg, reg_t& mask);
+  virtual int_t set_batched_system_conditional(int_t src_reg, reg_t &mask);
 
-  virtual void store_cregister(uint_t qubit,int val);
-  virtual void copy_cregister(uint_t dest,uint_t src);
-  virtual void store_cmemory(uint_t qubit,int val);
+  virtual void store_cregister(uint_t qubit, int val);
+  virtual void copy_cregister(uint_t dest, uint_t src);
+  virtual void store_cmemory(uint_t qubit, int val);
 
-  //copy classical register stored on qreg 
-  void read_measured_data(ClassicalRegister& creg);
+  // copy classical register stored on qreg
+  void read_measured_data(ClassicalRegister &creg);
 
-  //apply Pauli ops to multiple-shots (apply sampled Pauli noises)
-  virtual void apply_batched_pauli_ops(const std::vector<std::vector<Operations::Op>> &ops);
+  // apply Pauli ops to multiple-shots (apply sampled Pauli noises)
+  virtual void
+  apply_batched_pauli_ops(const std::vector<std::vector<Operations::Op>> &ops);
 
-  //Apply Kraus to multiple-shots
+  // Apply Kraus to multiple-shots
   virtual void apply_batched_kraus(const reg_t &qubits,
-                   const std::vector<cmatrix_t> &kmats,
-                   std::vector<RngEngine>& rng);
+                                   const std::vector<cmatrix_t> &kmats,
+                                   std::vector<RngEngine> &rng);
 
   //-----------------------------------------------------------------------
   // Norms
   //-----------------------------------------------------------------------
-  
+
   // Returns the norm of the current vector
   double norm() const;
 
@@ -377,12 +377,14 @@ class QubitVectorThrust {
 
   // Return the norm for of the vector obtained after apply the 1-qubit
   // matrix mat to the vector.
-  // The matrix is input as vector of the column-major vectorized 1-qubit matrix.
+  // The matrix is input as vector of the column-major vectorized 1-qubit
+  // matrix.
   double norm(const uint_t qubit, const cvector_t<double> &mat) const;
 
   // Return the norm for of the vector obtained after apply the N-qubit
   // matrix mat to the vector.
-  // The matrix is input as vector of the column-major vectorized N-qubit matrix.
+  // The matrix is input as vector of the column-major vectorized N-qubit
+  // matrix.
   double norm(const reg_t &qubits, const cvector_t<double> &mat) const;
 
   // Return the norm for of the vector obtained after apply the 1-qubit
@@ -405,12 +407,13 @@ class QubitVectorThrust {
 
   // Return the expectation value of an N-qubit Pauli matrix.
   // The Pauli is input as a length N string of I,X,Y,Z characters.
-  double expval_pauli(const reg_t &qubits, const std::string &pauli,const complex_t initial_phase=1.0) const;
-  //for multi-chunk inter chunk expectation
   double expval_pauli(const reg_t &qubits, const std::string &pauli,
-                      const QubitVectorThrust<data_t>& pair_chunk,
-                      const uint_t z_count,const uint_t z_count_pair,const complex_t initial_phase=1.0) const;
-
+                      const complex_t initial_phase = 1.0) const;
+  // for multi-chunk inter chunk expectation
+  double expval_pauli(const reg_t &qubits, const std::string &pauli,
+                      const QubitVectorThrust<data_t> &pair_chunk,
+                      const uint_t z_count, const uint_t z_count_pair,
+                      const complex_t initial_phase = 1.0) const;
 
   //-----------------------------------------------------------------------
   // JSON configuration settings
@@ -420,7 +423,7 @@ class QubitVectorThrust {
   void set_json_chop_threshold(double threshold);
 
   // Set the threshold for chopping values to 0 in JSON
-  double get_json_chop_threshold() {return json_chop_threshold_;}
+  double get_json_chop_threshold() { return json_chop_threshold_; }
 
   //-----------------------------------------------------------------------
   // OpenMP configuration settings
@@ -430,39 +433,32 @@ class QubitVectorThrust {
   void set_omp_threads(int n);
 
   // Get the maximum number of OpenMP thread for operations.
-  uint_t get_omp_threads() {return omp_threads_;}
+  uint_t get_omp_threads() { return omp_threads_; }
 
   // Set the qubit threshold for activating OpenMP.
   // If self.qubits() > threshold OpenMP will be activated.
   void set_omp_threshold(int n);
 
   // Get the qubit threshold for activating OpenMP.
-  uint_t get_omp_threshold() {return omp_threshold_;}
+  uint_t get_omp_threshold() { return omp_threshold_; }
 
-  //set number of threads per group(GPU)
-  void set_num_threads_per_group(int n)
-  {
-    num_threads_per_group_ = n;
-  }
+  // set number of threads per group(GPU)
+  void set_num_threads_per_group(int n) { num_threads_per_group_ = n; }
 
-  //cuStateVec
-  void cuStateVec_enable(bool flg)
-  {
-    cuStateVec_enable_ = flg;
-  }
+  // cuStateVec
+  void cuStateVec_enable(bool flg) { cuStateVec_enable_ = flg; }
 
   //-----------------------------------------------------------------------
   // Optimization configuration settings
   //-----------------------------------------------------------------------
 
   // Set the sample_measure index size
-  void set_sample_measure_index_size(int n) {sample_measure_index_size_ = n;}
+  void set_sample_measure_index_size(int n) { sample_measure_index_size_ = n; }
 
   // Get the sample_measure index size
-  int get_sample_measure_index_size() {return sample_measure_index_size_;}
+  int get_sample_measure_index_size() { return sample_measure_index_size_; }
 
 protected:
-
   //-----------------------------------------------------------------------
   // Protected data members
   //-----------------------------------------------------------------------
@@ -492,13 +488,14 @@ class QubitVectorThrust {
 
   //-----------------------------------------------------------------------
   // Config settings
-  //----------------------------------------------------------------------- 
-  uint_t omp_threads_ = 1;     // Disable multithreading by default
-  uint_t omp_threshold_ = 14;  // Qubit threshold for multithreading when enabled
+  //-----------------------------------------------------------------------
+  uint_t omp_threads_ = 1;    // Disable multithreading by default
+  uint_t omp_threshold_ = 14; // Qubit threshold for multithreading when enabled
   int sample_measure_index_size_ = 1; // Sample measure indexing qubit size
-  double json_chop_threshold_ = 0;  // Threshold for choping small values
-                                    // in JSON serialization
-  int num_threads_per_group_ = 1;   //number of threads per GPU for multi-chunks/shots
+  double json_chop_threshold_ = 0;    // Threshold for choping small values
+                                      // in JSON serialization
+  int num_threads_per_group_ =
+      1; // number of threads per GPU for multi-chunks/shots
 
   //-----------------------------------------------------------------------
   // Error Messages
@@ -517,27 +514,31 @@ class QubitVectorThrust {
   void apply_function(Function func, uint_t count = 0) const;
 
   template <typename Function>
-  void apply_function(Function func, const std::vector<std::complex<double>>& mat, const std::vector<uint_t>& prm, uint_t count = 0) const;
+  void apply_function(Function func,
+                      const std::vector<std::complex<double>> &mat,
+                      const std::vector<uint_t> &prm, uint_t count = 0) const;
 
   template <typename Function>
-  void apply_function_sum(double* pSum,Function func,bool async=false) const;
+  void apply_function_sum(double *pSum, Function func,
+                          bool async = false) const;
 
   template <typename Function>
-  void apply_function_sum2(double* pSum,Function func,bool async=false) const;
+  void apply_function_sum2(double *pSum, Function func,
+                           bool async = false) const;
 
-  //get number of chunk to be applied
+  // get number of chunk to be applied
   uint_t get_chunk_count(void);
-  
+
 #ifdef AER_DEBUG
-  //for debugging
+  // for debugging
   mutable uint_t debug_count;
 
-  void DebugMsg(const char* str,const reg_t &qubits) const;
-  void DebugMsg(const char* str,const int qubit) const;
-  void DebugMsg(const char* str) const;
-  void DebugMsg(const char* str,const std::complex<double> c) const;
-  void DebugMsg(const char* str,const double d) const;
-  void DebugMsg(const char* str,const std::vector<double>& v) const;
+  void DebugMsg(const char *str, const reg_t &qubits) const;
+  void DebugMsg(const char *str, const int qubit) const;
+  void DebugMsg(const char *str) const;
+  void DebugMsg(const char *str, const std::complex<double> c) const;
+  void DebugMsg(const char *str, const double d) const;
+  void DebugMsg(const char *str, const std::vector<double> &v) const;
   virtual void DebugDump(void) const;
 #endif
 };
@@ -557,9 +558,7 @@ inline void to_json(json_t &js, const QubitVectorThrust<data_t> &qv) {
   js = qv.json();
 }
 
-template <typename data_t>
-json_t QubitVectorThrust<data_t>::json() const 
-{
+template <typename data_t> json_t QubitVectorThrust<data_t>::json() const {
   thrust::complex<data_t> t;
   uint_t i;
 
@@ -570,7 +569,7 @@ json_t QubitVectorThrust<data_t>::json() const
   DebugMsg("json()");
 #endif
 
-  for(i=0;i<data_size_;i++){
+  for (i = 0; i < data_size_; i++) {
     t = chunk_.Get(i);
     js[i][0] = t.real();
     js[i][1] = t.imag();
@@ -585,40 +584,45 @@ json_t QubitVectorThrust<data_t>::json() const
 template <typename data_t>
 void QubitVectorThrust<data_t>::check_qubit(const uint_t qubit) const {
   if (qubit + 1 > num_qubits_) {
-    std::string error = "QubitVectorThrust: qubit index " + std::to_string(qubit) +
-                        " > " + std::to_string(num_qubits_);
+    std::string error = "QubitVectorThrust: qubit index " +
+                        std::to_string(qubit) + " > " +
+                        std::to_string(num_qubits_);
     throw std::runtime_error(error);
   }
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::check_matrix(const cvector_t<data_t> &vec, uint_t nqubits) const {
+void QubitVectorThrust<data_t>::check_matrix(const cvector_t<data_t> &vec,
+                                             uint_t nqubits) const {
   const size_t DIM = 1ull << nqubits;
   const auto SIZE = vec.size();
   if (SIZE != DIM * DIM) {
-    std::string error = "QubitVectorThrust: vector size is " + std::to_string(SIZE) +
+    std::string error = "QubitVectorThrust: vector size is " +
+                        std::to_string(SIZE) +
                         " != " + std::to_string(DIM * DIM);
     throw std::runtime_error(error);
   }
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::check_vector(const cvector_t<data_t> &vec, uint_t nqubits) const {
+void QubitVectorThrust<data_t>::check_vector(const cvector_t<data_t> &vec,
+                                             uint_t nqubits) const {
   const size_t DIM = 1ull << nqubits;
   const auto SIZE = vec.size();
   if (SIZE != DIM) {
-    std::string error = "QubitVectorThrust: vector size is " + std::to_string(SIZE) +
-                        " != " + std::to_string(DIM);
+    std::string error = "QubitVectorThrust: vector size is " +
+                        std::to_string(SIZE) + " != " + std::to_string(DIM);
     throw std::runtime_error(error);
   }
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::check_dimension(const QubitVectorThrust &qv) const {
+void QubitVectorThrust<data_t>::check_dimension(
+    const QubitVectorThrust &qv) const {
   if (data_size_ != qv.size_) {
     std::string error = "QubitVectorThrust: vectors are different shape " +
-                         std::to_string(data_size_) + " != " +
-                         std::to_string(qv.num_states_);
+                        std::to_string(data_size_) +
+                        " != " + std::to_string(qv.num_states_);
     throw std::runtime_error(error);
   }
 }
@@ -626,7 +630,8 @@ void QubitVectorThrust<data_t>::check_dimension(const QubitVectorThrust &qv) con
 template <typename data_t>
 void QubitVectorThrust<data_t>::check_checkpoint() const {
   if (!checkpoint_) {
-    throw std::runtime_error("QubitVectorThrust: checkpoint must exist for inner_product() or revert()");
+    throw std::runtime_error("QubitVectorThrust: checkpoint must exist for "
+                             "inner_product() or revert()");
   }
 }
 
@@ -635,8 +640,8 @@ void QubitVectorThrust<data_t>::check_checkpoint() const {
 //------------------------------------------------------------------------------
 
 template <typename data_t>
-QubitVectorThrust<data_t>::QubitVectorThrust(size_t num_qubits) : num_qubits_(0)
-{
+QubitVectorThrust<data_t>::QubitVectorThrust(size_t num_qubits)
+    : num_qubits_(0) {
   chunk_index_ = 0;
   multi_chunk_distribution_ = false;
   multi_shots_ = false;
@@ -648,23 +653,18 @@ QubitVectorThrust<data_t>::QubitVectorThrust(size_t num_qubits) : num_qubits_(0)
   debug_count = 0;
 #endif
 
-  if(num_qubits != 0){
+  if (num_qubits != 0) {
     set_num_qubits(num_qubits);
   }
   register_blocking_ = false;
 }
 
 template <typename data_t>
-QubitVectorThrust<data_t>::QubitVectorThrust() : QubitVectorThrust(0)
-{
+QubitVectorThrust<data_t>::QubitVectorThrust() : QubitVectorThrust(0) {}
 
-}
-
-template <typename data_t>
-QubitVectorThrust<data_t>::~QubitVectorThrust() 
-{
-  if(chunk_manager_){
-    if(chunk_.is_mapped()){
+template <typename data_t> QubitVectorThrust<data_t>::~QubitVectorThrust() {
+  if (chunk_manager_) {
+    if (chunk_.is_mapped()) {
       chunk_.unmap();
       chunk_manager_->UnmapChunk(chunk_);
     }
@@ -681,59 +681,56 @@ template <typename data_t>
 thrust::complex<data_t> &QubitVectorThrust<data_t>::operator[](uint_t element) {
   // Error checking
   if (element > data_size_) {
-    std::string error = "QubitVectorThrust: vector index " + std::to_string(element) +
-                        " > " + std::to_string(data_size_);
+    std::string error = "QubitVectorThrust: vector index " +
+                        std::to_string(element) + " > " +
+                        std::to_string(data_size_);
     throw std::runtime_error(error);
   }
 
   return chunk_[element];
 }
 
-
 template <typename data_t>
-thrust::complex<data_t> QubitVectorThrust<data_t>::operator[](uint_t element) const
-{
+thrust::complex<data_t>
+QubitVectorThrust<data_t>::operator[](uint_t element) const {
   // Error checking
   if (element > data_size_) {
-    std::string error = "QubitVectorThrust: vector index " + std::to_string(element) +
-                        " > " + std::to_string(data_size_);
+    std::string error = "QubitVectorThrust: vector index " +
+                        std::to_string(element) + " > " +
+                        std::to_string(data_size_);
     throw std::runtime_error(error);
   }
 
 #ifdef AER_DEBUG
-    DebugMsg(" calling []");
+  DebugMsg(" calling []");
 #endif
 
   return chunk_[element];
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::set_state(uint_t pos, std::complex<data_t>& c)
-{
-  if(pos < data_size_){
+void QubitVectorThrust<data_t>::set_state(uint_t pos, std::complex<data_t> &c) {
+  if (pos < data_size_) {
     thrust::complex<data_t> t = c;
-    chunk_.Set(pos,t);
+    chunk_.Set(pos, t);
   }
 }
 
 template <typename data_t>
-std::complex<data_t> QubitVectorThrust<data_t>::get_state(uint_t pos) const
-{
+std::complex<data_t> QubitVectorThrust<data_t>::get_state(uint_t pos) const {
   std::complex<data_t> ret = 0.0;
 
-  if(pos < data_size_){
+  if (pos < data_size_) {
     ret = chunk_.Get(pos);
   }
   return ret;
 }
 
-
 template <typename data_t>
-cvector_t<data_t> QubitVectorThrust<data_t>::vector() const 
-{
+cvector_t<data_t> QubitVectorThrust<data_t>::vector() const {
   cvector_t<data_t> ret(data_size_, 0.);
 
-  chunk_.CopyOut((thrust::complex<data_t>*)&ret[0], data_size_);
+  chunk_.CopyOut((thrust::complex<data_t> *)&ret[0], data_size_);
 
 #ifdef AER_DEBUG
   DebugMsg("vector");
@@ -743,67 +740,69 @@ cvector_t<data_t> QubitVectorThrust<data_t>::vector() const
 }
 
 template <typename data_t>
-cdict_t<data_t> QubitVectorThrust<data_t>::vector_ket(double epsilon) const{
-    // non-optimized version; relies on creating a copy of the statevector
-    return AER::Utils::vec2ket(vector(), epsilon, 16);
+cdict_t<data_t> QubitVectorThrust<data_t>::vector_ket(double epsilon) const {
+  // non-optimized version; relies on creating a copy of the statevector
+  return AER::Utils::vec2ket(vector(), epsilon, 16);
 }
 
 template <typename data_t>
-AER::Vector<std::complex<data_t>> QubitVectorThrust<data_t>::copy_to_vector() const 
-{
+AER::Vector<std::complex<data_t>>
+QubitVectorThrust<data_t>::copy_to_vector() const {
   cvector_t<data_t> ret(data_size_, 0.);
-  chunk_.CopyOut((thrust::complex<data_t>*)&ret[0], data_size_);
+  chunk_.CopyOut((thrust::complex<data_t> *)&ret[0], data_size_);
 
 #ifdef AER_DEBUG
   DebugMsg("copy_to_vector");
 #endif
 
-  return AER::Vector<std::complex<data_t>>::copy_from_buffer(data_size_, &ret[0]);
+  return AER::Vector<std::complex<data_t>>::copy_from_buffer(data_size_,
+                                                             &ret[0]);
 }
 
 template <typename data_t>
-AER::Vector<std::complex<data_t>> QubitVectorThrust<data_t>::move_to_vector() 
-{
+AER::Vector<std::complex<data_t>> QubitVectorThrust<data_t>::move_to_vector() {
   cvector_t<data_t> ret(data_size_, 0.);
-  chunk_.CopyOut((thrust::complex<data_t>*)&ret[0], data_size_);
+  chunk_.CopyOut((thrust::complex<data_t> *)&ret[0], data_size_);
 
 #ifdef AER_DEBUG
   DebugMsg("move_to_vector", ret[0]);
   DebugDump();
 #endif
-  return AER::Vector<std::complex<data_t>>::copy_from_buffer(data_size_, &ret[0]);
+  return AER::Vector<std::complex<data_t>>::copy_from_buffer(data_size_,
+                                                             &ret[0]);
 }
 
-
 //------------------------------------------------------------------------------
 // State initialize component
 //------------------------------------------------------------------------------
 template <typename data_t>
-void QubitVectorThrust<data_t>::initialize_component(const reg_t &qubits, const cvector_t<double> &state0) 
-{
-  if(qubits.size() == 1){
-      apply_function(Chunk::initialize_component_1qubit_func<data_t>(qubits[0],state0[0],state0[1]) );
-  }
-  else if(qubits.size() <= chunk_.container()->matrix_bits()){
+void QubitVectorThrust<data_t>::initialize_component(
+    const reg_t &qubits, const cvector_t<double> &state0) {
+  if (qubits.size() == 1) {
+    apply_function(Chunk::initialize_component_1qubit_func<data_t>(
+        qubits[0], state0[0], state0[1]));
+  } else if (qubits.size() <= chunk_.container()->matrix_bits()) {
     auto qubits_sorted = qubits;
     std::sort(qubits_sorted.begin(), qubits_sorted.end());
 
     auto qubits_param = qubits;
     int i;
-    for(i=0;i<qubits.size();i++)
+    for (i = 0; i < qubits.size(); i++)
       qubits_param.push_back(qubits_sorted[i]);
 
-//    chunk_.StoreMatrix(state0);
-//    chunk_.StoreUintParams(qubits_param);
+    //    chunk_.StoreMatrix(state0);
+    //    chunk_.StoreUintParams(qubits_param);
 
-    apply_function(Chunk::initialize_component_func<data_t>(state0,qubits_sorted), state0, qubits_param );
-  }
-  else{
-    //if initial state is larger that matrix buffer, set one by one.
+    apply_function(
+        Chunk::initialize_component_func<data_t>(state0, qubits_sorted), state0,
+        qubits_param);
+  } else {
+    // if initial state is larger that matrix buffer, set one by one.
     uint_t DIM = 1ull << qubits.size();
     uint_t i;
-    for(i=0;i<DIM;i++){
-        apply_function(Chunk::initialize_large_component_func<data_t>(state0[i],qubits,i) );
+    for (i = 0; i < DIM; i++) {
+      apply_function(
+          Chunk::initialize_large_component_func<data_t>(state0[i], qubits, i));
     }
   }
 }
@@ -811,9 +810,7 @@ void QubitVectorThrust<data_t>::initialize_component(const reg_t &qubits, const
 //------------------------------------------------------------------------------
 // Utility
 //------------------------------------------------------------------------------
-template <typename data_t>
-void QubitVectorThrust<data_t>::zero()
-{
+template <typename data_t> void QubitVectorThrust<data_t>::zero() {
 #ifdef AER_DEBUG
   DebugMsg("zero");
 #endif
@@ -826,34 +823,38 @@ void QubitVectorThrust<data_t>::zero()
 }
 
 template <typename data_t>
-bool QubitVectorThrust<data_t>::chunk_setup(int chunk_bits,int num_qubits,uint_t chunk_index,uint_t num_local_chunks)
-{
-  //set global chunk ID / shot ID
+bool QubitVectorThrust<data_t>::chunk_setup(int chunk_bits, int num_qubits,
+                                            uint_t chunk_index,
+                                            uint_t num_local_chunks) {
+  // set global chunk ID / shot ID
   chunk_index_ = chunk_index;
 
-  if(chunk_manager_){
-    if(chunk_.is_mapped()){
+  if (chunk_manager_) {
+    if (chunk_.is_mapped()) {
       chunk_.unmap();
       chunk_manager_->UnmapChunk(chunk_);
     }
 
-    if(chunk_manager_->chunk_bits() == chunk_bits && chunk_manager_->num_qubits() == num_qubits){
-      bool mapped = chunk_manager_->MapChunk(chunk_,0);
+    if (chunk_manager_->chunk_bits() == chunk_bits &&
+        chunk_manager_->num_qubits() == num_qubits) {
+      bool mapped = chunk_manager_->MapChunk(chunk_, 0);
       chunk_.set_chunk_index(chunk_index_);
       return mapped;
     }
     chunk_manager_.reset();
   }
 
-  //only first chunk call allocation function
-  if(chunk_bits > 0 && num_qubits > 0){
+  // only first chunk call allocation function
+  if (chunk_bits > 0 && num_qubits > 0) {
     chunk_manager_ = std::make_shared<Chunk::ChunkManager<data_t>>();
     chunk_manager_->set_num_threads_per_group(num_threads_per_group_);
-    chunk_manager_->Allocate(chunk_bits,num_qubits,num_local_chunks,chunk_index_,max_matrix_bits_, is_density_matrix(), cuStateVec_enable_);
+    chunk_manager_->Allocate(chunk_bits, num_qubits, num_local_chunks,
+                             chunk_index_, max_matrix_bits_,
+                             is_density_matrix(), cuStateVec_enable_);
   }
 
   multi_chunk_distribution_ = false;
-  if(chunk_bits < num_qubits){
+  if (chunk_bits < num_qubits) {
     multi_chunk_distribution_ = true;
   }
 
@@ -862,28 +863,28 @@ bool QubitVectorThrust<data_t>::chunk_setup(int chunk_bits,int num_qubits,uint_t
   send_chunk_.unmap();
   recv_chunk_.unmap();
 
-  //mapping/setting chunk
-  bool mapped = chunk_manager_->MapChunk(chunk_,0);
+  // mapping/setting chunk
+  bool mapped = chunk_manager_->MapChunk(chunk_, 0);
   chunk_.set_chunk_index(chunk_index_);
 
   return mapped;
 }
 
 template <typename data_t>
-bool QubitVectorThrust<data_t>::chunk_setup(QubitVectorThrust<data_t>& base,const uint_t chunk_index)
-{
+bool QubitVectorThrust<data_t>::chunk_setup(QubitVectorThrust<data_t> &base,
+                                            const uint_t chunk_index) {
   chunk_manager_ = base.chunk_manager_;
 
   multi_chunk_distribution_ = base.multi_chunk_distribution_;
-  if(!multi_chunk_distribution_){
-    if(chunk_manager_->chunk_bits() == chunk_manager_->num_qubits()){
+  if (!multi_chunk_distribution_) {
+    if (chunk_manager_->chunk_bits() == chunk_manager_->num_qubits()) {
       multi_shots_ = true;
       base.multi_shots_ = true;
     }
   }
   cuStateVec_enable_ = base.cuStateVec_enable_;
 
-  //set global chunk ID / shot ID
+  // set global chunk ID / shot ID
   chunk_index_ = chunk_index;
 
   chunk_.unmap();
@@ -891,23 +892,21 @@ bool QubitVectorThrust<data_t>::chunk_setup(QubitVectorThrust<data_t>& base,cons
   send_chunk_.unmap();
   recv_chunk_.unmap();
 
-  //mapping/setting chunk
-  bool mapped = chunk_manager_->MapChunk(chunk_,0);
+  // mapping/setting chunk
+  bool mapped = chunk_manager_->MapChunk(chunk_, 0);
   chunk_.set_chunk_index(chunk_index_);
 
   return mapped;
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::set_max_matrix_bits(int_t bits)
-{
-  if(bits > max_matrix_bits_){
+void QubitVectorThrust<data_t>::set_max_matrix_bits(int_t bits) {
+  if (bits > max_matrix_bits_) {
     max_matrix_bits_ = bits;
   }
 }
 template <typename data_t>
-void QubitVectorThrust<data_t>::set_num_qubits(size_t num_qubits)
-{
+void QubitVectorThrust<data_t>::set_num_qubits(size_t num_qubits) {
   num_qubits_ = num_qubits;
   data_size_ = 1ull << num_qubits;
 
@@ -915,17 +914,21 @@ void QubitVectorThrust<data_t>::set_num_qubits(size_t num_qubits)
 
   register_blocking_ = false;
 
-  //set OpenMP threads for ThrustCPU
-  if(num_qubits_ > omp_threshold_ && omp_threads_ > 1)
+  // set OpenMP threads for ThrustCPU
+  if (num_qubits_ > omp_threshold_ && omp_threads_ > 1)
     chunk_.container()->set_omp_threads(omp_threads_);
 
 #ifdef AER_DEBUG
-  if(chunk_.pos() == 0){
-    spdlog::debug(" ==== Thrust qubit vector initialization {} qubits ====",num_qubits_);
-    if(chunk_.device() >= 0)
-      spdlog::debug("    TEST [id={}]: device = {}, pos = {}, place = {} / {}",chunk_index_,chunk_.device(),chunk_.pos(),chunk_.place(),chunk_manager_->num_places());
+  if (chunk_.pos() == 0) {
+    spdlog::debug(" ==== Thrust qubit vector initialization {} qubits ====",
+                  num_qubits_);
+    if (chunk_.device() >= 0)
+      spdlog::debug("    TEST [id={}]: device = {}, pos = {}, place = {} / {}",
+                    chunk_index_, chunk_.device(), chunk_.pos(), chunk_.place(),
+                    chunk_manager_->num_places());
     else
-      spdlog::debug("    TEST [id={}]: allocated on host (place = {})",chunk_index_,chunk_.place());
+      spdlog::debug("    TEST [id={}]: allocated on host (place = {})",
+                    chunk_index_, chunk_.place());
   }
 #endif
 }
@@ -940,33 +943,31 @@ size_t QubitVectorThrust<data_t>::required_memory_mb(uint_t num_qubits) const {
   return mem_mb;
 }
 
-
-template <typename data_t>
-void QubitVectorThrust<data_t>::checkpoint()
-{
+template <typename data_t> void QubitVectorThrust<data_t>::checkpoint() {
 #ifdef AER_DEBUG
   DebugMsg("calling checkpoint");
   DebugDump();
 #endif
 
   checkpoint_.resize(data_size_);
-  chunk_.CopyOut((thrust::complex<data_t>*)thrust::raw_pointer_cast(checkpoint_.data()),data_size_);
+  chunk_.CopyOut(
+      (thrust::complex<data_t> *)thrust::raw_pointer_cast(checkpoint_.data()),
+      data_size_);
 
 #ifdef AER_DEBUG
   DebugMsg("checkpoint done");
 #endif
 }
 
-
-template <typename data_t>
-void QubitVectorThrust<data_t>::revert(bool keep) 
-{
+template <typename data_t> void QubitVectorThrust<data_t>::revert(bool keep) {
 #ifdef AER_DEBUG
   DebugMsg("calling revert");
 #endif
 
-  if(checkpoint_.size() == data_size_){
-    chunk_.CopyIn((thrust::complex<data_t>*)thrust::raw_pointer_cast(checkpoint_.data()),data_size_);
+  if (checkpoint_.size() == data_size_) {
+    chunk_.CopyIn(
+        (thrust::complex<data_t> *)thrust::raw_pointer_cast(checkpoint_.data()),
+        data_size_);
     checkpoint_.clear();
     checkpoint_.shrink_to_fit();
   }
@@ -974,59 +975,60 @@ void QubitVectorThrust<data_t>::revert(bool keep)
 #ifdef AER_DEBUG
   DebugMsg("revert");
 #endif
-
 }
 
 template <typename data_t>
-std::complex<double> QubitVectorThrust<data_t>::inner_product() const
-{
+std::complex<double> QubitVectorThrust<data_t>::inner_product() const {
 
 #ifdef AER_DEBUG
   DebugMsg("calling inner_product");
 #endif
 
   double dot;
-  data_t* vec0;
-  data_t* vec1;
+  data_t *vec0;
+  data_t *vec1;
 
-  if(checkpoint_.size() != data_size_){
-    return std::complex<double>(0.0,0.0);
+  if (checkpoint_.size() != data_size_) {
+    return std::complex<double>(0.0, 0.0);
   }
 
   chunk_.set_device();
 
-  vec0 = (data_t*)chunk_.pointer();
-  vec1 = (data_t*)thrust::raw_pointer_cast(checkpoint_.data());
+  vec0 = (data_t *)chunk_.pointer();
+  vec1 = (data_t *)thrust::raw_pointer_cast(checkpoint_.data());
 #ifdef AER_THRUST_CUDA
   cudaStream_t strm = chunk_.stream();
-  if(strm)
-    dot = thrust::inner_product(thrust::device,vec0,vec0 + data_size_*2,vec1,0.0);
+  if (strm)
+    dot = thrust::inner_product(thrust::device, vec0, vec0 + data_size_ * 2,
+                                vec1, 0.0);
   else
-    dot = thrust::inner_product(thrust::omp::par,vec0,vec0 + data_size_*2,vec1,0.0);
+    dot = thrust::inner_product(thrust::omp::par, vec0, vec0 + data_size_ * 2,
+                                vec1, 0.0);
 #else
-  if(num_qubits_ > omp_threshold_ && omp_threads_ > 1)
-    dot = thrust::inner_product(thrust::device,vec0,vec0 + data_size_*2,vec1,0.0);
+  if (num_qubits_ > omp_threshold_ && omp_threads_ > 1)
+    dot = thrust::inner_product(thrust::device, vec0, vec0 + data_size_ * 2,
+                                vec1, 0.0);
   else
-    dot = thrust::inner_product(thrust::seq,vec0,vec0 + data_size_*2,vec1,0.0);
+    dot = thrust::inner_product(thrust::seq, vec0, vec0 + data_size_ * 2, vec1,
+                                0.0);
 #endif
 
 #ifdef AER_DEBUG
-  DebugMsg("inner_product",std::complex<double>(dot,0.0));
+  DebugMsg("inner_product", std::complex<double>(dot, 0.0));
 #endif
 
-  return std::complex<double>(dot,0.0);
+  return std::complex<double>(dot, 0.0);
 }
 
 template <typename data_t>
-bool QubitVectorThrust<data_t>::fetch_chunk(void) const
-{
+bool QubitVectorThrust<data_t>::fetch_chunk(void) const {
   int idev;
 
-  if(chunk_.device() < 0){ //on host
+  if (chunk_.device() < 0) { // on host
     idev = chunk_.place() % chunk_manager_->num_places();
-    do{
+    do {
       chunk_manager_->MapBufferChunk(buffer_chunk_, idev);
-    }while(!buffer_chunk_.is_mapped());
+    } while (!buffer_chunk_.is_mapped());
     chunk_.map_cache(buffer_chunk_);
     buffer_chunk_.CopyIn(chunk_);
   }
@@ -1034,55 +1036,48 @@ bool QubitVectorThrust<data_t>::fetch_chunk(void) const
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::release_chunk(bool write_back) const
-{
-  if(chunk_.device() < 0){    //on host
+void QubitVectorThrust<data_t>::release_chunk(bool write_back) const {
+  if (chunk_.device() < 0) { // on host
     buffer_chunk_.CopyOut(chunk_);
     buffer_chunk_.synchronize();
     chunk_manager_->UnmapBufferChunk(buffer_chunk_);
     chunk_.unmap_cache();
-  }
-  else{
-    if(chunk_.pos() == 0){
-      chunk_.synchronize();    //synchronize stream before chunk exchange
+  } else {
+    if (chunk_.pos() == 0) {
+      chunk_.synchronize(); // synchronize stream before chunk exchange
     }
   }
-
 }
 
-
 template <typename data_t>
-void QubitVectorThrust<data_t>::enter_register_blocking(const reg_t& qubits)
-{
+void QubitVectorThrust<data_t>::enter_register_blocking(const reg_t &qubits) {
   register_blocking_ = true;
   chunk_.set_blocked_qubits(qubits);
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::leave_register_blocking(void)
-{
+void QubitVectorThrust<data_t>::leave_register_blocking(void) {
   chunk_.apply_blocked_gates();
   register_blocking_ = false;
 }
 
-
 template <typename data_t>
-thrust::complex<data_t>* QubitVectorThrust<data_t>::send_buffer(uint_t& size_in_byte)
-{
-  thrust::complex<data_t>* pRet;
+thrust::complex<data_t> *
+QubitVectorThrust<data_t>::send_buffer(uint_t &size_in_byte) {
+  thrust::complex<data_t> *pRet;
 
 #ifdef AER_DISABLE_GDR
-  if(chunk_.device() < 0){
+  if (chunk_.device() < 0) {
     pRet = chunk_.pointer();
-  }
-  else{   //if there is no GPUDirectRDMA support, copy chunk on CPU before using MPI
+  } else { // if there is no GPUDirectRDMA support, copy chunk on CPU before
+           // using MPI
     pRet = nullptr;
-    if(chunk_manager_->MapBufferChunkOnHost(send_chunk_)){
+    if (chunk_manager_->MapBufferChunkOnHost(send_chunk_)) {
       chunk_.CopyOut(send_chunk_);
       pRet = send_chunk_.pointer();
-    }
-    else{
-      throw std::runtime_error("QubitVectorThrust: send buffer can not be allocated");
+    } else {
+      throw std::runtime_error(
+          "QubitVectorThrust: send buffer can not be allocated");
     }
   }
 #else
@@ -1095,22 +1090,22 @@ thrust::complex<data_t>* QubitVectorThrust<data_t>::send_buffer(uint_t& size_in_
 }
 
 template <typename data_t>
-thrust::complex<data_t>* QubitVectorThrust<data_t>::recv_buffer(uint_t& size_in_byte)
-{
+thrust::complex<data_t> *
+QubitVectorThrust<data_t>::recv_buffer(uint_t &size_in_byte) {
 
 #ifdef AER_DISABLE_GDR
-  if(chunk_.device() < 0){
-    chunk_manager_->MapBufferChunk(recv_chunk_,chunk_.place());
-  }
-  else{   //if there is no GPUDirectRDMA support, receive in CPU memory
+  if (chunk_.device() < 0) {
+    chunk_manager_->MapBufferChunk(recv_chunk_, chunk_.place());
+  } else { // if there is no GPUDirectRDMA support, receive in CPU memory
     chunk_manager_->MapBufferChunkOnHost(recv_chunk_);
   }
 #else
-  if(!recv_chunk_.is_mapped())
-    chunk_manager_->MapBufferChunk(recv_chunk_,chunk_.place());
+  if (!recv_chunk_.is_mapped())
+    chunk_manager_->MapBufferChunk(recv_chunk_, chunk_.place());
 #endif
-  if(!recv_chunk_.is_mapped()){
-    throw std::runtime_error("QubitVectorThrust: receive buffer can not be allocated");
+  if (!recv_chunk_.is_mapped()) {
+    throw std::runtime_error(
+        "QubitVectorThrust: receive buffer can not be allocated");
   }
   chunk_.synchronize();
 
@@ -1119,10 +1114,9 @@ thrust::complex<data_t>* QubitVectorThrust<data_t>::recv_buffer(uint_t& size_in_
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::release_send_buffer(void) const
-{
+void QubitVectorThrust<data_t>::release_send_buffer(void) const {
 #ifdef AER_DISABLE_GDR
-  if(send_chunk_.is_mapped()){
+  if (send_chunk_.is_mapped()) {
     chunk_manager_->UnmapBufferChunk(send_chunk_);
   }
 #else
@@ -1131,44 +1125,39 @@ void QubitVectorThrust<data_t>::release_send_buffer(void) const
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::release_recv_buffer(void) const
-{
-  if(recv_chunk_.is_mapped()){
+void QubitVectorThrust<data_t>::release_recv_buffer(void) const {
+  if (recv_chunk_.is_mapped()) {
     chunk_manager_->UnmapBufferChunk(recv_chunk_);
   }
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::set_conditional(int_t reg)
-{
+void QubitVectorThrust<data_t>::set_conditional(int_t reg) {
   chunk_.set_conditional(reg);
 }
 
 template <typename data_t>
-bool QubitVectorThrust<data_t>::enable_batch(bool flg) const
-{
+bool QubitVectorThrust<data_t>::enable_batch(bool flg) const {
   bool prev = enable_batch_;
 
-//  if(flg != prev){
-//    chunk_.synchronize();
-//  }
+  //  if(flg != prev){
+  //    chunk_.synchronize();
+  //  }
   enable_batch_ = flg;
 
   return prev;
 }
 
 template <typename data_t>
-uint_t QubitVectorThrust<data_t>::get_chunk_count(void)
-{
-  if(multi_chunk_distribution_){
-    if(chunk_.device() < 0 || cuStateVec_enable_)
+uint_t QubitVectorThrust<data_t>::get_chunk_count(void) {
+  if (multi_chunk_distribution_) {
+    if (chunk_.device() < 0 || cuStateVec_enable_)
       return 1;
-    else if(chunk_.pos() != 0)
-      return 0;   //first chunk execute all in batch
-  }
-  else{   //multi-shots
-    if(enable_batch_ && chunk_.pos() != 0)
-      return 0;   //first chunk execute all in batch
+    else if (chunk_.pos() != 0)
+      return 0; // first chunk execute all in batch
+  } else {      // multi-shots
+    if (enable_batch_ && chunk_.pos() != 0)
+      return 0; // first chunk execute all in batch
   }
   return chunk_.container()->num_chunks();
 }
@@ -1176,27 +1165,27 @@ uint_t QubitVectorThrust<data_t>::get_chunk_count(void)
 //------------------------------------------------------------------------------
 // Initialization
 //------------------------------------------------------------------------------
-template <typename data_t>
-void QubitVectorThrust<data_t>::initialize()
-{
+template <typename data_t> void QubitVectorThrust<data_t>::initialize() {
   thrust::complex<data_t> t;
   t = 1.0;
 
-  if(multi_chunk_distribution_){
-    if(chunk_index_ == 0){
-      apply_function(Chunk::initialize_kernel<data_t>(t,chunk_manager_->chunk_bits(),(1ull << chunk_manager_->num_qubits())));
-    }
-    else{
+  if (multi_chunk_distribution_) {
+    if (chunk_index_ == 0) {
+      apply_function(Chunk::initialize_kernel<data_t>(
+          t, chunk_manager_->chunk_bits(),
+          (1ull << chunk_manager_->num_qubits())));
+    } else {
       zero();
     }
     chunk_.synchronize();
-  }
-  else{
-    apply_function(Chunk::initialize_kernel<data_t>(t,chunk_manager_->chunk_bits(),(1ull << chunk_manager_->chunk_bits())));
+  } else {
+    apply_function(Chunk::initialize_kernel<data_t>(
+        t, chunk_manager_->chunk_bits(),
+        (1ull << chunk_manager_->chunk_bits())));
   }
 
 #ifdef AER_DEBUG
-  if(chunk_.pos() == 0){
+  if (chunk_.pos() == 0) {
     DebugMsg("initialize done");
     DebugDump();
   }
@@ -1206,39 +1195,44 @@ void QubitVectorThrust<data_t>::initialize()
 template <typename data_t>
 template <typename list_t>
 void QubitVectorThrust<data_t>::initialize_from_vector(const list_t &statevec) {
-  if(data_size_ < statevec.size()) {
-    std::string error = "QubitVectorThrust::initialize input vector is incorrect length (" + 
-                        std::to_string(data_size_) + "!=" +
-                        std::to_string(statevec.size()) + ")";
+  if (data_size_ < statevec.size()) {
+    std::string error =
+        "QubitVectorThrust::initialize input vector is incorrect length (" +
+        std::to_string(data_size_) + "!=" + std::to_string(statevec.size()) +
+        ")";
     throw std::runtime_error(error);
   }
 
   // Convert vector data type to complex<data_t>
   AER::Vector<std::complex<data_t>> tmp(data_size_, false);
   int_t i;
-#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
-  for(i=0; i < data_size_; i++){
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
+  for (i = 0; i < data_size_; i++) {
     tmp[i] = statevec[i];
   }
   initialize_from_data(&tmp[0], tmp.size());
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::initialize_from_vector(const std::vector<std::complex<data_t>>& vec) {
+void QubitVectorThrust<data_t>::initialize_from_vector(
+    const std::vector<std::complex<data_t>> &vec) {
   initialize_from_data(&vec[0], vec.size());
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::initialize_from_vector(const AER::Vector<std::complex<data_t>>& vec) {
+void QubitVectorThrust<data_t>::initialize_from_vector(
+    const AER::Vector<std::complex<data_t>> &vec) {
   initialize_from_data(vec.data(), vec.size());
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::initialize_from_data(const std::complex<data_t>* statevec, const size_t num_states) 
-{
+void QubitVectorThrust<data_t>::initialize_from_data(
+    const std::complex<data_t> *statevec, const size_t num_states) {
   if (data_size_ != num_states) {
-    std::string error = "QubitVectorThrust::initialize input vector is incorrect length (" +
-                        std::to_string(data_size_) + "!=" + std::to_string(num_states) + ")";
+    std::string error =
+        "QubitVectorThrust::initialize input vector is incorrect length (" +
+        std::to_string(data_size_) + "!=" + std::to_string(num_states) + ")";
     throw std::runtime_error(error);
   }
 
@@ -1246,54 +1240,49 @@ void QubitVectorThrust<data_t>::initialize_from_data(const std::complex<data_t>*
   DebugMsg("calling initialize_from_data");
 #endif
 
-  chunk_.CopyIn((thrust::complex<data_t>*)(statevec), data_size_);
+  chunk_.CopyIn((thrust::complex<data_t> *)(statevec), data_size_);
 
 #ifdef AER_DEBUG
   DebugMsg("initialize_from_data");
   DebugDump();
 #endif
-
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::initialize_creg(uint_t num_memory, uint_t num_register)
-{
-  if(chunk_manager_){
+void QubitVectorThrust<data_t>::initialize_creg(uint_t num_memory,
+                                                uint_t num_register) {
+  if (chunk_manager_) {
     num_creg_bits_ = num_register;
     num_cmem_bits_ = num_memory;
-    if(chunk_.pos() == 0){
-      chunk_.container()->allocate_creg(num_cmem_bits_,num_creg_bits_);
+    if (chunk_.pos() == 0) {
+      chunk_.container()->allocate_creg(num_cmem_bits_, num_creg_bits_);
     }
   }
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::initialize_creg(uint_t num_memory,
-                       uint_t num_register,
-                       const std::string &memory_hex,
-                       const std::string &register_hex)
-{
-  if(chunk_manager_){
+void QubitVectorThrust<data_t>::initialize_creg(
+    uint_t num_memory, uint_t num_register, const std::string &memory_hex,
+    const std::string &register_hex) {
+  if (chunk_manager_) {
     num_creg_bits_ = num_register;
     num_cmem_bits_ = num_memory;
-    if(chunk_.pos() == 0){
-      chunk_.container()->allocate_creg(num_cmem_bits_,num_creg_bits_);
+    if (chunk_.pos() == 0) {
+      chunk_.container()->allocate_creg(num_cmem_bits_, num_creg_bits_);
 
       int_t i;
-      for(i=0;i<num_register;i++){
-        if(register_hex[register_hex.size() - 1 - i] == '0'){
-          store_cregister(i,0);
-        }
-        else{
-          store_cregister(i,1);
+      for (i = 0; i < num_register; i++) {
+        if (register_hex[register_hex.size() - 1 - i] == '0') {
+          store_cregister(i, 0);
+        } else {
+          store_cregister(i, 1);
         }
       }
-      for(i=0;i<num_memory;i++){
-        if(memory_hex[memory_hex.size() - 1 - i] == '0'){
-          store_cregister(i+num_creg_bits_,0);
-        }
-        else{
-          store_cregister(i+num_creg_bits_,1);
+      for (i = 0; i < num_memory; i++) {
+        if (memory_hex[memory_hex.size() - 1 - i] == '0') {
+          store_cregister(i + num_creg_bits_, 0);
+        } else {
+          store_cregister(i + num_creg_bits_, 1);
         }
       }
     }
@@ -1305,21 +1294,23 @@ void QubitVectorThrust<data_t>::initialize_creg(uint_t num_memory,
 
 template <typename data_t>
 template <typename Function>
-void QubitVectorThrust<data_t>::apply_function(Function func, uint_t count) const
-{
+void QubitVectorThrust<data_t>::apply_function(Function func,
+                                               uint_t count) const {
   uint_t chunk_count = count;
-  if(chunk_count == 0){
-    if(!cuStateVec_enable_ && func.batch_enable() && ((multi_chunk_distribution_ && chunk_.device() >= 0) || enable_batch_)){
-      if(chunk_.pos() == 0)        //only first chunk on device calculates all the chunks
+  if (chunk_count == 0) {
+    if (!cuStateVec_enable_ && func.batch_enable() &&
+        ((multi_chunk_distribution_ && chunk_.device() >= 0) ||
+         enable_batch_)) {
+      if (chunk_.pos() ==
+          0) // only first chunk on device calculates all the chunks
         chunk_count = chunk_.container()->num_chunks();
       else
         return;
-    }
-    else
+    } else
       chunk_count = 1;
   }
 
-  //set global state index
+  // set global state index
   func.set_base_index(chunk_index_ << num_qubits_);
 
   chunk_.Execute(func, chunk_count);
@@ -1332,23 +1323,26 @@ void QubitVectorThrust<data_t>::apply_function(Function func, uint_t count) cons
 
 template <typename data_t>
 template <typename Function>
-void QubitVectorThrust<data_t>::apply_function(Function func, const std::vector<std::complex<double>>& mat, const std::vector<uint_t>& prm, uint_t count) const
-{
+void QubitVectorThrust<data_t>::apply_function(
+    Function func, const std::vector<std::complex<double>> &mat,
+    const std::vector<uint_t> &prm, uint_t count) const {
   uint_t chunk_count = count;
-  if(chunk_count == 0){
-    if(!cuStateVec_enable_ && func.batch_enable() && ((multi_chunk_distribution_ && chunk_.device() >= 0) || enable_batch_)){
-      if(chunk_.pos() == 0)        //only first chunk on device calculates all the chunks
+  if (chunk_count == 0) {
+    if (!cuStateVec_enable_ && func.batch_enable() &&
+        ((multi_chunk_distribution_ && chunk_.device() >= 0) ||
+         enable_batch_)) {
+      if (chunk_.pos() ==
+          0) // only first chunk on device calculates all the chunks
         chunk_count = chunk_.container()->num_chunks();
       else
         return;
-    }
-    else
+    } else
       chunk_count = 1;
   }
 
-  if(mat.size() > 0)
+  if (mat.size() > 0)
     chunk_.StoreMatrix(mat);
-  if(prm.size() > 0)
+  if (prm.size() > 0)
     chunk_.StoreUintParams(prm);
   chunk_.Execute(func, chunk_count);
 
@@ -1360,14 +1354,17 @@ void QubitVectorThrust<data_t>::apply_function(Function func, const std::vector<
 
 template <typename data_t>
 template <typename Function>
-void QubitVectorThrust<data_t>::apply_function_sum(double* pSum,Function func,bool async) const
-{
+void QubitVectorThrust<data_t>::apply_function_sum(double *pSum, Function func,
+                                                   bool async) const {
   uint_t count = 1;
 #ifdef AER_THRUST_CUDA
-  if(!cuStateVec_enable_ && func.batch_enable() && ((multi_chunk_distribution_ && chunk_.device() >= 0 && num_qubits_ == num_qubits()) || (enable_batch_))){
-    if(chunk_.pos() != 0){
-      //only first chunk on device calculates all the chunks
-      if(pSum)
+  if (!cuStateVec_enable_ && func.batch_enable() &&
+      ((multi_chunk_distribution_ && chunk_.device() >= 0 &&
+        num_qubits_ == num_qubits()) ||
+       (enable_batch_))) {
+    if (chunk_.pos() != 0) {
+      // only first chunk on device calculates all the chunks
+      if (pSum)
         *pSum = 0.0;
       return;
     }
@@ -1376,25 +1373,28 @@ void QubitVectorThrust<data_t>::apply_function_sum(double* pSum,Function func,bo
 #endif
 
   func.set_base_index(chunk_index_ << num_qubits_);
-  chunk_.ExecuteSum(pSum,func,count);
+  chunk_.ExecuteSum(pSum, func, count);
 #ifdef AER_DEBUG
-  DebugMsg(func.name(),(int)count);
+  DebugMsg(func.name(), (int)count);
 #endif
 
-  if(!async)
+  if (!async)
     chunk_.synchronize();
 }
 
 template <typename data_t>
 template <typename Function>
-void QubitVectorThrust<data_t>::apply_function_sum2(double* pSum,Function func,bool async) const
-{
+void QubitVectorThrust<data_t>::apply_function_sum2(double *pSum, Function func,
+                                                    bool async) const {
   uint_t count = 1;
 #ifdef AER_THRUST_CUDA
-  if(!cuStateVec_enable_ && func.batch_enable() && ((multi_chunk_distribution_ && chunk_.device() >= 0 && num_qubits_ == num_qubits()) || (enable_batch_))){
-    if(chunk_.pos() != 0){
-      //only first chunk on device calculates all the chunks
-      if(pSum){
+  if (!cuStateVec_enable_ && func.batch_enable() &&
+      ((multi_chunk_distribution_ && chunk_.device() >= 0 &&
+        num_qubits_ == num_qubits()) ||
+       (enable_batch_))) {
+    if (chunk_.pos() != 0) {
+      // only first chunk on device calculates all the chunks
+      if (pSum) {
         pSum[0] = 0.0;
         pSum[1] = 0.0;
       }
@@ -1405,12 +1405,12 @@ void QubitVectorThrust<data_t>::apply_function_sum2(double* pSum,Function func,b
 #endif
 
   func.set_base_index(chunk_index_ << num_qubits_);
-  chunk_.ExecuteSum2(pSum,func,count);
+  chunk_.ExecuteSum2(pSum, func, count);
 #ifdef AER_DEBUG
-  DebugMsg(func.name(),(int)count);
+  DebugMsg(func.name(), (int)count);
 #endif
 
-  if(!async)
+  if (!async)
     chunk_.synchronize();
 }
 
@@ -1421,14 +1421,13 @@ void QubitVectorThrust<data_t>::apply_function_sum2(double* pSum,Function func,b
  ******************************************************************************/
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::set_omp_threads(int n) 
-{
+void QubitVectorThrust<data_t>::set_omp_threads(int n) {
   if (n > 0)
     omp_threads_ = n;
 
 #ifdef _OPENMP
-  //disable nested parallel for ThrustCPU
-  if(omp_get_num_threads() > 1)
+  // disable nested parallel for ThrustCPU
+  if (omp_get_num_threads() > 1)
     omp_threads_ = 1;
 #endif
 }
@@ -1444,92 +1443,86 @@ void QubitVectorThrust<data_t>::set_json_chop_threshold(double threshold) {
   json_chop_threshold_ = threshold;
 }
 
-
 /*******************************************************************************
  *
  * MATRIX MULTIPLICATION
  *
  ******************************************************************************/
 
-
 template <typename data_t>
 void QubitVectorThrust<data_t>::apply_matrix(const reg_t &qubits,
-                                       const cvector_t<double> &mat)
-{
+                                             const cvector_t<double> &mat) {
   uint_t count = get_chunk_count();
-  if(count == 0)
+  if (count == 0)
     return;
 
-  if(qubits.size() == 1 && register_blocking_)
-    chunk_.queue_blocked_gate('u',qubits[0],0,&mat[0]);
+  if (qubits.size() == 1 && register_blocking_)
+    chunk_.queue_blocked_gate('u', qubits[0], 0, &mat[0]);
   else
-    chunk_.apply_matrix(qubits,0,mat,count);
+    chunk_.apply_matrix(qubits, 0, mat, count);
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::apply_multiplexer(const reg_t &control_qubits,
-                                            const reg_t &target_qubits,
-                                            const cvector_t<double>  &mat)
-{
+void QubitVectorThrust<data_t>::apply_multiplexer(
+    const reg_t &control_qubits, const reg_t &target_qubits,
+    const cvector_t<double> &mat) {
   const size_t control_count = control_qubits.size();
-  const size_t target_count  = target_qubits.size();
-  const uint_t DIM = 1ull << (target_count+control_count);
+  const size_t target_count = target_qubits.size();
+  const uint_t DIM = 1ull << (target_count + control_count);
   const uint_t columns = 1ull << target_count;
   const uint_t blocks = 1ull << control_count;
 
   auto qubits = target_qubits;
-  for (const auto &q : control_qubits) {qubits.push_back(q);}
+  for (const auto &q : control_qubits) {
+    qubits.push_back(q);
+  }
   size_t N = qubits.size();
 
-  cvector_t<double> matMP(DIM*DIM,0.0);
-  uint_t b,i,j;
+  cvector_t<double> matMP(DIM * DIM, 0.0);
+  uint_t b, i, j;
 
-  //make DIMxDIM matrix
-  for(b = 0; b < blocks; b++){
-    for(i = 0; i < columns; i++){
-      for(j = 0; j < columns; j++){
-        matMP[(i+b*columns) + DIM*(b*columns+j)] += mat[i+b*columns + DIM * j];
+  // make DIMxDIM matrix
+  for (b = 0; b < blocks; b++) {
+    for (i = 0; i < columns; i++) {
+      for (j = 0; j < columns; j++) {
+        matMP[(i + b * columns) + DIM * (b * columns + j)] +=
+            mat[i + b * columns + DIM * j];
       }
     }
   }
 
 #ifdef AER_DEBUG
-  DebugMsg("apply_multiplexer",control_qubits);
-  DebugMsg("                 ",target_qubits);
+  DebugMsg("apply_multiplexer", control_qubits);
+  DebugMsg("                 ", target_qubits);
 #endif
 
-  apply_matrix(qubits,matMP);
+  apply_matrix(qubits, matMP);
 }
 
-
 template <typename data_t>
-void QubitVectorThrust<data_t>::apply_diagonal_matrix(const reg_t &qubits,
-                                                const cvector_t<double> &diag)
-{
+void QubitVectorThrust<data_t>::apply_diagonal_matrix(
+    const reg_t &qubits, const cvector_t<double> &diag) {
   uint_t count = get_chunk_count();
-  if(count == 0)
+  if (count == 0)
     return;
 
   const int_t N = qubits.size();
-  if(N == 1 && register_blocking_)
-    chunk_.queue_blocked_gate('d',qubits[0],0,&diag[0]);
+  if (N == 1 && register_blocking_)
+    chunk_.queue_blocked_gate('d', qubits[0], 0, &diag[0]);
   else
-    chunk_.apply_diagonal_matrix(qubits,0,diag,count);
+    chunk_.apply_diagonal_matrix(qubits, 0, diag, count);
 }
 
-
 template <typename data_t>
-void QubitVectorThrust<data_t>::apply_permutation_matrix(const reg_t& qubits,
-             const std::vector<std::pair<uint_t, uint_t>> &pairs)
-{
+void QubitVectorThrust<data_t>::apply_permutation_matrix(
+    const reg_t &qubits, const std::vector<std::pair<uint_t, uint_t>> &pairs) {
   uint_t count = get_chunk_count();
-  if(count == 0)
+  if (count == 0)
     return;
 
-  chunk_.apply_permutation(qubits,pairs,count);
+  chunk_.apply_permutation(qubits, pairs, count);
 }
 
-
 /*******************************************************************************
  *
  * APPLY OPTIMIZED GATES
@@ -1540,180 +1533,172 @@ void QubitVectorThrust<data_t>::apply_permutation_matrix(const reg_t& qubits,
 // Multi-controlled gates
 //------------------------------------------------------------------------------
 template <typename data_t>
-void QubitVectorThrust<data_t>::apply_mcx(const reg_t &qubits) 
-{
+void QubitVectorThrust<data_t>::apply_mcx(const reg_t &qubits) {
   uint_t count = get_chunk_count();
-  if(count == 0)
+  if (count == 0)
     return;
 
-  if(register_blocking_){
+  if (register_blocking_) {
     int i;
     uint_t mask = 0;
-    for(i=0;i<qubits.size()-1;i++){
+    for (i = 0; i < qubits.size() - 1; i++) {
       mask |= (1ull << qubits[i]);
     }
-    chunk_.queue_blocked_gate('x',qubits[qubits.size()-1],mask);
-  }
-  else{
+    chunk_.queue_blocked_gate('x', qubits[qubits.size() - 1], mask);
+  } else {
     chunk_.apply_X(qubits, count);
   }
 }
 
-
 template <typename data_t>
-void QubitVectorThrust<data_t>::apply_mcy(const reg_t &qubits) 
-{
+void QubitVectorThrust<data_t>::apply_mcy(const reg_t &qubits) {
   uint_t count = get_chunk_count();
-  if(count == 0)
+  if (count == 0)
     return;
 
-  if(register_blocking_){
+  if (register_blocking_) {
     int i;
     uint_t mask = 0;
-    for(i=0;i<qubits.size()-1;i++){
+    for (i = 0; i < qubits.size() - 1; i++) {
       mask |= (1ull << qubits[i]);
     }
-    chunk_.queue_blocked_gate('y',qubits[qubits.size()-1],mask);
-  }
-  else{
+    chunk_.queue_blocked_gate('y', qubits[qubits.size() - 1], mask);
+  } else {
     chunk_.apply_Y(qubits, count);
   }
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::apply_mcswap(const reg_t &qubits)
-{
+void QubitVectorThrust<data_t>::apply_mcswap(const reg_t &qubits) {
   uint_t count = get_chunk_count();
-  if(count == 0)
+  if (count == 0)
     return;
 
-  chunk_.apply_swap(qubits,qubits.size()-2,count);
+  chunk_.apply_swap(qubits, qubits.size() - 2, count);
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::apply_multi_swaps(const reg_t &qubits)
-{
+void QubitVectorThrust<data_t>::apply_multi_swaps(const reg_t &qubits) {
   uint_t count = get_chunk_count();
-  if(count == 0)
+  if (count == 0)
     return;
 
-  chunk_.apply_multi_swaps(qubits,chunk_.container()->num_chunks());
+  chunk_.apply_multi_swaps(qubits, chunk_.container()->num_chunks());
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::apply_chunk_swap(const reg_t &qubits, QubitVectorThrust<data_t> &src, bool write_back)
-{
-  int q0,q1,t;
+void QubitVectorThrust<data_t>::apply_chunk_swap(const reg_t &qubits,
+                                                 QubitVectorThrust<data_t> &src,
+                                                 bool write_back) {
+  int q0, q1, t;
 
   q0 = qubits[0];
   q1 = qubits[1];
 
-  if(q0 > q1){
+  if (q0 > q1) {
     t = q0;
     q0 = q1;
     q1 = t;
   }
 
-  if(q0 >= num_qubits_){  //exchange whole of chunk each other
-    if(chunk_.device() >= 0 || src.chunk_.device() < 0)
+  if (q0 >= num_qubits_) { // exchange whole of chunk each other
+    if (chunk_.device() >= 0 || src.chunk_.device() < 0)
       chunk_.Swap(src.chunk_);
     else
       src.chunk_.Swap(chunk_);
-  }
-  else{
-    thrust::complex<data_t>* pChunk0;
-    thrust::complex<data_t>* pChunk1;
+  } else {
+    thrust::complex<data_t> *pChunk0;
+    thrust::complex<data_t> *pChunk1;
     Chunk::Chunk<data_t> bufferChunk;
 
-    if(chunk_.device() >= 0){
-      if(chunk_.container()->peer_access(src.chunk_.device())){
+    if (chunk_.device() >= 0) {
+      if (chunk_.container()->peer_access(src.chunk_.device())) {
         pChunk1 = src.chunk_.pointer();
-      }
-      else{
-        do{
-          chunk_manager_->MapBufferChunk(bufferChunk,chunk_.place());
-        }while(!bufferChunk.is_mapped());
+      } else {
+        do {
+          chunk_manager_->MapBufferChunk(bufferChunk, chunk_.place());
+        } while (!bufferChunk.is_mapped());
         bufferChunk.set_chunk_index(src.chunk_index_);
         bufferChunk.CopyIn(src.chunk_);
         pChunk1 = bufferChunk.pointer();
       }
       pChunk0 = chunk_.pointer();
-    }
-    else{
-      if(src.chunk_.device() >= 0){
-        do{
-          chunk_manager_->MapBufferChunk(bufferChunk,src.chunk_.place());
-        }while(!bufferChunk.is_mapped());
+    } else {
+      if (src.chunk_.device() >= 0) {
+        do {
+          chunk_manager_->MapBufferChunk(bufferChunk, src.chunk_.place());
+        } while (!bufferChunk.is_mapped());
         bufferChunk.set_chunk_index(chunk_index_);
         bufferChunk.CopyIn(chunk_);
         pChunk0 = bufferChunk.pointer();
         pChunk1 = src.chunk_.pointer();
-      }
-      else{
+      } else {
         pChunk1 = src.chunk_.pointer();
         pChunk0 = chunk_.pointer();
       }
     }
 
 #ifdef AER_DEBUG
-    DebugMsg("chunk swap",qubits);
+    DebugMsg("chunk swap", qubits);
 #endif
 
-    if(q0 < num_qubits_){
-      if(chunk_index_ < src.chunk_index_)
+    if (q0 < num_qubits_) {
+      if (chunk_index_ < src.chunk_index_)
         pChunk0 += (1ull << q0);
       else
         pChunk1 += (1ull << q0);
     }
 
-    if(bufferChunk.is_mapped()){
-      bufferChunk.Execute(Chunk::CSwapChunk_func<data_t>(qubits,num_qubits_,pChunk0,pChunk1,true), 1);
-      if(pChunk1 == bufferChunk.pointer())
+    if (bufferChunk.is_mapped()) {
+      bufferChunk.Execute(Chunk::CSwapChunk_func<data_t>(
+                              qubits, num_qubits_, pChunk0, pChunk1, true),
+                          1);
+      if (pChunk1 == bufferChunk.pointer())
         bufferChunk.CopyOut(src.chunk_);
       else
         bufferChunk.CopyOut(chunk_);
       bufferChunk.synchronize();
       chunk_manager_->UnmapBufferChunk(bufferChunk);
-    }
-    else{
-      chunk_.Execute(Chunk::CSwapChunk_func<data_t>(qubits,num_qubits_,pChunk0,pChunk1,true), 1);
+    } else {
+      chunk_.Execute(Chunk::CSwapChunk_func<data_t>(qubits, num_qubits_,
+                                                    pChunk0, pChunk1, true),
+                     1);
       chunk_.synchronize();
     }
   }
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::apply_chunk_swap(const reg_t &qubits, uint_t remote_chunk_index)
-{
-  int q0,q1,t;
+void QubitVectorThrust<data_t>::apply_chunk_swap(const reg_t &qubits,
+                                                 uint_t remote_chunk_index) {
+  int q0, q1, t;
 
   q0 = qubits[qubits.size() - 2];
   q1 = qubits[qubits.size() - 1];
 
-  if(q0 > q1){
+  if (q0 > q1) {
     t = q0;
     q0 = q1;
     q1 = t;
   }
 
-  if(q0 >= num_qubits_){  //exchange whole of chunk each other
+  if (q0 >= num_qubits_) { // exchange whole of chunk each other
 #ifdef AER_DEBUG
-    DebugMsg("SWAP chunks between process",qubits);
+    DebugMsg("SWAP chunks between process", qubits);
 #endif
     chunk_.CopyIn(recv_chunk_);
-  }
-  else{
-    thrust::complex<data_t>* pLocal;
-    thrust::complex<data_t>* pRemote;
+  } else {
+    thrust::complex<data_t> *pLocal;
+    thrust::complex<data_t> *pRemote;
     Chunk::Chunk<data_t> buffer;
 
 #ifdef AER_DISABLE_GDR
-    if(chunk_.device() >= 0){    //if there is no GPUDirectRDMA support, copy chunk from CPU
-      chunk_manager_->MapBufferChunk(buffer,chunk_.place());
+    if (chunk_.device() >=
+        0) { // if there is no GPUDirectRDMA support, copy chunk from CPU
+      chunk_manager_->MapBufferChunk(buffer, chunk_.place());
       buffer.CopyIn(recv_chunk_);
       pRemote = buffer.pointer();
-    }
-    else{
+    } else {
       pRemote = recv_chunk_.pointer();
     }
 #else
@@ -1721,19 +1706,21 @@ void QubitVectorThrust<data_t>::apply_chunk_swap(const reg_t &qubits, uint_t rem
 #endif
     pLocal = chunk_.pointer();
 
-    if(chunk_index_ < remote_chunk_index)
+    if (chunk_index_ < remote_chunk_index)
       pLocal += (1ull << q0);
     else
       pRemote += (1ull << q0);
 
 #ifdef AER_DEBUG
-    DebugMsg("chunk swap (process)",qubits);
+    DebugMsg("chunk swap (process)", qubits);
 #endif
 
-    chunk_.Execute(Chunk::CSwapChunk_func<data_t>(qubits,num_qubits_,pLocal,pRemote,false),1);
-    chunk_.synchronize();    //should be synchronized here
+    chunk_.Execute(Chunk::CSwapChunk_func<data_t>(qubits, num_qubits_, pLocal,
+                                                  pRemote, false),
+                   1);
+    chunk_.synchronize(); // should be synchronized here
 
-    if(buffer.is_mapped()){
+    if (buffer.is_mapped()) {
       chunk_manager_->UnmapBufferChunk(buffer);
     }
   }
@@ -1745,41 +1732,40 @@ void QubitVectorThrust<data_t>::apply_chunk_swap(const reg_t &qubits, uint_t rem
 #endif
 }
 
-//swap part of chunks
+// swap part of chunks
 template <typename data_t>
-void QubitVectorThrust<data_t>::apply_chunk_swap(QubitVectorThrust<data_t> &src, uint_t dest_offset, uint_t src_offset, uint_t size)
-{
-  if(src.chunk_index_ == chunk_index_)   //save swapped 
-    chunk_.Swap(src.recv_chunk_,dest_offset,src_offset,size, false);
+void QubitVectorThrust<data_t>::apply_chunk_swap(QubitVectorThrust<data_t> &src,
+                                                 uint_t dest_offset,
+                                                 uint_t src_offset,
+                                                 uint_t size) {
+  if (src.chunk_index_ == chunk_index_) // save swapped
+    chunk_.Swap(src.recv_chunk_, dest_offset, src_offset, size, false);
   else
-    chunk_.Swap(src.chunk_,dest_offset,src_offset,size);
+    chunk_.Swap(src.chunk_, dest_offset, src_offset, size);
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::apply_mcphase(const reg_t &qubits, const std::complex<double> phase)
-{
+void QubitVectorThrust<data_t>::apply_mcphase(
+    const reg_t &qubits, const std::complex<double> phase) {
   uint_t count = get_chunk_count();
-  if(count == 0)
+  if (count == 0)
     return;
 
-  if(register_blocking_){
+  if (register_blocking_) {
     int i;
     uint_t mask = 0;
-    for(i=0;i<qubits.size()-1;i++){
+    for (i = 0; i < qubits.size() - 1; i++) {
       mask |= (1ull << qubits[i]);
     }
-    chunk_.queue_blocked_gate('p',qubits[qubits.size()-1],mask,&phase);
-  }
-  else{
-    chunk_.apply_phase(qubits,qubits.size()-1,phase,count);
+    chunk_.queue_blocked_gate('p', qubits[qubits.size() - 1], mask, &phase);
+  } else {
+    chunk_.apply_phase(qubits, qubits.size() - 1, phase, count);
   }
 }
 
-
 template <typename data_t>
 void QubitVectorThrust<data_t>::apply_mcu(const reg_t &qubits,
-                                    const cvector_t<double> &mat) 
-{
+                                          const cvector_t<double> &mat) {
   // Calculate the permutation positions for the last qubit.
   const size_t N = qubits.size();
 
@@ -1795,63 +1781,61 @@ void QubitVectorThrust<data_t>::apply_mcu(const reg_t &qubits,
     // Otherwise apply general diagonal gate
     const cvector_t<double> diag = {{mat[0], mat[3]}};
 
-    if(N == 1){
+    if (N == 1) {
       // If N=1 this is just a single-qubit matrix
       apply_diagonal_matrix(qubits[0], diag);
       return;
-    }
-    else{
-      if(register_blocking_){
+    } else {
+      if (register_blocking_) {
         int i;
         uint_t mask = 0;
-        for(i=0;i<qubits.size()-1;i++){
+        for (i = 0; i < qubits.size() - 1; i++) {
           mask |= (1ull << qubits[i]);
         }
-        chunk_.queue_blocked_gate('d',qubits[qubits.size()-1],mask,&diag[0]);
-      }
-      else{
+        chunk_.queue_blocked_gate('d', qubits[qubits.size() - 1], mask,
+                                  &diag[0]);
+      } else {
         uint_t count = get_chunk_count();
-        if(count == 0)
+        if (count == 0)
           return;
 
-        chunk_.apply_diagonal_matrix(qubits,qubits.size()-1,diag,count);
+        chunk_.apply_diagonal_matrix(qubits, qubits.size() - 1, diag, count);
       }
     }
-  }
-  else{
-    if(N == 1){
+  } else {
+    if (N == 1) {
       // If N=1 this is just a single-qubit matrix
       apply_matrix(qubits[0], mat);
       return;
-    }
-    else{
-      if(register_blocking_){
+    } else {
+      if (register_blocking_) {
         int i;
         uint_t mask = 0;
-        for(i=0;i<qubits.size()-1;i++){
+        for (i = 0; i < qubits.size() - 1; i++) {
           mask |= (1ull << qubits[i]);
         }
-        chunk_.queue_blocked_gate('u',qubits[qubits.size()-1],mask,&mat[0]);
-      }
-      else{
+        chunk_.queue_blocked_gate('u', qubits[qubits.size() - 1], mask,
+                                  &mat[0]);
+      } else {
         uint_t count = get_chunk_count();
-        if(count == 0)
+        if (count == 0)
           return;
 
-        chunk_.apply_matrix(qubits,qubits.size()-1,mat,count);
+        chunk_.apply_matrix(qubits, qubits.size() - 1, mat, count);
       }
     }
   }
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::apply_rotation(const reg_t &qubits, const Rotation r, const double theta)
-{
+void QubitVectorThrust<data_t>::apply_rotation(const reg_t &qubits,
+                                               const Rotation r,
+                                               const double theta) {
   uint_t count = get_chunk_count();
-  if(count == 0)
+  if (count == 0)
     return;
 
-  chunk_.apply_rotation(qubits,r,theta,count);
+  chunk_.apply_rotation(qubits, r, theta, count);
 }
 
 //------------------------------------------------------------------------------
@@ -1860,10 +1844,9 @@ void QubitVectorThrust<data_t>::apply_rotation(const reg_t &qubits, const Rotati
 
 template <typename data_t>
 void QubitVectorThrust<data_t>::apply_matrix(const uint_t qubit,
-                                       const cvector_t<double>& mat)
-{
+                                             const cvector_t<double> &mat) {
   uint_t count = get_chunk_count();
-  if(count == 0)
+  if (count == 0)
     return;
 
   // Check if matrix is diagonal and if so use optimized lambda
@@ -1872,29 +1855,26 @@ void QubitVectorThrust<data_t>::apply_matrix(const uint_t qubit,
     apply_diagonal_matrix(qubit, diag);
     return;
   }
-  if(register_blocking_){
-    chunk_.queue_blocked_gate('u',qubit,0,&mat[0]);
-  }
-  else{
+  if (register_blocking_) {
+    chunk_.queue_blocked_gate('u', qubit, 0, &mat[0]);
+  } else {
     reg_t qubits = {qubit};
-    chunk_.apply_matrix(qubits,0,mat,count);
+    chunk_.apply_matrix(qubits, 0, mat, count);
   }
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::apply_diagonal_matrix(const uint_t qubit,
-                                                const cvector_t<double>& diag) 
-{
+void QubitVectorThrust<data_t>::apply_diagonal_matrix(
+    const uint_t qubit, const cvector_t<double> &diag) {
   uint_t count = get_chunk_count();
-  if(count == 0)
+  if (count == 0)
     return;
 
-  if(register_blocking_){
-    chunk_.queue_blocked_gate('d',qubit,0,&diag[0]);
-  }
-  else{
+  if (register_blocking_) {
+    chunk_.queue_blocked_gate('d', qubit, 0, &diag[0]);
+  } else {
     reg_t qubits = {qubit};
-    chunk_.apply_diagonal_matrix(qubits,0,diag,count);
+    chunk_.apply_diagonal_matrix(qubits, 0, diag, count);
   }
 }
 
@@ -1903,16 +1883,15 @@ void QubitVectorThrust<data_t>::apply_diagonal_matrix(const uint_t qubit,
  * NORMS
  *
  ******************************************************************************/
-template <typename data_t>
-double QubitVectorThrust<data_t>::norm() const
-{
+template <typename data_t> double QubitVectorThrust<data_t>::norm() const {
   double ret;
   uint_t count = 1;
 
 #ifdef AER_THRUST_CUDA
-  if(enable_batch_ && ((multi_chunk_distribution_ && chunk_.device() >= 0) || !multi_chunk_distribution_)){
-    if(chunk_.pos() != 0)
-      return 0.0;   //first chunk execute all in batch
+  if (enable_batch_ && ((multi_chunk_distribution_ && chunk_.device() >= 0) ||
+                        !multi_chunk_distribution_)) {
+    if (chunk_.pos() != 0)
+      return 0.0; // first chunk execute all in batch
     count = chunk_.container()->num_chunks();
   }
 #endif
@@ -1920,25 +1899,23 @@ double QubitVectorThrust<data_t>::norm() const
   ret = chunk_.norm(count);
 
 #ifdef AER_DEBUG
-  DebugMsg("norm",ret);
+  DebugMsg("norm", ret);
 #endif
 
   return ret;
 }
 
-
 template <typename data_t>
-double QubitVectorThrust<data_t>::norm(const reg_t &qubits, const cvector_t<double> &mat) const 
-{
+double QubitVectorThrust<data_t>::norm(const reg_t &qubits,
+                                       const cvector_t<double> &mat) const {
   const size_t N = qubits.size();
 
-  if(N == 1){
+  if (N == 1) {
     return norm(qubits[0], mat);
-  }
-  else{
+  } else {
     auto qubits_sorted = qubits;
     std::sort(qubits_sorted.begin(), qubits_sorted.end());
-    for(int_t i=0;i<N;i++){
+    for (int_t i = 0; i < N; i++) {
       qubits_sorted.push_back(qubits[i]);
     }
 
@@ -1946,26 +1923,26 @@ double QubitVectorThrust<data_t>::norm(const reg_t &qubits, const cvector_t<doub
     chunk_.StoreUintParams(qubits_sorted);
 
     double ret;
-    apply_function_sum(&ret,Chunk::NormMatrixMultNxN<data_t>(N));
+    apply_function_sum(&ret, Chunk::NormMatrixMultNxN<data_t>(N));
     return ret;
   }
 }
 
-
 template <typename data_t>
-double QubitVectorThrust<data_t>::norm_diagonal(const reg_t &qubits, const cvector_t<double> &mat) const {
+double
+QubitVectorThrust<data_t>::norm_diagonal(const reg_t &qubits,
+                                         const cvector_t<double> &mat) const {
 
   const uint_t N = qubits.size();
 
-  if(N == 1){
+  if (N == 1) {
     return norm_diagonal(qubits[0], mat);
-  }
-  else{
+  } else {
     chunk_.StoreMatrix(mat);
     chunk_.StoreUintParams(qubits);
 
     double ret;
-    apply_function_sum(&ret,Chunk::NormDiagonalMultNxN<data_t>(qubits) );
+    apply_function_sum(&ret, Chunk::NormDiagonalMultNxN<data_t>(qubits));
     return ret;
   }
 }
@@ -1974,37 +1951,35 @@ double QubitVectorThrust<data_t>::norm_diagonal(const reg_t &qubits, const cvect
 // Single-qubit specialization
 //------------------------------------------------------------------------------
 template <typename data_t>
-double QubitVectorThrust<data_t>::norm(const uint_t qubit, const cvector_t<double> &mat) const
-{
+double QubitVectorThrust<data_t>::norm(const uint_t qubit,
+                                       const cvector_t<double> &mat) const {
   double ret;
-  apply_function_sum(&ret,Chunk::NormMatrixMult2x2<data_t>(mat,qubit));
+  apply_function_sum(&ret, Chunk::NormMatrixMult2x2<data_t>(mat, qubit));
 
   return ret;
 }
 
 template <typename data_t>
-double QubitVectorThrust<data_t>::norm_diagonal(const uint_t qubit, const cvector_t<double> &mat) const
-{
+double
+QubitVectorThrust<data_t>::norm_diagonal(const uint_t qubit,
+                                         const cvector_t<double> &mat) const {
   double ret;
-  apply_function_sum(&ret,Chunk::NormDiagonalMult2x2<data_t>(mat,qubit));
+  apply_function_sum(&ret, Chunk::NormDiagonalMult2x2<data_t>(mat, qubit));
 
   return ret;
 }
 
-
-
 /*******************************************************************************
  *
  * Probabilities
  *
  ******************************************************************************/
 template <typename data_t>
-double QubitVectorThrust<data_t>::probability(const uint_t outcome) const 
-{
+double QubitVectorThrust<data_t>::probability(const uint_t outcome) const {
   std::complex<data_t> ret;
   ret = (std::complex<data_t>)chunk_.Get(outcome);
 
-  return std::real(ret)*std::real(ret) + std::imag(ret) * std::imag(ret);
+  return std::real(ret) * std::real(ret) + std::imag(ret) * std::imag(ret);
 }
 
 template <typename data_t>
@@ -2015,20 +1990,21 @@ std::vector<double> QubitVectorThrust<data_t>::probabilities() const {
   DebugMsg("calling probabilities");
 #endif
 
-#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) num_threads(omp_threads_)
-  for (int_t j=0; j < END; j++) {
+#pragma omp parallel for if (num_qubits_ > omp_threshold_ && omp_threads_ > 1) \
+    num_threads(omp_threads_)
+  for (int_t j = 0; j < END; j++) {
     probs[j] = probability(j);
   }
 
 #ifdef AER_DEBUG
-  DebugMsg("probabilities",probs);
+  DebugMsg("probabilities", probs);
 #endif
   return probs;
 }
 
 template <typename data_t>
-std::vector<double> QubitVectorThrust<data_t>::probabilities(const reg_t &qubits) const 
-{
+std::vector<double>
+QubitVectorThrust<data_t>::probabilities(const reg_t &qubits) const {
   const size_t N = qubits.size();
   const int_t DIM = 1 << N;
   std::vector<double> probs(DIM, 0.);
@@ -2036,46 +2012,41 @@ std::vector<double> QubitVectorThrust<data_t>::probabilities(const reg_t &qubits
   chunk_.probabilities(probs, qubits);
 
 #ifdef AER_DEBUG
-  DebugMsg("probabilities",probs);
+  DebugMsg("probabilities", probs);
 #endif
 
   return probs;
 }
 
-#define QV_RESET_TOTAL_PROB     0
-#define QV_RESET_CURRENT_PROB   1
-#define QV_RESET_SUM_PROB       2
-#define QV_RESET_TARGET_PROB    3
+#define QV_RESET_TOTAL_PROB 0
+#define QV_RESET_CURRENT_PROB 1
+#define QV_RESET_SUM_PROB 2
+#define QV_RESET_TARGET_PROB 3
 
 template <typename data_t>
-class reset_after_measure_func : public Chunk::GateFuncBase<data_t>
-{
+class reset_after_measure_func : public Chunk::GateFuncBase<data_t> {
 protected:
   int num_qubits_;
-  double* probs_;
+  double *probs_;
   uint_t prob_buf_size_;
   uint_t iter_;
-public:
 
-  reset_after_measure_func(int nq,double* probs,uint_t prob_size,uint_t iter)
-  {
+public:
+  reset_after_measure_func(int nq, double *probs, uint_t prob_size,
+                           uint_t iter) {
     num_qubits_ = nq;
     probs_ = probs;
     prob_buf_size_ = prob_size;
     iter_ = iter;
   }
 
-  bool is_diagonal(void)
-  {
-    return true;
-  }
+  bool is_diagonal(void) { return true; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
+  __host__ __device__ void operator()(const uint_t &i) const {
     thrust::complex<data_t> q;
-    thrust::complex<data_t>* vec;
+    thrust::complex<data_t> *vec;
     double scale;
-    uint_t* qubits;
+    uint_t *qubits;
     int j;
 
     vec = this->data_;
@@ -2083,79 +2054,68 @@ class reset_after_measure_func : public Chunk::GateFuncBase<data_t>
 
     uint_t iChunk = (i >> this->chunk_bits_);
 
-    scale = 1.0/sqrt(probs_[iChunk + QV_RESET_CURRENT_PROB*prob_buf_size_]);
+    scale = 1.0 / sqrt(probs_[iChunk + QV_RESET_CURRENT_PROB * prob_buf_size_]);
     uint_t my_bit = 0;
-    for(j=0;j<num_qubits_;j++){
-      my_bit += ( ((i >> qubits[j]) & 1) << j);
+    for (j = 0; j < num_qubits_; j++) {
+      my_bit += (((i >> qubits[j]) & 1) << j);
     }
-    if(iter_ == my_bit)
-      vec[i] = scale*vec[i];
+    if (iter_ == my_bit)
+      vec[i] = scale * vec[i];
     else
       vec[i] = 0.0;
   }
-  const char* name(void)
-  {
-    return "reset_after_measure";
-  }
+  const char *name(void) { return "reset_after_measure"; }
 };
 
 template <typename data_t>
-class set_probability_buffer_for_reset_func : public Chunk::GateFuncBase<data_t>
-{
+class set_probability_buffer_for_reset_func
+    : public Chunk::GateFuncBase<data_t> {
 protected:
   uint_t reduce_buf_size_;
   uint_t prob_buf_size_;
-  double* probs_;
-  double* reduce_;
-public:
+  double *probs_;
+  double *reduce_;
 
-  set_probability_buffer_for_reset_func(double* probs,uint_t prob_size,double* reduce,uint_t red_size)
-  {
+public:
+  set_probability_buffer_for_reset_func(double *probs, uint_t prob_size,
+                                        double *reduce, uint_t red_size) {
     probs_ = probs;
     reduce_ = reduce;
     prob_buf_size_ = prob_size;
     reduce_buf_size_ = red_size;
   }
-  bool is_diagonal(void)
-  {
-    return true;
-  }
-  uint_t size(int num_qubits)
-  {
+  bool is_diagonal(void) { return true; }
+  uint_t size(int num_qubits) {
     this->chunk_bits_ = 0;
     return 1;
   }
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
+  __host__ __device__ void operator()(const uint_t &i) const {
     uint_t iChunk = i;
-    if(reduce_){
-      probs_[iChunk] = reduce_[iChunk*reduce_buf_size_];
+    if (reduce_) {
+      probs_[iChunk] = reduce_[iChunk * reduce_buf_size_];
     }
-    probs_[iChunk + QV_RESET_CURRENT_PROB*prob_buf_size_] = 0.0;
-    probs_[iChunk + QV_RESET_SUM_PROB*prob_buf_size_] = 0.0;
-  }
-  const char* name(void)
-  {
-    return "set_probability_buffer_for_reset";
+    probs_[iChunk + QV_RESET_CURRENT_PROB * prob_buf_size_] = 0.0;
+    probs_[iChunk + QV_RESET_SUM_PROB * prob_buf_size_] = 0.0;
   }
+  const char *name(void) { return "set_probability_buffer_for_reset"; }
 };
 
 template <typename data_t>
-class check_measure_probability_func : public Chunk::GateFuncBase<data_t>
-{
+class check_measure_probability_func : public Chunk::GateFuncBase<data_t> {
 protected:
   int num_qubits_;
   uint_t reduce_buf_size_;
   uint_t prob_buf_size_;
-  double* probs_;
-  double* reduce_;
+  double *probs_;
+  double *reduce_;
   uint_t iter_;
   uint_t num_mem_;
   uint_t num_reg_;
-public:
 
-  check_measure_probability_func(int nq,double* probs,uint_t prob_size,double* reduce,uint_t red_size,uint_t iter,uint_t nm,uint_t nr)
-  {
+public:
+  check_measure_probability_func(int nq, double *probs, uint_t prob_size,
+                                 double *reduce, uint_t red_size, uint_t iter,
+                                 uint_t nm, uint_t nr) {
     num_qubits_ = nq;
     probs_ = probs;
     reduce_ = reduce;
@@ -2165,197 +2125,193 @@ class check_measure_probability_func : public Chunk::GateFuncBase<data_t>
     num_mem_ = nm;
     num_reg_ = nr;
   }
-  bool is_diagonal(void)
-  {
-    return true;
-  }
-  uint_t size(int num_qubits)
-  {
+  bool is_diagonal(void) { return true; }
+  uint_t size(int num_qubits) {
     this->chunk_bits_ = 0;
     return 1;
   }
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
+  __host__ __device__ void operator()(const uint_t &i) const {
     uint_t iChunk = i;
-    double p0,p1,p_total,rnd,p;
-    uint_t bit,j;
-    uint_t* qubits;
-    uint_t* mem_bits;
-    uint_t* reg_bits;
+    double p0, p1, p_total, rnd, p;
+    uint_t bit, j;
+    uint_t *qubits;
+    uint_t *mem_bits;
+    uint_t *reg_bits;
     bool reset = false;
 
     p_total = probs_[iChunk];
-    p0 = reduce_[iChunk*reduce_buf_size_];
-    p1 = probs_[iChunk + QV_RESET_SUM_PROB*prob_buf_size_];
-    probs_[iChunk + QV_RESET_SUM_PROB*prob_buf_size_] = p0 + p1;  //update sum
-    rnd = probs_[iChunk + QV_RESET_TARGET_PROB*prob_buf_size_];
+    p0 = reduce_[iChunk * reduce_buf_size_];
+    p1 = probs_[iChunk + QV_RESET_SUM_PROB * prob_buf_size_];
+    probs_[iChunk + QV_RESET_SUM_PROB * prob_buf_size_] = p0 + p1; // update sum
+    rnd = probs_[iChunk + QV_RESET_TARGET_PROB * prob_buf_size_];
 
     p = p0;
-    if(rnd < ((p0 + p1) / p_total)){
+    if (rnd < ((p0 + p1) / p_total)) {
       bit = iter_;
       reset = true;
-    }
-    else if(iter_ + 2 == (1ull << num_qubits_)){  //last one
+    } else if (iter_ + 2 == (1ull << num_qubits_)) { // last one
       bit = iter_ + 1;
       p = p_total - p0 - p1;
       reset = true;
     }
-    probs_[iChunk + QV_RESET_CURRENT_PROB*prob_buf_size_] = p;
+    probs_[iChunk + QV_RESET_CURRENT_PROB * prob_buf_size_] = p;
 
-    uint_t n64,i64,ibit,sreg;
+    uint_t n64, i64, ibit, sreg;
     n64 = (this->num_creg_bits_ + 63) >> 6;
     sreg = this->num_creg_bits_ - QV_NUM_INTERNAL_REGS;
-    if(reset){
-      //save measure
+    if (reset) {
+      // save measure
       qubits = this->params_;
       mem_bits = qubits + num_qubits_;
       reg_bits = mem_bits + num_mem_;
-      for(j=0;j<num_mem_;j++){
+      for (j = 0; j < num_mem_; j++) {
         i64 = mem_bits[j] >> 6;
         ibit = mem_bits[j] & 63;
-        this->cregs_[iChunk*n64 + i64] = (this->cregs_[iChunk*n64 + i64] & (~(1ull << ibit))) | (((bit >> j) & 1) << ibit);
+        this->cregs_[iChunk * n64 + i64] =
+            (this->cregs_[iChunk * n64 + i64] & (~(1ull << ibit))) |
+            (((bit >> j) & 1) << ibit);
       }
-      for(j=0;j<num_reg_;j++){
+      for (j = 0; j < num_reg_; j++) {
         i64 = reg_bits[j] >> 6;
         ibit = reg_bits[j] & 63;
-        this->cregs_[iChunk*n64 + i64] = (this->cregs_[iChunk*n64 + i64] & (~(1ull << ibit))) | (((bit >> j) & 1) << ibit);
+        this->cregs_[iChunk * n64 + i64] =
+            (this->cregs_[iChunk * n64 + i64] & (~(1ull << ibit))) |
+            (((bit >> j) & 1) << ibit);
       }
 
-      if(bit == iter_){  //applying only for iter != last, last case will be aplied out of loop
-        //set system register[0] to 0 not to execute measure/reset kernels anymore
+      if (bit == iter_) { // applying only for iter != last, last case will be
+                          // aplied out of loop
+        // set system register[0] to 0 not to execute measure/reset kernels
+        // anymore
         i64 = sreg >> 6;
         ibit = sreg & 63;
-        this->cregs_[iChunk*n64 + i64] &= (~(1ull << ibit));
-
-        //set system register[1] to 1 to apply reset
-        i64 = (sreg+1) >> 6;
-        ibit = (sreg+1) & 63;
-        this->cregs_[iChunk*n64 + i64] |= (1ull << ibit);
-      }
-      else{
-        //set system register[1] to 0
-        i64 = (sreg+1) >> 6;
-        ibit = (sreg+1) & 63;
-        this->cregs_[iChunk*n64 + i64] &= (~(1ull << ibit));
+        this->cregs_[iChunk * n64 + i64] &= (~(1ull << ibit));
+
+        // set system register[1] to 1 to apply reset
+        i64 = (sreg + 1) >> 6;
+        ibit = (sreg + 1) & 63;
+        this->cregs_[iChunk * n64 + i64] |= (1ull << ibit);
+      } else {
+        // set system register[1] to 0
+        i64 = (sreg + 1) >> 6;
+        ibit = (sreg + 1) & 63;
+        this->cregs_[iChunk * n64 + i64] &= (~(1ull << ibit));
       }
+    } else {
+      // set system register[1] to 0
+      i64 = (sreg + 1) >> 6;
+      ibit = (sreg + 1) & 63;
+      this->cregs_[iChunk * n64 + i64] &= (~(1ull << ibit));
     }
-    else{
-      //set system register[1] to 0
-      i64 = (sreg+1) >> 6;
-      ibit = (sreg+1) & 63;
-      this->cregs_[iChunk*n64 + i64] &= (~(1ull << ibit));
-    }
-  }
-  const char* name(void)
-  {
-    return "check_measure_probability";
   }
+  const char *name(void) { return "check_measure_probability"; }
 };
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::apply_batched_measure(const reg_t& qubits,std::vector<RngEngine>& rng,const reg_t& cmemory,const reg_t& cregs)
-{
+void QubitVectorThrust<data_t>::apply_batched_measure(
+    const reg_t &qubits, std::vector<RngEngine> &rng, const reg_t &cmemory,
+    const reg_t &cregs) {
   const int_t DIM = 1 << qubits.size();
-  uint_t i,count = 1;
-  if(enable_batch_){
-    if(chunk_.pos() != 0){
-      return;   //first chunk execute all in batch
+  uint_t i, count = 1;
+  if (enable_batch_) {
+    if (chunk_.pos() != 0) {
+      return; // first chunk execute all in batch
     }
   }
   count = chunk_.container()->num_chunks();
 
-  //set system register[0] to 1 used for conditional register
+  // set system register[0] to 1 used for conditional register
   uint_t system_reg = num_creg_bits_ + num_cmem_bits_;
 
-  //handling conditional
+  // handling conditional
   int_t reg_cond = chunk_.get_conditional();
-  if(reg_cond >= 0){
-    //copy conditional register to system register
+  if (reg_cond >= 0) {
+    // copy conditional register to system register
     chunk_.set_conditional(-1);
-    copy_cregister(system_reg,reg_cond);
-    store_cregister(system_reg+1,0);
-  }
-  else{
-    //can be applied to all states
-    store_cregister(system_reg,1);
+    copy_cregister(system_reg, reg_cond);
+    store_cregister(system_reg + 1, 0);
+  } else {
+    // can be applied to all states
+    store_cregister(system_reg, 1);
   }
   chunk_.set_conditional(system_reg);
   chunk_.keep_conditional(true);
 
-  //total probability
-  apply_function_sum(nullptr,Chunk::norm_func<data_t>(),true);
-  apply_function(set_probability_buffer_for_reset_func<data_t>(chunk_.probability_buffer(),chunk_.container()->num_chunks(),
-                                                               chunk_.reduce_buffer(),chunk_.reduce_buffer_size()) );
+  // total probability
+  apply_function_sum(nullptr, Chunk::norm_func<data_t>(), true);
+  apply_function(set_probability_buffer_for_reset_func<data_t>(
+      chunk_.probability_buffer(), chunk_.container()->num_chunks(),
+      chunk_.reduce_buffer(), chunk_.reduce_buffer_size()));
 
   reg_t params(qubits.size() + cmemory.size() + cregs.size());
-  for(i=0;i<qubits.size();i++){
+  for (i = 0; i < qubits.size(); i++) {
     params[i] = qubits[i];
   }
-  for(i=0;i<cmemory.size();i++){
-    params[i+qubits.size()] = cmemory[i] + num_creg_bits_;
+  for (i = 0; i < cmemory.size(); i++) {
+    params[i + qubits.size()] = cmemory[i] + num_creg_bits_;
   }
-  for(i=0;i<cregs.size();i++){
-    params[cmemory.size()+qubits.size()+i] = cregs[i];
+  for (i = 0; i < cregs.size(); i++) {
+    params[cmemory.size() + qubits.size() + i] = cregs[i];
   }
   chunk_.StoreUintParams(params);
 
-  //probability
+  // probability
   std::vector<double> r(count);
-  for(i=0;i<count;i++){
+  for (i = 0; i < count; i++) {
     r[i] = rng[i].rand();
   }
-  chunk_.container()->copy_to_probability_buffer(r,QV_RESET_TARGET_PROB);
+  chunk_.container()->copy_to_probability_buffer(r, QV_RESET_TARGET_PROB);
 
-  //loop for probability
-  for(i=0;i<DIM-1;i++){
+  // loop for probability
+  for (i = 0; i < DIM - 1; i++) {
     chunk_.set_conditional(system_reg);
-    apply_function_sum(nullptr,Chunk::probability_func<data_t>(qubits,i),true);
+    apply_function_sum(nullptr, Chunk::probability_func<data_t>(qubits, i),
+                       true);
 
-    apply_function(check_measure_probability_func<data_t>(qubits.size(),chunk_.probability_buffer(),chunk_.container()->num_chunks(),
-                                                                        chunk_.reduce_buffer(),chunk_.reduce_buffer_size(),
-                                                                        i,cmemory.size(),cregs.size()) );
+    apply_function(check_measure_probability_func<data_t>(
+        qubits.size(), chunk_.probability_buffer(),
+        chunk_.container()->num_chunks(), chunk_.reduce_buffer(),
+        chunk_.reduce_buffer_size(), i, cmemory.size(), cregs.size()));
 
-    chunk_.set_conditional(system_reg+1);
-    apply_function(reset_after_measure_func<data_t>(qubits.size(),chunk_.probability_buffer(),chunk_.container()->num_chunks(),i ));
-    store_cregister(system_reg+1,0);
+    chunk_.set_conditional(system_reg + 1);
+    apply_function(reset_after_measure_func<data_t>(
+        qubits.size(), chunk_.probability_buffer(),
+        chunk_.container()->num_chunks(), i));
+    store_cregister(system_reg + 1, 0);
   }
-  //for last case
+  // for last case
   chunk_.keep_conditional(false);
   chunk_.set_conditional(system_reg);
-  apply_function(reset_after_measure_func<data_t>(qubits.size(),chunk_.probability_buffer(),chunk_.container()->num_chunks(),DIM-1 ));
+  apply_function(reset_after_measure_func<data_t>(
+      qubits.size(), chunk_.probability_buffer(),
+      chunk_.container()->num_chunks(), DIM - 1));
 
   chunk_.container()->request_creg_update();
 }
 
 template <typename data_t>
-class reset_func : public Chunk::GateFuncBase<data_t>
-{
+class reset_func : public Chunk::GateFuncBase<data_t> {
 protected:
   int num_qubits_;
-  double* probs_;
+  double *probs_;
   uint_t iter_;
   uint_t prob_buf_size_;
-public:
 
-  reset_func(int nq,double* probs,uint_t prob_size,uint_t iter)
-  {
+public:
+  reset_func(int nq, double *probs, uint_t prob_size, uint_t iter) {
     num_qubits_ = nq;
     probs_ = probs;
     iter_ = iter;
     prob_buf_size_ = prob_size;
   }
 
-  bool is_diagonal(void)
-  {
-    return true;
-  }
+  bool is_diagonal(void) { return true; }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
+  __host__ __device__ void operator()(const uint_t &i) const {
     thrust::complex<data_t> q;
-    thrust::complex<data_t>* vec;
+    thrust::complex<data_t> *vec;
     double scale;
-    uint_t* qubits;
+    uint_t *qubits;
     int j;
 
     vec = this->data_;
@@ -2363,127 +2319,123 @@ class reset_func : public Chunk::GateFuncBase<data_t>
 
     uint_t iChunk = (i >> this->chunk_bits_);
 
-    scale = 1.0/sqrt(probs_[iChunk + QV_RESET_CURRENT_PROB*prob_buf_size_]);
+    scale = 1.0 / sqrt(probs_[iChunk + QV_RESET_CURRENT_PROB * prob_buf_size_]);
 
     uint_t my_bit = 0;
-    for(j=0;j<num_qubits_;j++){
-      my_bit += ( ((i >> qubits[j]) & 1) << j);
+    for (j = 0; j < num_qubits_; j++) {
+      my_bit += (((i >> qubits[j]) & 1) << j);
     }
-    if(my_bit == 0){
+    if (my_bit == 0) {
       uint_t i_pair = i;
-      for(j=0;j<num_qubits_;j++){
-        if( ((iter_ >> j) & 1) != 0)
+      for (j = 0; j < num_qubits_; j++) {
+        if (((iter_ >> j) & 1) != 0)
           i_pair += (1ull << qubits[j]);
       }
-      vec[i] = scale*vec[i_pair];
-      if(i != i_pair){
+      vec[i] = scale * vec[i_pair];
+      if (i != i_pair) {
         vec[i_pair] = 0.0;
       }
-    }
-    else if(iter_ != my_bit){
+    } else if (iter_ != my_bit) {
       vec[i] = 0.0;
     }
   }
-  const char* name(void)
-  {
-    return "reset";
-  }
+  const char *name(void) { return "reset"; }
 };
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::apply_batched_reset(const reg_t& qubits,std::vector<RngEngine>& rng)
-{
+void QubitVectorThrust<data_t>::apply_batched_reset(
+    const reg_t &qubits, std::vector<RngEngine> &rng) {
   const int_t DIM = 1 << qubits.size();
-  uint_t i,count = 1;
-  if(enable_batch_){
-    if(chunk_.pos() != 0){
-      return;   //first chunk execute all in batch
+  uint_t i, count = 1;
+  if (enable_batch_) {
+    if (chunk_.pos() != 0) {
+      return; // first chunk execute all in batch
     }
   }
   count = chunk_.container()->num_chunks();
 
-  //set system register[0] to 1 used for conditional register
+  // set system register[0] to 1 used for conditional register
   uint_t system_reg = num_creg_bits_ + num_cmem_bits_;
 
-  //handling conditional
+  // handling conditional
   int_t reg_cond = chunk_.get_conditional();
-  if(reg_cond >= 0){
-    //copy conditional register to system register
+  if (reg_cond >= 0) {
+    // copy conditional register to system register
     chunk_.set_conditional(-1);
-    copy_cregister(system_reg,reg_cond);
-    store_cregister(system_reg+1,0);
-  }
-  else{
-    //can be applied to all states
-    store_cregister(system_reg,1);
+    copy_cregister(system_reg, reg_cond);
+    store_cregister(system_reg + 1, 0);
+  } else {
+    // can be applied to all states
+    store_cregister(system_reg, 1);
   }
   chunk_.set_conditional(system_reg);
   chunk_.keep_conditional(true);
 
-  //total probability
-  apply_function_sum(nullptr,Chunk::norm_func<data_t>(),true);
-  apply_function(set_probability_buffer_for_reset_func<data_t>(chunk_.probability_buffer(),chunk_.container()->num_chunks(),
-                                                               chunk_.reduce_buffer(),chunk_.reduce_buffer_size()) );
+  // total probability
+  apply_function_sum(nullptr, Chunk::norm_func<data_t>(), true);
+  apply_function(set_probability_buffer_for_reset_func<data_t>(
+      chunk_.probability_buffer(), chunk_.container()->num_chunks(),
+      chunk_.reduce_buffer(), chunk_.reduce_buffer_size()));
 
-  //probability
+  // probability
   std::vector<double> r(count);
-  for(i=0;i<count;i++){
+  for (i = 0; i < count; i++) {
     r[i] = rng[i].rand();
   }
-  chunk_.container()->copy_to_probability_buffer(r,QV_RESET_TARGET_PROB);
+  chunk_.container()->copy_to_probability_buffer(r, QV_RESET_TARGET_PROB);
 
   chunk_.StoreUintParams(qubits);
-  for(i=0;i<DIM-1;i++){
+  for (i = 0; i < DIM - 1; i++) {
     chunk_.set_conditional(system_reg);
-    apply_function_sum(nullptr,Chunk::probability_func<data_t>(qubits,i),true);
+    apply_function_sum(nullptr, Chunk::probability_func<data_t>(qubits, i),
+                       true);
 
-    apply_function(check_measure_probability_func<data_t>(qubits.size(),chunk_.probability_buffer(),chunk_.container()->num_chunks(),
-                                                                        chunk_.reduce_buffer(),chunk_.reduce_buffer_size(),
-                                                                        i,0,0) );
+    apply_function(check_measure_probability_func<data_t>(
+        qubits.size(), chunk_.probability_buffer(),
+        chunk_.container()->num_chunks(), chunk_.reduce_buffer(),
+        chunk_.reduce_buffer_size(), i, 0, 0));
 
-    chunk_.set_conditional(system_reg+1);
-    apply_function(reset_func<data_t>(qubits.size(),chunk_.probability_buffer(),chunk_.container()->num_chunks(),i ) );
-    store_cregister(system_reg+1,0);
+    chunk_.set_conditional(system_reg + 1);
+    apply_function(reset_func<data_t>(qubits.size(),
+                                      chunk_.probability_buffer(),
+                                      chunk_.container()->num_chunks(), i));
+    store_cregister(system_reg + 1, 0);
   }
   chunk_.keep_conditional(false);
   chunk_.set_conditional(system_reg);
-  apply_function(reset_func<data_t>(qubits.size(),chunk_.probability_buffer(),chunk_.container()->num_chunks(),DIM-1 ) );
+  apply_function(reset_func<data_t>(qubits.size(), chunk_.probability_buffer(),
+                                    chunk_.container()->num_chunks(), DIM - 1));
 }
 
-
-
 template <typename data_t>
-int QubitVectorThrust<data_t>::measured_cregister(uint_t qubit)
-{
-  //read from memory
+int QubitVectorThrust<data_t>::measured_cregister(uint_t qubit) {
+  // read from memory
   return chunk_.measured_cbit(qubit);
 }
 
 template <typename data_t>
-int QubitVectorThrust<data_t>::measured_cmemory(uint_t qubit)
-{
-  //read from memory
+int QubitVectorThrust<data_t>::measured_cmemory(uint_t qubit) {
+  // read from memory
   return chunk_.measured_cbit(qubit + num_creg_bits_);
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::read_measured_data(ClassicalRegister& creg)
-{
+void QubitVectorThrust<data_t>::read_measured_data(ClassicalRegister &creg) {
   uint_t i;
   reg_t pos(1);
   reg_t dummy_pos;
 
-  for(i=0;i<creg.memory_size();i++){
+  for (i = 0; i < creg.memory_size(); i++) {
     int bit = chunk_.measured_cbit(i + num_creg_bits_);
-    if(bit >= 0){
+    if (bit >= 0) {
       const reg_t outcome = Utils::int2reg(bit, 2, 1);
       pos[0] = i;
-      creg.store_measure(outcome, pos , dummy_pos);
+      creg.store_measure(outcome, pos, dummy_pos);
     }
   }
-  for(i=0;i<creg.register_size();i++){
+  for (i = 0; i < creg.register_size(); i++) {
     int bit = chunk_.measured_cbit(i);
-    if(bit >= 0){
+    if (bit >= 0) {
       const reg_t outcome = Utils::int2reg(bit, 2, 1);
       pos[0] = i;
       creg.store_measure(outcome, dummy_pos, pos);
@@ -2492,193 +2444,165 @@ void QubitVectorThrust<data_t>::read_measured_data(ClassicalRegister& creg)
 }
 
 template <typename data_t>
-class set_creg_func : public Chunk::GateFuncBase<data_t>
-{
+class set_creg_func : public Chunk::GateFuncBase<data_t> {
 protected:
   uint_t reg_set_;
   uint_t val_;
+
 public:
-  set_creg_func(uint_t reg_set,uint_t val)
-  {
+  set_creg_func(uint_t reg_set, uint_t val) {
     reg_set_ = reg_set;
     val_ = val;
   }
-  bool is_diagonal(void)
-  {
-    return true;
-  }
-  uint_t size(int num_qubits)
-  {
+  bool is_diagonal(void) { return true; }
+  uint_t size(int num_qubits) {
     this->chunk_bits_ = 0;
     return 1;
   }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
+  __host__ __device__ void operator()(const uint_t &i) const {
     uint_t iChunk = i;
-    uint_t n64,i64,ibit;
+    uint_t n64, i64, ibit;
     n64 = (this->num_creg_bits_ + 63) >> 6;
 
     i64 = reg_set_ >> 6;
     ibit = reg_set_ & 63;
-    this->cregs_[iChunk*n64 + i64] = (this->cregs_[iChunk*n64 + i64] & (~(1ull << ibit))) | (val_ << ibit);
-  }
-  const char* name(void)
-  {
-    return "set_creg";
+    this->cregs_[iChunk * n64 + i64] =
+        (this->cregs_[iChunk * n64 + i64] & (~(1ull << ibit))) | (val_ << ibit);
   }
+  const char *name(void) { return "set_creg"; }
 };
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::store_cregister(uint_t qubit,int val)
-{
-  apply_function(set_creg_func<data_t>(qubit,(uint_t)val));
+void QubitVectorThrust<data_t>::store_cregister(uint_t qubit, int val) {
+  apply_function(set_creg_func<data_t>(qubit, (uint_t)val));
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::store_cmemory(uint_t qubit,int val)
-{
-  apply_function(set_creg_func<data_t>(qubit + num_creg_bits_,(uint_t)val));
+void QubitVectorThrust<data_t>::store_cmemory(uint_t qubit, int val) {
+  apply_function(set_creg_func<data_t>(qubit + num_creg_bits_, (uint_t)val));
 }
 
 template <typename data_t>
-class set_batched_creg_func : public Chunk::GateFuncBase<data_t>
-{
+class set_batched_creg_func : public Chunk::GateFuncBase<data_t> {
 protected:
   int_t reg_set_;
   int_t reg_copy_;
+
 public:
-  set_batched_creg_func(int_t reg_set,int_t reg_copy)
-  {
+  set_batched_creg_func(int_t reg_set, int_t reg_copy) {
     reg_set_ = reg_set;
     reg_copy_ = reg_copy;
   }
-  bool is_diagonal(void)
-  {
-    return true;
-  }
-  uint_t size(int num_qubits)
-  {
+  bool is_diagonal(void) { return true; }
+  uint_t size(int num_qubits) {
     this->chunk_bits_ = 0;
     return 1;
   }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
+  __host__ __device__ void operator()(const uint_t &i) const {
     uint_t iChunk = i;
-    uint_t n64,i64,ibit;
-    uint_t* mask;
+    uint_t n64, i64, ibit;
+    uint_t *mask;
     uint_t val = 1;
     n64 = (this->num_creg_bits_ + 63) >> 6;
     int j;
 
     mask = this->params_;
 
-    if(reg_copy_ >= 0){   //mask conditional register
+    if (reg_copy_ >= 0) { // mask conditional register
       i64 = reg_copy_ >> 6;
       ibit = reg_copy_ & 63;
-      val = (this->cregs_[iChunk*n64 + i64] >> ibit) & 1;
+      val = (this->cregs_[iChunk * n64 + i64] >> ibit) & 1;
     }
     val &= mask[iChunk];
 
     i64 = reg_set_ >> 6;
     ibit = reg_set_ & 63;
-    this->cregs_[iChunk*n64 + i64] = (this->cregs_[iChunk*n64 + i64] & (~(1ull << ibit))) | (val << ibit);
-  }
-  const char* name(void)
-  {
-    return "set_batched_creg";
+    this->cregs_[iChunk * n64 + i64] =
+        (this->cregs_[iChunk * n64 + i64] & (~(1ull << ibit))) | (val << ibit);
   }
+  const char *name(void) { return "set_batched_creg"; }
 };
 
 template <typename data_t>
-int_t QubitVectorThrust<data_t>::set_batched_system_conditional(int_t src_reg, reg_t& mask)
-{
-  int_t sys_reg = num_creg_bits_ + num_cmem_bits_ + QV_NUM_INTERNAL_REGS - 1; //use last internal reg
+int_t QubitVectorThrust<data_t>::set_batched_system_conditional(int_t src_reg,
+                                                                reg_t &mask) {
+  int_t sys_reg = num_creg_bits_ + num_cmem_bits_ + QV_NUM_INTERNAL_REGS -
+                  1; // use last internal reg
 
-  //copy bit from src_reg to system reg and mask them
+  // copy bit from src_reg to system reg and mask them
   chunk_.StoreUintParams(mask);
-  apply_function(set_batched_creg_func<data_t>(sys_reg,src_reg));
+  apply_function(set_batched_creg_func<data_t>(sys_reg, src_reg));
 
   return sys_reg;
 }
 
 template <typename data_t>
-class copy_creg_func : public Chunk::GateFuncBase<data_t>
-{
+class copy_creg_func : public Chunk::GateFuncBase<data_t> {
 protected:
   uint_t reg_dest_;
   uint_t reg_src_;
+
 public:
-  copy_creg_func(uint_t dest,uint_t src)
-  {
+  copy_creg_func(uint_t dest, uint_t src) {
     reg_dest_ = dest;
     reg_src_ = src;
   }
-  bool is_diagonal(void)
-  {
-    return true;
-  }
-  uint_t size(int num_qubits)
-  {
+  bool is_diagonal(void) { return true; }
+  uint_t size(int num_qubits) {
     this->chunk_bits_ = 0;
     return 1;
   }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
+  __host__ __device__ void operator()(const uint_t &i) const {
     uint_t iChunk = i;
-    uint_t n64,i64,ibit,val;
+    uint_t n64, i64, ibit, val;
     n64 = (this->num_creg_bits_ + 63) >> 6;
 
     i64 = reg_src_ >> 6;
     ibit = reg_src_ & 63;
-    val = (this->cregs_[iChunk*n64 + i64] >> ibit) & 1;
+    val = (this->cregs_[iChunk * n64 + i64] >> ibit) & 1;
 
     i64 = reg_dest_ >> 6;
     ibit = reg_dest_ & 63;
-    this->cregs_[iChunk*n64 + i64] = (this->cregs_[iChunk*n64 + i64] & (~(1ull << ibit))) | (val << ibit);
-  }
-  const char* name(void)
-  {
-    return "copy_creg";
+    this->cregs_[iChunk * n64 + i64] =
+        (this->cregs_[iChunk * n64 + i64] & (~(1ull << ibit))) | (val << ibit);
   }
+  const char *name(void) { return "copy_creg"; }
 };
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::copy_cregister(uint_t dest,uint_t src)
-{
-  apply_function(copy_creg_func<data_t>(dest,src));
+void QubitVectorThrust<data_t>::copy_cregister(uint_t dest, uint_t src) {
+  apply_function(copy_creg_func<data_t>(dest, src));
 }
 
 //------------------------------------------------------------------------------
 // Sample measure outcomes
 //------------------------------------------------------------------------------
 template <typename data_t>
-reg_t QubitVectorThrust<data_t>::sample_measure(const std::vector<double> &rnds) const
-{
+reg_t QubitVectorThrust<data_t>::sample_measure(
+    const std::vector<double> &rnds) const {
   uint_t count = 1;
 #ifdef AER_THRUST_CUDA
-  if((multi_chunk_distribution_ && chunk_.device() >= 0) || enable_batch_){
-    if(chunk_.pos() != 0)
-      return reg_t();   //first chunk execute all in batch
+  if ((multi_chunk_distribution_ && chunk_.device() >= 0) || enable_batch_) {
+    if (chunk_.pos() != 0)
+      return reg_t(); // first chunk execute all in batch
     count = chunk_.container()->num_chunks();
   }
 #endif
 
 #ifdef AER_DEBUG
   reg_t samples;
-  DebugMsg("sample_measure begin",(int)count);
-  samples = chunk_.sample_measure(rnds,1,true,count);
-  DebugMsg("sample_measure",samples);
+  DebugMsg("sample_measure begin", (int)count);
+  samples = chunk_.sample_measure(rnds, 1, true, count);
+  DebugMsg("sample_measure", samples);
   return samples;
 #else
-  return chunk_.sample_measure(rnds,1,true,count);
+  return chunk_.sample_measure(rnds, 1, true, count);
 #endif
 }
 
-
-
 /*******************************************************************************
  *
  * EXPECTATION VALUES
@@ -2686,10 +2610,11 @@ reg_t QubitVectorThrust<data_t>::sample_measure(const std::vector<double> &rnds)
  ******************************************************************************/
 
 template <typename data_t>
-double QubitVectorThrust<data_t>::expval_pauli(const reg_t &qubits,
-                                               const std::string &pauli,const complex_t initial_phase) const 
-{
-  return chunk_.expval_pauli(qubits,pauli,initial_phase);
+double
+QubitVectorThrust<data_t>::expval_pauli(const reg_t &qubits,
+                                        const std::string &pauli,
+                                        const complex_t initial_phase) const {
+  return chunk_.expval_pauli(qubits, pauli, initial_phase);
 
   uint_t x_mask, z_mask, num_y, x_max;
   std::tie(x_mask, z_mask, num_y, x_max) = pauli_masks_and_phase(qubits, pauli);
@@ -2701,8 +2626,8 @@ double QubitVectorThrust<data_t>::expval_pauli(const reg_t &qubits,
   }
   double ret;
   // specialize x_max == 0
-  if(x_mask == 0) {
-    apply_function_sum(&ret, Chunk::expval_pauli_Z_func<data_t>(z_mask) );
+  if (x_mask == 0) {
+    apply_function_sum(&ret, Chunk::expval_pauli_Z_func<data_t>(z_mask));
     return ret;
   }
 
@@ -2710,61 +2635,56 @@ double QubitVectorThrust<data_t>::expval_pauli(const reg_t &qubits,
   // This is (-1j) ** number of Y terms modulo 4
   auto phase = std::complex<data_t>(initial_phase);
   add_y_phase(num_y, phase);
-  apply_function_sum(&ret, Chunk::expval_pauli_XYZ_func<data_t>(x_mask, z_mask, x_max, phase) );
+  apply_function_sum(
+      &ret, Chunk::expval_pauli_XYZ_func<data_t>(x_mask, z_mask, x_max, phase));
   return ret;
 }
 
-
 template <typename data_t>
-double QubitVectorThrust<data_t>::expval_pauli(const reg_t &qubits,
-                                               const std::string &pauli,
-                                               const QubitVectorThrust<data_t>& pair_chunk,
-                                               const uint_t z_count,const uint_t z_count_pair,const complex_t initial_phase) const 
-{
+double QubitVectorThrust<data_t>::expval_pauli(
+    const reg_t &qubits, const std::string &pauli,
+    const QubitVectorThrust<data_t> &pair_chunk, const uint_t z_count,
+    const uint_t z_count_pair, const complex_t initial_phase) const {
   uint_t x_mask, z_mask, num_y, x_max;
   std::tie(x_mask, z_mask, num_y, x_max) = pauli_masks_and_phase(qubits, pauli);
 
-  //get pointer to pairing chunk (copy if needed)
+  // get pointer to pairing chunk (copy if needed)
   double ret;
-  thrust::complex<data_t>* pair_ptr;
+  thrust::complex<data_t> *pair_ptr;
   Chunk::Chunk<data_t> buffer;
 
-  if(pair_chunk.data() == this->data()){
+  if (pair_chunk.data() == this->data()) {
 #ifdef AER_DISABLE_GDR
-    if(chunk_.device() >= 0){    //if there is no GPUDirectRDMA support, copy chunk from CPU
-      chunk_manager_->MapBufferChunk(buffer,chunk_.place());
+    if (chunk_.device() >=
+        0) { // if there is no GPUDirectRDMA support, copy chunk from CPU
+      chunk_manager_->MapBufferChunk(buffer, chunk_.place());
       buffer.CopyIn(recv_chunk_);
       pair_ptr = buffer.pointer();
-    }
-    else{
+    } else {
       pair_ptr = recv_chunk_.pointer();
     }
 #else
     pair_ptr = recv_chunk_.pointer();
 #endif
-  }
-  else{   //on other memory space, copy required
-    if(chunk_.device() >= 0){
-      if(chunk_.container()->peer_access(pair_chunk.chunk_.device())){
+  } else { // on other memory space, copy required
+    if (chunk_.device() >= 0) {
+      if (chunk_.container()->peer_access(pair_chunk.chunk_.device())) {
         pair_ptr = pair_chunk.chunk_.pointer();
-      }
-      else{
-        do{
-          chunk_manager_->MapBufferChunk(buffer,chunk_.place());
-        }while(!buffer.is_mapped());
+      } else {
+        do {
+          chunk_manager_->MapBufferChunk(buffer, chunk_.place());
+        } while (!buffer.is_mapped());
         buffer.CopyIn(pair_chunk.chunk_);
         pair_ptr = buffer.pointer();
       }
-    }
-    else{
-      if(pair_chunk.chunk_.device() >= 0){
-        do{
-          chunk_manager_->MapBufferChunk(buffer,chunk_.place());
-        }while(!buffer.is_mapped());
+    } else {
+      if (pair_chunk.chunk_.device() >= 0) {
+        do {
+          chunk_manager_->MapBufferChunk(buffer, chunk_.place());
+        } while (!buffer.is_mapped());
         buffer.CopyIn(chunk_);
         pair_ptr = buffer.pointer();
-      }
-      else{
+      } else {
         pair_ptr = pair_chunk.chunk_.pointer();
       }
     }
@@ -2775,17 +2695,19 @@ double QubitVectorThrust<data_t>::expval_pauli(const reg_t &qubits,
   auto phase = std::complex<data_t>(initial_phase);
   add_y_phase(num_y, phase);
 
-  apply_function_sum(&ret, Chunk::expval_pauli_inter_chunk_func<data_t>(x_mask, z_mask, phase, pair_ptr,z_count,z_count_pair) );
+  apply_function_sum(
+      &ret, Chunk::expval_pauli_inter_chunk_func<data_t>(
+                x_mask, z_mask, phase, pair_ptr, z_count, z_count_pair));
 
-  if(buffer.is_mapped()){
+  if (buffer.is_mapped()) {
     chunk_manager_->UnmapBufferChunk(buffer);
   }
 
-  if(pair_chunk.data() == this->data()){
+  if (pair_chunk.data() == this->data()) {
     release_recv_buffer();
   }
 
-  if(pair_chunk.data() == this->data()){
+  if (pair_chunk.data() == this->data()) {
     release_recv_buffer();
   }
 
@@ -2798,12 +2720,10 @@ double QubitVectorThrust<data_t>::expval_pauli(const reg_t &qubits,
  *
  ******************************************************************************/
 
-
 template <typename data_t>
 void QubitVectorThrust<data_t>::apply_pauli(const reg_t &qubits,
                                             const std::string &pauli,
-                                            const complex_t &coeff)
-{
+                                            const complex_t &coeff) {
   uint_t x_mask, z_mask, num_y, x_max;
   std::tie(x_mask, z_mask, num_y, x_max) = pauli_masks_and_phase(qubits, pauli);
 
@@ -2814,35 +2734,33 @@ void QubitVectorThrust<data_t>::apply_pauli(const reg_t &qubits,
   auto phase = std::complex<data_t>(coeff);
   add_y_phase(num_y, phase);
 
-  if(x_mask == 0){
+  if (x_mask == 0) {
     apply_function(Chunk::multi_pauli_Z_func<data_t>(z_mask, phase));
-  }
-  else{
-    apply_function(Chunk::multi_pauli_func<data_t>(x_mask, z_mask, x_max, phase) );
+  } else {
+    apply_function(
+        Chunk::multi_pauli_func<data_t>(x_mask, z_mask, x_max, phase));
   }
 }
 
-//batched Pauli operation used for Pauli noise
+// batched Pauli operation used for Pauli noise
 template <typename data_t>
-class batched_pauli_func : public Chunk::GateFuncBase<data_t>
-{
+class batched_pauli_func : public Chunk::GateFuncBase<data_t> {
 protected:
   thrust::complex<data_t> coeff_;
   int num_qubits_state_;
+
 public:
-  batched_pauli_func(int nqs,std::complex<data_t> c)
-  {
+  batched_pauli_func(int nqs, std::complex<data_t> c) {
     num_qubits_state_ = nqs;
     coeff_ = c;
   }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    thrust::complex<data_t>* vec;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    thrust::complex<data_t> *vec;
     thrust::complex<data_t> q0;
     thrust::complex<data_t> q1;
-    uint_t idx0,idx1;
-    uint_t* param;
+    uint_t idx0, idx1;
+    uint_t *param;
     thrust::complex<data_t> phase;
 
     uint_t iChunk = (i >> (num_qubits_state_ - 1));
@@ -2855,16 +2773,15 @@ class batched_pauli_func : public Chunk::GateFuncBase<data_t>
     uint_t mask_l_;
     uint_t mask_u_;
 
-    mask_u_ = ~((1ull << (x_max+1)) - 1);
+    mask_u_ = ~((1ull << (x_max + 1)) - 1);
     mask_l_ = (1ull << x_max) - 1;
 
     vec = this->data_;
 
-    if(x_mask_ == 0){
+    if (x_mask_ == 0) {
       idx0 = i << 1;
       idx1 = idx0 + 1;
-    }
-    else{
+    } else {
       idx0 = ((i << 1) & mask_u_) | (i & mask_l_);
       idx1 = idx0 ^ x_mask_;
     }
@@ -2872,76 +2789,71 @@ class batched_pauli_func : public Chunk::GateFuncBase<data_t>
     q0 = vec[idx0];
     q1 = vec[idx1];
 
-    if(num_y == 0)
+    if (num_y == 0)
       phase = coeff_;
-    else if(num_y == 1)
-      phase = thrust::complex<data_t>(coeff_.imag(),-coeff_.real());
-    else if(num_y == 2)
-      phase = thrust::complex<data_t>(-coeff_.real(),-coeff_.imag());
+    else if (num_y == 1)
+      phase = thrust::complex<data_t>(coeff_.imag(), -coeff_.real());
+    else if (num_y == 2)
+      phase = thrust::complex<data_t>(-coeff_.real(), -coeff_.imag());
     else
-      phase = thrust::complex<data_t>(-coeff_.imag(),coeff_.real());
+      phase = thrust::complex<data_t>(-coeff_.imag(), coeff_.real());
 
-    if(z_mask_ != 0){
-      if(Chunk::pop_count_kernel(idx0 & z_mask_) & 1)
+    if (z_mask_ != 0) {
+      if (Chunk::pop_count_kernel(idx0 & z_mask_) & 1)
         q0 *= -1;
 
-      if(Chunk::pop_count_kernel(idx1 & z_mask_) & 1)
+      if (Chunk::pop_count_kernel(idx1 & z_mask_) & 1)
         q1 *= -1;
     }
-    if(x_mask_ == 0){
+    if (x_mask_ == 0) {
       vec[idx0] = q0 * phase;
       vec[idx1] = q1 * phase;
-    }
-    else{
+    } else {
       vec[idx0] = q1 * phase;
       vec[idx1] = q0 * phase;
     }
   }
-  const char* name(void)
-  {
-    return "batched_pauli";
-  }
+  const char *name(void) { return "batched_pauli"; }
 };
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::apply_batched_pauli_ops(const std::vector<std::vector<Operations::Op>>& ops)
-{
-  if(enable_batch_ && chunk_.pos() != 0){
-    return;   //first chunk execute all in batch
+void QubitVectorThrust<data_t>::apply_batched_pauli_ops(
+    const std::vector<std::vector<Operations::Op>> &ops) {
+  if (enable_batch_ && chunk_.pos() != 0) {
+    return; // first chunk execute all in batch
   }
   uint_t count = ops.size();
   int num_inner_threads = omp_get_max_threads() / num_threads_per_group_;
   int_t i;
 
-  reg_t params(4*count);
+  reg_t params(4 * count);
 
-  auto count_paulis = [this,&params,ops](int_t i){
+  auto count_paulis = [this, &params, ops](int_t i) {
     int_t j;
     uint_t x_max = 0;
     uint_t num_y = 0;
     uint_t x_mask = 0;
     uint_t z_mask = 0;
 
-    for(j=0;j<ops[i].size();j++){
-      if(ops[i][j].conditional)
+    for (j = 0; j < ops[i].size(); j++) {
+      if (ops[i][j].conditional)
         set_conditional(ops[i][j].conditional_reg);
 
-      if(ops[i][j].name == "x"){
+      if (ops[i][j].name == "x") {
         x_mask ^= (1ull << ops[i][j].qubits[0]);
         x_max = std::max<uint_t>(x_max, (ops[i][j].qubits[0]));
-      }
-      else if(ops[i][j].name == "z"){
+      } else if (ops[i][j].name == "z") {
         z_mask ^= (1ull << ops[i][j].qubits[0]);
-      }
-      else if(ops[i][j].name == "y"){
+      } else if (ops[i][j].name == "y") {
         x_mask ^= (1ull << ops[i][j].qubits[0]);
         z_mask ^= (1ull << ops[i][j].qubits[0]);
         x_max = std::max<uint_t>(x_max, (ops[i][j].qubits[0]));
         num_y++;
-      }
-      else if(ops[i][j].name == "pauli"){
-        uint_t pauli_x_mask = 0, pauli_z_mask = 0, pauli_num_y = 0, pauli_x_max = 0;
-        std::tie(pauli_x_mask, pauli_z_mask, pauli_num_y, pauli_x_max) = pauli_masks_and_phase(ops[i][j].qubits, ops[i][j].string_params[0]);
+      } else if (ops[i][j].name == "pauli") {
+        uint_t pauli_x_mask = 0, pauli_z_mask = 0, pauli_num_y = 0,
+               pauli_x_max = 0;
+        std::tie(pauli_x_mask, pauli_z_mask, pauli_num_y, pauli_x_max) =
+            pauli_masks_and_phase(ops[i][j].qubits, ops[i][j].string_params[0]);
 
         x_mask ^= pauli_x_mask;
         z_mask ^= pauli_z_mask;
@@ -2949,29 +2861,30 @@ void QubitVectorThrust<data_t>::apply_batched_pauli_ops(const std::vector<std::v
         num_y += pauli_num_y;
       }
     }
-    params[i*4] = x_max;
-    params[i*4+1] = num_y % 4;
-    params[i*4+2] = x_mask;
-    params[i*4+3] = z_mask;
+    params[i * 4] = x_max;
+    params[i * 4 + 1] = num_y % 4;
+    params[i * 4 + 2] = x_mask;
+    params[i * 4 + 3] = z_mask;
   };
-  Utils::apply_omp_parallel_for((num_inner_threads > 1),0,count,count_paulis,num_inner_threads);
+  Utils::apply_omp_parallel_for((num_inner_threads > 1), 0, count, count_paulis,
+                                num_inner_threads);
 
-  thrust::complex<data_t> coeff(1.0,0.0);
+  thrust::complex<data_t> coeff(1.0, 0.0);
   chunk_.StoreUintParams(params);
-  apply_function(batched_pauli_func<data_t>(num_qubits_,coeff) );
+  apply_function(batched_pauli_func<data_t>(num_qubits_, coeff));
 }
 
 template <typename data_t>
-class MatrixMult2x2_conditional : public Chunk::GateFuncBase<data_t>
-{
+class MatrixMult2x2_conditional : public Chunk::GateFuncBase<data_t> {
 protected:
-  thrust::complex<double> m0,m1,m2,m3;
+  thrust::complex<double> m0, m1, m2, m3;
   uint_t offset0;
   uint_t prob_buf_size_;
-  double* probs_;
+  double *probs_;
+
 public:
-  MatrixMult2x2_conditional(const cvector_t<double>& mat,int q,double* probs,uint_t prob_size)
-  {
+  MatrixMult2x2_conditional(const cvector_t<double> &mat, int q, double *probs,
+                            uint_t prob_size) {
     m0 = mat[0];
     m1 = mat[1];
     m2 = mat[2];
@@ -2983,16 +2896,16 @@ class MatrixMult2x2_conditional : public Chunk::GateFuncBase<data_t>
     prob_buf_size_ = prob_size;
   }
 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
-    uint_t i0,i1;
-    thrust::complex<data_t> q0,q1;
-    thrust::complex<data_t>* vec0;
-    thrust::complex<data_t>* vec1;
-    double p,p0,p1,rnd;
+  __host__ __device__ void operator()(const uint_t &i) const {
+    uint_t i0, i1;
+    thrust::complex<data_t> q0, q1;
+    thrust::complex<data_t> *vec0;
+    thrust::complex<data_t> *vec1;
+    double p, p0, p1, rnd;
 
     uint_t iChunk = i >> this->chunk_bits_;
-    double scale  = 1.0/sqrt(probs_[iChunk + QV_RESET_CURRENT_PROB*prob_buf_size_]);
+    double scale =
+        1.0 / sqrt(probs_[iChunk + QV_RESET_CURRENT_PROB * prob_buf_size_]);
 
     vec0 = this->data_;
     vec1 = vec0 + offset0;
@@ -3003,202 +2916,192 @@ class MatrixMult2x2_conditional : public Chunk::GateFuncBase<data_t>
 
     q0 = vec0[i0];
     q1 = vec1[i0];
-    vec0[i0] = scale*(m0 * q0 + m2 * q1);
-    vec1[i0] = scale*(m1 * q0 + m3 * q1);
-  }
-  const char* name(void)
-  {
-    return "MatrixMult2x2_conditional";
+    vec0[i0] = scale * (m0 * q0 + m2 * q1);
+    vec1[i0] = scale * (m1 * q0 + m3 * q1);
   }
+  const char *name(void) { return "MatrixMult2x2_conditional"; }
 };
 
 template <typename data_t>
-class MatrixMultNxN_conditional : public Chunk::GateFuncWithCache<data_t>
-{
+class MatrixMultNxN_conditional : public Chunk::GateFuncWithCache<data_t> {
 protected:
   uint_t prob_buf_size_;
-  double* probs_;
+  double *probs_;
+
 public:
-  MatrixMultNxN_conditional(uint_t nq,double* probs,uint_t prob_size) : Chunk::GateFuncWithCache<data_t>(nq)
-  {
+  MatrixMultNxN_conditional(uint_t nq, double *probs, uint_t prob_size)
+      : Chunk::GateFuncWithCache<data_t>(nq) {
     probs_ = probs;
     prob_buf_size_ = prob_size;
   }
 
-  __host__ __device__ void run_with_cache(uint_t _tid,uint_t _idx,thrust::complex<data_t>* _cache) const
-  {
-    uint_t j,threadID;
-    thrust::complex<data_t> q,r;
+  __host__ __device__ void
+  run_with_cache(uint_t _tid, uint_t _idx,
+                 thrust::complex<data_t> *_cache) const {
+    uint_t j, threadID;
+    thrust::complex<data_t> q, r;
     thrust::complex<double> m;
-    uint_t mat_size,irow;
-    thrust::complex<data_t>* vec;
-    thrust::complex<double>* pMat;
+    uint_t mat_size, irow;
+    thrust::complex<data_t> *vec;
+    thrust::complex<double> *pMat;
 
     uint_t iChunk = _idx >> this->chunk_bits_;
 
     vec = this->data_;
     pMat = this->matrix_;
 
-    double scale = 1.0/sqrt(probs_[iChunk + QV_RESET_CURRENT_PROB*prob_buf_size_]);
+    double scale =
+        1.0 / sqrt(probs_[iChunk + QV_RESET_CURRENT_PROB * prob_buf_size_]);
 
     mat_size = 1ull << this->nqubits_;
     irow = _tid & (mat_size - 1);
 
     r = 0.0;
-    for(j=0;j<mat_size;j++){
-      m = pMat[irow + mat_size*j];
+    for (j = 0; j < mat_size; j++) {
+      m = pMat[irow + mat_size * j];
       q = _cache[(_tid & 1023) - irow + j];
-      r += m*q;
+      r += m * q;
     }
-    vec[_idx] = r*scale;
+    vec[_idx] = r * scale;
   }
 
-  const char* name(void)
-  {
-    return "multNxN_conditional";
-  }
+  const char *name(void) { return "multNxN_conditional"; }
 };
 
 template <typename data_t>
-class check_kraus_probability_func : public Chunk::GateFuncBase<data_t>
-{
+class check_kraus_probability_func : public Chunk::GateFuncBase<data_t> {
 protected:
   uint_t reduce_buf_size_;
   uint_t prob_buf_size_;
-  double* probs_;
-  double* reduce_;
+  double *probs_;
+  double *reduce_;
+
 public:
-  check_kraus_probability_func(double* probs,uint_t prob_size,double* reduce,uint_t red_size)
-  {
+  check_kraus_probability_func(double *probs, uint_t prob_size, double *reduce,
+                               uint_t red_size) {
     probs_ = probs;
     reduce_ = reduce;
     prob_buf_size_ = prob_size;
     reduce_buf_size_ = red_size;
   }
-  bool is_diagonal(void)
-  {
-    return true;
-  }
-  uint_t size(int num_qubits)
-  {
+  bool is_diagonal(void) { return true; }
+  uint_t size(int num_qubits) {
     this->chunk_bits_ = 0;
     return 1;
   }
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
+  __host__ __device__ void operator()(const uint_t &i) const {
     uint_t iChunk = i;
-    double p0,p1,rnd;
+    double p0, p1, rnd;
     bool mult = false;
 
-    p0 = reduce_[iChunk*reduce_buf_size_];
-    probs_[iChunk + QV_RESET_CURRENT_PROB*prob_buf_size_] = p0;
-    p1 = probs_[iChunk + QV_RESET_SUM_PROB*prob_buf_size_];
-    probs_[iChunk + QV_RESET_SUM_PROB*prob_buf_size_] = p0 + p1;  //update sum
-    rnd = probs_[iChunk + QV_RESET_TARGET_PROB*prob_buf_size_];
+    p0 = reduce_[iChunk * reduce_buf_size_];
+    probs_[iChunk + QV_RESET_CURRENT_PROB * prob_buf_size_] = p0;
+    p1 = probs_[iChunk + QV_RESET_SUM_PROB * prob_buf_size_];
+    probs_[iChunk + QV_RESET_SUM_PROB * prob_buf_size_] = p0 + p1; // update sum
+    rnd = probs_[iChunk + QV_RESET_TARGET_PROB * prob_buf_size_];
 
-    uint_t n64,i64,ibit,sreg;
+    uint_t n64, i64, ibit, sreg;
     n64 = (this->num_creg_bits_ + 63) >> 6;
     sreg = this->num_creg_bits_ - QV_NUM_INTERNAL_REGS;
-    if(rnd >= p1 && rnd < p0 + p1){
-      //set system register[0] to 0 not to execute Kraus kernels anymore
+    if (rnd >= p1 && rnd < p0 + p1) {
+      // set system register[0] to 0 not to execute Kraus kernels anymore
       i64 = sreg >> 6;
       ibit = sreg & 63;
-      this->cregs_[iChunk*n64 + i64] &= (~(1ull << ibit));
+      this->cregs_[iChunk * n64 + i64] &= (~(1ull << ibit));
 
-      //set system register[1] to 1 to multiply matrix
-      i64 = (sreg+1) >> 6;
-      ibit = (sreg+1) & 63;
-      this->cregs_[iChunk*n64 + i64] |= (1ull << ibit);
+      // set system register[1] to 1 to multiply matrix
+      i64 = (sreg + 1) >> 6;
+      ibit = (sreg + 1) & 63;
+      this->cregs_[iChunk * n64 + i64] |= (1ull << ibit);
+    } else {
+      // set system register[1] to 0
+      i64 = (sreg + 1) >> 6;
+      ibit = (sreg + 1) & 63;
+      this->cregs_[iChunk * n64 + i64] &= (~(1ull << ibit));
     }
-    else{
-      //set system register[1] to 0
-      i64 = (sreg+1) >> 6;
-      ibit = (sreg+1) & 63;
-      this->cregs_[iChunk*n64 + i64] &= (~(1ull << ibit));
-    }
-  }
-  const char* name(void)
-  {
-    return "check_kraus_probability";
   }
+  const char *name(void) { return "check_kraus_probability"; }
 };
 
-
 template <typename data_t>
-void QubitVectorThrust<data_t>::apply_batched_kraus(const reg_t &qubits,
-                                            const std::vector<cmatrix_t> &kmats,
-                                            std::vector<RngEngine>& rng)
-{
+void QubitVectorThrust<data_t>::apply_batched_kraus(
+    const reg_t &qubits, const std::vector<cmatrix_t> &kmats,
+    std::vector<RngEngine> &rng) {
   const size_t N = qubits.size();
-  uint_t i,count;
+  uint_t i, count;
   double ret;
 
   count = chunk_.container()->num_chunks();
 
-  //set system register[0] to 1 used for conditional register
+  // set system register[0] to 1 used for conditional register
   uint_t system_reg = num_creg_bits_ + num_cmem_bits_;
 
-  //handling conditional
+  // handling conditional
   int_t reg_cond = chunk_.get_conditional();
-  if(reg_cond >= 0){
-    //copy conditional register to system register
+  if (reg_cond >= 0) {
+    // copy conditional register to system register
     chunk_.set_conditional(-1);
-    copy_cregister(system_reg,reg_cond);
-    store_cregister(system_reg+1,0);
-  }
-  else{
-    //can be applied to all states
-    store_cregister(system_reg,1);
+    copy_cregister(system_reg, reg_cond);
+    store_cregister(system_reg + 1, 0);
+  } else {
+    // can be applied to all states
+    store_cregister(system_reg, 1);
   }
   chunk_.set_conditional(system_reg);
   chunk_.keep_conditional(true);
 
-  //total probability
-  apply_function(set_probability_buffer_for_reset_func<data_t>(chunk_.probability_buffer(),chunk_.container()->num_chunks(),
-                                                               nullptr,0) );
+  // total probability
+  apply_function(set_probability_buffer_for_reset_func<data_t>(
+      chunk_.probability_buffer(), chunk_.container()->num_chunks(), nullptr,
+      0));
 
   std::vector<double> r(count);
-  for(i=0;i<count;i++){
+  for (i = 0; i < count; i++) {
     r[i] = rng[i].rand(0., 1.);
   }
-  chunk_.container()->copy_to_probability_buffer(r,QV_RESET_TARGET_PROB);
+  chunk_.container()->copy_to_probability_buffer(r, QV_RESET_TARGET_PROB);
 
-  if(N == 1){
-    for(i=0;i<kmats.size();i++){
+  if (N == 1) {
+    for (i = 0; i < kmats.size(); i++) {
       cvector_t<double> vmat = Utils::vectorize_matrix(kmats[i]);
 
       chunk_.set_conditional(system_reg);
-      apply_function_sum(nullptr,Chunk::NormMatrixMult2x2<data_t>(vmat,qubits[0]),true);
+      apply_function_sum(
+          nullptr, Chunk::NormMatrixMult2x2<data_t>(vmat, qubits[0]), true);
 
-      apply_function(check_kraus_probability_func<data_t>(chunk_.probability_buffer(),chunk_.container()->num_chunks(),
-                                                          chunk_.reduce_buffer(),chunk_.reduce_buffer_size() ) );
+      apply_function(check_kraus_probability_func<data_t>(
+          chunk_.probability_buffer(), chunk_.container()->num_chunks(),
+          chunk_.reduce_buffer(), chunk_.reduce_buffer_size()));
 
-      //multiply only when system reg[1] is 1
-      chunk_.set_conditional(system_reg+1);
-      apply_function(MatrixMult2x2_conditional<data_t>(vmat,qubits[0],chunk_.probability_buffer(),chunk_.container()->num_chunks()) );
-      store_cregister(system_reg+1,0);
+      // multiply only when system reg[1] is 1
+      chunk_.set_conditional(system_reg + 1);
+      apply_function(MatrixMult2x2_conditional<data_t>(
+          vmat, qubits[0], chunk_.probability_buffer(),
+          chunk_.container()->num_chunks()));
+      store_cregister(system_reg + 1, 0);
     }
-  }
-  else{
+  } else {
     auto qubits_sorted = qubits;
     std::sort(qubits_sorted.begin(), qubits_sorted.end());
-    for(i=0;i<N;i++)
+    for (i = 0; i < N; i++)
       qubits_sorted.push_back(qubits[i]);
     chunk_.StoreUintParams(qubits_sorted);
 
-    for(i=0;i<kmats.size();i++){
+    for (i = 0; i < kmats.size(); i++) {
       chunk_.set_conditional(system_reg);
 
       chunk_.StoreMatrix(Utils::vectorize_matrix(kmats[i]));
-      apply_function_sum(nullptr,Chunk::NormMatrixMultNxN<data_t>(N),true);
+      apply_function_sum(nullptr, Chunk::NormMatrixMultNxN<data_t>(N), true);
 
-      apply_function(check_kraus_probability_func<data_t>(chunk_.probability_buffer(),chunk_.container()->num_chunks(),
-                                                          chunk_.reduce_buffer(),chunk_.reduce_buffer_size() ) );
+      apply_function(check_kraus_probability_func<data_t>(
+          chunk_.probability_buffer(), chunk_.container()->num_chunks(),
+          chunk_.reduce_buffer(), chunk_.reduce_buffer_size()));
 
-      //multiply only when system reg[1] is 1
-      chunk_.set_conditional(system_reg+1);
-      apply_function(MatrixMultNxN_conditional<data_t>(N,chunk_.probability_buffer(),chunk_.container()->num_chunks()) );
-      store_cregister(system_reg+1,0);
+      // multiply only when system reg[1] is 1
+      chunk_.set_conditional(system_reg + 1);
+      apply_function(MatrixMultNxN_conditional<data_t>(
+          N, chunk_.probability_buffer(), chunk_.container()->num_chunks()));
+      store_cregister(system_reg + 1, 0);
     }
   }
   chunk_.set_conditional(-1);
@@ -3206,119 +3109,115 @@ void QubitVectorThrust<data_t>::apply_batched_kraus(const reg_t &qubits,
 }
 
 template <typename data_t>
-class bfunc_kernel : public Chunk::GateFuncBase<data_t>
-{
+class bfunc_kernel : public Chunk::GateFuncBase<data_t> {
 protected:
   uint_t bfunc_num_regs_;
   Operations::RegComparison bfunc_;
+
 public:
-  bfunc_kernel(uint_t n,Operations::RegComparison bfunc)
-  {
-    bfunc_num_regs_ = n;    //number of registers to be updated
+  bfunc_kernel(uint_t n, Operations::RegComparison bfunc) {
+    bfunc_num_regs_ = n; // number of registers to be updated
     bfunc_ = bfunc;
   }
-  bool is_diagonal(void)
-  {
-    return true;
-  }
-  uint_t size(int num_qubits)
-  {
+  bool is_diagonal(void) { return true; }
+  uint_t size(int num_qubits) {
     this->chunk_bits_ = 0;
     return 1;
   }
 
-  //in uint param array: array of qubits results to be stored, mask registers, target registers 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
+  // in uint param array: array of qubits results to be stored, mask registers,
+  // target registers
+  __host__ __device__ void operator()(const uint_t &i) const {
     uint_t iChunk = i;
     uint_t n64 = (this->num_creg_bits_ + 63) >> 6;
-    uint_t* regs = this->params_;
-    uint_t* mask = regs + bfunc_num_regs_;
-    uint_t* target = mask + n64;
+    uint_t *regs = this->params_;
+    uint_t *mask = regs + bfunc_num_regs_;
+    uint_t *target = mask + n64;
     int_t comp;
-    uint_t j,i64,ibit;
+    uint_t j, i64, ibit;
     bool ret = true;
 
-    for(j=0;j<n64;j++){
-      comp = (this->cregs_[iChunk*n64 + n64-j-1] & mask[n64-j-1]) - target[n64-j-1];
-      if(comp < 0){
-        if(bfunc_ == Operations::RegComparison::Less || bfunc_ == Operations::RegComparison::LessEqual){
+    for (j = 0; j < n64; j++) {
+      comp = (this->cregs_[iChunk * n64 + n64 - j - 1] & mask[n64 - j - 1]) -
+             target[n64 - j - 1];
+      if (comp < 0) {
+        if (bfunc_ == Operations::RegComparison::Less ||
+            bfunc_ == Operations::RegComparison::LessEqual) {
           break;
-        }
-        else if(bfunc_ == Operations::RegComparison::Equal || bfunc_ == Operations::RegComparison::Greater || bfunc_ == Operations::RegComparison::GreaterEqual){
-          ret= false;
+        } else if (bfunc_ == Operations::RegComparison::Equal ||
+                   bfunc_ == Operations::RegComparison::Greater ||
+                   bfunc_ == Operations::RegComparison::GreaterEqual) {
+          ret = false;
           break;
         }
-      }
-      else if(comp > 0){
-        if(bfunc_ == Operations::RegComparison::Greater || bfunc_ == Operations::RegComparison::GreaterEqual){
+      } else if (comp > 0) {
+        if (bfunc_ == Operations::RegComparison::Greater ||
+            bfunc_ == Operations::RegComparison::GreaterEqual) {
           break;
-        }
-        else if(bfunc_ == Operations::RegComparison::Equal || bfunc_ == Operations::RegComparison::Less || bfunc_ == Operations::RegComparison::LessEqual){
-          ret= false;
+        } else if (bfunc_ == Operations::RegComparison::Equal ||
+                   bfunc_ == Operations::RegComparison::Less ||
+                   bfunc_ == Operations::RegComparison::LessEqual) {
+          ret = false;
           break;
         }
-      }
-      else if(bfunc_ == Operations::RegComparison::NotEqual && mask[n64-j-1] != 0){
-        ret= false;
+      } else if (bfunc_ == Operations::RegComparison::NotEqual &&
+                 mask[n64 - j - 1] != 0) {
+        ret = false;
         break;
       }
     }
-    //store result in creg
-    if(ret){
-      for(j=0;j<bfunc_num_regs_;j++){
+    // store result in creg
+    if (ret) {
+      for (j = 0; j < bfunc_num_regs_; j++) {
         i64 = regs[j] >> 6;
         ibit = regs[j] & 63;
-        this->cregs_[iChunk*n64 + i64] |= (1ull << ibit);
+        this->cregs_[iChunk * n64 + i64] |= (1ull << ibit);
       }
-    }
-    else{
-      for(j=0;j<bfunc_num_regs_;j++){
+    } else {
+      for (j = 0; j < bfunc_num_regs_; j++) {
         i64 = regs[j] >> 6;
         ibit = regs[j] & 63;
-        this->cregs_[iChunk*n64 + i64] &= ~(1ull << ibit);
+        this->cregs_[iChunk * n64 + i64] &= ~(1ull << ibit);
       }
     }
   }
 
-  const char* name(void)
-  {
-    return "bfunc_kernel";
-  }
-
+  const char *name(void) { return "bfunc_kernel"; }
 };
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::apply_bfunc(const Operations::Op &op)
-{
-  if(((multi_chunk_distribution_ && chunk_.device() >= 0) || enable_batch_) && chunk_.pos() != 0)
-    return;   //first chunk execute all in batch
+void QubitVectorThrust<data_t>::apply_bfunc(const Operations::Op &op) {
+  if (((multi_chunk_distribution_ && chunk_.device() >= 0) || enable_batch_) &&
+      chunk_.pos() != 0)
+    return; // first chunk execute all in batch
 
   reg_t params;
-  int_t i,n64,n,iparam;
+  int_t i, n64, n, iparam;
 
-  //registers to be updated
-  for(i=0;i<op.registers.size();i++)
+  // registers to be updated
+  for (i = 0; i < op.registers.size(); i++)
     params.push_back(op.registers[i]);
 
-  n64 = (num_creg_bits_ + num_cmem_bits_ + QV_NUM_INTERNAL_REGS + 63) >> 6;   //number of 64-bit integer
+  n64 = (num_creg_bits_ + num_cmem_bits_ + QV_NUM_INTERNAL_REGS + 63) >>
+        6; // number of 64-bit integer
 
-  for(iparam=0;iparam<2;iparam++){
-    uint_t val,added = 0;
+  for (iparam = 0; iparam < 2; iparam++) {
+    uint_t val, added = 0;
     n = op.string_params[iparam].size();
-    for(i=0;i<n-2;i+=16){
+    for (i = 0; i < n - 2; i += 16) {
       std::string tmp;
       tmp = "0x";
-      if(i + 16 > n - 2)
-        tmp += op.string_params[iparam].substr(2,n-2-i);
+      if (i + 16 > n - 2)
+        tmp += op.string_params[iparam].substr(2, n - 2 - i);
       else
-        tmp += op.string_params[iparam].substr(n-i-16,16);
+        tmp += op.string_params[iparam].substr(n - i - 16, 16);
       val = std::stoull(tmp, nullptr, 16);
 
       params.push_back(val);
       added++;
     }
-    for(i=added;i<n64;i++){  //pack 0 if there is not enough values in string_params
+    for (i = added; i < n64;
+         i++) { // pack 0 if there is not enough values in string_params
       val = 0;
       params.push_back(val);
     }
@@ -3326,198 +3225,189 @@ void QubitVectorThrust<data_t>::apply_bfunc(const Operations::Op &op)
 
   chunk_.StoreUintParams(params);
 
-  apply_function(bfunc_kernel<data_t>(op.registers.size(),op.bfunc));
+  apply_function(bfunc_kernel<data_t>(op.registers.size(), op.bfunc));
 
   chunk_.container()->request_creg_update();
 }
 
 template <typename data_t>
-class roerror_kernel : public Chunk::GateFuncBase<data_t>
-{
+class roerror_kernel : public Chunk::GateFuncBase<data_t> {
 protected:
   uint_t num_regs_;
   uint_t num_mems_;
-  double* rnd_buf_;
+  double *rnd_buf_;
+
 public:
-  roerror_kernel(uint_t n,uint_t nr,double* pRnd)
-  {
+  roerror_kernel(uint_t n, uint_t nr, double *pRnd) {
     num_regs_ = nr;
     num_mems_ = n;
     rnd_buf_ = pRnd;
   }
-  bool is_diagonal(void)
-  {
-    return true;
-  }
-  uint_t size(int num_qubits)
-  {
+  bool is_diagonal(void) { return true; }
+  uint_t size(int num_qubits) {
     this->chunk_bits_ = 0;
     return 1;
   }
 
-  //in uint param array: array of qubits results to be stored, mask registers, target registers 
-  __host__ __device__ void operator()(const uint_t &i) const
-  {
+  // in uint param array: array of qubits results to be stored, mask registers,
+  // target registers
+  __host__ __device__ void operator()(const uint_t &i) const {
     uint_t iChunk = i;
     uint_t n64 = (this->num_creg_bits_ + 63) >> 6;
-    uint_t* mems = this->params_;
-    uint_t* probs_offset = mems + num_mems_;
-    double* probs = (double*)this->matrix_;
-    uint_t j,i64,ibit,ip,outcome;
-    double total_prob,p;
+    uint_t *mems = this->params_;
+    uint_t *probs_offset = mems + num_mems_;
+    double *probs = (double *)this->matrix_;
+    uint_t j, i64, ibit, ip, outcome;
+    double total_prob, p;
 
     ip = 0;
-    for(j=0;j<num_mems_;j++){
-      i64 = (mems[j]+num_regs_) >> 6;
-      ibit = (mems[j]+num_regs_) & 63;
-      ip += ( ((this->cregs_[iChunk*n64 + i64] >> ibit) & 1) << j);
+    for (j = 0; j < num_mems_; j++) {
+      i64 = (mems[j] + num_regs_) >> 6;
+      ibit = (mems[j] + num_regs_) & 63;
+      ip += (((this->cregs_[iChunk * n64 + i64] >> ibit) & 1) << j);
     }
 
     total_prob = 0;
-    for(j=probs_offset[ip];j<probs_offset[ip+1];j++){
+    for (j = probs_offset[ip]; j < probs_offset[ip + 1]; j++) {
       total_prob += probs[j];
     }
-    outcome = probs_offset[ip+1];
+    outcome = probs_offset[ip + 1];
     p = 0;
-    for(j=probs_offset[ip];j<probs_offset[ip+1];j++){
+    for (j = probs_offset[ip]; j < probs_offset[ip + 1]; j++) {
       p += probs[j];
-      if(p/total_prob >= rnd_buf_[iChunk]){
+      if (p / total_prob >= rnd_buf_[iChunk]) {
         outcome = j;
         break;
       }
     }
     outcome -= probs_offset[ip];
 
-    for(j=0;j<num_mems_;j++){
-      i64 = (mems[j]+num_regs_) >> 6;
-      ibit = (mems[j]+num_regs_) & 63;
-      this->cregs_[iChunk*n64 + i64] = (this->cregs_[iChunk*n64 + i64] & (~(1ull << ibit)) ) | (((outcome >> j) & 1) << ibit);
+    for (j = 0; j < num_mems_; j++) {
+      i64 = (mems[j] + num_regs_) >> 6;
+      ibit = (mems[j] + num_regs_) & 63;
+      this->cregs_[iChunk * n64 + i64] =
+          (this->cregs_[iChunk * n64 + i64] & (~(1ull << ibit))) |
+          (((outcome >> j) & 1) << ibit);
     }
   }
 
-  const char* name(void)
-  {
-    return "roerror_kernel";
-  }
-
+  const char *name(void) { return "roerror_kernel"; }
 };
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::apply_roerror(const Operations::Op &op, std::vector<RngEngine> &rng)
-{
-  if(((multi_chunk_distribution_ && chunk_.device() >= 0) || enable_batch_) && chunk_.pos() != 0)
-    return;   //first chunk execute all in batch
+void QubitVectorThrust<data_t>::apply_roerror(const Operations::Op &op,
+                                              std::vector<RngEngine> &rng) {
+  if (((multi_chunk_distribution_ && chunk_.device() >= 0) || enable_batch_) &&
+      chunk_.pos() != 0)
+    return; // first chunk execute all in batch
 
   reg_t params;
   std::vector<double> probs;
-  int_t i,j,offset;
+  int_t i, j, offset;
 
-  for(i=0;i<op.memory.size();i++)
+  for (i = 0; i < op.memory.size(); i++)
     params.push_back(op.memory[i]);
 
   offset = 0;
-  for(i=0;i<op.probs.size();i++){
+  for (i = 0; i < op.probs.size(); i++) {
     params.push_back(offset);
     offset += op.probs[i].size();
-    probs.insert(probs.end(),op.probs[i].begin(),op.probs[i].end());
+    probs.insert(probs.end(), op.probs[i].begin(), op.probs[i].end());
   }
   params.push_back(offset);
 
   std::vector<double> r(chunk_.container()->num_chunks());
-  for(i=0;i<chunk_.container()->num_chunks();i++){
+  for (i = 0; i < chunk_.container()->num_chunks(); i++) {
     r[i] = rng[i].rand(0., 1.);
   }
-  chunk_.container()->copy_to_probability_buffer(r,0);
+  chunk_.container()->copy_to_probability_buffer(r, 0);
 
   chunk_.StoreUintParams(params);
-  if((offset & 1) == 1)
+  if ((offset & 1) == 1)
     probs.push_back(0.0);
-  chunk_.StoreMatrix((std::complex<double>*)&probs[0],probs.size()/2);
+  chunk_.StoreMatrix((std::complex<double> *)&probs[0], probs.size() / 2);
 
-  apply_function(roerror_kernel<data_t>(op.memory.size(),num_creg_bits_,chunk_.probability_buffer()));
+  apply_function(roerror_kernel<data_t>(op.memory.size(), num_creg_bits_,
+                                        chunk_.probability_buffer()));
 
   chunk_.container()->request_creg_update();
 }
 
-
 #ifdef AER_DEBUG
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::DebugMsg(const char* str,const reg_t &qubits) const
-{
+void QubitVectorThrust<data_t>::DebugMsg(const char *str,
+                                         const reg_t &qubits) const {
   std::string qstr;
   int iq;
-  for(iq=0;iq<qubits.size();iq++){
+  for (iq = 0; iq < qubits.size(); iq++) {
     qstr += std::to_string(qubits[iq]);
     qstr += ' ';
   }
 
-  spdlog::debug(" [{}] : {} {}, {}",debug_count++,str,qubits.size(),qstr);
+  spdlog::debug(" [{}] : {} {}, {}", debug_count++, str, qubits.size(), qstr);
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::DebugMsg(const char* str,const int qubit) const
-{
-  spdlog::debug(" [{}] : {} {} ",debug_count++,str,qubit);
+void QubitVectorThrust<data_t>::DebugMsg(const char *str,
+                                         const int qubit) const {
+  spdlog::debug(" [{}] : {} {} ", debug_count++, str, qubit);
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::DebugMsg(const char* str) const
-{
-  spdlog::debug(" [{}] : {} ",debug_count++,str);
+void QubitVectorThrust<data_t>::DebugMsg(const char *str) const {
+  spdlog::debug(" [{}] : {} ", debug_count++, str);
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::DebugMsg(const char* str,const std::complex<double> c) const
-{
-  spdlog::debug(" [{0}] {1} : {2:e}, {3:e} ",debug_count++,str,std::real(c),imag(c));
+void QubitVectorThrust<data_t>::DebugMsg(const char *str,
+                                         const std::complex<double> c) const {
+  spdlog::debug(" [{0}] {1} : {2:e}, {3:e} ", debug_count++, str, std::real(c),
+                imag(c));
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::DebugMsg(const char* str,const double d) const
-{
-  spdlog::debug(" [{0}] {1} : {2:e}",debug_count++,str,d);
+void QubitVectorThrust<data_t>::DebugMsg(const char *str,
+                                         const double d) const {
+  spdlog::debug(" [{0}] {1} : {2:e}", debug_count++, str, d);
 }
 
 template <typename data_t>
-void QubitVectorThrust<data_t>::DebugMsg(const char* str,const std::vector<double>& v) const
-{
+void QubitVectorThrust<data_t>::DebugMsg(const char *str,
+                                         const std::vector<double> &v) const {
   std::string vstr;
-  int i,n;
+  int i, n;
   n = v.size();
-  for(i=0;i<n;i++){
+  for (i = 0; i < n; i++) {
     vstr += std::to_string(v[i]);
     vstr += ' ';
   }
 
-  spdlog::debug(" [{}] {} : <{}>",debug_count++,str,vstr);
+  spdlog::debug(" [{}] {} : <{}>", debug_count++, str, vstr);
 }
 
-
 template <typename data_t>
-void QubitVectorThrust<data_t>::DebugDump(void) const
-{
+void QubitVectorThrust<data_t>::DebugDump(void) const {
   thrust::complex<data_t> t;
-  uint_t i,idx,n;
+  uint_t i, idx, n;
 
   chunk_.synchronize();
 
   n = 16;
-  if(n > data_size_)
+  if (n > data_size_)
     n = data_size_;
-  for(i=0;i<n;i++){
-    idx = i*data_size_/n;
+  for (i = 0; i < n; i++) {
+    idx = i * data_size_ / n;
     t = chunk_.Get(idx);
-    spdlog::debug("   {0:05b} | {1:e}, {2:e}",idx,t.real(),t.imag());
+    spdlog::debug("   {0:05b} | {1:e}, {2:e}", idx, t.real(), t.imag());
   }
-  if(n < data_size_){
-    idx = data_size_-1;
+  if (n < data_size_) {
+    idx = data_size_ - 1;
     t = chunk_.Get(idx);
-    spdlog::debug("   {0:05b} | {1:e}, {2:e}",idx,t.real(),t.imag());
+    spdlog::debug("   {0:05b} | {1:e}, {2:e}", idx, t.real(), t.imag());
   }
 }
 
-
 #endif
 
 //------------------------------------------------------------------------------
@@ -3527,7 +3417,8 @@ void QubitVectorThrust<data_t>::DebugDump(void) const
 
 // ostream overload for templated qubitvector
 template <typename data_t>
-inline std::ostream &operator<<(std::ostream &out, const AER::QV::QubitVectorThrust<data_t>&qv) {
+inline std::ostream &operator<<(std::ostream &out,
+                                const AER::QV::QubitVectorThrust<data_t> &qv) {
 
   out << "[";
   size_t last = qv.size() - 1;
diff --git a/src/simulators/statevector/qv_avx2.cpp b/src/simulators/statevector/qv_avx2.cpp
index dfffd75b78..fa81ee0425 100644
--- a/src/simulators/statevector/qv_avx2.cpp
+++ b/src/simulators/statevector/qv_avx2.cpp
@@ -12,12 +12,12 @@
  * that they have been altered from the originals.
  */
 #include "qv_avx2.hpp"
-#include <immintrin.h>
+#include <complex>
 #include <cstdint>
 #include <cstring>
+#include <immintrin.h>
 #include <type_traits>
 #include <utility>
-#include <complex>
 
 #ifdef _OPENMP
 #include <omp.h>
@@ -41,17 +41,14 @@
 namespace {
 
 /** Remember we cannot use STL (or memcpy) **/
-template <typename T, typename U>
-void copy(T dest, const U orig, size_t size) {
+template <typename T, typename U> void copy(T dest, const U orig, size_t size) {
   for (auto i = 0; i < size; ++i)
     dest[i] = orig[i];
 }
 
 template <size_t num_qubits>
-inline void fill_indices(uint64_t index0,
-                         uint64_t* indexes,
-                         const size_t indexes_size,
-                         const uint64_t* qregs) {
+inline void fill_indices(uint64_t index0, uint64_t *indexes,
+                         const size_t indexes_size, const uint64_t *qregs) {
   for (size_t i = 0; i < indexes_size; ++i)
     indexes[i] = index0;
 
@@ -126,9 +123,8 @@ const uint64_t MASKS[] = {0ULL,
                           4611686018427387903ULL,
                           9223372036854775807ULL};
 
-template<size_t num_qubits>
-inline uint64_t index0(const uint64_t* sorted_qubits,
-                       const uint64_t k) {
+template <size_t num_qubits>
+inline uint64_t index0(const uint64_t *sorted_qubits, const uint64_t k) {
   uint64_t lowbits, retval = k;
   for (size_t j = 0; j < num_qubits; j++) {
     lowbits = retval & MASKS[sorted_qubits[j]];
@@ -140,12 +136,9 @@ inline uint64_t index0(const uint64_t* sorted_qubits,
 }
 
 template <size_t num_qubits, typename Lambda, typename param_t>
-void avx_apply_lambda(const uint64_t data_size,
-                      const uint64_t skip,
-                      Lambda&& func,
-                      const uint64_t* sorted_qubits,
-                      const size_t omp_threads,
-                      const param_t& params) {
+void avx_apply_lambda(const uint64_t data_size, const uint64_t skip,
+                      Lambda &&func, const uint64_t *sorted_qubits,
+                      const size_t omp_threads, const param_t &params) {
   const int64_t END = data_size >> num_qubits;
 
 #pragma omp parallel for if (omp_threads > 1) num_threads(omp_threads)
@@ -156,11 +149,9 @@ void avx_apply_lambda(const uint64_t data_size,
 }
 
 template <typename Lambda, typename param_t>
-void avx_apply_lambda(const uint64_t data_size,
-                      const uint64_t skip,
-                      Lambda&& func,
-                      const size_t omp_threads,
-                      const param_t& params) {
+void avx_apply_lambda(const uint64_t data_size, const uint64_t skip,
+                      Lambda &&func, const size_t omp_threads,
+                      const param_t &params) {
 #pragma omp parallel for if (omp_threads > 1) num_threads(omp_threads)
   for (int64_t k = 0; k < data_size; k += skip) {
     std::forward<Lambda>(func)(k, params);
@@ -168,8 +159,8 @@ void avx_apply_lambda(const uint64_t data_size,
 }
 
 template <typename FloatType>
-using m256_t = typename std::
-    conditional<std::is_same<FloatType, double>::value, __m256d, __m256>::type;
+using m256_t = typename std::conditional<std::is_same<FloatType, double>::value,
+                                         __m256d, __m256>::type;
 
 // These Views are helpers for encapsulate access to real and imaginary parts of
 // the original source (QubitVector::data_). SIMD operations requires getting a
@@ -177,113 +168,99 @@ using m256_t = typename std::
 // with memory layout of the form:
 //  [real|imag|real|imag|real|imag|...]
 // we require special indexing to the elements.
-template <typename FloatType>
-struct RealVectorView {
+template <typename FloatType> struct RealVectorView {
   RealVectorView() = delete;
   // Unfortunately, shared_ptr implies allocations and we cannot afford
   // them in this piece of code, so this is the reason to use raw pointers.
-  RealVectorView(FloatType* data) : data_(data) {}
-  inline FloatType* operator[](size_t i) { return &data_[i * 2]; }
-  inline const FloatType* operator[](size_t i) const { return &data_[i * 2]; }
-  FloatType* data_ = nullptr;
+  RealVectorView(FloatType *data) : data_(data) {}
+  inline FloatType *operator[](size_t i) { return &data_[i * 2]; }
+  inline const FloatType *operator[](size_t i) const { return &data_[i * 2]; }
+  FloatType *data_ = nullptr;
 };
 
-template <typename FloatType>
-struct ImaginaryVectorView : std::false_type {};
+template <typename FloatType> struct ImaginaryVectorView : std::false_type {};
 
-template <>
-struct ImaginaryVectorView<double> {
+template <> struct ImaginaryVectorView<double> {
   ImaginaryVectorView() = delete;
-  ImaginaryVectorView(double* data) : data_(data) {}
+  ImaginaryVectorView(double *data) : data_(data) {}
   // SIMD vectorization takes n bytes depending on the underlaying type, so
   // for doubles, SIMD loads 4 consecutive values (4 * sizeof(double) = 32
   // bytes)
-  inline double* operator[](size_t i) { return &data_[i * 2 + 4]; }
-  inline const double* operator[](size_t i) const { return &data_[i * 2 + 4]; }
-  double* data_ = nullptr;
+  inline double *operator[](size_t i) { return &data_[i * 2 + 4]; }
+  inline const double *operator[](size_t i) const { return &data_[i * 2 + 4]; }
+  double *data_ = nullptr;
 };
 
-template <>
-struct ImaginaryVectorView<float> {
+template <> struct ImaginaryVectorView<float> {
   ImaginaryVectorView() = delete;
-  ImaginaryVectorView(float* data) : data_(data) {}
+  ImaginaryVectorView(float *data) : data_(data) {}
   // SIMD vectorization takes n bytes depending on the underlaying type, so
   // for floats, SIMD loads 8 consecutive (8 * sizeof(float) = 32 bytes)
-  inline float* operator[](size_t i) { return &data_[i * 2 + 8]; }
-  inline const float* operator[](size_t i) const { return &data_[i * 2 + 8]; }
-  float* data_ = nullptr;
+  inline float *operator[](size_t i) { return &data_[i * 2 + 8]; }
+  inline const float *operator[](size_t i) const { return &data_[i * 2 + 8]; }
+  float *data_ = nullptr;
 };
 
-static auto _mm256_mul(const m256_t<double>& left,
-                       const m256_t<double>& right) {
+static auto _mm256_mul(const m256_t<double> &left,
+                       const m256_t<double> &right) {
   return _mm256_mul_pd(left, right);
 }
 
-static auto _mm256_mul(const m256_t<float>& left, const m256_t<float>& right) {
+static auto _mm256_mul(const m256_t<float> &left, const m256_t<float> &right) {
   return _mm256_mul_ps(left, right);
 }
 
-static auto _mm256_fnmadd(const m256_t<double>& left,
-                          const m256_t<double>& right,
-                          const m256_t<double>& ret) {
+static auto _mm256_fnmadd(const m256_t<double> &left,
+                          const m256_t<double> &right,
+                          const m256_t<double> &ret) {
   return _mm256_fnmadd_pd(left, right, ret);
 }
 
-static auto _mm256_fnmadd(const m256_t<float>& left,
-                          const m256_t<float>& right,
-                          const m256_t<float>& ret) {
+static auto _mm256_fnmadd(const m256_t<float> &left, const m256_t<float> &right,
+                          const m256_t<float> &ret) {
   return _mm256_fnmadd_ps(left, right, ret);
 }
 
-static auto _mm256_fmadd(const m256_t<double>& left,
-                         const m256_t<double>& right,
-                         const m256_t<double>& ret) {
+static auto _mm256_fmadd(const m256_t<double> &left,
+                         const m256_t<double> &right,
+                         const m256_t<double> &ret) {
   return _mm256_fmadd_pd(left, right, ret);
 }
 
-static auto _mm256_fmadd(const m256_t<float>& left,
-                         const m256_t<float>& right,
-                         const m256_t<float>& ret) {
+static auto _mm256_fmadd(const m256_t<float> &left, const m256_t<float> &right,
+                         const m256_t<float> &ret) {
   return _mm256_fmadd_ps(left, right, ret);
 }
 
-static auto _mm256_set1(double d) {
-  return _mm256_set1_pd(d);
-}
+static auto _mm256_set1(double d) { return _mm256_set1_pd(d); }
 
-static auto _mm256_set1(float f) {
-  return _mm256_set1_ps(f);
-}
+static auto _mm256_set1(float f) { return _mm256_set1_ps(f); }
 
-static auto _mm256_load(double const* d) {
-  return _mm256_load_pd(d);
-}
+static auto _mm256_load(double const *d) { return _mm256_load_pd(d); }
 
-static auto _mm256_load(float const* f) {
-  return _mm256_load_ps(f);
-}
+static auto _mm256_load(float const *f) { return _mm256_load_ps(f); }
 
-static void _mm256_store(float* f, const m256_t<float>& c) {
+static void _mm256_store(float *f, const m256_t<float> &c) {
   _mm256_store_ps(f, c);
 }
 
-static void _mm256_store(double* d, const m256_t<double>& c) {
+static void _mm256_store(double *d, const m256_t<double> &c) {
   _mm256_store_pd(d, c);
 }
 
-static m256_t<double>_mm256_hsub(m256_t<double>& vec1, m256_t<double>& vec2) {
+static m256_t<double> _mm256_hsub(m256_t<double> &vec1, m256_t<double> &vec2) {
   return _mm256_hsub_pd(vec1, vec2);
 }
 
-static m256_t<float> _mm256_hsub(m256_t<float>& vec1, m256_t<float>& vec2) {
+static m256_t<float> _mm256_hsub(m256_t<float> &vec1, m256_t<float> &vec2) {
   return _mm256_hsub_ps(vec1, vec2);
 }
 
-static m256_t<double> _mm256_swith_real_and_imag(m256_t<double>& vec) {
+static m256_t<double> _mm256_swith_real_and_imag(m256_t<double> &vec) {
   return _mm256_permute_pd(vec, 0b0101);
 }
 
-static m256_t<float> _mm256_swith_real_and_imag(m256_t<float>& vec) {
+static m256_t<float> _mm256_swith_real_and_imag(m256_t<float> &vec) {
   return _mm256_permute_ps(vec, _MM_SHUFFLE(2, 3, 0, 1));
 }
 
@@ -295,32 +272,29 @@ static m256_t<float> _mm256_neg(float dummy) {
   return _mm256_setr_ps(1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0);
 }
 
-static m256_t<double> _mm256_align(m256_t<double>& vec) {
-  return vec;
-}
+static m256_t<double> _mm256_align(m256_t<double> &vec) { return vec; }
 
-static m256_t<float> _mm256_align(m256_t<float>& vec) {
+static m256_t<float> _mm256_align(m256_t<float> &vec) {
   return _mm256_permute_ps(vec, _MM_SHUFFLE(3, 1, 2, 0));
 }
 
 template <typename FloatType>
-static inline void _mm_complex_multiply(m256_t<FloatType>& vec1,
-                                        m256_t<FloatType>& vec2) {
+static inline void _mm_complex_multiply(m256_t<FloatType> &vec1,
+                                        m256_t<FloatType> &vec2) {
   m256_t<FloatType> vec3 = _mm256_mul(vec1, vec2);
   vec2 = _mm256_swith_real_and_imag(vec2);
-  vec2 = _mm256_mul(vec2, _mm256_neg((FloatType) .0));
+  vec2 = _mm256_mul(vec2, _mm256_neg((FloatType).0));
   m256_t<FloatType> vec4 = _mm256_mul(vec1, vec2);
   vec1 = _mm256_hsub(vec3, vec4);
   vec1 = _mm256_align(vec1);
 }
 
 template <typename FloatType>
-static inline void _mm_complex_multiply(m256_t<FloatType>& real_ret,
-                                        m256_t<FloatType>& imag_ret,
-                                        m256_t<FloatType>& real_left,
-                                        m256_t<FloatType>& imag_left,
-                                        const m256_t<FloatType>& real_right,
-                                        const m256_t<FloatType>& imag_right) {
+static inline void
+_mm_complex_multiply(m256_t<FloatType> &real_ret, m256_t<FloatType> &imag_ret,
+                     m256_t<FloatType> &real_left, m256_t<FloatType> &imag_left,
+                     const m256_t<FloatType> &real_right,
+                     const m256_t<FloatType> &imag_right) {
   real_ret = _mm256_mul(real_left, real_right);
   imag_ret = _mm256_mul(real_left, imag_right);
   real_ret = _mm256_fnmadd(imag_left, imag_right, real_ret);
@@ -329,12 +303,9 @@ static inline void _mm_complex_multiply(m256_t<FloatType>& real_ret,
 
 template <typename FloatType>
 static inline void _mm_complex_multiply_add(
-    m256_t<FloatType>& real_ret,
-    m256_t<FloatType>& imag_ret,
-    m256_t<FloatType>& real_left,
-    m256_t<FloatType>& imag_left,
-    const m256_t<FloatType>& real_right,
-    const m256_t<FloatType>& imag_right) {
+    m256_t<FloatType> &real_ret, m256_t<FloatType> &imag_ret,
+    m256_t<FloatType> &real_left, m256_t<FloatType> &imag_left,
+    const m256_t<FloatType> &real_right, const m256_t<FloatType> &imag_right) {
   real_ret = _mm256_fmadd(real_left, real_right, real_ret);
   imag_ret = _mm256_fmadd(real_left, imag_right, imag_ret);
   real_ret = _mm256_fnmadd(imag_left, imag_right, real_ret);
@@ -342,14 +313,11 @@ static inline void _mm_complex_multiply_add(
 }
 
 template <typename FloatType>
-static inline void _mm_complex_inner_product(size_t dim,
-                                             m256_t<FloatType> vreals[],
-                                             m256_t<FloatType> vimags[],
-                                             const FloatType* cmplxs,
-                                             m256_t<FloatType>& vret_real,
-                                             m256_t<FloatType>& vret_imag,
-                                             m256_t<FloatType>& vtmp_0,
-                                             m256_t<FloatType>& vtmp_1) {
+static inline void _mm_complex_inner_product(
+    size_t dim, m256_t<FloatType> vreals[], m256_t<FloatType> vimags[],
+    const FloatType *cmplxs, m256_t<FloatType> &vret_real,
+    m256_t<FloatType> &vret_imag, m256_t<FloatType> &vtmp_0,
+    m256_t<FloatType> &vtmp_1) {
   vtmp_0 = _mm256_set1(cmplxs[0]);
   vtmp_1 = _mm256_set1(cmplxs[1]);
   _mm_complex_multiply<FloatType>(vret_real, vret_imag, vreals[0], vimags[0],
@@ -362,10 +330,10 @@ static inline void _mm_complex_inner_product(size_t dim,
   }
 }
 
-static inline void _mm_load_twoarray_complex(const double* real_addr_0,
-                                             const double* imag_addr_1,
-                                             m256_t<double>& real_ret,
-                                             m256_t<double>& imag_ret) {
+static inline void _mm_load_twoarray_complex(const double *real_addr_0,
+                                             const double *imag_addr_1,
+                                             m256_t<double> &real_ret,
+                                             m256_t<double> &imag_ret) {
   real_ret = _mm256_load(real_addr_0);
   imag_ret = _mm256_load(imag_addr_1);
   auto tmp0 = _mm256_permute4x64_pd(real_ret, 2 * 64 + 3 * 16 + 0 * 4 + 1 * 1);
@@ -376,10 +344,10 @@ static inline void _mm_load_twoarray_complex(const double* real_addr_0,
   imag_ret = _mm256_permute4x64_pd(imag_ret, 3 * 64 + 1 * 16 + 2 * 4 + 0 * 1);
 }
 
-static inline void _mm_load_twoarray_complex(const float* real_addr_0,
-                                             const float* imag_addr_1,
-                                             m256_t<float>& real_ret,
-                                             m256_t<float>& imag_ret) {
+static inline void _mm_load_twoarray_complex(const float *real_addr_0,
+                                             const float *imag_addr_1,
+                                             m256_t<float> &real_ret,
+                                             m256_t<float> &imag_ret) {
   real_ret = _mm256_load(real_addr_0);
   imag_ret = _mm256_load(imag_addr_1);
   auto tmp0 = _mm256_permutevar8x32_ps(
@@ -394,10 +362,10 @@ static inline void _mm_load_twoarray_complex(const float* real_addr_0,
                                       _mm256_set_epi32(7, 5, 3, 1, 6, 4, 2, 0));
 }
 
-static inline void _mm_store_twoarray_complex(m256_t<float>& real_ret,
-                                              m256_t<float>& imag_ret,
-                                              float* cmplx_addr_0,
-                                              float* cmplx_addr_1) {
+static inline void _mm_store_twoarray_complex(m256_t<float> &real_ret,
+                                              m256_t<float> &imag_ret,
+                                              float *cmplx_addr_0,
+                                              float *cmplx_addr_1) {
   real_ret = _mm256_permutevar8x32_ps(real_ret,
                                       _mm256_set_epi32(7, 3, 6, 2, 5, 1, 4, 0));
   imag_ret = _mm256_permutevar8x32_ps(imag_ret,
@@ -412,10 +380,10 @@ static inline void _mm_store_twoarray_complex(m256_t<float>& real_ret,
   _mm256_store(cmplx_addr_1, imag_ret);
 }
 
-static inline void _mm_store_twoarray_complex(m256_t<double>& real_ret,
-                                              m256_t<double>& imag_ret,
-                                              double* cmplx_addr_0,
-                                              double* cmplx_addr_1) {
+static inline void _mm_store_twoarray_complex(m256_t<double> &real_ret,
+                                              m256_t<double> &imag_ret,
+                                              double *cmplx_addr_0,
+                                              double *cmplx_addr_1) {
   real_ret = _mm256_permute4x64_pd(real_ret, 3 * 64 + 1 * 16 + 2 * 4 + 0 * 1);
   imag_ret = _mm256_permute4x64_pd(imag_ret, 3 * 64 + 1 * 16 + 2 * 4 + 0 * 1);
   auto tmp0 = _mm256_permute4x64_pd(real_ret, 2 * 64 + 3 * 16 + 0 * 4 + 1 * 1);
@@ -427,10 +395,10 @@ static inline void _mm_store_twoarray_complex(m256_t<double>& real_ret,
 }
 
 template <typename FloatType, size_t num_qubits>
-inline void reorder(const uint64_t* qreg_orig, uint64_t* qreg, FloatType* mat) {
+inline void reorder(const uint64_t *qreg_orig, uint64_t *qreg, FloatType *mat) {
   constexpr auto DIMENSION = (1ULL << num_qubits);
 
-  auto sort = [](uint64_t* unordered, size_t size) {
+  auto sort = [](uint64_t *unordered, size_t size) {
     for (size_t i = 0; i < size; ++i) {
       for (size_t j = 0; j < size - 1 - i; ++j) {
         if (unordered[j] > unordered[j + 1]) {
@@ -443,7 +411,7 @@ inline void reorder(const uint64_t* qreg_orig, uint64_t* qreg, FloatType* mat) {
   };
   sort(qreg, num_qubits);
 
-  auto build_mask = [&](size_t* masks) {
+  auto build_mask = [&](size_t *masks) {
     for (size_t i = 0; i < num_qubits; ++i)
       for (size_t j = 0; j < num_qubits; ++j)
         if (qreg_orig[i] == qreg[j])
@@ -452,7 +420,7 @@ inline void reorder(const uint64_t* qreg_orig, uint64_t* qreg, FloatType* mat) {
   size_t masks[num_qubits];
   build_mask(masks);
 
-  auto build_index = [&](size_t* indexes) {
+  auto build_index = [&](size_t *indexes) {
     for (size_t i = 0; i < DIMENSION; ++i) {
       size_t index = 0U;
       for (size_t j = 0; j < num_qubits; ++j) {
@@ -478,16 +446,16 @@ inline void reorder(const uint64_t* qreg_orig, uint64_t* qreg, FloatType* mat) {
   }
 }
 
-}  // End anonymous namespace
+} // End anonymous namespace
 
 namespace AER {
 namespace QV {
 
 template <size_t num_qubits>
-inline void _apply_matrix_float_avx_q0q1q2(RealVectorView<float>& reals,
-                                           ImaginaryVectorView<float>& imags,
-                                           const float* mat,
-                                           const uint64_t* qregs,
+inline void _apply_matrix_float_avx_q0q1q2(RealVectorView<float> &reals,
+                                           ImaginaryVectorView<float> &imags,
+                                           const float *mat,
+                                           const uint64_t *qregs,
                                            const uint64_t index0) {
   constexpr auto indexes_size = (1ULL << num_qubits);
   uint64_t indexes[1ULL << num_qubits];
@@ -533,34 +501,34 @@ inline void _apply_matrix_float_avx_q0q1q2(RealVectorView<float>& reals,
       imag_ret1 = _mm256_permutevar8x32_ps(imag_ret1, _MASKS[j - 1]);
 
       switch (j) {
-        case 1:
-          real_ret = _mm256_blend_ps(real_ret, real_ret1, 0b00000010);
-          imag_ret = _mm256_blend_ps(imag_ret, imag_ret1, 0b00000010);
-          break;
-        case 2:
-          real_ret = _mm256_blend_ps(real_ret, real_ret1, 0b00000100);
-          imag_ret = _mm256_blend_ps(imag_ret, imag_ret1, 0b00000100);
-          break;
-        case 3:
-          real_ret = _mm256_blend_ps(real_ret, real_ret1, 0b00001000);
-          imag_ret = _mm256_blend_ps(imag_ret, imag_ret1, 0b00001000);
-          break;
-        case 4:
-          real_ret = _mm256_blend_ps(real_ret, real_ret1, 0b00010000);
-          imag_ret = _mm256_blend_ps(imag_ret, imag_ret1, 0b00010000);
-          break;
-        case 5:
-          real_ret = _mm256_blend_ps(real_ret, real_ret1, 0b00100000);
-          imag_ret = _mm256_blend_ps(imag_ret, imag_ret1, 0b00100000);
-          break;
-        case 6:
-          real_ret = _mm256_blend_ps(real_ret, real_ret1, 0b01000000);
-          imag_ret = _mm256_blend_ps(imag_ret, imag_ret1, 0b01000000);
-          break;
-        case 7:
-          real_ret = _mm256_blend_ps(real_ret, real_ret1, 0b10000000);
-          imag_ret = _mm256_blend_ps(imag_ret, imag_ret1, 0b10000000);
-          break;
+      case 1:
+        real_ret = _mm256_blend_ps(real_ret, real_ret1, 0b00000010);
+        imag_ret = _mm256_blend_ps(imag_ret, imag_ret1, 0b00000010);
+        break;
+      case 2:
+        real_ret = _mm256_blend_ps(real_ret, real_ret1, 0b00000100);
+        imag_ret = _mm256_blend_ps(imag_ret, imag_ret1, 0b00000100);
+        break;
+      case 3:
+        real_ret = _mm256_blend_ps(real_ret, real_ret1, 0b00001000);
+        imag_ret = _mm256_blend_ps(imag_ret, imag_ret1, 0b00001000);
+        break;
+      case 4:
+        real_ret = _mm256_blend_ps(real_ret, real_ret1, 0b00010000);
+        imag_ret = _mm256_blend_ps(imag_ret, imag_ret1, 0b00010000);
+        break;
+      case 5:
+        real_ret = _mm256_blend_ps(real_ret, real_ret1, 0b00100000);
+        imag_ret = _mm256_blend_ps(imag_ret, imag_ret1, 0b00100000);
+        break;
+      case 6:
+        real_ret = _mm256_blend_ps(real_ret, real_ret1, 0b01000000);
+        imag_ret = _mm256_blend_ps(imag_ret, imag_ret1, 0b01000000);
+        break;
+      case 7:
+        real_ret = _mm256_blend_ps(real_ret, real_ret1, 0b10000000);
+        imag_ret = _mm256_blend_ps(imag_ret, imag_ret1, 0b10000000);
+        break;
       }
     }
     _mm_store_twoarray_complex(real_ret, imag_ret, reals[index], imags[index]);
@@ -568,10 +536,10 @@ inline void _apply_matrix_float_avx_q0q1q2(RealVectorView<float>& reals,
 }
 
 template <size_t num_qubits>
-inline void _apply_matrix_float_avx_qLqL(RealVectorView<float>& reals,
-                                         ImaginaryVectorView<float>& imags,
-                                         const float* mat,
-                                         const uint64_t* qregs,
+inline void _apply_matrix_float_avx_qLqL(RealVectorView<float> &reals,
+                                         ImaginaryVectorView<float> &imags,
+                                         const float *mat,
+                                         const uint64_t *qregs,
                                          const uint64_t index0) {
   __m256i masks[3];
   __m256 real_ret, imag_ret, real_ret1, imag_ret1;
@@ -590,7 +558,7 @@ inline void _apply_matrix_float_avx_qLqL(RealVectorView<float>& reals,
     masks[0] = _mm256_set_epi32(7, 6, 5, 4, 2, 3, 0, 1);
     masks[1] = _mm256_set_epi32(7, 2, 5, 0, 3, 6, 1, 4);
     masks[2] = _mm256_set_epi32(2, 6, 0, 4, 3, 7, 1, 5);
-  } else {  // if (q0 == 1 && q1 == 2) {
+  } else { // if (q0 == 1 && q1 == 2) {
     masks[0] = _mm256_set_epi32(7, 6, 5, 4, 1, 0, 3, 2);
     masks[1] = _mm256_set_epi32(7, 6, 1, 0, 3, 2, 5, 4);
     masks[2] = _mm256_set_epi32(1, 0, 5, 4, 3, 2, 7, 6);
@@ -624,60 +592,60 @@ inline void _apply_matrix_float_avx_qLqL(RealVectorView<float>& reals,
       imag_ret1 = _mm256_permutevar8x32_ps(imag_ret1, masks[j]);
 
       switch (j) {
-        case 0:
-          real_ret = (qregs[1] == 1)
-                         ? _mm256_blend_ps(real_ret, real_ret1, 0b00100010)
-                         :  // (0,1)
-                         (qregs[0] == 0)
-                             ? _mm256_blend_ps(real_ret, real_ret1, 0b00001010)
-                             :  // (0,2)
-                             _mm256_blend_ps(real_ret, real_ret1,
-                                             0b00001100);  //  (1,2)
-          imag_ret = (qregs[1] == 1)
-                         ? _mm256_blend_ps(imag_ret, imag_ret1, 0b00100010)
-                         :  // (0,1)
-                         (qregs[0] == 0)
-                             ? _mm256_blend_ps(imag_ret, imag_ret1, 0b00001010)
-                             :  // (0,2)
-                             _mm256_blend_ps(imag_ret, imag_ret1,
-                                             0b00001100);  //  (1,2)
-          break;
-        case 1:
-          real_ret = (qregs[1] == 1)
-                         ? _mm256_blend_ps(real_ret, real_ret1, 0b01000100)
-                         :  // (0,1)
-                         (qregs[0] == 0)
-                             ? _mm256_blend_ps(real_ret, real_ret1, 0b01010000)
-                             :  // (0,2)
-                             _mm256_blend_ps(real_ret, real_ret1,
-                                             0b00110000);  //   (1,2)
-          imag_ret = (qregs[1] == 1)
-                         ? _mm256_blend_ps(imag_ret, imag_ret1, 0b01000100)
-                         :  // (0,1)
-                         (qregs[0] == 0)
-                             ? _mm256_blend_ps(imag_ret, imag_ret1, 0b01010000)
-                             :  // (0,2)
-                             _mm256_blend_ps(imag_ret, imag_ret1,
-                                             0b00110000);  //   (1,2)
-          break;
-        case 2:
-          real_ret = (qregs[1] == 1)
-                         ? _mm256_blend_ps(real_ret, real_ret1, 0b10001000)
-                         :  // (0,1)
-                         (qregs[0] == 0)
-                             ? _mm256_blend_ps(real_ret, real_ret1, 0b10100000)
-                             :  // (0,2)
-                             _mm256_blend_ps(real_ret, real_ret1,
-                                             0b11000000);  //  (1,2)
-          imag_ret = (qregs[1] == 1)
-                         ? _mm256_blend_ps(imag_ret, imag_ret1, 0b10001000)
-                         :  // (0,1)
-                         (qregs[0] == 0)
-                             ? _mm256_blend_ps(imag_ret, imag_ret1, 0b10100000)
-                             :  // (0,2)
-                             _mm256_blend_ps(imag_ret, imag_ret1,
-                                             0b11000000);  //  (1,2)
-          break;
+      case 0:
+        real_ret = (qregs[1] == 1)
+                       ? _mm256_blend_ps(real_ret, real_ret1, 0b00100010)
+                       : // (0,1)
+                       (qregs[0] == 0)
+                       ? _mm256_blend_ps(real_ret, real_ret1, 0b00001010)
+                       : // (0,2)
+                       _mm256_blend_ps(real_ret, real_ret1,
+                                       0b00001100); //  (1,2)
+        imag_ret = (qregs[1] == 1)
+                       ? _mm256_blend_ps(imag_ret, imag_ret1, 0b00100010)
+                       : // (0,1)
+                       (qregs[0] == 0)
+                       ? _mm256_blend_ps(imag_ret, imag_ret1, 0b00001010)
+                       : // (0,2)
+                       _mm256_blend_ps(imag_ret, imag_ret1,
+                                       0b00001100); //  (1,2)
+        break;
+      case 1:
+        real_ret = (qregs[1] == 1)
+                       ? _mm256_blend_ps(real_ret, real_ret1, 0b01000100)
+                       : // (0,1)
+                       (qregs[0] == 0)
+                       ? _mm256_blend_ps(real_ret, real_ret1, 0b01010000)
+                       : // (0,2)
+                       _mm256_blend_ps(real_ret, real_ret1,
+                                       0b00110000); //   (1,2)
+        imag_ret = (qregs[1] == 1)
+                       ? _mm256_blend_ps(imag_ret, imag_ret1, 0b01000100)
+                       : // (0,1)
+                       (qregs[0] == 0)
+                       ? _mm256_blend_ps(imag_ret, imag_ret1, 0b01010000)
+                       : // (0,2)
+                       _mm256_blend_ps(imag_ret, imag_ret1,
+                                       0b00110000); //   (1,2)
+        break;
+      case 2:
+        real_ret = (qregs[1] == 1)
+                       ? _mm256_blend_ps(real_ret, real_ret1, 0b10001000)
+                       : // (0,1)
+                       (qregs[0] == 0)
+                       ? _mm256_blend_ps(real_ret, real_ret1, 0b10100000)
+                       : // (0,2)
+                       _mm256_blend_ps(real_ret, real_ret1,
+                                       0b11000000); //  (1,2)
+        imag_ret = (qregs[1] == 1)
+                       ? _mm256_blend_ps(imag_ret, imag_ret1, 0b10001000)
+                       : // (0,1)
+                       (qregs[0] == 0)
+                       ? _mm256_blend_ps(imag_ret, imag_ret1, 0b10100000)
+                       : // (0,2)
+                       _mm256_blend_ps(imag_ret, imag_ret1,
+                                       0b11000000); //  (1,2)
+        break;
       }
     }
     _mm_store_twoarray_complex(real_ret, imag_ret, reals[index], imags[index]);
@@ -685,10 +653,9 @@ inline void _apply_matrix_float_avx_qLqL(RealVectorView<float>& reals,
 }
 
 template <size_t num_qubits>
-inline void _apply_matrix_float_avx_qL(RealVectorView<float>& reals,
-                                       ImaginaryVectorView<float>& imags,
-                                       const float* mat,
-                                       const uint64_t* qregs,
+inline void _apply_matrix_float_avx_qL(RealVectorView<float> &reals,
+                                       ImaginaryVectorView<float> &imags,
+                                       const float *mat, const uint64_t *qregs,
                                        const uint64_t index0) {
   __m256i mask;
   __m256 real_ret, imag_ret, real_ret1, imag_ret1;
@@ -703,7 +670,7 @@ inline void _apply_matrix_float_avx_qL(RealVectorView<float>& reals,
     mask = _mm256_set_epi32(6, 7, 4, 5, 2, 3, 0, 1);
   } else if (qregs[0] == 1) {
     mask = _mm256_set_epi32(5, 4, 7, 6, 1, 0, 3, 2);
-  } else {  // if (q0 == 2) {
+  } else { // if (q0 == 2) {
     mask = _mm256_set_epi32(3, 2, 1, 0, 7, 6, 5, 4);
   }
 
@@ -733,26 +700,25 @@ inline void _apply_matrix_float_avx_qL(RealVectorView<float>& reals,
 
     real_ret =
         (qregs[0] == 0) ? _mm256_blend_ps(real_ret, real_ret1, 0b10101010)
-                        :  // (0,H,H)
+                        : // (0,H,H)
             (qregs[0] == 1) ? _mm256_blend_ps(real_ret, real_ret1, 0b11001100)
-                            :                                      // (1,H,H)
-                _mm256_blend_ps(real_ret, real_ret1, 0b11110000);  //  (2,H,H)
+                            :                                 // (1,H,H)
+            _mm256_blend_ps(real_ret, real_ret1, 0b11110000); //  (2,H,H)
     imag_ret =
         (qregs[0] == 0) ? _mm256_blend_ps(imag_ret, imag_ret1, 0b10101010)
-                        :  // (0,H,H)
+                        : // (0,H,H)
             (qregs[0] == 1) ? _mm256_blend_ps(imag_ret, imag_ret1, 0b11001100)
-                            :                                      // (1,H,H)
-                _mm256_blend_ps(imag_ret, imag_ret1, 0b11110000);  //  (2,H,H)
+                            :                                 // (1,H,H)
+            _mm256_blend_ps(imag_ret, imag_ret1, 0b11110000); //  (2,H,H)
 
     _mm_store_twoarray_complex(real_ret, imag_ret, reals[index], imags[index]);
   }
 }
 
 template <size_t num_qubits>
-inline void _apply_matrix_float_avx(RealVectorView<float>& reals,
-                                    ImaginaryVectorView<float>& imags,
-                                    const float* mat,
-                                    const uint64_t* qregs,
+inline void _apply_matrix_float_avx(RealVectorView<float> &reals,
+                                    ImaginaryVectorView<float> &imags,
+                                    const float *mat, const uint64_t *qregs,
                                     const uint64_t index0) {
   __m256 real_ret, imag_ret;
   __m256 vreals[1ULL << num_qubits], vimags[1ULL << num_qubits];
@@ -779,10 +745,10 @@ inline void _apply_matrix_float_avx(RealVectorView<float>& reals,
 }
 
 template <size_t num_qubits>
-inline void _apply_matrix_double_avx_q0q1(RealVectorView<double>& reals,
-                                          ImaginaryVectorView<double>& imags,
-                                          const double* mat,
-                                          const uint64_t* qregs,
+inline void _apply_matrix_double_avx_q0q1(RealVectorView<double> &reals,
+                                          ImaginaryVectorView<double> &imags,
+                                          const double *mat,
+                                          const uint64_t *qregs,
                                           const uint64_t index0) {
   const int PERM_D_Q0Q1_0 = 3 * 64 + 2 * 16 + 0 * 4 + 1 * 1;
   const int PERM_D_Q0Q1_1 = 3 * 64 + 0 * 16 + 1 * 4 + 2 * 1;
@@ -801,18 +767,18 @@ inline void _apply_matrix_double_avx_q0q1(RealVectorView<double>& reals,
     _mm_load_twoarray_complex(reals[index], imags[index], vreals[i], vimags[i]);
     for (size_t j = 1; j < 4; ++j) {
       switch (j) {
-        case 1:
-          vreals[i + j] = _mm256_permute4x64_pd(vreals[i], PERM_D_Q0Q1_0);
-          vimags[i + j] = _mm256_permute4x64_pd(vimags[i], PERM_D_Q0Q1_0);
-          break;
-        case 2:
-          vreals[i + j] = _mm256_permute4x64_pd(vreals[i], PERM_D_Q0Q1_1);
-          vimags[i + j] = _mm256_permute4x64_pd(vimags[i], PERM_D_Q0Q1_1);
-          break;
-        case 3:
-          vreals[i + j] = _mm256_permute4x64_pd(vreals[i], PERM_D_Q0Q1_2);
-          vimags[i + j] = _mm256_permute4x64_pd(vimags[i], PERM_D_Q0Q1_2);
-          break;
+      case 1:
+        vreals[i + j] = _mm256_permute4x64_pd(vreals[i], PERM_D_Q0Q1_0);
+        vimags[i + j] = _mm256_permute4x64_pd(vimags[i], PERM_D_Q0Q1_0);
+        break;
+      case 2:
+        vreals[i + j] = _mm256_permute4x64_pd(vreals[i], PERM_D_Q0Q1_1);
+        vimags[i + j] = _mm256_permute4x64_pd(vimags[i], PERM_D_Q0Q1_1);
+        break;
+      case 3:
+        vreals[i + j] = _mm256_permute4x64_pd(vreals[i], PERM_D_Q0Q1_2);
+        vimags[i + j] = _mm256_permute4x64_pd(vimags[i], PERM_D_Q0Q1_2);
+        break;
       }
     }
   }
@@ -830,24 +796,24 @@ inline void _apply_matrix_double_avx_q0q1(RealVectorView<double>& reals,
                                         tmp0, tmp1);
       mindex += (1ULL << (num_qubits + 1));
       switch (j) {
-        case 1:
-          real_ret1 = _mm256_permute4x64_pd(real_ret1, PERM_D_Q0Q1_0);
-          imag_ret1 = _mm256_permute4x64_pd(imag_ret1, PERM_D_Q0Q1_0);
-          real_ret = _mm256_blend_pd(real_ret, real_ret1, 0b0010);
-          imag_ret = _mm256_blend_pd(imag_ret, imag_ret1, 0b0010);
-          break;
-        case 2:
-          real_ret1 = _mm256_permute4x64_pd(real_ret1, PERM_D_Q0Q1_1);
-          imag_ret1 = _mm256_permute4x64_pd(imag_ret1, PERM_D_Q0Q1_1);
-          real_ret = _mm256_blend_pd(real_ret, real_ret1, 0b0100);
-          imag_ret = _mm256_blend_pd(imag_ret, imag_ret1, 0b0100);
-          break;
-        case 3:
-          real_ret1 = _mm256_permute4x64_pd(real_ret1, PERM_D_Q0Q1_2);
-          imag_ret1 = _mm256_permute4x64_pd(imag_ret1, PERM_D_Q0Q1_2);
-          real_ret = _mm256_blend_pd(real_ret, real_ret1, 0b1000);
-          imag_ret = _mm256_blend_pd(imag_ret, imag_ret1, 0b1000);
-          break;
+      case 1:
+        real_ret1 = _mm256_permute4x64_pd(real_ret1, PERM_D_Q0Q1_0);
+        imag_ret1 = _mm256_permute4x64_pd(imag_ret1, PERM_D_Q0Q1_0);
+        real_ret = _mm256_blend_pd(real_ret, real_ret1, 0b0010);
+        imag_ret = _mm256_blend_pd(imag_ret, imag_ret1, 0b0010);
+        break;
+      case 2:
+        real_ret1 = _mm256_permute4x64_pd(real_ret1, PERM_D_Q0Q1_1);
+        imag_ret1 = _mm256_permute4x64_pd(imag_ret1, PERM_D_Q0Q1_1);
+        real_ret = _mm256_blend_pd(real_ret, real_ret1, 0b0100);
+        imag_ret = _mm256_blend_pd(imag_ret, imag_ret1, 0b0100);
+        break;
+      case 3:
+        real_ret1 = _mm256_permute4x64_pd(real_ret1, PERM_D_Q0Q1_2);
+        imag_ret1 = _mm256_permute4x64_pd(imag_ret1, PERM_D_Q0Q1_2);
+        real_ret = _mm256_blend_pd(real_ret, real_ret1, 0b1000);
+        imag_ret = _mm256_blend_pd(imag_ret, imag_ret1, 0b1000);
+        break;
       }
     }
     _mm_store_twoarray_complex(real_ret, imag_ret, reals[index], imags[index]);
@@ -855,10 +821,10 @@ inline void _apply_matrix_double_avx_q0q1(RealVectorView<double>& reals,
 }
 
 template <size_t num_qubits>
-inline void _apply_matrix_double_avx_qL(RealVectorView<double>& reals,
-                                        ImaginaryVectorView<double>& imags,
-                                        const double* mat,
-                                        const uint64_t* qregs,
+inline void _apply_matrix_double_avx_qL(RealVectorView<double> &reals,
+                                        ImaginaryVectorView<double> &imags,
+                                        const double *mat,
+                                        const uint64_t *qregs,
                                         const uint64_t index0) {
   const int PERM_D_Q0 = 2 * 64 + 3 * 16 + 0 * 4 + 1 * 1;
   const int PERM_D_Q1 = 1 * 64 + 0 * 16 + 3 * 4 + 2 * 1;
@@ -912,10 +878,9 @@ inline void _apply_matrix_double_avx_qL(RealVectorView<double>& reals,
 }
 
 template <size_t num_qubits>
-inline void _apply_matrix_double_avx(RealVectorView<double>& reals,
-                                     ImaginaryVectorView<double>& imags,
-                                     const double* mat,
-                                     const uint64_t* qregs,
+inline void _apply_matrix_double_avx(RealVectorView<double> &reals,
+                                     ImaginaryVectorView<double> &imags,
+                                     const double *mat, const uint64_t *qregs,
                                      const uint64_t index0) {
   __m256d real_ret, imag_ret;
   __m256d vreals[1ULL << num_qubits], vimags[1ULL << num_qubits];
@@ -942,37 +907,35 @@ inline void _apply_matrix_double_avx(RealVectorView<double>& reals,
 }
 
 template <size_t num_qubits>
-inline Avx _apply_avx_kernel(const uint64_t* qregs,
-                             float* data,
-                             const uint64_t data_size,
-                             const float* mat,
+inline Avx _apply_avx_kernel(const uint64_t *qregs, float *data,
+                             const uint64_t data_size, const float *mat,
                              const size_t omp_threads) {
   RealVectorView<float> real = {data};
   ImaginaryVectorView<float> img = {data};
 
   if (num_qubits > 2 && qregs[2] == 2) {
-    auto lambda = [&](const uint64_t index0, const float* m) -> void {
+    auto lambda = [&](const uint64_t index0, const float *m) -> void {
       _apply_matrix_float_avx_q0q1q2<num_qubits>(real, img, m, qregs, index0);
     };
 
     avx_apply_lambda<num_qubits>(data_size, 1, lambda, qregs, omp_threads, mat);
 
   } else if (num_qubits > 1 && qregs[1] < 3) {
-    auto lambda = [&](const uint64_t index0, const float* m) -> void {
+    auto lambda = [&](const uint64_t index0, const float *m) -> void {
       _apply_matrix_float_avx_qLqL<num_qubits>(real, img, m, qregs, index0);
     };
 
     avx_apply_lambda<num_qubits>(data_size, 2, lambda, qregs, omp_threads, mat);
 
   } else if (qregs[0] < 3) {
-    auto lambda = [&](const uint64_t index0, const float* m) -> void {
+    auto lambda = [&](const uint64_t index0, const float *m) -> void {
       _apply_matrix_float_avx_qL<num_qubits>(real, img, m, qregs, index0);
     };
 
     avx_apply_lambda<num_qubits>(data_size, 4, lambda, qregs, omp_threads, mat);
 
   } else {
-    auto lambda = [&](const uint64_t index0, const float* m) -> void {
+    auto lambda = [&](const uint64_t index0, const float *m) -> void {
       _apply_matrix_float_avx<num_qubits>(real, img, m, qregs, index0);
     };
 
@@ -982,30 +945,28 @@ inline Avx _apply_avx_kernel(const uint64_t* qregs,
 }
 
 template <size_t num_qubits>
-inline Avx _apply_avx_kernel(const uint64_t* qregs,
-                             double* data,
-                             const size_t data_size,
-                             const double* mat,
+inline Avx _apply_avx_kernel(const uint64_t *qregs, double *data,
+                             const size_t data_size, const double *mat,
                              const size_t omp_threads) {
   RealVectorView<double> real = {data};
   ImaginaryVectorView<double> img = {data};
 
   if (num_qubits > 1 && qregs[1] == 1) {
-    auto lambda = [&](const uint64_t index0, const double* m) -> void {
+    auto lambda = [&](const uint64_t index0, const double *m) -> void {
       _apply_matrix_double_avx_q0q1<num_qubits>(real, img, m, qregs, index0);
     };
 
     avx_apply_lambda<num_qubits>(data_size, 1, lambda, qregs, omp_threads, mat);
 
   } else if (qregs[0] < 2) {
-    auto lambda = [&](const uint64_t index0, const double* m) -> void {
+    auto lambda = [&](const uint64_t index0, const double *m) -> void {
       _apply_matrix_double_avx_qL<num_qubits>(real, img, m, qregs, index0);
     };
 
     avx_apply_lambda<num_qubits>(data_size, 2, lambda, qregs, omp_threads, mat);
 
   } else {
-    auto lambda = [&](const uint64_t index0, const double* m) -> void {
+    auto lambda = [&](const uint64_t index0, const double *m) -> void {
       _apply_matrix_double_avx<num_qubits>(real, img, m, qregs, index0);
     };
 
@@ -1031,15 +992,13 @@ is_simd_applicable(uint64_t data_size) {
 }
 
 template <typename FloatType, size_t num_qubits>
-inline Avx apply_matrix_avx(FloatType* data,
-                            const uint64_t data_size,
-                            const uint64_t* qregs,
-                            const FloatType* mat,
+inline Avx apply_matrix_avx(FloatType *data, const uint64_t data_size,
+                            const uint64_t *qregs, const FloatType *mat,
                             const size_t omp_threads) {
   if (!is_simd_applicable<FloatType>(data_size))
     return Avx::NotApplied;
 
-  auto transpose = [](const FloatType* matrix, FloatType* transposed) {
+  auto transpose = [](const FloatType *matrix, FloatType *transposed) {
     for (size_t i = 0; i < (1U << num_qubits); ++i) {
       for (size_t j = 0; j < (1U << num_qubits); ++j) {
         // This is for accessing the real part of the vector of complex numbers,
@@ -1068,82 +1027,72 @@ inline Avx apply_matrix_avx(FloatType* data,
 }
 
 template <typename FloatType>
-Avx apply_matrix_avx(FloatType* qv_data,
-                     const uint64_t data_size,
-                     const uint64_t* qregs,
-                     const size_t qregs_size,
-                     const FloatType* mat,
-                     const size_t omp_threads) {
+Avx apply_matrix_avx(FloatType *qv_data, const uint64_t data_size,
+                     const uint64_t *qregs, const size_t qregs_size,
+                     const FloatType *mat, const size_t omp_threads) {
   switch (qregs_size) {
-    case 1:
-      return apply_matrix_avx<FloatType, 1>(qv_data, data_size, qregs, mat,
-                                            omp_threads);
-    case 2:
-      return apply_matrix_avx<FloatType, 2>(qv_data, data_size, qregs, mat,
-                                            omp_threads);
-    case 3:
-      return apply_matrix_avx<FloatType, 3>(qv_data, data_size, qregs, mat,
-                                            omp_threads);
-    case 4:
-      return apply_matrix_avx<FloatType, 4>(qv_data, data_size, qregs, mat,
-                                            omp_threads);
-    case 5:
-      return apply_matrix_avx<FloatType, 5>(qv_data, data_size, qregs, mat,
-                                            omp_threads);
-    case 6:
-      return apply_matrix_avx<FloatType, 6>(qv_data, data_size, qregs, mat,
-                                            omp_threads);
-    default:
-      return Avx::NotApplied;
+  case 1:
+    return apply_matrix_avx<FloatType, 1>(qv_data, data_size, qregs, mat,
+                                          omp_threads);
+  case 2:
+    return apply_matrix_avx<FloatType, 2>(qv_data, data_size, qregs, mat,
+                                          omp_threads);
+  case 3:
+    return apply_matrix_avx<FloatType, 3>(qv_data, data_size, qregs, mat,
+                                          omp_threads);
+  case 4:
+    return apply_matrix_avx<FloatType, 4>(qv_data, data_size, qregs, mat,
+                                          omp_threads);
+  case 5:
+    return apply_matrix_avx<FloatType, 5>(qv_data, data_size, qregs, mat,
+                                          omp_threads);
+  case 6:
+    return apply_matrix_avx<FloatType, 6>(qv_data, data_size, qregs, mat,
+                                          omp_threads);
+  default:
+    return Avx::NotApplied;
   }
 }
 
-template Avx apply_matrix_avx<double>(double*,
-                                      const uint64_t data_size,
-                                      const uint64_t* qregs,
+template Avx apply_matrix_avx<double>(double *, const uint64_t data_size,
+                                      const uint64_t *qregs,
                                       const size_t qregs_size,
-                                      const double* mat,
+                                      const double *mat,
                                       const size_t omp_threads);
 
-template Avx apply_matrix_avx<float>(float* data,
-                                     const uint64_t data_size,
-                                     const uint64_t* qregs,
-                                     const size_t qregs_size,
-                                     const float* mat,
+template Avx apply_matrix_avx<float>(float *data, const uint64_t data_size,
+                                     const uint64_t *qregs,
+                                     const size_t qregs_size, const float *mat,
                                      const size_t omp_threads);
 
-template <typename data_t>
-std::complex<data_t>* _to_complex(data_t* vec) {
-  return reinterpret_cast<std::complex<data_t>*>(vec);
+template <typename data_t> std::complex<data_t> *_to_complex(data_t *vec) {
+  return reinterpret_cast<std::complex<data_t> *>(vec);
 }
 
 template <typename data_t>
-const std::complex<data_t>* _to_complex(const data_t* vec) {
-  return reinterpret_cast<const std::complex<data_t>*>(vec);
+const std::complex<data_t> *_to_complex(const data_t *vec) {
+  return reinterpret_cast<const std::complex<data_t> *>(vec);
 }
 
-static m256_t<double> _load_diagonal_input(const std::complex<double>* input_vec,
-                                           std::complex<double>* tmp,
-                                           const uint64_t i,
-                                           const uint64_t* qregs,
-                                           const size_t qregs_size,
-                                           const size_t q0_mask) {
+static m256_t<double>
+_load_diagonal_input(const std::complex<double> *input_vec,
+                     std::complex<double> *tmp, const uint64_t i,
+                     const uint64_t *qregs, const size_t qregs_size,
+                     const size_t q0_mask) {
   uint64_t vec_idx0 = 0;
   for (size_t j = 0; j < qregs_size; ++j)
     if (i & (MASKS[qregs[j]] + 1UL))
       vec_idx0 += (MASKS[j] + 1UL);
   tmp[0] = input_vec[vec_idx0];
   tmp[1] = input_vec[vec_idx0 | q0_mask];
-  return _mm256_load(reinterpret_cast<double*>(tmp));
+  return _mm256_load(reinterpret_cast<double *>(tmp));
 }
 
-static m256_t<float> _load_diagonal_input(const std::complex<float>* input_vec,
-                                          std::complex<float>* tmp,
-                                          const uint64_t i,
-                                          const uint64_t* qregs,
-                                          const size_t qregs_size,
-                                          const size_t q0_mask,
-                                          const size_t q1_mask) {
+static m256_t<float>
+_load_diagonal_input(const std::complex<float> *input_vec,
+                     std::complex<float> *tmp, const uint64_t i,
+                     const uint64_t *qregs, const size_t qregs_size,
+                     const size_t q0_mask, const size_t q1_mask) {
   uint64_t vec_idx0 = 0;
   for (size_t j = 0; j < qregs_size; ++j)
     if (i & (MASKS[qregs[j]] + 1UL))
@@ -1152,16 +1101,13 @@ static m256_t<float> _load_diagonal_input(const std::complex<float>* input_vec,
   tmp[1] = input_vec[vec_idx0 | q0_mask];
   tmp[2] = input_vec[vec_idx0 | q1_mask];
   tmp[3] = input_vec[vec_idx0 | q0_mask | q1_mask];
-  return _mm256_load(reinterpret_cast<float*>(tmp));
+  return _mm256_load(reinterpret_cast<float *>(tmp));
 }
 
 template <>
-Avx apply_diagonal_matrix_avx<double>(double* qv_data_,
-                                      const uint64_t data_size,
-                                      const uint64_t* qregs,
-                                      const size_t qregs_size,
-                                      const double* vec_,
-                                      const size_t omp_threads) {
+Avx apply_diagonal_matrix_avx<double>(
+    double *qv_data_, const uint64_t data_size, const uint64_t *qregs,
+    const size_t qregs_size, const double *vec_, const size_t omp_threads) {
 
   auto qv_data = _to_complex(qv_data_);
   const auto input_vec = _to_complex(vec_);
@@ -1171,37 +1117,40 @@ Avx apply_diagonal_matrix_avx<double>(double* qv_data_,
   {
 #endif
 #if !defined(_WIN64) && !defined(_WIN32)
-  void* data = nullptr;
-  posix_memalign(&data, 64, sizeof(std::complex<double>) * 2);
-  auto double_tmp = reinterpret_cast<std::complex<double>*>(data);
+    void *data = nullptr;
+    posix_memalign(&data, 64, sizeof(std::complex<double>) * 2);
+    auto double_tmp = reinterpret_cast<std::complex<double> *>(data);
 #else
-  auto double_tmp = reinterpret_cast<std::complex<double>*>(malloc(sizeof(std::complex<double>) * 2));
+  auto double_tmp = reinterpret_cast<std::complex<double> *>(
+      malloc(sizeof(std::complex<double>) * 2));
 #endif
 
-  size_t q0_mask_ = 0;
-  for (int i = 0; i < qregs_size; ++i) {
-    if (qregs[i] == 0) {
-      q0_mask_ = 1UL << i;
-      break;
+    size_t q0_mask_ = 0;
+    for (int i = 0; i < qregs_size; ++i) {
+      if (qregs[i] == 0) {
+        q0_mask_ = 1UL << i;
+        break;
+      }
     }
-  }
 
-  const size_t q0_mask = q0_mask_;
-  const auto batch = (data_size <= (1UL << 5) ? 0 : 4);
-  const int64_t END = data_size >> (batch + 1);
-
-  #pragma omp for
-  for (int64_t k = 0; k < END; k += 1) {
-    const auto base = k << (batch + 1);
-    const auto until = base + (1UL << (batch + 1));
-    for (auto i = base; i < until; i+=2) {
-      auto tgt_qv_data = _mm256_load(reinterpret_cast<double*>(&(qv_data[i])));
-      auto input_data = _load_diagonal_input(input_vec, double_tmp, i, qregs, qregs_size, q0_mask);
-      _mm_complex_multiply<double>(tgt_qv_data, input_data);
-      _mm256_store(reinterpret_cast<double*>(&(qv_data[i])), tgt_qv_data);
+    const size_t q0_mask = q0_mask_;
+    const auto batch = (data_size <= (1UL << 5) ? 0 : 4);
+    const int64_t END = data_size >> (batch + 1);
+
+#pragma omp for
+    for (int64_t k = 0; k < END; k += 1) {
+      const auto base = k << (batch + 1);
+      const auto until = base + (1UL << (batch + 1));
+      for (auto i = base; i < until; i += 2) {
+        auto tgt_qv_data =
+            _mm256_load(reinterpret_cast<double *>(&(qv_data[i])));
+        auto input_data = _load_diagonal_input(input_vec, double_tmp, i, qregs,
+                                               qregs_size, q0_mask);
+        _mm_complex_multiply<double>(tgt_qv_data, input_data);
+        _mm256_store(reinterpret_cast<double *>(&(qv_data[i])), tgt_qv_data);
+      }
     }
-  }
-  free(double_tmp);
+    free(double_tmp);
 #if defined(_OPENMP)
   }
 #endif
@@ -1210,11 +1159,9 @@ Avx apply_diagonal_matrix_avx<double>(double* qv_data_,
 }
 
 template <>
-Avx apply_diagonal_matrix_avx<float>(float* qv_data_,
-                                     const uint64_t data_size,
-                                     const uint64_t* qregs,
-                                     const size_t qregs_size,
-                                     const float* vec_,
+Avx apply_diagonal_matrix_avx<float>(float *qv_data_, const uint64_t data_size,
+                                     const uint64_t *qregs,
+                                     const size_t qregs_size, const float *vec_,
                                      const size_t omp_threads) {
 
   if (data_size < (1UL << 2))
@@ -1227,44 +1174,48 @@ Avx apply_diagonal_matrix_avx<float>(float* qv_data_,
 #pragma omp parallel if (omp_threads > 1) num_threads(omp_threads)
   {
 #if !defined(_WIN64) && !defined(_WIN32)
-  void* data = nullptr;
-  posix_memalign(&data, 64, sizeof(std::complex<float>) * 4);
-  auto float_tmp = reinterpret_cast<std::complex<float>*>(data);
+    void *data = nullptr;
+    posix_memalign(&data, 64, sizeof(std::complex<float>) * 4);
+    auto float_tmp = reinterpret_cast<std::complex<float> *>(data);
 #else
-  auto float_tmp = reinterpret_cast<std::complex<float>*>(malloc(sizeof(std::complex<float>) * 4));
+    auto float_tmp = reinterpret_cast<std::complex<float> *>(
+        malloc(sizeof(std::complex<float>) * 4));
 #endif
 #else
-  auto float_tmp = reinterpret_cast<std::complex<float>*>(malloc(sizeof(std::complex<float>) * 4));
+  auto float_tmp = reinterpret_cast<std::complex<float> *>(
+      malloc(sizeof(std::complex<float>) * 4));
 #endif
 
-  size_t q0_mask_ = 0;
-  size_t q1_mask_ = 0;
-  for (size_t i = 0; i < qregs_size; ++i) {
-    if (qregs[i] == 0) {
-      q0_mask_ = 1UL << i;
-    } else if (qregs[i] == 1) {
-      q1_mask_ = 1UL << i;
+    size_t q0_mask_ = 0;
+    size_t q1_mask_ = 0;
+    for (size_t i = 0; i < qregs_size; ++i) {
+      if (qregs[i] == 0) {
+        q0_mask_ = 1UL << i;
+      } else if (qregs[i] == 1) {
+        q1_mask_ = 1UL << i;
+      }
     }
-  }
 
-  const size_t q0_mask = q0_mask_;
-  const size_t q1_mask = q1_mask_;
-  const auto batch = (data_size <= (1UL << 6) ? 0 : 4);
-  const int64_t END = data_size >> (batch + 1);
-
-  #pragma omp for
-  for (int64_t k = 0; k < END; k += 1) {
-    const auto base = k << (batch + 2);
-    const auto until = base + (1UL << (batch + 2));
-    for (auto i = base; i < until; i+=4) {
-      m256_t<float> tgt_qv_data = _mm256_load(reinterpret_cast<float*>(&(qv_data[i])));
-      auto input_data = _load_diagonal_input(input_vec, float_tmp, i, qregs, qregs_size, q0_mask, q1_mask);
-      _mm_complex_multiply<float>(tgt_qv_data, input_data);
-      _mm256_store(reinterpret_cast<float*>(&(qv_data[i])), tgt_qv_data);
-    }
-  };
+    const size_t q0_mask = q0_mask_;
+    const size_t q1_mask = q1_mask_;
+    const auto batch = (data_size <= (1UL << 6) ? 0 : 4);
+    const int64_t END = data_size >> (batch + 1);
+
+#pragma omp for
+    for (int64_t k = 0; k < END; k += 1) {
+      const auto base = k << (batch + 2);
+      const auto until = base + (1UL << (batch + 2));
+      for (auto i = base; i < until; i += 4) {
+        m256_t<float> tgt_qv_data =
+            _mm256_load(reinterpret_cast<float *>(&(qv_data[i])));
+        auto input_data = _load_diagonal_input(input_vec, float_tmp, i, qregs,
+                                               qregs_size, q0_mask, q1_mask);
+        _mm_complex_multiply<float>(tgt_qv_data, input_data);
+        _mm256_store(reinterpret_cast<float *>(&(qv_data[i])), tgt_qv_data);
+      }
+    };
 
-  free(float_tmp);
+    free(float_tmp);
 #if defined(_OPENMP)
   }
 #endif
diff --git a/src/simulators/statevector/qv_avx2.hpp b/src/simulators/statevector/qv_avx2.hpp
index 4fbbd24acd..ffe291f438 100644
--- a/src/simulators/statevector/qv_avx2.hpp
+++ b/src/simulators/statevector/qv_avx2.hpp
@@ -24,21 +24,14 @@ namespace QV {
 enum class Avx { NotApplied, Applied };
 
 template <typename FloatType>
-Avx apply_matrix_avx(FloatType* data,
-                     const uint64_t data_size,
-                     const uint64_t* qregs,
-                     const size_t qregs_size,
-                     const FloatType* mat,
-                     const size_t omp_threads);
-
+Avx apply_matrix_avx(FloatType *data, const uint64_t data_size,
+                     const uint64_t *qregs, const size_t qregs_size,
+                     const FloatType *mat, const size_t omp_threads);
 
 template <typename FloatType>
-Avx apply_diagonal_matrix_avx(FloatType* data,
-                              const uint64_t data_size,
-                              const uint64_t* qregs,
-                              const size_t qregs_size,
-                              const FloatType* vec,
-                              const size_t omp_threads);
+Avx apply_diagonal_matrix_avx(FloatType *data, const uint64_t data_size,
+                              const uint64_t *qregs, const size_t qregs_size,
+                              const FloatType *vec, const size_t omp_threads);
 
 } // end namespace QV
 } // end namespace AER
diff --git a/src/simulators/statevector/statevector_state.hpp b/src/simulators/statevector/statevector_state.hpp
old mode 100755
new mode 100644
index d5ce0b8ffb..00cbdb79ae
--- a/src/simulators/statevector/statevector_state.hpp
+++ b/src/simulators/statevector/statevector_state.hpp
@@ -12,7 +12,6 @@
  * that they have been altered from the originals.
  */
 
-
 #ifndef _statevector_state_hpp
 #define _statevector_state_hpp
 
@@ -22,8 +21,8 @@
 
 #include "framework/json.hpp"
 #include "framework/utils.hpp"
-#include "simulators/state_chunk.hpp"
 #include "qubitvector.hpp"
+#include "simulators/state_chunk.hpp"
 #ifdef AER_THRUST_SUPPORTED
 #include "qubitvector_thrust.hpp"
 #endif
@@ -37,28 +36,43 @@ using OpType = Operations::OpType;
 // OpSet of supported instructions
 const Operations::OpSet StateOpSet(
     // Op types
-    {OpType::gate, OpType::measure,
-     OpType::reset, OpType::initialize,
-     OpType::snapshot, OpType::barrier,
-     OpType::bfunc, OpType::roerror,
-     OpType::matrix, OpType::diagonal_matrix,
-     OpType::multiplexer, OpType::kraus, OpType::qerror_loc,
-     OpType::sim_op, OpType::set_statevec,
-     OpType::save_expval, OpType::save_expval_var,
-     OpType::save_probs, OpType::save_probs_ket,
-     OpType::save_amps, OpType::save_amps_sq,
-     OpType::save_state, OpType::save_statevec,
-     OpType::save_statevec_dict, OpType::save_densmat,
-     OpType::jump, OpType::mark
-     },
+    {OpType::gate,
+     OpType::measure,
+     OpType::reset,
+     OpType::initialize,
+     OpType::snapshot,
+     OpType::barrier,
+     OpType::bfunc,
+     OpType::roerror,
+     OpType::matrix,
+     OpType::diagonal_matrix,
+     OpType::multiplexer,
+     OpType::kraus,
+     OpType::qerror_loc,
+     OpType::sim_op,
+     OpType::set_statevec,
+     OpType::save_expval,
+     OpType::save_expval_var,
+     OpType::save_probs,
+     OpType::save_probs_ket,
+     OpType::save_amps,
+     OpType::save_amps_sq,
+     OpType::save_state,
+     OpType::save_statevec,
+     OpType::save_statevec_dict,
+     OpType::save_densmat,
+     OpType::jump,
+     OpType::mark},
     // Gates
-    {"u1",     "u2",      "u3",  "u",    "U",    "CX",   "cx",   "cz",
-     "cy",     "cp",      "cu1", "cu2",  "cu3",  "swap", "id",   "p",
-     "x",      "y",       "z",   "h",    "s",    "sdg",  "t",    "tdg",
-     "r",      "rx",      "ry",  "rz",   "rxx",  "ryy",  "rzz",  "rzx",
-     "ccx",    "cswap",   "mcx", "mcy",  "mcz",  "mcu1", "mcu2", "mcu3",
-     "mcswap", "mcphase", "mcr", "mcrx", "mcry", "mcry", "sx",   "sxdg",
-     "csx", "mcsx", "csxdg", "mcsxdg",  "delay", "pauli", "mcx_gray", "cu", "mcu", "mcp"},
+    {"u1",   "u2",    "u3",     "u",     "U",     "CX",       "cx",
+     "cz",   "cy",    "cp",     "cu1",   "cu2",   "cu3",      "swap",
+     "id",   "p",     "x",      "y",     "z",     "h",        "s",
+     "sdg",  "t",     "tdg",    "r",     "rx",    "ry",       "rz",
+     "rxx",  "ryy",   "rzz",    "rzx",   "ccx",   "cswap",    "mcx",
+     "mcy",  "mcz",   "mcu1",   "mcu2",  "mcu3",  "mcswap",   "mcphase",
+     "mcr",  "mcrx",  "mcry",   "mcry",  "sx",    "sxdg",     "csx",
+     "mcsx", "csxdg", "mcsxdg", "delay", "pauli", "mcx_gray", "cu",
+     "mcu",  "mcp"},
     // Snapshots
     {"statevector", "memory", "register", "probabilities",
      "probabilities_with_variance", "expectation_value_pauli", "density_matrix",
@@ -69,10 +83,31 @@ const Operations::OpSet StateOpSet(
 
 // Allowed gates enum class
 enum class Gates {
-  id, h, s, sdg, t, tdg,
-  rxx, ryy, rzz, rzx,
-  mcx, mcy, mcz, mcr, mcrx, mcry,
-  mcrz, mcp, mcu2, mcu3, mcu, mcswap, mcsx, mcsxdg, pauli
+  id,
+  h,
+  s,
+  sdg,
+  t,
+  tdg,
+  rxx,
+  ryy,
+  rzz,
+  rzx,
+  mcx,
+  mcy,
+  mcz,
+  mcr,
+  mcrx,
+  mcry,
+  mcrz,
+  mcp,
+  mcu2,
+  mcu3,
+  mcu,
+  mcswap,
+  mcsx,
+  mcsxdg,
+  pauli
 };
 
 // Allowed snapshots enum class
@@ -117,16 +152,14 @@ class State : public QuantumState::StateChunk<statevec_t> {
   // Apply an operation
   // If the op is not in allowed_ops an exeption will be raised.
   void apply_op(const int_t iChunk, const Operations::Op &op,
-                        ExperimentResult &result,
-                        RngEngine& rng,
-                        bool final_op = false) override;
+                ExperimentResult &result, RngEngine &rng,
+                bool final_op = false) override;
 
   // Initializes an n-qubit state to the all |0> state
   virtual void initialize_qreg(uint_t num_qubits) override;
 
   // Initializes to a specific n-qubit state
-  virtual void initialize_statevector(uint_t num_qubits,
-                                      statevec_t &&state);
+  virtual void initialize_statevector(uint_t num_qubits, statevec_t &&state);
 
   // Returns the required memory for storing an n-qubit state in megabytes.
   // For this state the memory is independent of the number of ops
@@ -158,12 +191,11 @@ class State : public QuantumState::StateChunk<statevec_t> {
   //-----------------------------------------------------------------------
   // Apply instructions
   //-----------------------------------------------------------------------
-  //apply op to multiple shots , return flase if op is not supported to execute in a batch
+  // apply op to multiple shots , return flase if op is not supported to execute
+  // in a batch
   bool apply_batched_op(const int_t iChunk, const Operations::Op &op,
-                                ExperimentResult &result,
-                                std::vector<RngEngine> &rng,
-                                bool final_op = false) override;
-
+                        ExperimentResult &result, std::vector<RngEngine> &rng,
+                        bool final_op = false) override;
 
   // Applies a sypported Gate operation to the state class.
   // If the input is not in allowed_gates an exeption will be raised.
@@ -173,8 +205,9 @@ class State : public QuantumState::StateChunk<statevec_t> {
   // If a state subclass supports this function it then "measure"
   // should be contained in the set returned by the 'allowed_ops'
   // method.
-  virtual void apply_measure(const int_t iChunk, const reg_t &qubits, const reg_t &cmemory,
-                             const reg_t &cregister, RngEngine &rng);
+  virtual void apply_measure(const int_t iChunk, const reg_t &qubits,
+                             const reg_t &cmemory, const reg_t &cregister,
+                             RngEngine &rng);
 
   // Reset the specified qubits to the |0> state by simulating
   // a measurement, applying a conditional x-gate if the outcome is 1, and
@@ -185,23 +218,26 @@ class State : public QuantumState::StateChunk<statevec_t> {
   // by applying a reset to the these qubits and then
   // computing the tensor product with the new state |psi>
   // /psi> is given in params
-  void apply_initialize(const int_t iChunk, const reg_t &qubits, const cvector_t &params,
-                        RngEngine &rng);
+  void apply_initialize(const int_t iChunk, const reg_t &qubits,
+                        const cvector_t &params, RngEngine &rng);
 
   void initialize_from_vector(const int_t iChunk, const cvector_t &params);
 
   // Apply a supported snapshot instruction
   // If the input is not in allowed_snapshots an exeption will be raised.
-  virtual void apply_snapshot(const int_t iChunk, const Operations::Op &op, ExperimentResult &result, bool last_op = false);
+  virtual void apply_snapshot(const int_t iChunk, const Operations::Op &op,
+                              ExperimentResult &result, bool last_op = false);
 
   // Apply a matrix to given qubits (identity on all other qubits)
   void apply_matrix(const int_t iChunk, const Operations::Op &op);
 
   // Apply a vectorized matrix to given qubits (identity on all other qubits)
-  void apply_matrix(const int_t iChunk, const reg_t &qubits, const cvector_t &vmat);
+  void apply_matrix(const int_t iChunk, const reg_t &qubits,
+                    const cvector_t &vmat);
 
-  //apply diagonal matrix
-  void apply_diagonal_matrix(const int_t iChunk, const reg_t &qubits, const cvector_t & diag); 
+  // apply diagonal matrix
+  void apply_diagonal_matrix(const int_t iChunk, const reg_t &qubits,
+                             const cvector_t &diag);
 
   // Apply a vector of control matrices to given qubits (identity on all other
   // qubits)
@@ -215,8 +251,8 @@ class State : public QuantumState::StateChunk<statevec_t> {
                          const reg_t &target_qubits, const cmatrix_t &mat);
 
   // Apply a Kraus error operation
-  void apply_kraus(const int_t iChunk, const reg_t &qubits, const std::vector<cmatrix_t> &krausops,
-                   RngEngine &rng);
+  void apply_kraus(const int_t iChunk, const reg_t &qubits,
+                   const std::vector<cmatrix_t> &krausops, RngEngine &rng);
 
   //-----------------------------------------------------------------------
   // Save data instructions
@@ -227,12 +263,11 @@ class State : public QuantumState::StateChunk<statevec_t> {
   // state to the results, otherwise it will use copy semantics to leave
   // the current simulator state unchanged.
   void apply_save_statevector(const int_t iChunk, const Operations::Op &op,
-                              ExperimentResult &result,
-                              bool last_op);
+                              ExperimentResult &result, bool last_op);
 
   // Save the current state of the statevector simulator as a ket-form map.
   void apply_save_statevector_dict(const int_t iChunk, const Operations::Op &op,
-                                  ExperimentResult &result);
+                                   ExperimentResult &result);
 
   // Save the current density matrix or reduced density matrix
   void apply_save_density_matrix(const int_t iChunk, const Operations::Op &op,
@@ -248,7 +283,7 @@ class State : public QuantumState::StateChunk<statevec_t> {
 
   // Helper function for computing expectation value
   virtual double expval_pauli(const int_t iChunk, const reg_t &qubits,
-                              const std::string& pauli) override;
+                              const std::string &pauli) override;
   //-----------------------------------------------------------------------
   // Measurement Helpers
   //-----------------------------------------------------------------------
@@ -268,10 +303,12 @@ class State : public QuantumState::StateChunk<statevec_t> {
   // 1 -> |q1 = 0, q0 = 1> state
   // 2 -> |q1 = 1, q0 = 0> state
   // 3 -> |q1 = 1, q0 = 1> state
-  std::pair<uint_t, double> sample_measure_with_prob(const int_t iChunk, const reg_t &qubits,
+  std::pair<uint_t, double> sample_measure_with_prob(const int_t iChunk,
+                                                     const reg_t &qubits,
                                                      RngEngine &rng);
 
-  void measure_reset_update(const int_t iChunk, const std::vector<uint_t> &qubits,
+  void measure_reset_update(const int_t iChunk,
+                            const std::vector<uint_t> &qubits,
                             const uint_t final_state, const uint_t meas_state,
                             const double meas_prob);
 
@@ -285,20 +322,20 @@ class State : public QuantumState::StateChunk<statevec_t> {
   //-----------------------------------------------------------------------
 
   // Snapshot current qubit probabilities for a measurement (average)
-  void snapshot_probabilities(const int_t iChunk, const Operations::Op &op, ExperimentResult &result,
-                              SnapshotDataType type);
+  void snapshot_probabilities(const int_t iChunk, const Operations::Op &op,
+                              ExperimentResult &result, SnapshotDataType type);
 
   // Snapshot the expectation value of a Pauli operator
-  void snapshot_pauli_expval(const int_t iChunk, const Operations::Op &op, ExperimentResult &result,
-                             SnapshotDataType type);
+  void snapshot_pauli_expval(const int_t iChunk, const Operations::Op &op,
+                             ExperimentResult &result, SnapshotDataType type);
 
   // Snapshot the expectation value of a matrix operator
-  void snapshot_matrix_expval(const int_t iChunk, const Operations::Op &op, ExperimentResult &result,
-                              SnapshotDataType type);
+  void snapshot_matrix_expval(const int_t iChunk, const Operations::Op &op,
+                              ExperimentResult &result, SnapshotDataType type);
 
   // Snapshot reduced density matrix
-  void snapshot_density_matrix(const int_t iChunk, const Operations::Op &op, ExperimentResult &result,
-                               SnapshotDataType type);
+  void snapshot_density_matrix(const int_t iChunk, const Operations::Op &op,
+                               ExperimentResult &result, SnapshotDataType type);
 
   // Return the reduced density matrix for the simulator
   cmatrix_t density_matrix(const int_t iChunk, const reg_t &qubits);
@@ -311,7 +348,8 @@ class State : public QuantumState::StateChunk<statevec_t> {
   //-----------------------------------------------------------------------
 
   // Optimize phase gate with diagonal [1, phase]
-  void apply_gate_phase(const int_t iChunk, const uint_t qubit, const complex_t phase);
+  void apply_gate_phase(const int_t iChunk, const uint_t qubit,
+                        const complex_t phase);
 
   //-----------------------------------------------------------------------
   // Multi-controlled u3
@@ -320,8 +358,8 @@ class State : public QuantumState::StateChunk<statevec_t> {
   // Apply N-qubit multi-controlled single qubit gate specified by
   // 4 parameters u4(theta, phi, lambda, gamma)
   // NOTE: if N=1 this is just a regular u4 gate.
-  void apply_gate_mcu(const int_t iChunk, const reg_t &qubits, const double theta,
-                      const double phi, const double lambda,
+  void apply_gate_mcu(const int_t iChunk, const reg_t &qubits,
+                      const double theta, const double phi, const double lambda,
                       const double gamma);
 
   //-----------------------------------------------------------------------
@@ -345,7 +383,6 @@ class State : public QuantumState::StateChunk<statevec_t> {
 
   // Table of allowed snapshot types to enum class members
   const static stringmap_t<Snapshots> snapshotset_;
-
 };
 
 //=========================================================================
@@ -353,73 +390,72 @@ class State : public QuantumState::StateChunk<statevec_t> {
 //=========================================================================
 
 template <class statevec_t>
-const stringmap_t<Gates> State<statevec_t>::gateset_({
-    // 1-qubit gates
-    {"delay", Gates::id},// Delay gate
-    {"id", Gates::id},   // Pauli-Identity gate
-    {"x", Gates::mcx},   // Pauli-X gate
-    {"y", Gates::mcy},   // Pauli-Y gate
-    {"z", Gates::mcz},   // Pauli-Z gate
-    {"s", Gates::s},     // Phase gate (aka sqrt(Z) gate)
-    {"sdg", Gates::sdg}, // Conjugate-transpose of Phase gate
-    {"h", Gates::h},     // Hadamard gate (X + Z / sqrt(2))
-    {"t", Gates::t},     // T-gate (sqrt(S))
-    {"tdg", Gates::tdg}, // Conjguate-transpose of T gate
-    {"p", Gates::mcp},   // Parameterized phase gate 
-    {"sx", Gates::mcsx}, // Sqrt(X) gate
-    {"sxdg", Gates::mcsxdg}, // Inverse Sqrt(X) gate
-    // 1-qubit rotation Gates
-    {"r", Gates::mcr},   // R rotation gate
-    {"rx", Gates::mcrx}, // Pauli-X rotation gate
-    {"ry", Gates::mcry}, // Pauli-Y rotation gate
-    {"rz", Gates::mcrz}, // Pauli-Z rotation gate
-    // Waltz Gates
-    {"u1", Gates::mcp},  // zero-X90 pulse waltz gate
-    {"u2", Gates::mcu2}, // single-X90 pulse waltz gate
-    {"u3", Gates::mcu3}, // two X90 pulse waltz gate
-    {"u", Gates::mcu3}, // two X90 pulse waltz gate
-    {"U", Gates::mcu3}, // two X90 pulse waltz gate
-    // 2-qubit gates
-    {"CX", Gates::mcx},      // Controlled-X gate (CNOT)
-    {"cx", Gates::mcx},      // Controlled-X gate (CNOT)
-    {"cy", Gates::mcy},      // Controlled-Y gate
-    {"cz", Gates::mcz},      // Controlled-Z gate
-    {"cp", Gates::mcp},      // Controlled-Phase gate 
-    {"cu1", Gates::mcp},     // Controlled-u1 gate
-    {"cu2", Gates::mcu2},    // Controlled-u2 gate
-    {"cu3", Gates::mcu3},    // Controlled-u3 gate
-    {"cu", Gates::mcu},      // Controlled-u4 gate
-    {"cp", Gates::mcp},      // Controlled-Phase gate 
-    {"swap", Gates::mcswap}, // SWAP gate
-    {"rxx", Gates::rxx},     // Pauli-XX rotation gate
-    {"ryy", Gates::ryy},     // Pauli-YY rotation gate
-    {"rzz", Gates::rzz},     // Pauli-ZZ rotation gate
-    {"rzx", Gates::rzx},     // Pauli-ZX rotation gate
-    {"csx", Gates::mcsx},    // Controlled-Sqrt(X) gate
-    {"csxdg", Gates::mcsxdg}, // Controlled-Sqrt(X)dg gate
-    // 3-qubit gates
-    {"ccx", Gates::mcx},      // Controlled-CX gate (Toffoli)
-    {"cswap", Gates::mcswap}, // Controlled SWAP gate (Fredkin)
-    // Multi-qubit controlled gates
-    {"mcx", Gates::mcx},      // Multi-controlled-X gate
-    {"mcy", Gates::mcy},      // Multi-controlled-Y gate
-    {"mcz", Gates::mcz},      // Multi-controlled-Z gate
-    {"mcr", Gates::mcr},      // Multi-controlled R-rotation gate
-    {"mcrx", Gates::mcrx},    // Multi-controlled X-rotation gate
-    {"mcry", Gates::mcry},    // Multi-controlled Y-rotation gate
-    {"mcrz", Gates::mcrz},    // Multi-controlled Z-rotation gate
-    {"mcphase", Gates::mcp},  // Multi-controlled-Phase gate 
-    {"mcp", Gates::mcp},      // Multi-controlled-Phase gate 
-    {"mcu1", Gates::mcp},     // Multi-controlled-u1
-    {"mcu2", Gates::mcu2},    // Multi-controlled-u2
-    {"mcu3", Gates::mcu3},    // Multi-controlled-u3
-    {"mcu", Gates::mcu},      // Multi-controlled-u4
-    {"mcswap", Gates::mcswap},// Multi-controlled SWAP gate
-    {"mcsx", Gates::mcsx},    // Multi-controlled-Sqrt(X) gate
-    {"mcsxdg", Gates::mcsxdg}, // Multi-controlled-Sqrt(X)dg gate
-    {"pauli", Gates::pauli},   // Multi-qubit Pauli gate
-    {"mcx_gray", Gates::mcx}
-});
+const stringmap_t<Gates> State<statevec_t>::gateset_(
+    {                           // 1-qubit gates
+     {"delay", Gates::id},      // Delay gate
+     {"id", Gates::id},         // Pauli-Identity gate
+     {"x", Gates::mcx},         // Pauli-X gate
+     {"y", Gates::mcy},         // Pauli-Y gate
+     {"z", Gates::mcz},         // Pauli-Z gate
+     {"s", Gates::s},           // Phase gate (aka sqrt(Z) gate)
+     {"sdg", Gates::sdg},       // Conjugate-transpose of Phase gate
+     {"h", Gates::h},           // Hadamard gate (X + Z / sqrt(2))
+     {"t", Gates::t},           // T-gate (sqrt(S))
+     {"tdg", Gates::tdg},       // Conjguate-transpose of T gate
+     {"p", Gates::mcp},         // Parameterized phase gate
+     {"sx", Gates::mcsx},       // Sqrt(X) gate
+     {"sxdg", Gates::mcsxdg},   // Inverse Sqrt(X) gate
+                                // 1-qubit rotation Gates
+     {"r", Gates::mcr},         // R rotation gate
+     {"rx", Gates::mcrx},       // Pauli-X rotation gate
+     {"ry", Gates::mcry},       // Pauli-Y rotation gate
+     {"rz", Gates::mcrz},       // Pauli-Z rotation gate
+                                // Waltz Gates
+     {"u1", Gates::mcp},        // zero-X90 pulse waltz gate
+     {"u2", Gates::mcu2},       // single-X90 pulse waltz gate
+     {"u3", Gates::mcu3},       // two X90 pulse waltz gate
+     {"u", Gates::mcu3},        // two X90 pulse waltz gate
+     {"U", Gates::mcu3},        // two X90 pulse waltz gate
+                                // 2-qubit gates
+     {"CX", Gates::mcx},        // Controlled-X gate (CNOT)
+     {"cx", Gates::mcx},        // Controlled-X gate (CNOT)
+     {"cy", Gates::mcy},        // Controlled-Y gate
+     {"cz", Gates::mcz},        // Controlled-Z gate
+     {"cp", Gates::mcp},        // Controlled-Phase gate
+     {"cu1", Gates::mcp},       // Controlled-u1 gate
+     {"cu2", Gates::mcu2},      // Controlled-u2 gate
+     {"cu3", Gates::mcu3},      // Controlled-u3 gate
+     {"cu", Gates::mcu},        // Controlled-u4 gate
+     {"cp", Gates::mcp},        // Controlled-Phase gate
+     {"swap", Gates::mcswap},   // SWAP gate
+     {"rxx", Gates::rxx},       // Pauli-XX rotation gate
+     {"ryy", Gates::ryy},       // Pauli-YY rotation gate
+     {"rzz", Gates::rzz},       // Pauli-ZZ rotation gate
+     {"rzx", Gates::rzx},       // Pauli-ZX rotation gate
+     {"csx", Gates::mcsx},      // Controlled-Sqrt(X) gate
+     {"csxdg", Gates::mcsxdg},  // Controlled-Sqrt(X)dg gate
+                                // 3-qubit gates
+     {"ccx", Gates::mcx},       // Controlled-CX gate (Toffoli)
+     {"cswap", Gates::mcswap},  // Controlled SWAP gate (Fredkin)
+                                // Multi-qubit controlled gates
+     {"mcx", Gates::mcx},       // Multi-controlled-X gate
+     {"mcy", Gates::mcy},       // Multi-controlled-Y gate
+     {"mcz", Gates::mcz},       // Multi-controlled-Z gate
+     {"mcr", Gates::mcr},       // Multi-controlled R-rotation gate
+     {"mcrx", Gates::mcrx},     // Multi-controlled X-rotation gate
+     {"mcry", Gates::mcry},     // Multi-controlled Y-rotation gate
+     {"mcrz", Gates::mcrz},     // Multi-controlled Z-rotation gate
+     {"mcphase", Gates::mcp},   // Multi-controlled-Phase gate
+     {"mcp", Gates::mcp},       // Multi-controlled-Phase gate
+     {"mcu1", Gates::mcp},      // Multi-controlled-u1
+     {"mcu2", Gates::mcu2},     // Multi-controlled-u2
+     {"mcu3", Gates::mcu3},     // Multi-controlled-u3
+     {"mcu", Gates::mcu},       // Multi-controlled-u4
+     {"mcswap", Gates::mcswap}, // Multi-controlled SWAP gate
+     {"mcsx", Gates::mcsx},     // Multi-controlled-Sqrt(X) gate
+     {"mcsxdg", Gates::mcsxdg}, // Multi-controlled-Sqrt(X)dg gate
+     {"pauli", Gates::pauli},   // Multi-qubit Pauli gate
+     {"mcx_gray", Gates::mcx}});
 
 template <class statevec_t>
 const stringmap_t<Snapshots> State<statevec_t>::snapshotset_(
@@ -446,45 +482,43 @@ const stringmap_t<Snapshots> State<statevec_t>::snapshotset_(
 //-------------------------------------------------------------------------
 
 template <class statevec_t>
-void State<statevec_t>::initialize_qreg(uint_t num_qubits) 
-{
+void State<statevec_t>::initialize_qreg(uint_t num_qubits) {
   int_t i;
-  if(BaseState::qregs_.size() == 0)
-    BaseState::allocate(num_qubits,num_qubits,1);
+  if (BaseState::qregs_.size() == 0)
+    BaseState::allocate(num_qubits, num_qubits, 1);
 
   initialize_omp();
 
-  for(i=0;i<BaseState::qregs_.size();i++){
+  for (i = 0; i < BaseState::qregs_.size(); i++) {
     BaseState::qregs_[i].set_num_qubits(BaseState::chunk_bits_);
   }
 
-  if(BaseState::multi_chunk_distribution_){
-    if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0){
-#pragma omp parallel for 
-      for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-        for(int_t iChunk = BaseState::top_chunk_of_group_[ig];iChunk < BaseState::top_chunk_of_group_[ig + 1];iChunk++){
-          if(BaseState::global_chunk_index_ + iChunk == 0 || this->num_qubits_ == this->chunk_bits_){
+  if (BaseState::multi_chunk_distribution_) {
+    if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0) {
+#pragma omp parallel for
+      for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+        for (int_t iChunk = BaseState::top_chunk_of_group_[ig];
+             iChunk < BaseState::top_chunk_of_group_[ig + 1]; iChunk++) {
+          if (BaseState::global_chunk_index_ + iChunk == 0 ||
+              this->num_qubits_ == this->chunk_bits_) {
             BaseState::qregs_[iChunk].initialize();
-          }
-          else{
+          } else {
             BaseState::qregs_[iChunk].zero();
           }
         }
       }
-    }
-    else{
-      for(i=0;i<BaseState::qregs_.size();i++){
-        if(BaseState::global_chunk_index_ + i == 0 || this->num_qubits_ == this->chunk_bits_){
+    } else {
+      for (i = 0; i < BaseState::qregs_.size(); i++) {
+        if (BaseState::global_chunk_index_ + i == 0 ||
+            this->num_qubits_ == this->chunk_bits_) {
           BaseState::qregs_[i].initialize();
-        }
-        else{
+        } else {
           BaseState::qregs_[i].zero();
         }
       }
     }
-  }
-  else{
-    for(i=0;i<BaseState::qregs_.size();i++){
+  } else {
+    for (i = 0; i < BaseState::qregs_.size(); i++) {
       BaseState::qregs_[i].initialize();
     }
   }
@@ -493,41 +527,47 @@ void State<statevec_t>::initialize_qreg(uint_t num_qubits)
 
 template <class statevec_t>
 void State<statevec_t>::initialize_statevector(uint_t num_qubits,
-                                               statevec_t &&state) 
-{
+                                               statevec_t &&state) {
   if (state.num_qubits() != num_qubits) {
-    throw std::invalid_argument("QubitVector::State::initialize: initial state does not match qubit number");
+    throw std::invalid_argument("QubitVector::State::initialize: initial state "
+                                "does not match qubit number");
   }
 
   if (BaseState::qregs_.size() == 1) {
     BaseState::qregs_[0] = std::move(state);
   } else {
-    if(BaseState::qregs_.size() == 0)
-      BaseState::allocate(num_qubits,num_qubits,1);
+    if (BaseState::qregs_.size() == 0)
+      BaseState::allocate(num_qubits, num_qubits, 1);
     initialize_omp();
 
     int_t iChunk;
-    for(iChunk=0;iChunk<BaseState::qregs_.size();iChunk++){
+    for (iChunk = 0; iChunk < BaseState::qregs_.size(); iChunk++) {
       BaseState::qregs_[iChunk].set_num_qubits(BaseState::chunk_bits_);
     }
 
-    if(BaseState::multi_chunk_distribution_){
-      uint_t local_offset = BaseState::global_chunk_index_ << BaseState::chunk_bits_;
-      if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0){
+    if (BaseState::multi_chunk_distribution_) {
+      uint_t local_offset = BaseState::global_chunk_index_
+                            << BaseState::chunk_bits_;
+      if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0) {
 #pragma omp parallel for private(iChunk)
-        for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-          for(iChunk = BaseState::top_chunk_of_group_[ig];iChunk < BaseState::top_chunk_of_group_[ig + 1];iChunk++)
-            BaseState::qregs_[iChunk].initialize_from_data(state.data() + local_offset + (iChunk << BaseState::chunk_bits_), 1ull << BaseState::chunk_bits_);
+        for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+          for (iChunk = BaseState::top_chunk_of_group_[ig];
+               iChunk < BaseState::top_chunk_of_group_[ig + 1]; iChunk++)
+            BaseState::qregs_[iChunk].initialize_from_data(
+                state.data() + local_offset +
+                    (iChunk << BaseState::chunk_bits_),
+                1ull << BaseState::chunk_bits_);
         }
+      } else {
+        for (iChunk = 0; iChunk < BaseState::qregs_.size(); iChunk++)
+          BaseState::qregs_[iChunk].initialize_from_data(
+              state.data() + local_offset + (iChunk << BaseState::chunk_bits_),
+              1ull << BaseState::chunk_bits_);
       }
-      else{
-        for(iChunk=0;iChunk<BaseState::qregs_.size();iChunk++)
-          BaseState::qregs_[iChunk].initialize_from_data(state.data() + local_offset + (iChunk << BaseState::chunk_bits_), 1ull << BaseState::chunk_bits_);
-      }
-    }
-    else{
-      for(iChunk=0;iChunk<BaseState::qregs_.size();iChunk++){
-        BaseState::qregs_[iChunk].initialize_from_data(state.data(), 1ull << BaseState::chunk_bits_);
+    } else {
+      for (iChunk = 0; iChunk < BaseState::qregs_.size(); iChunk++) {
+        BaseState::qregs_[iChunk].initialize_from_data(
+            state.data(), 1ull << BaseState::chunk_bits_);
       }
     }
   }
@@ -535,46 +575,43 @@ void State<statevec_t>::initialize_statevector(uint_t num_qubits,
   apply_global_phase();
 }
 
-template <class statevec_t> void State<statevec_t>::initialize_omp() 
-{
+template <class statevec_t> void State<statevec_t>::initialize_omp() {
   uint_t i;
 
-  for(i=0;i<BaseState::qregs_.size();i++){
+  for (i = 0; i < BaseState::qregs_.size(); i++) {
     BaseState::qregs_[i].set_omp_threshold(omp_qubit_threshold_);
     if (BaseState::threads_ > 0)
-      BaseState::qregs_[i].set_omp_threads(BaseState::threads_); // set allowed OMP threads in qubitvector
+      BaseState::qregs_[i].set_omp_threads(
+          BaseState::threads_); // set allowed OMP threads in qubitvector
   }
 }
 
-
 //-------------------------------------------------------------------------
 // Utility
 //-------------------------------------------------------------------------
 
-template <class statevec_t>
-void State<statevec_t>::apply_global_phase() 
-{
+template <class statevec_t> void State<statevec_t>::apply_global_phase() {
   if (BaseState::has_global_phase_) {
     int_t i;
-    if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0){
-#pragma omp parallel for 
-      for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-        for(int_t iChunk = BaseState::top_chunk_of_group_[ig];iChunk < BaseState::top_chunk_of_group_[ig + 1];iChunk++)
-          BaseState::qregs_[iChunk].apply_diagonal_matrix({0}, {BaseState::global_phase_, BaseState::global_phase_});
+    if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0) {
+#pragma omp parallel for
+      for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+        for (int_t iChunk = BaseState::top_chunk_of_group_[ig];
+             iChunk < BaseState::top_chunk_of_group_[ig + 1]; iChunk++)
+          BaseState::qregs_[iChunk].apply_diagonal_matrix(
+              {0}, {BaseState::global_phase_, BaseState::global_phase_});
       }
-    }
-    else{
-      for(i=0;i<BaseState::qregs_.size();i++)
-        BaseState::qregs_[i].apply_diagonal_matrix({0}, {BaseState::global_phase_, BaseState::global_phase_});
+    } else {
+      for (i = 0; i < BaseState::qregs_.size(); i++)
+        BaseState::qregs_[i].apply_diagonal_matrix(
+            {0}, {BaseState::global_phase_, BaseState::global_phase_});
     }
   }
 }
 
 template <class statevec_t>
-size_t State<statevec_t>::required_memory_mb(uint_t num_qubits,
-                                             const std::vector<Operations::Op> &ops)
-                                             const 
-{
+size_t State<statevec_t>::required_memory_mb(
+    uint_t num_qubits, const std::vector<Operations::Op> &ops) const {
   (void)ops; // avoid unused variable compiler warning
   statevec_t tmp;
   return tmp.required_memory_mb(num_qubits);
@@ -586,40 +623,43 @@ void State<statevec_t>::set_config(const json_t &config) {
 
   // Set threshold for truncating snapshots
   JSON::get_value(json_chop_threshold_, "zero_threshold", config);
-  for(int_t i=0;i<BaseState::qregs_.size();i++){
+  for (int_t i = 0; i < BaseState::qregs_.size(); i++) {
     BaseState::qregs_[i].set_json_chop_threshold(json_chop_threshold_);
   }
 
   // Set OMP threshold for state update functions
-  JSON::get_value(omp_qubit_threshold_, "statevector_parallel_threshold", config);
+  JSON::get_value(omp_qubit_threshold_, "statevector_parallel_threshold",
+                  config);
 
   // Set the sample measure indexing size
   int index_size;
   if (JSON::get_value(index_size, "statevector_sample_measure_opt", config)) {
-    for(int_t i=0;i<BaseState::qregs_.size();i++){
+    for (int_t i = 0; i < BaseState::qregs_.size(); i++) {
       BaseState::qregs_[i].set_sample_measure_index_size(index_size);
     }
   }
 }
 
-
 template <class statevec_t>
-auto State<statevec_t>::move_to_vector(const int_t iChunkIn)
-{
-  if(BaseState::multi_chunk_distribution_){
-    size_t size_required = 2*(sizeof(std::complex<double>) << BaseState::num_qubits_) + (sizeof(std::complex<double>) << BaseState::chunk_bits_)*BaseState::num_local_chunks_;
-    if((size_required >> 20) > Utils::get_system_memory_mb()){
-      throw std::runtime_error(std::string("There is not enough memory to store states"));
+auto State<statevec_t>::move_to_vector(const int_t iChunkIn) {
+  if (BaseState::multi_chunk_distribution_) {
+    size_t size_required =
+        2 * (sizeof(std::complex<double>) << BaseState::num_qubits_) +
+        (sizeof(std::complex<double>) << BaseState::chunk_bits_) *
+            BaseState::num_local_chunks_;
+    if ((size_required >> 20) > Utils::get_system_memory_mb()) {
+      throw std::runtime_error(
+          std::string("There is not enough memory to store states"));
     }
     int_t iChunk;
     auto state = BaseState::qregs_[0].move_to_vector();
     state.resize(BaseState::num_local_chunks_ << BaseState::chunk_bits_);
 
-#pragma omp parallel for if(BaseState::chunk_omp_parallel_) private(iChunk)
-    for(iChunk=1;iChunk<BaseState::qregs_.size();iChunk++){
+#pragma omp parallel for if (BaseState::chunk_omp_parallel_) private(iChunk)
+    for (iChunk = 1; iChunk < BaseState::qregs_.size(); iChunk++) {
       auto tmp = BaseState::qregs_[iChunk].move_to_vector();
-      uint_t j,offset = iChunk << BaseState::chunk_bits_;
-      for(j=0;j<tmp.size();j++){
+      uint_t j, offset = iChunk << BaseState::chunk_bits_;
+      for (j = 0; j < tmp.size(); j++) {
         state[offset + j] = tmp[j];
       }
     }
@@ -628,29 +668,31 @@ auto State<statevec_t>::move_to_vector(const int_t iChunkIn)
     BaseState::gather_state(state);
 #endif
     return state;
-  }
-  else {
+  } else {
     return std::move(BaseState::qregs_[iChunkIn].move_to_vector());
   }
 }
 
 template <class statevec_t>
-auto State<statevec_t>::copy_to_vector(const int_t iChunkIn)
-{
-  if(BaseState::multi_chunk_distribution_){
-    size_t size_required = 2*(sizeof(std::complex<double>) << BaseState::num_qubits_) + (sizeof(std::complex<double>) << BaseState::chunk_bits_)*BaseState::num_local_chunks_;
-    if((size_required >> 20) > Utils::get_system_memory_mb()){
-      throw std::runtime_error(std::string("There is not enough memory to store states"));
+auto State<statevec_t>::copy_to_vector(const int_t iChunkIn) {
+  if (BaseState::multi_chunk_distribution_) {
+    size_t size_required =
+        2 * (sizeof(std::complex<double>) << BaseState::num_qubits_) +
+        (sizeof(std::complex<double>) << BaseState::chunk_bits_) *
+            BaseState::num_local_chunks_;
+    if ((size_required >> 20) > Utils::get_system_memory_mb()) {
+      throw std::runtime_error(
+          std::string("There is not enough memory to store states"));
     }
     int_t iChunk;
     auto state = BaseState::qregs_[0].copy_to_vector();
     state.resize(BaseState::num_local_chunks_ << BaseState::chunk_bits_);
 
-#pragma omp parallel for if(BaseState::chunk_omp_parallel_) private(iChunk)
-    for(iChunk=1;iChunk<BaseState::qregs_.size();iChunk++){
+#pragma omp parallel for if (BaseState::chunk_omp_parallel_) private(iChunk)
+    for (iChunk = 1; iChunk < BaseState::qregs_.size(); iChunk++) {
       auto tmp = BaseState::qregs_[iChunk].copy_to_vector();
-      uint_t j,offset = iChunk << BaseState::chunk_bits_;
-      for(j=0;j<tmp.size();j++){
+      uint_t j, offset = iChunk << BaseState::chunk_bits_;
+      for (j = 0; j < tmp.size(); j++) {
         state[offset + j] = tmp[j];
       }
     }
@@ -659,179 +701,171 @@ auto State<statevec_t>::copy_to_vector(const int_t iChunkIn)
     BaseState::gather_state(state);
 #endif
     return state;
-  }
-  else
+  } else
     return BaseState::qregs_[iChunkIn].copy_to_vector();
 }
 
-
 //=========================================================================
 // Implementation: apply operations
 //=========================================================================
 template <class statevec_t>
 void State<statevec_t>::apply_op(const int_t iChunk, const Operations::Op &op,
-                        ExperimentResult &result,
-                        RngEngine& rng,
-                        bool final_op)
-{
-  if(BaseState::check_conditional(iChunk, op)) {
+                                 ExperimentResult &result, RngEngine &rng,
+                                 bool final_op) {
+  if (BaseState::check_conditional(iChunk, op)) {
     switch (op.type) {
-      case OpType::barrier:
-      case OpType::nop:
-      case OpType::qerror_loc:
-        break;
-      case OpType::reset:
-        apply_reset(iChunk, op.qubits, rng);
-        break;
-      case OpType::initialize:
-        apply_initialize(iChunk, op.qubits, op.params, rng);
-        break;
-      case OpType::measure:
-        apply_measure(iChunk, op.qubits, op.memory, op.registers, rng);
-        break;
-      case OpType::bfunc:
-        BaseState::cregs_[0].apply_bfunc(op);
-        break;
-      case OpType::roerror:
-        BaseState::cregs_[0].apply_roerror(op, rng);
-        break;
-      case OpType::gate:
-        apply_gate(iChunk, op);
-        break;
-      case OpType::snapshot:
-        apply_snapshot(iChunk, op, result, final_op);
-        break;
-      case OpType::matrix:
-        apply_matrix(iChunk, op);
-        break;
-      case OpType::diagonal_matrix:
-        apply_diagonal_matrix(iChunk, op.qubits, op.params);
-        break;
-      case OpType::multiplexer:
-        apply_multiplexer(iChunk, op.regs[0], op.regs[1],
-                          op.mats); // control qubits ([0]) & target qubits([1])
-        break;
-      case OpType::kraus:
-        apply_kraus(iChunk, op.qubits, op.mats, rng);
-        break;
-      case OpType::sim_op:
-        if(op.name == "begin_register_blocking"){
-          BaseState::qregs_[iChunk].enter_register_blocking(op.qubits);
-        }
-        else if(op.name == "end_register_blocking"){
-          BaseState::qregs_[iChunk].leave_register_blocking();
-        }
-        break;
-      case OpType::set_statevec:
-        initialize_from_vector(iChunk, op.params);
-        break;
-      case OpType::save_expval:
-      case OpType::save_expval_var:
-        BaseState::apply_save_expval(iChunk, op, result);
-        break;
-      case OpType::save_densmat:
-        apply_save_density_matrix(iChunk, op, result);
-        break;
-      case OpType::save_state:
-      case OpType::save_statevec:
-        apply_save_statevector(iChunk, op, result, final_op);
-        break;
-      case OpType::save_statevec_dict:
-        apply_save_statevector_dict(iChunk, op, result);
-        break;
-      case OpType::save_probs:
-      case OpType::save_probs_ket:
-        apply_save_probs(iChunk, op, result);
-        break;
-      case OpType::save_amps:
-      case OpType::save_amps_sq:
-        apply_save_amplitudes(iChunk, op, result);
-        break;
-      default:
-        throw std::invalid_argument(
-            "QubitVector::State::invalid instruction \'" + op.name + "\'.");
-    }
-  }
-}
-
-template <class statevec_t>
-bool State<statevec_t>::apply_batched_op(const int_t iChunk, 
-                                  const Operations::Op &op,
-                                  ExperimentResult &result,
-                                  std::vector<RngEngine> &rng,
-                                  bool final_op) 
-{
-  if(op.conditional){
-    BaseState::qregs_[iChunk].set_conditional(op.conditional_reg);
-  }
-
-  switch (op.type) {
     case OpType::barrier:
     case OpType::nop:
     case OpType::qerror_loc:
       break;
     case OpType::reset:
-      BaseState::qregs_[iChunk].apply_batched_reset(op.qubits,rng);
+      apply_reset(iChunk, op.qubits, rng);
       break;
     case OpType::initialize:
-      BaseState::qregs_[iChunk].apply_batched_reset(op.qubits,rng);
-      BaseState::qregs_[iChunk].initialize_component(op.qubits, op.params);
+      apply_initialize(iChunk, op.qubits, op.params, rng);
       break;
     case OpType::measure:
-      BaseState::qregs_[iChunk].apply_batched_measure(op.qubits,rng,op.memory,op.registers);
+      apply_measure(iChunk, op.qubits, op.memory, op.registers, rng);
       break;
     case OpType::bfunc:
-      BaseState::qregs_[iChunk].apply_bfunc(op);
+      BaseState::cregs_[0].apply_bfunc(op);
       break;
     case OpType::roerror:
-      BaseState::qregs_[iChunk].apply_roerror(op, rng);
+      BaseState::cregs_[0].apply_roerror(op, rng);
       break;
     case OpType::gate:
       apply_gate(iChunk, op);
       break;
+    case OpType::snapshot:
+      apply_snapshot(iChunk, op, result, final_op);
+      break;
     case OpType::matrix:
       apply_matrix(iChunk, op);
       break;
     case OpType::diagonal_matrix:
-      BaseState::qregs_[iChunk].apply_diagonal_matrix(op.qubits, op.params);
+      apply_diagonal_matrix(iChunk, op.qubits, op.params);
       break;
     case OpType::multiplexer:
       apply_multiplexer(iChunk, op.regs[0], op.regs[1],
                         op.mats); // control qubits ([0]) & target qubits([1])
       break;
     case OpType::kraus:
-      BaseState::qregs_[iChunk].apply_batched_kraus(op.qubits, op.mats,rng);
+      apply_kraus(iChunk, op.qubits, op.mats, rng);
       break;
     case OpType::sim_op:
-      if(op.name == "begin_register_blocking"){
+      if (op.name == "begin_register_blocking") {
         BaseState::qregs_[iChunk].enter_register_blocking(op.qubits);
-      }
-      else if(op.name == "end_register_blocking"){
+      } else if (op.name == "end_register_blocking") {
         BaseState::qregs_[iChunk].leave_register_blocking();
       }
-      else{
-        return false;
-      }
       break;
     case OpType::set_statevec:
-      BaseState::qregs_[iChunk].initialize_from_vector(op.params);
+      initialize_from_vector(iChunk, op.params);
+      break;
+    case OpType::save_expval:
+    case OpType::save_expval_var:
+      BaseState::apply_save_expval(iChunk, op, result);
+      break;
+    case OpType::save_densmat:
+      apply_save_density_matrix(iChunk, op, result);
+      break;
+    case OpType::save_state:
+    case OpType::save_statevec:
+      apply_save_statevector(iChunk, op, result, final_op);
+      break;
+    case OpType::save_statevec_dict:
+      apply_save_statevector_dict(iChunk, op, result);
+      break;
+    case OpType::save_probs:
+    case OpType::save_probs_ket:
+      apply_save_probs(iChunk, op, result);
+      break;
+    case OpType::save_amps:
+    case OpType::save_amps_sq:
+      apply_save_amplitudes(iChunk, op, result);
       break;
     default:
-      //other operations should be called to indivisual chunks by apply_op
+      throw std::invalid_argument("QubitVector::State::invalid instruction \'" +
+                                  op.name + "\'.");
+    }
+  }
+}
+
+template <class statevec_t>
+bool State<statevec_t>::apply_batched_op(const int_t iChunk,
+                                         const Operations::Op &op,
+                                         ExperimentResult &result,
+                                         std::vector<RngEngine> &rng,
+                                         bool final_op) {
+  if (op.conditional) {
+    BaseState::qregs_[iChunk].set_conditional(op.conditional_reg);
+  }
+
+  switch (op.type) {
+  case OpType::barrier:
+  case OpType::nop:
+  case OpType::qerror_loc:
+    break;
+  case OpType::reset:
+    BaseState::qregs_[iChunk].apply_batched_reset(op.qubits, rng);
+    break;
+  case OpType::initialize:
+    BaseState::qregs_[iChunk].apply_batched_reset(op.qubits, rng);
+    BaseState::qregs_[iChunk].initialize_component(op.qubits, op.params);
+    break;
+  case OpType::measure:
+    BaseState::qregs_[iChunk].apply_batched_measure(op.qubits, rng, op.memory,
+                                                    op.registers);
+    break;
+  case OpType::bfunc:
+    BaseState::qregs_[iChunk].apply_bfunc(op);
+    break;
+  case OpType::roerror:
+    BaseState::qregs_[iChunk].apply_roerror(op, rng);
+    break;
+  case OpType::gate:
+    apply_gate(iChunk, op);
+    break;
+  case OpType::matrix:
+    apply_matrix(iChunk, op);
+    break;
+  case OpType::diagonal_matrix:
+    BaseState::qregs_[iChunk].apply_diagonal_matrix(op.qubits, op.params);
+    break;
+  case OpType::multiplexer:
+    apply_multiplexer(iChunk, op.regs[0], op.regs[1],
+                      op.mats); // control qubits ([0]) & target qubits([1])
+    break;
+  case OpType::kraus:
+    BaseState::qregs_[iChunk].apply_batched_kraus(op.qubits, op.mats, rng);
+    break;
+  case OpType::sim_op:
+    if (op.name == "begin_register_blocking") {
+      BaseState::qregs_[iChunk].enter_register_blocking(op.qubits);
+    } else if (op.name == "end_register_blocking") {
+      BaseState::qregs_[iChunk].leave_register_blocking();
+    } else {
       return false;
+    }
+    break;
+  case OpType::set_statevec:
+    BaseState::qregs_[iChunk].initialize_from_vector(op.params);
+    break;
+  default:
+    // other operations should be called to indivisual chunks by apply_op
+    return false;
   }
   return true;
 }
 
-
 //=========================================================================
 // Implementation: Save data
 //=========================================================================
 
 template <class statevec_t>
-void State<statevec_t>::apply_save_probs(const int_t iChunk, const Operations::Op &op,
-                                         ExperimentResult &result) 
-{
+void State<statevec_t>::apply_save_probs(const int_t iChunk,
+                                         const Operations::Op &op,
+                                         ExperimentResult &result) {
   // get probs as hexadecimal
   auto probs = measure_probs(iChunk, op.qubits);
   if (op.type == Operations::OpType::save_probs_ket) {
@@ -845,60 +879,59 @@ void State<statevec_t>::apply_save_probs(const int_t iChunk, const Operations::O
   }
 }
 
-
 template <class statevec_t>
 double State<statevec_t>::expval_pauli(const int_t iChunk, const reg_t &qubits,
-                                       const std::string& pauli) 
-{
-  if(!BaseState::multi_chunk_distribution_)
+                                       const std::string &pauli) {
+  if (!BaseState::multi_chunk_distribution_)
     return BaseState::qregs_[iChunk].expval_pauli(qubits, pauli);
 
-  //multi-chunk distribution
+  // multi-chunk distribution
   reg_t qubits_in_chunk;
   reg_t qubits_out_chunk;
   std::string pauli_in_chunk;
   std::string pauli_out_chunk;
-  int_t i,n;
+  int_t i, n;
   double expval(0.);
 
-  //get inner/outer chunk pauli string
+  // get inner/outer chunk pauli string
   n = pauli.size();
-  for(i=0;i<n;i++){
-    if(qubits[i] < BaseState::chunk_bits_){
+  for (i = 0; i < n; i++) {
+    if (qubits[i] < BaseState::chunk_bits_) {
       qubits_in_chunk.push_back(qubits[i]);
-      pauli_in_chunk.push_back(pauli[n-i-1]);
-    }
-    else{
+      pauli_in_chunk.push_back(pauli[n - i - 1]);
+    } else {
       qubits_out_chunk.push_back(qubits[i]);
-      pauli_out_chunk.push_back(pauli[n-i-1]);
+      pauli_out_chunk.push_back(pauli[n - i - 1]);
     }
   }
 
-  if(qubits_out_chunk.size() > 0){  //there are bits out of chunk
+  if (qubits_out_chunk.size() > 0) { // there are bits out of chunk
     std::complex<double> phase = 1.0;
 
-    std::reverse(pauli_out_chunk.begin(),pauli_out_chunk.end());
-    std::reverse(pauli_in_chunk.begin(),pauli_in_chunk.end());
+    std::reverse(pauli_out_chunk.begin(), pauli_out_chunk.end());
+    std::reverse(pauli_in_chunk.begin(), pauli_in_chunk.end());
 
     uint_t x_mask, z_mask, num_y, x_max;
-    std::tie(x_mask, z_mask, num_y, x_max) = AER::QV::pauli_masks_and_phase(qubits_out_chunk, pauli_out_chunk);
+    std::tie(x_mask, z_mask, num_y, x_max) =
+        AER::QV::pauli_masks_and_phase(qubits_out_chunk, pauli_out_chunk);
 
-    AER::QV::add_y_phase(num_y,phase);
+    AER::QV::add_y_phase(num_y, phase);
 
-    if(x_mask != 0){    //pairing state is out of chunk
+    if (x_mask != 0) { // pairing state is out of chunk
       bool on_same_process = true;
 #ifdef AER_MPI
       int proc_bits = 0;
       uint_t procs = BaseState::distributed_procs_;
-      while(procs > 1){
-        if((procs & 1) != 0){
+      while (procs > 1) {
+        if ((procs & 1) != 0) {
           proc_bits = -1;
           break;
         }
         proc_bits++;
         procs >>= 1;
       }
-      if(x_mask & (~((1ull << (BaseState::num_qubits_ - proc_bits)) - 1)) != 0){    //data exchange between processes is required
+      if (x_mask & (~((1ull << (BaseState::num_qubits_ - proc_bits)) - 1)) !=
+                       0) { // data exchange between processes is required
         on_same_process = false;
       }
 #endif
@@ -909,86 +942,115 @@ double State<statevec_t>::expval_pauli(const int_t iChunk, const reg_t &qubits,
 
       const uint_t mask_u = ~((1ull << (x_max + 1)) - 1);
       const uint_t mask_l = (1ull << x_max) - 1;
-      if(on_same_process){
-        auto apply_expval_pauli_chunk = [this, x_mask, z_mask, x_max,mask_u,mask_l, qubits_in_chunk, pauli_in_chunk, phase](int_t iGroup)
-        {
+      if (on_same_process) {
+        auto apply_expval_pauli_chunk = [this, x_mask, z_mask, x_max, mask_u,
+                                         mask_l, qubits_in_chunk,
+                                         pauli_in_chunk, phase](int_t iGroup) {
           double expval = 0.0;
-          for(int_t iChunk = BaseState::top_chunk_of_group_[iGroup];iChunk < BaseState::top_chunk_of_group_[iGroup + 1];iChunk++){
+          for (int_t iChunk = BaseState::top_chunk_of_group_[iGroup];
+               iChunk < BaseState::top_chunk_of_group_[iGroup + 1]; iChunk++) {
             uint_t pair_chunk = iChunk ^ x_mask;
-            if(iChunk < pair_chunk){
-              uint_t z_count,z_count_pair;
+            if (iChunk < pair_chunk) {
+              uint_t z_count, z_count_pair;
               z_count = AER::Utils::popcount(iChunk & z_mask);
               z_count_pair = AER::Utils::popcount(pair_chunk & z_mask);
 
-              expval += BaseState::qregs_[iChunk-BaseState::global_chunk_index_].expval_pauli(qubits_in_chunk, pauli_in_chunk,BaseState::qregs_[pair_chunk],z_count,z_count_pair,phase);
+              expval +=
+                  BaseState::qregs_[iChunk - BaseState::global_chunk_index_]
+                      .expval_pauli(qubits_in_chunk, pauli_in_chunk,
+                                    BaseState::qregs_[pair_chunk], z_count,
+                                    z_count_pair, phase);
             }
           }
           return expval;
         };
-        expval += Utils::apply_omp_parallel_for_reduction((BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0),0,BaseState::num_global_chunks_/2,apply_expval_pauli_chunk);
-      }
-      else{
-        for(int_t i=0;i<BaseState::num_global_chunks_/2;i++){
+        expval += Utils::apply_omp_parallel_for_reduction(
+            (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0), 0,
+            BaseState::num_global_chunks_ / 2, apply_expval_pauli_chunk);
+      } else {
+        for (int_t i = 0; i < BaseState::num_global_chunks_ / 2; i++) {
           uint_t iChunk = ((i << 1) & mask_u) | (i & mask_l);
           uint_t pair_chunk = iChunk ^ x_mask;
           uint_t iProc = BaseState::get_process_by_chunk(pair_chunk);
-          if(BaseState::chunk_index_begin_[BaseState::distributed_rank_] <= iChunk && BaseState::chunk_index_end_[BaseState::distributed_rank_] > iChunk){  //on this process
-            uint_t z_count,z_count_pair;
+          if (BaseState::chunk_index_begin_[BaseState::distributed_rank_] <=
+                  iChunk &&
+              BaseState::chunk_index_end_[BaseState::distributed_rank_] >
+                  iChunk) { // on this process
+            uint_t z_count, z_count_pair;
             z_count = AER::Utils::popcount(iChunk & z_mask);
             z_count_pair = AER::Utils::popcount(pair_chunk & z_mask);
 
-            if(iProc == BaseState::distributed_rank_){  //pair is on the same process
-              expval += BaseState::qregs_[iChunk-BaseState::global_chunk_index_].expval_pauli(qubits_in_chunk, pauli_in_chunk,BaseState::qregs_[pair_chunk - BaseState::global_chunk_index_],z_count,z_count_pair,phase);
-            }
-            else{
-              BaseState::recv_chunk(iChunk-BaseState::global_chunk_index_,pair_chunk);
-              //refer receive buffer to calculate expectation value
-              expval += BaseState::qregs_[iChunk-BaseState::global_chunk_index_].expval_pauli(qubits_in_chunk, pauli_in_chunk,BaseState::qregs_[iChunk-BaseState::global_chunk_index_],z_count,z_count_pair,phase);
+            if (iProc ==
+                BaseState::distributed_rank_) { // pair is on the same process
+              expval +=
+                  BaseState::qregs_[iChunk - BaseState::global_chunk_index_]
+                      .expval_pauli(
+                          qubits_in_chunk, pauli_in_chunk,
+                          BaseState::qregs_[pair_chunk -
+                                            BaseState::global_chunk_index_],
+                          z_count, z_count_pair, phase);
+            } else {
+              BaseState::recv_chunk(iChunk - BaseState::global_chunk_index_,
+                                    pair_chunk);
+              // refer receive buffer to calculate expectation value
+              expval +=
+                  BaseState::qregs_[iChunk - BaseState::global_chunk_index_]
+                      .expval_pauli(
+                          qubits_in_chunk, pauli_in_chunk,
+                          BaseState::qregs_[iChunk -
+                                            BaseState::global_chunk_index_],
+                          z_count, z_count_pair, phase);
             }
-          }
-          else if(iProc == BaseState::distributed_rank_){  //pair is on this process
-            BaseState::send_chunk(iChunk-BaseState::global_chunk_index_,pair_chunk);
+          } else if (iProc ==
+                     BaseState::distributed_rank_) { // pair is on this process
+            BaseState::send_chunk(iChunk - BaseState::global_chunk_index_,
+                                  pair_chunk);
           }
         }
       }
-    }
-    else{ //no exchange between chunks
+    } else { // no exchange between chunks
       z_mask >>= BaseState::chunk_bits_;
-      if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1){
-#pragma omp parallel for reduction(+:expval)
-        for(int_t ig=0;ig<BaseState::num_groups_;ig++){
+      if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1) {
+#pragma omp parallel for reduction(+ : expval)
+        for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
           double e_tmp = 0.0;
-          for(int_t iChunk = BaseState::top_chunk_of_group_[ig];iChunk < BaseState::top_chunk_of_group_[ig + 1];iChunk++){
+          for (int_t iChunk = BaseState::top_chunk_of_group_[ig];
+               iChunk < BaseState::top_chunk_of_group_[ig + 1]; iChunk++) {
             double sign = 1.0;
-            if (z_mask && (AER::Utils::popcount((iChunk + BaseState::global_chunk_index_) & z_mask) & 1))
+            if (z_mask &&
+                (AER::Utils::popcount(
+                     (iChunk + BaseState::global_chunk_index_) & z_mask) &
+                 1))
               sign = -1.0;
-            e_tmp += sign * BaseState::qregs_[iChunk].expval_pauli(qubits_in_chunk, pauli_in_chunk);
+            e_tmp += sign * BaseState::qregs_[iChunk].expval_pauli(
+                                qubits_in_chunk, pauli_in_chunk);
           }
           expval += e_tmp;
         }
-      }
-      else{
-        for(i=0;i<BaseState::qregs_.size();i++){
+      } else {
+        for (i = 0; i < BaseState::qregs_.size(); i++) {
           double sign = 1.0;
-          if (z_mask && (AER::Utils::popcount((i + BaseState::global_chunk_index_) & z_mask) & 1))
+          if (z_mask && (AER::Utils::popcount(
+                             (i + BaseState::global_chunk_index_) & z_mask) &
+                         1))
             sign = -1.0;
-          expval += sign * BaseState::qregs_[i].expval_pauli(qubits_in_chunk, pauli_in_chunk);
+          expval += sign * BaseState::qregs_[i].expval_pauli(qubits_in_chunk,
+                                                             pauli_in_chunk);
         }
       }
     }
-  }
-  else{ //all bits are inside chunk
-    if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1){
-#pragma omp parallel for reduction(+:expval)
-      for(int_t ig=0;ig<BaseState::num_groups_;ig++){
+  } else { // all bits are inside chunk
+    if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1) {
+#pragma omp parallel for reduction(+ : expval)
+      for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
         double e_tmp = 0.0;
-        for(int_t iChunk = BaseState::top_chunk_of_group_[ig];iChunk < BaseState::top_chunk_of_group_[ig + 1];iChunk++)
+        for (int_t iChunk = BaseState::top_chunk_of_group_[ig];
+             iChunk < BaseState::top_chunk_of_group_[ig + 1]; iChunk++)
           e_tmp += BaseState::qregs_[iChunk].expval_pauli(qubits, pauli);
         expval += e_tmp;
       }
-    }
-    else{
-      for(i=0;i<BaseState::qregs_.size();i++)
+    } else {
+      for (i = 0; i < BaseState::qregs_.size(); i++)
         expval += BaseState::qregs_[i].expval_pauli(qubits, pauli);
     }
   }
@@ -1000,83 +1062,82 @@ double State<statevec_t>::expval_pauli(const int_t iChunk, const reg_t &qubits,
 }
 
 template <class statevec_t>
-void State<statevec_t>::apply_save_statevector(const int_t iChunk, const Operations::Op &op,
+void State<statevec_t>::apply_save_statevector(const int_t iChunk,
+                                               const Operations::Op &op,
                                                ExperimentResult &result,
-                                               bool last_op) 
-{
+                                               bool last_op) {
   if (op.qubits.size() != BaseState::num_qubits_) {
-    throw std::invalid_argument(
-        op.name + " was not applied to all qubits."
-        " Only the full statevector can be saved.");
+    throw std::invalid_argument(op.name +
+                                " was not applied to all qubits."
+                                " Only the full statevector can be saved.");
   }
-  std::string key = (op.string_params[0] == "_method_")
-                      ? "statevector"
-                      : op.string_params[0];
+  std::string key =
+      (op.string_params[0] == "_method_") ? "statevector" : op.string_params[0];
 
   if (last_op) {
     auto v = move_to_vector(iChunk);
     result.save_data_pershot(BaseState::chunk_creg(iChunk), key, std::move(v),
-                                  OpType::save_statevec, op.save_type);
+                             OpType::save_statevec, op.save_type);
   } else {
-    result.save_data_pershot(BaseState::chunk_creg(iChunk), key, copy_to_vector(iChunk),
-                                OpType::save_statevec, op.save_type);
+    result.save_data_pershot(BaseState::chunk_creg(iChunk), key,
+                             copy_to_vector(iChunk), OpType::save_statevec,
+                             op.save_type);
   }
 }
 
 template <class statevec_t>
-void State<statevec_t>::apply_save_statevector_dict(const int_t iChunk, const Operations::Op &op,
-                                                   ExperimentResult &result) 
-{
+void State<statevec_t>::apply_save_statevector_dict(const int_t iChunk,
+                                                    const Operations::Op &op,
+                                                    ExperimentResult &result) {
   if (op.qubits.size() != BaseState::num_qubits_) {
-    throw std::invalid_argument(
-        op.name + " was not applied to all qubits."
-        " Only the full statevector can be saved.");
+    throw std::invalid_argument(op.name +
+                                " was not applied to all qubits."
+                                " Only the full statevector can be saved.");
   }
-  if(BaseState::multi_chunk_distribution_){
+  if (BaseState::multi_chunk_distribution_) {
     auto vec = copy_to_vector(iChunk);
     std::map<std::string, complex_t> result_state_ket;
     for (size_t k = 0; k < vec.size(); ++k) {
-      if (std::abs(vec[k]) >= json_chop_threshold_){
+      if (std::abs(vec[k]) >= json_chop_threshold_) {
         std::string key = Utils::int2hex(k);
         result_state_ket.insert({key, vec[k]});
       }
     }
     result.save_data_pershot(BaseState::chunk_creg(iChunk), op.string_params[0],
-                                 std::move(result_state_ket), op.type, op.save_type);
-  }
-  else{
+                             std::move(result_state_ket), op.type,
+                             op.save_type);
+  } else {
     auto state_ket = BaseState::qregs_[iChunk].vector_ket(json_chop_threshold_);
     std::map<std::string, complex_t> result_state_ket;
-    for (auto const& it : state_ket){
+    for (auto const &it : state_ket) {
       result_state_ket[it.first] = it.second;
     }
     result.save_data_pershot(BaseState::chunk_creg(iChunk), op.string_params[0],
-                                 std::move(result_state_ket), op.type, op.save_type);
+                             std::move(result_state_ket), op.type,
+                             op.save_type);
   }
 }
 
 template <class statevec_t>
-void State<statevec_t>::apply_save_density_matrix(const int_t iChunk, const Operations::Op &op,
-                                                  ExperimentResult &result) 
-{
+void State<statevec_t>::apply_save_density_matrix(const int_t iChunk,
+                                                  const Operations::Op &op,
+                                                  ExperimentResult &result) {
   cmatrix_t reduced_state;
 
   // Check if tracing over all qubits
   if (op.qubits.empty()) {
     reduced_state = cmatrix_t(1, 1);
 
-    if(!BaseState::multi_chunk_distribution_){
+    if (!BaseState::multi_chunk_distribution_) {
       reduced_state[0] = BaseState::qregs_[iChunk].norm();
-    }
-    else{
+    } else {
       double sum = 0.0;
-      if(BaseState::chunk_omp_parallel_){
-#pragma omp parallel for reduction(+:sum)
-        for(int_t i=0;i<BaseState::qregs_.size();i++)
+      if (BaseState::chunk_omp_parallel_) {
+#pragma omp parallel for reduction(+ : sum)
+        for (int_t i = 0; i < BaseState::qregs_.size(); i++)
           sum += BaseState::qregs_[i].norm();
-      }
-      else{
-        for(int_t i=0;i<BaseState::qregs_.size();i++)
+      } else {
+        for (int_t i = 0; i < BaseState::qregs_.size(); i++)
           sum += BaseState::qregs_[i].norm();
       }
 #ifdef AER_MPI
@@ -1093,27 +1154,30 @@ void State<statevec_t>::apply_save_density_matrix(const int_t iChunk, const Oper
 }
 
 template <class statevec_t>
-void State<statevec_t>::apply_save_amplitudes(const int_t iChunkIn, const Operations::Op &op,
-                                              ExperimentResult &result) 
-{
+void State<statevec_t>::apply_save_amplitudes(const int_t iChunkIn,
+                                              const Operations::Op &op,
+                                              ExperimentResult &result) {
   if (op.int_params.empty()) {
-    throw std::invalid_argument("Invalid save_amplitudes instructions (empty params).");
+    throw std::invalid_argument(
+        "Invalid save_amplitudes instructions (empty params).");
   }
   const int_t size = op.int_params.size();
   if (op.type == Operations::OpType::save_amps) {
     Vector<complex_t> amps(size, false);
-    if(!BaseState::multi_chunk_distribution_){
+    if (!BaseState::multi_chunk_distribution_) {
       for (int_t i = 0; i < size; ++i) {
         amps[i] = BaseState::qregs_[iChunkIn].get_state(op.int_params[i]);
       }
-    }
-    else{
+    } else {
       for (int_t i = 0; i < size; ++i) {
         uint_t idx = BaseState::mapped_index(op.int_params[i]);
         uint_t iChunk = idx >> BaseState::chunk_bits_;
         amps[i] = 0.0;
-        if(iChunk >= BaseState::global_chunk_index_ && iChunk < BaseState::global_chunk_index_ + BaseState::qregs_.size()){
-          amps[i] = BaseState::qregs_[iChunk - BaseState::global_chunk_index_].get_state(idx - (iChunk << BaseState::chunk_bits_));
+        if (iChunk >= BaseState::global_chunk_index_ &&
+            iChunk <
+                BaseState::global_chunk_index_ + BaseState::qregs_.size()) {
+          amps[i] = BaseState::qregs_[iChunk - BaseState::global_chunk_index_]
+                        .get_state(idx - (iChunk << BaseState::chunk_bits_));
         }
 #ifdef AER_MPI
         complex_t amp = amps[i];
@@ -1122,30 +1186,34 @@ void State<statevec_t>::apply_save_amplitudes(const int_t iChunkIn, const Operat
 #endif
       }
     }
-    result.save_data_pershot(BaseState::chunk_creg(iChunkIn), op.string_params[0],
-                                 std::move(amps), op.type, op.save_type);
-  }
-  else{
-    rvector_t amps_sq(size,0);
-    if(!BaseState::multi_chunk_distribution_){
+    result.save_data_pershot(BaseState::chunk_creg(iChunkIn),
+                             op.string_params[0], std::move(amps), op.type,
+                             op.save_type);
+  } else {
+    rvector_t amps_sq(size, 0);
+    if (!BaseState::multi_chunk_distribution_) {
       for (int_t i = 0; i < size; ++i) {
         amps_sq[i] = BaseState::qregs_[iChunkIn].probability(op.int_params[i]);
       }
-    }
-    else{
+    } else {
       for (int_t i = 0; i < size; ++i) {
         uint_t idx = BaseState::mapped_index(op.int_params[i]);
         uint_t iChunk = idx >> BaseState::chunk_bits_;
-        if(iChunk >= BaseState::global_chunk_index_ && iChunk < BaseState::global_chunk_index_ + BaseState::qregs_.size()){
-          amps_sq[i] = BaseState::qregs_[iChunk - BaseState::global_chunk_index_].probability(idx - (iChunk << BaseState::chunk_bits_));
+        if (iChunk >= BaseState::global_chunk_index_ &&
+            iChunk <
+                BaseState::global_chunk_index_ + BaseState::qregs_.size()) {
+          amps_sq[i] =
+              BaseState::qregs_[iChunk - BaseState::global_chunk_index_]
+                  .probability(idx - (iChunk << BaseState::chunk_bits_));
         }
       }
 #ifdef AER_MPI
       BaseState::reduce_sum(amps_sq);
 #endif
     }
-   result.save_data_average(BaseState::chunk_creg(iChunkIn), op.string_params[0],
-                            std::move(amps_sq), op.type, op.save_type);
+    result.save_data_average(BaseState::chunk_creg(iChunkIn),
+                             op.string_params[0], std::move(amps_sq), op.type,
+                             op.save_type);
   }
 }
 
@@ -1154,9 +1222,9 @@ void State<statevec_t>::apply_save_amplitudes(const int_t iChunkIn, const Operat
 //=========================================================================
 
 template <class statevec_t>
-void State<statevec_t>::apply_snapshot(const int_t iChunk, const Operations::Op &op,
-                                       ExperimentResult &result,
-                                       bool last_op) {
+void State<statevec_t>::apply_snapshot(const int_t iChunk,
+                                       const Operations::Op &op,
+                                       ExperimentResult &result, bool last_op) {
 
   // Look for snapshot type in snapshotset
   auto it = snapshotset_.find(op.name);
@@ -1164,82 +1232,82 @@ void State<statevec_t>::apply_snapshot(const int_t iChunk, const Operations::Op
     throw std::invalid_argument(
         "QubitVectorState::invalid snapshot instruction \'" + op.name + "\'.");
   switch (it->second) {
-    case Snapshots::statevector:
-      if (last_op) {
-        result.legacy_data.add_pershot_snapshot("statevector", op.string_params[0],
-                                         move_to_vector(iChunk));
-      } else {
-        result.legacy_data.add_pershot_snapshot("statevector", op.string_params[0],
-                                         copy_to_vector(iChunk));
-      }
-      break;
-    case Snapshots::cmemory:
-      BaseState::snapshot_creg_memory(iChunk, op, result);
-      break;
-    case Snapshots::cregister:
-      BaseState::snapshot_creg_register(iChunk, op, result);
-      break;
-    case Snapshots::probs: {
-      // get probs as hexadecimal
-      snapshot_probabilities(iChunk, op, result, SnapshotDataType::average);
-    } break;
-    case Snapshots::densmat: {
-      snapshot_density_matrix(iChunk, op, result, SnapshotDataType::average);
-    } break;
-    case Snapshots::expval_pauli: {
-      snapshot_pauli_expval(iChunk, op, result, SnapshotDataType::average);
-    } break;
-    case Snapshots::expval_matrix: {
-      snapshot_matrix_expval(iChunk, op, result, SnapshotDataType::average);
-    } break;
-    case Snapshots::probs_var: {
-      // get probs as hexadecimal
-      snapshot_probabilities(iChunk, op, result, SnapshotDataType::average_var);
-    } break;
-    case Snapshots::densmat_var: {
-      snapshot_density_matrix(iChunk, op, result, SnapshotDataType::average_var);
-    } break;
-    case Snapshots::expval_pauli_var: {
-      snapshot_pauli_expval(iChunk, op, result, SnapshotDataType::average_var);
-    } break;
-    case Snapshots::expval_matrix_var: {
-      snapshot_matrix_expval(iChunk, op, result, SnapshotDataType::average_var);
-    } break;
-    case Snapshots::expval_pauli_shot: {
-      snapshot_pauli_expval(iChunk, op, result, SnapshotDataType::pershot);
-    } break;
-    case Snapshots::expval_matrix_shot: {
-      snapshot_matrix_expval(iChunk, op, result, SnapshotDataType::pershot);
-    } break;
-    default:
-      // We shouldn't get here unless there is a bug in the snapshotset
-      throw std::invalid_argument(
-          "QubitVector::State::invalid snapshot instruction \'" + op.name +
-          "\'.");
+  case Snapshots::statevector:
+    if (last_op) {
+      result.legacy_data.add_pershot_snapshot(
+          "statevector", op.string_params[0], move_to_vector(iChunk));
+    } else {
+      result.legacy_data.add_pershot_snapshot(
+          "statevector", op.string_params[0], copy_to_vector(iChunk));
+    }
+    break;
+  case Snapshots::cmemory:
+    BaseState::snapshot_creg_memory(iChunk, op, result);
+    break;
+  case Snapshots::cregister:
+    BaseState::snapshot_creg_register(iChunk, op, result);
+    break;
+  case Snapshots::probs: {
+    // get probs as hexadecimal
+    snapshot_probabilities(iChunk, op, result, SnapshotDataType::average);
+  } break;
+  case Snapshots::densmat: {
+    snapshot_density_matrix(iChunk, op, result, SnapshotDataType::average);
+  } break;
+  case Snapshots::expval_pauli: {
+    snapshot_pauli_expval(iChunk, op, result, SnapshotDataType::average);
+  } break;
+  case Snapshots::expval_matrix: {
+    snapshot_matrix_expval(iChunk, op, result, SnapshotDataType::average);
+  } break;
+  case Snapshots::probs_var: {
+    // get probs as hexadecimal
+    snapshot_probabilities(iChunk, op, result, SnapshotDataType::average_var);
+  } break;
+  case Snapshots::densmat_var: {
+    snapshot_density_matrix(iChunk, op, result, SnapshotDataType::average_var);
+  } break;
+  case Snapshots::expval_pauli_var: {
+    snapshot_pauli_expval(iChunk, op, result, SnapshotDataType::average_var);
+  } break;
+  case Snapshots::expval_matrix_var: {
+    snapshot_matrix_expval(iChunk, op, result, SnapshotDataType::average_var);
+  } break;
+  case Snapshots::expval_pauli_shot: {
+    snapshot_pauli_expval(iChunk, op, result, SnapshotDataType::pershot);
+  } break;
+  case Snapshots::expval_matrix_shot: {
+    snapshot_matrix_expval(iChunk, op, result, SnapshotDataType::pershot);
+  } break;
+  default:
+    // We shouldn't get here unless there is a bug in the snapshotset
+    throw std::invalid_argument(
+        "QubitVector::State::invalid snapshot instruction \'" + op.name +
+        "\'.");
   }
 }
 
 template <class statevec_t>
-void State<statevec_t>::snapshot_probabilities(const int_t iChunk, const Operations::Op &op,
+void State<statevec_t>::snapshot_probabilities(const int_t iChunk,
+                                               const Operations::Op &op,
                                                ExperimentResult &result,
-                                               SnapshotDataType type) 
-{
+                                               SnapshotDataType type) {
   // get probs as hexadecimal
   int_t ishot = BaseState::get_global_shot_index(iChunk);
 
-  auto probs =
-      Utils::vec2ket(measure_probs(iChunk, op.qubits), json_chop_threshold_, 16);
+  auto probs = Utils::vec2ket(measure_probs(iChunk, op.qubits),
+                              json_chop_threshold_, 16);
   bool variance = type == SnapshotDataType::average_var;
   result.legacy_data.add_average_snapshot("probabilities", op.string_params[0],
-                                   BaseState::cregs_[ishot].memory_hex(),
-                                   std::move(probs), variance);
+                                          BaseState::cregs_[ishot].memory_hex(),
+                                          std::move(probs), variance);
 }
 
 template <class statevec_t>
-void State<statevec_t>::snapshot_pauli_expval(const int_t iChunk, const Operations::Op &op,
+void State<statevec_t>::snapshot_pauli_expval(const int_t iChunk,
+                                              const Operations::Op &op,
                                               ExperimentResult &result,
-                                              SnapshotDataType type) 
-{
+                                              SnapshotDataType type) {
   // Check empty edge case
   if (op.params_expval_pauli.empty()) {
     throw std::invalid_argument(
@@ -1259,25 +1327,27 @@ void State<statevec_t>::snapshot_pauli_expval(const int_t iChunk, const Operatio
   Utils::chop_inplace(expval, json_chop_threshold_);
   switch (type) {
   case SnapshotDataType::average:
-    result.legacy_data.add_average_snapshot("expectation_value", op.string_params[0],
-                              BaseState::cregs_[ishot].memory_hex(), expval, false);
+    result.legacy_data.add_average_snapshot(
+        "expectation_value", op.string_params[0],
+        BaseState::cregs_[ishot].memory_hex(), expval, false);
     break;
   case SnapshotDataType::average_var:
-    result.legacy_data.add_average_snapshot("expectation_value", op.string_params[0],
-                              BaseState::cregs_[ishot].memory_hex(), expval, true);
+    result.legacy_data.add_average_snapshot(
+        "expectation_value", op.string_params[0],
+        BaseState::cregs_[ishot].memory_hex(), expval, true);
     break;
   case SnapshotDataType::pershot:
-    result.legacy_data.add_pershot_snapshot("expectation_values", op.string_params[0],
-                              expval);
+    result.legacy_data.add_pershot_snapshot("expectation_values",
+                                            op.string_params[0], expval);
     break;
   }
 }
 
 template <class statevec_t>
-void State<statevec_t>::snapshot_matrix_expval(const int_t iChunk, const Operations::Op &op,
+void State<statevec_t>::snapshot_matrix_expval(const int_t iChunk,
+                                               const Operations::Op &op,
                                                ExperimentResult &result,
-                                               SnapshotDataType type) 
-{
+                                               SnapshotDataType type) {
   // Check empty edge case
   if (op.params_expval_matrix.empty()) {
     throw std::invalid_argument(
@@ -1287,16 +1357,15 @@ void State<statevec_t>::snapshot_matrix_expval(const int_t iChunk, const Operati
 
   reg_t qubits = op.qubits;
   // Cache the current quantum state
-  if(!BaseState::multi_chunk_distribution_)
+  if (!BaseState::multi_chunk_distribution_)
     BaseState::qregs_[iChunk].checkpoint();
-  else{
-    if(BaseState::chunk_omp_parallel_){
-#pragma omp parallel for 
-      for(int_t i=0;i<BaseState::qregs_.size();i++)
+  else {
+    if (BaseState::chunk_omp_parallel_) {
+#pragma omp parallel for
+      for (int_t i = 0; i < BaseState::qregs_.size(); i++)
         BaseState::qregs_[i].checkpoint();
-    }
-    else{
-      for(int_t i=0;i<BaseState::qregs_.size();i++)
+    } else {
+      for (int_t i = 0; i < BaseState::qregs_.size(); i++)
         BaseState::qregs_[i].checkpoint();
     }
   }
@@ -1311,17 +1380,16 @@ void State<statevec_t>::snapshot_matrix_expval(const int_t iChunk, const Operati
     // Revert the quantum state to cached checkpoint
     if (first)
       first = false;
-    else{
-      if(!BaseState::multi_chunk_distribution_)
+    else {
+      if (!BaseState::multi_chunk_distribution_)
         BaseState::qregs_[iChunk].revert(true);
-      else{
-        if(BaseState::chunk_omp_parallel_){
-#pragma omp parallel for 
-          for(int_t i=0;i<BaseState::qregs_.size();i++)
+      else {
+        if (BaseState::chunk_omp_parallel_) {
+#pragma omp parallel for
+          for (int_t i = 0; i < BaseState::qregs_.size(); i++)
             BaseState::qregs_[i].revert(true);
-        }
-        else{
-          for(int_t i=0;i<BaseState::qregs_.size();i++)
+        } else {
+          for (int_t i = 0; i < BaseState::qregs_.size(); i++)
             BaseState::qregs_[i].revert(true);
         }
       }
@@ -1340,30 +1408,28 @@ void State<statevec_t>::snapshot_matrix_expval(const int_t iChunk, const Operati
               : Utils::vectorize_matrix(mat); // diagonal or square matrix case
 
       if (vmat.size() == 1ULL << qubits.size()) {
-        if(!BaseState::multi_chunk_distribution_)
+        if (!BaseState::multi_chunk_distribution_)
           apply_diagonal_matrix(iChunk, sub_qubits, vmat);
-        else{
-          if(BaseState::chunk_omp_parallel_){
+        else {
+          if (BaseState::chunk_omp_parallel_) {
 #pragma omp parallel for
-            for(int_t i=0;i<BaseState::qregs_.size();i++)
+            for (int_t i = 0; i < BaseState::qregs_.size(); i++)
               apply_diagonal_matrix(i, sub_qubits, vmat);
-          }
-          else{
-            for(int_t i=0;i<BaseState::qregs_.size();i++)
+          } else {
+            for (int_t i = 0; i < BaseState::qregs_.size(); i++)
               apply_diagonal_matrix(i, sub_qubits, vmat);
           }
         }
       } else {
-        if(!BaseState::multi_chunk_distribution_)
+        if (!BaseState::multi_chunk_distribution_)
           BaseState::qregs_[iChunk].apply_matrix(sub_qubits, vmat);
-        else{
-          if(BaseState::chunk_omp_parallel_){
-#pragma omp parallel for 
-            for(int_t i=0;i<BaseState::qregs_.size();i++)
+        else {
+          if (BaseState::chunk_omp_parallel_) {
+#pragma omp parallel for
+            for (int_t i = 0; i < BaseState::qregs_.size(); i++)
               BaseState::qregs_[i].apply_matrix(sub_qubits, vmat);
-          }
-          else{
-            for(int_t i=0;i<BaseState::qregs_.size();i++)
+          } else {
+            for (int_t i = 0; i < BaseState::qregs_.size(); i++)
               BaseState::qregs_[i].apply_matrix(sub_qubits, vmat);
           }
         }
@@ -1371,33 +1437,31 @@ void State<statevec_t>::snapshot_matrix_expval(const int_t iChunk, const Operati
     }
     double exp_re = 0.0;
     double exp_im = 0.0;
-    if(!BaseState::multi_chunk_distribution_){
-      auto exp_tmp = coeff*BaseState::qregs_[iChunk].inner_product();
+    if (!BaseState::multi_chunk_distribution_) {
+      auto exp_tmp = coeff * BaseState::qregs_[iChunk].inner_product();
       exp_re += exp_tmp.real();
       exp_im += exp_tmp.imag();
-    }
-    else{
-      if(BaseState::chunk_omp_parallel_){
-#pragma omp parallel for reduction(+:exp_re,exp_im)
-        for(int_t i=0;i<BaseState::qregs_.size();i++){
-          auto exp_tmp = coeff*BaseState::qregs_[i].inner_product();
+    } else {
+      if (BaseState::chunk_omp_parallel_) {
+#pragma omp parallel for reduction(+ : exp_re, exp_im)
+        for (int_t i = 0; i < BaseState::qregs_.size(); i++) {
+          auto exp_tmp = coeff * BaseState::qregs_[i].inner_product();
           exp_re += exp_tmp.real();
           exp_im += exp_tmp.imag();
         }
-      }
-      else{
-        for(int_t i=0;i<BaseState::qregs_.size();i++){
-          auto exp_tmp = coeff*BaseState::qregs_[i].inner_product();
+      } else {
+        for (int_t i = 0; i < BaseState::qregs_.size(); i++) {
+          auto exp_tmp = coeff * BaseState::qregs_[i].inner_product();
           exp_re += exp_tmp.real();
           exp_im += exp_tmp.imag();
         }
       }
     }
-    complex_t t(exp_re,exp_im);
+    complex_t t(exp_re, exp_im);
     expval += t;
   }
 #ifdef AER_MPI
-  if(BaseState::multi_chunk_distribution_)
+  if (BaseState::multi_chunk_distribution_)
     BaseState::reduce_sum(expval);
 #endif
 
@@ -1405,36 +1469,38 @@ void State<statevec_t>::snapshot_matrix_expval(const int_t iChunk, const Operati
   Utils::chop_inplace(expval, json_chop_threshold_);
   switch (type) {
   case SnapshotDataType::average:
-    result.legacy_data.add_average_snapshot("expectation_value", op.string_params[0],
-                              BaseState::cregs_[ishot].memory_hex(), expval, false);
+    result.legacy_data.add_average_snapshot(
+        "expectation_value", op.string_params[0],
+        BaseState::cregs_[ishot].memory_hex(), expval, false);
     break;
   case SnapshotDataType::average_var:
-    result.legacy_data.add_average_snapshot("expectation_value", op.string_params[0],
-                              BaseState::cregs_[ishot].memory_hex(), expval, true);
+    result.legacy_data.add_average_snapshot(
+        "expectation_value", op.string_params[0],
+        BaseState::cregs_[ishot].memory_hex(), expval, true);
     break;
   case SnapshotDataType::pershot:
-    result.legacy_data.add_pershot_snapshot("expectation_values", op.string_params[0],
-                              expval);
+    result.legacy_data.add_pershot_snapshot("expectation_values",
+                                            op.string_params[0], expval);
     break;
   }
   // Revert to original state
-  if(!BaseState::multi_chunk_distribution_)
+  if (!BaseState::multi_chunk_distribution_)
     BaseState::qregs_[iChunk].revert(false);
-  else{
-    if(BaseState::chunk_omp_parallel_){
-#pragma omp parallel for 
-      for(int_t i=0;i<BaseState::qregs_.size();i++)
+  else {
+    if (BaseState::chunk_omp_parallel_) {
+#pragma omp parallel for
+      for (int_t i = 0; i < BaseState::qregs_.size(); i++)
         BaseState::qregs_[i].revert(false);
-    }
-    else{
-      for(int_t i=0;i<BaseState::qregs_.size();i++)
+    } else {
+      for (int_t i = 0; i < BaseState::qregs_.size(); i++)
         BaseState::qregs_[i].revert(false);
     }
   }
 }
 
 template <class statevec_t>
-void State<statevec_t>::snapshot_density_matrix(const int_t iChunk, const Operations::Op &op,
+void State<statevec_t>::snapshot_density_matrix(const int_t iChunk,
+                                                const Operations::Op &op,
                                                 ExperimentResult &result,
                                                 SnapshotDataType type) {
   cmatrix_t reduced_state;
@@ -1444,17 +1510,16 @@ void State<statevec_t>::snapshot_density_matrix(const int_t iChunk, const Operat
   if (op.qubits.empty()) {
     reduced_state = cmatrix_t(1, 1);
 
-    if(!BaseState::multi_chunk_distribution_)
+    if (!BaseState::multi_chunk_distribution_)
       reduced_state[0] = BaseState::qregs_[iChunk].norm();
-    else{
+    else {
       double sum = 0.0;
-      if(BaseState::chunk_omp_parallel_){
-#pragma omp parallel for reduction(+:sum)
-        for(int_t i=0;i<BaseState::qregs_.size();i++)
+      if (BaseState::chunk_omp_parallel_) {
+#pragma omp parallel for reduction(+ : sum)
+        for (int_t i = 0; i < BaseState::qregs_.size(); i++)
           sum += BaseState::qregs_[i].norm();
-      }
-      else{
-        for(int_t i=0;i<BaseState::qregs_.size();i++)
+      } else {
+        for (int_t i = 0; i < BaseState::qregs_.size(); i++)
           sum += BaseState::qregs_[i].norm();
       }
 #ifdef AER_MPI
@@ -1469,25 +1534,25 @@ void State<statevec_t>::snapshot_density_matrix(const int_t iChunk, const Operat
   // Add density matrix to result data
   switch (type) {
   case SnapshotDataType::average:
-    result.legacy_data.add_average_snapshot("density_matrix", op.string_params[0],
-                              BaseState::cregs_[ishot].memory_hex(),
-                              std::move(reduced_state), false);
+    result.legacy_data.add_average_snapshot(
+        "density_matrix", op.string_params[0],
+        BaseState::cregs_[ishot].memory_hex(), std::move(reduced_state), false);
     break;
   case SnapshotDataType::average_var:
-    result.legacy_data.add_average_snapshot("density_matrix", op.string_params[0],
-                              BaseState::cregs_[ishot].memory_hex(),
-                              std::move(reduced_state), true);
+    result.legacy_data.add_average_snapshot(
+        "density_matrix", op.string_params[0],
+        BaseState::cregs_[ishot].memory_hex(), std::move(reduced_state), true);
     break;
   case SnapshotDataType::pershot:
-    result.legacy_data.add_pershot_snapshot("density_matrix", op.string_params[0],
-                              std::move(reduced_state));
+    result.legacy_data.add_pershot_snapshot(
+        "density_matrix", op.string_params[0], std::move(reduced_state));
     break;
   }
 }
 
 template <class statevec_t>
-cmatrix_t State<statevec_t>::density_matrix(const int_t iChunk, const reg_t &qubits) 
-{
+cmatrix_t State<statevec_t>::density_matrix(const int_t iChunk,
+                                            const reg_t &qubits) {
   return vec2density(qubits, copy_to_vector(iChunk));
 }
 
@@ -1541,18 +1606,19 @@ cmatrix_t State<statevec_t>::vec2density(const reg_t &qubits, const T &vec) {
 //=========================================================================
 
 template <class statevec_t>
-void State<statevec_t>::apply_gate(const int_t iChunk, const Operations::Op &op) 
-{
-  if(!BaseState::global_chunk_indexing_){
-    reg_t qubits_in,qubits_out;
-    BaseState::get_inout_ctrl_qubits(op,qubits_out,qubits_in);
-    if(qubits_out.size() > 0){
+void State<statevec_t>::apply_gate(const int_t iChunk,
+                                   const Operations::Op &op) {
+  if (!BaseState::global_chunk_indexing_) {
+    reg_t qubits_in, qubits_out;
+    BaseState::get_inout_ctrl_qubits(op, qubits_out, qubits_in);
+    if (qubits_out.size() > 0) {
       uint_t mask = 0;
-      for(int i=0;i<qubits_out.size();i++){
+      for (int i = 0; i < qubits_out.size(); i++) {
         mask |= (1ull << (qubits_out[i] - BaseState::chunk_bits_));
       }
-      if(((BaseState::global_chunk_index_ + iChunk) & mask) == mask){
-        Operations::Op new_op = BaseState::remake_gate_in_chunk_qubits(op,qubits_in);
+      if (((BaseState::global_chunk_index_ + iChunk) & mask) == mask) {
+        Operations::Op new_op =
+            BaseState::remake_gate_in_chunk_qubits(op, qubits_in);
         apply_gate(iChunk, new_op);
       }
       return;
@@ -1565,131 +1631,141 @@ void State<statevec_t>::apply_gate(const int_t iChunk, const Operations::Op &op)
     throw std::invalid_argument(
         "QubitVectorState::invalid gate instruction \'" + op.name + "\'.");
   switch (it->second) {
-    case Gates::mcx:
-      // Includes X, CX, CCX, etc
-      BaseState::qregs_[iChunk].apply_mcx(op.qubits);
-      break;
-    case Gates::mcy:
-      // Includes Y, CY, CCY, etc
-      BaseState::qregs_[iChunk].apply_mcy(op.qubits);
-      break;
-    case Gates::mcz:
-      // Includes Z, CZ, CCZ, etc
-      BaseState::qregs_[iChunk].apply_mcphase(op.qubits, -1);
-      break;
-    case Gates::mcr:
-      BaseState::qregs_[iChunk].apply_mcu(op.qubits, Linalg::VMatrix::r(op.params[0], op.params[1]));
-      break;
-    case Gates::mcrx:
-      BaseState::qregs_[iChunk].apply_rotation(op.qubits, QV::Rotation::x, std::real(op.params[0]));
-      break;
-    case Gates::mcry:
-      BaseState::qregs_[iChunk].apply_rotation(op.qubits, QV::Rotation::y, std::real(op.params[0]));
-      break;
-    case Gates::mcrz:
-      BaseState::qregs_[iChunk].apply_rotation(op.qubits, QV::Rotation::z, std::real(op.params[0]));
-      break;
-    case Gates::rxx:
-      BaseState::qregs_[iChunk].apply_rotation(op.qubits, QV::Rotation::xx, std::real(op.params[0]));
-      break;
-    case Gates::ryy:
-      BaseState::qregs_[iChunk].apply_rotation(op.qubits, QV::Rotation::yy, std::real(op.params[0]));
-      break;
-    case Gates::rzz:
-      BaseState::qregs_[iChunk].apply_rotation(op.qubits, QV::Rotation::zz, std::real(op.params[0]));
-      break;
-    case Gates::rzx:
-      BaseState::qregs_[iChunk].apply_rotation(op.qubits, QV::Rotation::zx, std::real(op.params[0]));
-      break;
-    case Gates::id:
-      break;
-    case Gates::h:
-      apply_gate_mcu(iChunk, op.qubits, M_PI / 2., 0., M_PI, 0.);
-      break;
-    case Gates::s:
-      apply_gate_phase(iChunk, op.qubits[0], complex_t(0., 1.));
-      break;
-    case Gates::sdg:
-      apply_gate_phase(iChunk, op.qubits[0], complex_t(0., -1.));
-      break;
-    case Gates::t: {
-      const double isqrt2{1. / std::sqrt(2)};
-      apply_gate_phase(iChunk, op.qubits[0], complex_t(isqrt2, isqrt2));
-    } break;
-    case Gates::tdg: {
-      const double isqrt2{1. / std::sqrt(2)};
-      apply_gate_phase(iChunk, op.qubits[0], complex_t(isqrt2, -isqrt2));
-    } break;
-    case Gates::mcswap:
-      // Includes SWAP, CSWAP, etc
-      BaseState::qregs_[iChunk].apply_mcswap(op.qubits);
-      break;
-    case Gates::mcu3:
-      // Includes u3, cu3, etc
-      apply_gate_mcu(iChunk, op.qubits, std::real(op.params[0]), std::real(op.params[1]),
-                     std::real(op.params[2]), 0.);
-      break;
-    case Gates::mcu:
-      // Includes u3, cu3, etc
-      apply_gate_mcu(iChunk, op.qubits, std::real(op.params[0]), std::real(op.params[1]),
-                      std::real(op.params[2]), std::real(op.params[3]));
-      break;
-    case Gates::mcu2:
-      // Includes u2, cu2, etc
-      apply_gate_mcu(iChunk, op.qubits, M_PI / 2., std::real(op.params[0]),
-                     std::real(op.params[1]), 0.);
-      break;
-    case Gates::mcp:
-      // Includes u1, cu1, p, cp, mcp etc
-      BaseState::qregs_[iChunk].apply_mcphase(op.qubits,
-                                     std::exp(complex_t(0, 1) * op.params[0]));
-      break;
-    case Gates::mcsx:
-      // Includes sx, csx, mcsx etc
-      BaseState::qregs_[iChunk].apply_mcu(op.qubits, Linalg::VMatrix::SX);
-      break;
-    case Gates::mcsxdg:
-      BaseState::qregs_[iChunk].apply_mcu(op.qubits, Linalg::VMatrix::SXDG);
-      break;
-    case Gates::pauli:
-      BaseState::qregs_[iChunk].apply_pauli(op.qubits, op.string_params[0]);
-      break;
-    default:
-      // We shouldn't reach here unless there is a bug in gateset
-      throw std::invalid_argument(
-          "QubitVector::State::invalid gate instruction \'" + op.name + "\'.");
+  case Gates::mcx:
+    // Includes X, CX, CCX, etc
+    BaseState::qregs_[iChunk].apply_mcx(op.qubits);
+    break;
+  case Gates::mcy:
+    // Includes Y, CY, CCY, etc
+    BaseState::qregs_[iChunk].apply_mcy(op.qubits);
+    break;
+  case Gates::mcz:
+    // Includes Z, CZ, CCZ, etc
+    BaseState::qregs_[iChunk].apply_mcphase(op.qubits, -1);
+    break;
+  case Gates::mcr:
+    BaseState::qregs_[iChunk].apply_mcu(
+        op.qubits, Linalg::VMatrix::r(op.params[0], op.params[1]));
+    break;
+  case Gates::mcrx:
+    BaseState::qregs_[iChunk].apply_rotation(op.qubits, QV::Rotation::x,
+                                             std::real(op.params[0]));
+    break;
+  case Gates::mcry:
+    BaseState::qregs_[iChunk].apply_rotation(op.qubits, QV::Rotation::y,
+                                             std::real(op.params[0]));
+    break;
+  case Gates::mcrz:
+    BaseState::qregs_[iChunk].apply_rotation(op.qubits, QV::Rotation::z,
+                                             std::real(op.params[0]));
+    break;
+  case Gates::rxx:
+    BaseState::qregs_[iChunk].apply_rotation(op.qubits, QV::Rotation::xx,
+                                             std::real(op.params[0]));
+    break;
+  case Gates::ryy:
+    BaseState::qregs_[iChunk].apply_rotation(op.qubits, QV::Rotation::yy,
+                                             std::real(op.params[0]));
+    break;
+  case Gates::rzz:
+    BaseState::qregs_[iChunk].apply_rotation(op.qubits, QV::Rotation::zz,
+                                             std::real(op.params[0]));
+    break;
+  case Gates::rzx:
+    BaseState::qregs_[iChunk].apply_rotation(op.qubits, QV::Rotation::zx,
+                                             std::real(op.params[0]));
+    break;
+  case Gates::id:
+    break;
+  case Gates::h:
+    apply_gate_mcu(iChunk, op.qubits, M_PI / 2., 0., M_PI, 0.);
+    break;
+  case Gates::s:
+    apply_gate_phase(iChunk, op.qubits[0], complex_t(0., 1.));
+    break;
+  case Gates::sdg:
+    apply_gate_phase(iChunk, op.qubits[0], complex_t(0., -1.));
+    break;
+  case Gates::t: {
+    const double isqrt2{1. / std::sqrt(2)};
+    apply_gate_phase(iChunk, op.qubits[0], complex_t(isqrt2, isqrt2));
+  } break;
+  case Gates::tdg: {
+    const double isqrt2{1. / std::sqrt(2)};
+    apply_gate_phase(iChunk, op.qubits[0], complex_t(isqrt2, -isqrt2));
+  } break;
+  case Gates::mcswap:
+    // Includes SWAP, CSWAP, etc
+    BaseState::qregs_[iChunk].apply_mcswap(op.qubits);
+    break;
+  case Gates::mcu3:
+    // Includes u3, cu3, etc
+    apply_gate_mcu(iChunk, op.qubits, std::real(op.params[0]),
+                   std::real(op.params[1]), std::real(op.params[2]), 0.);
+    break;
+  case Gates::mcu:
+    // Includes u3, cu3, etc
+    apply_gate_mcu(iChunk, op.qubits, std::real(op.params[0]),
+                   std::real(op.params[1]), std::real(op.params[2]),
+                   std::real(op.params[3]));
+    break;
+  case Gates::mcu2:
+    // Includes u2, cu2, etc
+    apply_gate_mcu(iChunk, op.qubits, M_PI / 2., std::real(op.params[0]),
+                   std::real(op.params[1]), 0.);
+    break;
+  case Gates::mcp:
+    // Includes u1, cu1, p, cp, mcp etc
+    BaseState::qregs_[iChunk].apply_mcphase(
+        op.qubits, std::exp(complex_t(0, 1) * op.params[0]));
+    break;
+  case Gates::mcsx:
+    // Includes sx, csx, mcsx etc
+    BaseState::qregs_[iChunk].apply_mcu(op.qubits, Linalg::VMatrix::SX);
+    break;
+  case Gates::mcsxdg:
+    BaseState::qregs_[iChunk].apply_mcu(op.qubits, Linalg::VMatrix::SXDG);
+    break;
+  case Gates::pauli:
+    BaseState::qregs_[iChunk].apply_pauli(op.qubits, op.string_params[0]);
+    break;
+  default:
+    // We shouldn't reach here unless there is a bug in gateset
+    throw std::invalid_argument(
+        "QubitVector::State::invalid gate instruction \'" + op.name + "\'.");
   }
 }
 
 template <class statevec_t>
-void State<statevec_t>::apply_multiplexer(const int_t iChunk, const reg_t &control_qubits,
+void State<statevec_t>::apply_multiplexer(const int_t iChunk,
+                                          const reg_t &control_qubits,
                                           const reg_t &target_qubits,
-                                          const cmatrix_t &mat) 
-{
+                                          const cmatrix_t &mat) {
   if (control_qubits.empty() == false && target_qubits.empty() == false &&
       mat.size() > 0) {
     cvector_t vmat = Utils::vectorize_matrix(mat);
-    BaseState::qregs_[iChunk].apply_multiplexer(control_qubits, target_qubits, vmat);
+    BaseState::qregs_[iChunk].apply_multiplexer(control_qubits, target_qubits,
+                                                vmat);
   }
 }
 
 template <class statevec_t>
-void State<statevec_t>::apply_matrix(const int_t iChunk, const Operations::Op &op) 
-{
+void State<statevec_t>::apply_matrix(const int_t iChunk,
+                                     const Operations::Op &op) {
   if (op.qubits.empty() == false && op.mats[0].size() > 0) {
     if (Utils::is_diagonal(op.mats[0], .0)) {
-      apply_diagonal_matrix(iChunk, op.qubits, Utils::matrix_diagonal(op.mats[0]));
+      apply_diagonal_matrix(iChunk, op.qubits,
+                            Utils::matrix_diagonal(op.mats[0]));
     } else {
-      BaseState::qregs_[iChunk].apply_matrix(op.qubits,
-                                    Utils::vectorize_matrix(op.mats[0]));
+      BaseState::qregs_[iChunk].apply_matrix(
+          op.qubits, Utils::vectorize_matrix(op.mats[0]));
     }
   }
 }
 
 template <class statevec_t>
 void State<statevec_t>::apply_matrix(const int_t iChunk, const reg_t &qubits,
-                                     const cvector_t &vmat) 
-{
+                                     const cvector_t &vmat) {
   // Check if diagonal matrix
   if (vmat.size() == 1ULL << qubits.size()) {
     apply_diagonal_matrix(iChunk, qubits, vmat);
@@ -1699,31 +1775,34 @@ void State<statevec_t>::apply_matrix(const int_t iChunk, const reg_t &qubits,
 }
 
 template <class statevec_t>
-void State<statevec_t>::apply_diagonal_matrix(const int_t iChunk, const reg_t &qubits, const cvector_t & diag)
-{
-  if(BaseState::global_chunk_indexing_ || !BaseState::multi_chunk_distribution_){
-    //GPU computes all chunks in one kernel, so pass qubits and diagonal matrix as is
-    BaseState::qregs_[iChunk].apply_diagonal_matrix(qubits,diag);
-  }
-  else{
+void State<statevec_t>::apply_diagonal_matrix(const int_t iChunk,
+                                              const reg_t &qubits,
+                                              const cvector_t &diag) {
+  if (BaseState::global_chunk_indexing_ ||
+      !BaseState::multi_chunk_distribution_) {
+    // GPU computes all chunks in one kernel, so pass qubits and diagonal matrix
+    // as is
+    BaseState::qregs_[iChunk].apply_diagonal_matrix(qubits, diag);
+  } else {
     reg_t qubits_in = qubits;
     cvector_t diag_in = diag;
 
-    BaseState::block_diagonal_matrix(iChunk,qubits_in,diag_in);
-    BaseState::qregs_[iChunk].apply_diagonal_matrix(qubits_in,diag_in);
+    BaseState::block_diagonal_matrix(iChunk, qubits_in, diag_in);
+    BaseState::qregs_[iChunk].apply_diagonal_matrix(qubits_in, diag_in);
   }
 }
 
 template <class statevec_t>
-void State<statevec_t>::apply_gate_mcu(const int_t iChunk, const reg_t &qubits, double theta,
-                                       double phi, double lambda, double gamma) 
-{
-  BaseState::qregs_[iChunk].apply_mcu(qubits, Linalg::VMatrix::u4(theta, phi, lambda, gamma));
+void State<statevec_t>::apply_gate_mcu(const int_t iChunk, const reg_t &qubits,
+                                       double theta, double phi, double lambda,
+                                       double gamma) {
+  BaseState::qregs_[iChunk].apply_mcu(
+      qubits, Linalg::VMatrix::u4(theta, phi, lambda, gamma));
 }
 
 template <class statevec_t>
-void State<statevec_t>::apply_gate_phase(const int_t iChunk, uint_t qubit, complex_t phase) 
-{
+void State<statevec_t>::apply_gate_phase(const int_t iChunk, uint_t qubit,
+                                         complex_t phase) {
   cvector_t diag = {{1., phase}};
   apply_diagonal_matrix(iChunk, reg_t({qubit}), diag);
 }
@@ -1733,9 +1812,9 @@ void State<statevec_t>::apply_gate_phase(const int_t iChunk, uint_t qubit, compl
 //=========================================================================
 
 template <class statevec_t>
-void State<statevec_t>::apply_measure(const int_t iChunk, const reg_t &qubits, const reg_t &cmemory,
-                                      const reg_t &cregister, RngEngine &rng) 
-{
+void State<statevec_t>::apply_measure(const int_t iChunk, const reg_t &qubits,
+                                      const reg_t &cmemory,
+                                      const reg_t &cregister, RngEngine &rng) {
   int_t ishot = BaseState::get_global_shot_index(iChunk);
   // Actual measurement outcome
   const auto meas = sample_measure_with_prob(iChunk, qubits, rng);
@@ -1746,74 +1825,76 @@ void State<statevec_t>::apply_measure(const int_t iChunk, const reg_t &qubits, c
 }
 
 template <class statevec_t>
-rvector_t State<statevec_t>::measure_probs(const int_t iChunk, const reg_t &qubits) const 
-{
-  if(!BaseState::multi_chunk_distribution_)
+rvector_t State<statevec_t>::measure_probs(const int_t iChunk,
+                                           const reg_t &qubits) const {
+  if (!BaseState::multi_chunk_distribution_)
     return BaseState::qregs_[iChunk].probabilities(qubits);
 
   uint_t dim = 1ull << qubits.size();
-  rvector_t sum(dim,0.0);
-  int_t i,j,k;
+  rvector_t sum(dim, 0.0);
+  int_t i, j, k;
   reg_t qubits_in_chunk;
   reg_t qubits_out_chunk;
 
-  BaseState::qubits_inout(qubits,qubits_in_chunk,qubits_out_chunk);
+  BaseState::qubits_inout(qubits, qubits_in_chunk, qubits_out_chunk);
 
-  if(qubits_in_chunk.size() > 0){
-    if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0){
-#pragma omp parallel for private(i,j,k) 
-      for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-        for(int_t i = BaseState::top_chunk_of_group_[ig];i < BaseState::top_chunk_of_group_[ig + 1];i++){
+  if (qubits_in_chunk.size() > 0) {
+    if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0) {
+#pragma omp parallel for private(i, j, k)
+      for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+        for (int_t i = BaseState::top_chunk_of_group_[ig];
+             i < BaseState::top_chunk_of_group_[ig + 1]; i++) {
           auto chunkSum = BaseState::qregs_[i].probabilities(qubits_in_chunk);
 
-          if(qubits_in_chunk.size() == qubits.size()){
-            for(j=0;j<dim;j++){
-#pragma omp atomic 
+          if (qubits_in_chunk.size() == qubits.size()) {
+            for (j = 0; j < dim; j++) {
+#pragma omp atomic
               sum[j] += chunkSum[j];
             }
-          }
-          else{
-            for(j=0;j<chunkSum.size();j++){
+          } else {
+            for (j = 0; j < chunkSum.size(); j++) {
               int idx = 0;
               int i_in = 0;
-              for(k=0;k<qubits.size();k++){
-                if(qubits[k] < BaseState::chunk_bits_){
+              for (k = 0; k < qubits.size(); k++) {
+                if (qubits[k] < BaseState::chunk_bits_) {
                   idx += (((j >> i_in) & 1) << k);
                   i_in++;
-                }
-                else{
-                  if((((i + BaseState::global_chunk_index_) << BaseState::chunk_bits_) >> qubits[k]) & 1){
+                } else {
+                  if ((((i + BaseState::global_chunk_index_)
+                        << BaseState::chunk_bits_) >>
+                       qubits[k]) &
+                      1) {
                     idx += 1ull << k;
                   }
                 }
               }
-#pragma omp atomic 
+#pragma omp atomic
               sum[idx] += chunkSum[j];
             }
           }
         }
       }
-    }
-    else{
-      for(i=0;i<BaseState::qregs_.size();i++){
+    } else {
+      for (i = 0; i < BaseState::qregs_.size(); i++) {
         auto chunkSum = BaseState::qregs_[i].probabilities(qubits_in_chunk);
 
-        if(qubits_in_chunk.size() == qubits.size()){
-          for(j=0;j<dim;j++){
+        if (qubits_in_chunk.size() == qubits.size()) {
+          for (j = 0; j < dim; j++) {
             sum[j] += chunkSum[j];
           }
-        }
-        else{
-          for(j=0;j<chunkSum.size();j++){
+        } else {
+          for (j = 0; j < chunkSum.size(); j++) {
             int idx = 0;
             int i_in = 0;
-            for(k=0;k<qubits.size();k++){
-              if(qubits[k] < BaseState::chunk_bits_){
+            for (k = 0; k < qubits.size(); k++) {
+              if (qubits[k] < BaseState::chunk_bits_) {
                 idx += (((j >> i_in) & 1) << k);
                 i_in++;
-              }
-              else{
-                if((((i + BaseState::global_chunk_index_) << BaseState::chunk_bits_) >> qubits[k]) & 1){
+              } else {
+                if ((((i + BaseState::global_chunk_index_)
+                      << BaseState::chunk_bits_) >>
+                     qubits[k]) &
+                    1) {
                   idx += 1ull << k;
                 }
               }
@@ -1823,16 +1904,19 @@ rvector_t State<statevec_t>::measure_probs(const int_t iChunk, const reg_t &qubi
         }
       }
     }
-  }
-  else{ //there is no bit in chunk
-    if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0){
-#pragma omp parallel for private(i,j,k) 
-      for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-        for(int_t i = BaseState::top_chunk_of_group_[ig];i < BaseState::top_chunk_of_group_[ig + 1];i++){
+  } else { // there is no bit in chunk
+    if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0) {
+#pragma omp parallel for private(i, j, k)
+      for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+        for (int_t i = BaseState::top_chunk_of_group_[ig];
+             i < BaseState::top_chunk_of_group_[ig + 1]; i++) {
           auto nr = std::real(BaseState::qregs_[i].norm());
           int idx = 0;
-          for(k=0;k<qubits_out_chunk.size();k++){
-            if((((i + BaseState::global_chunk_index_) << (BaseState::chunk_bits_)) >> qubits_out_chunk[k]) & 1){
+          for (k = 0; k < qubits_out_chunk.size(); k++) {
+            if ((((i + BaseState::global_chunk_index_)
+                  << (BaseState::chunk_bits_)) >>
+                 qubits_out_chunk[k]) &
+                1) {
               idx += 1ull << k;
             }
           }
@@ -1840,13 +1924,15 @@ rvector_t State<statevec_t>::measure_probs(const int_t iChunk, const reg_t &qubi
           sum[idx] += nr;
         }
       }
-    }
-    else{
-      for(i=0;i<BaseState::qregs_.size();i++){
+    } else {
+      for (i = 0; i < BaseState::qregs_.size(); i++) {
         auto nr = std::real(BaseState::qregs_[i].norm());
         int idx = 0;
-        for(k=0;k<qubits_out_chunk.size();k++){
-          if((((i + BaseState::global_chunk_index_) << (BaseState::chunk_bits_)) >> qubits_out_chunk[k]) & 1){
+        for (k = 0; k < qubits_out_chunk.size(); k++) {
+          if ((((i + BaseState::global_chunk_index_)
+                << (BaseState::chunk_bits_)) >>
+               qubits_out_chunk[k]) &
+              1) {
             idx += 1ull << k;
           }
         }
@@ -1860,11 +1946,11 @@ rvector_t State<statevec_t>::measure_probs(const int_t iChunk, const reg_t &qubi
 #endif
 
   return sum;
-
 }
 
 template <class statevec_t>
-void State<statevec_t>::apply_reset(const int_t iChunk, const reg_t &qubits, RngEngine &rng) {
+void State<statevec_t>::apply_reset(const int_t iChunk, const reg_t &qubits,
+                                    RngEngine &rng) {
   // Simulate unobserved measurement
   const auto meas = sample_measure_with_prob(iChunk, qubits, rng);
   // Apply update to reset state
@@ -1872,9 +1958,8 @@ void State<statevec_t>::apply_reset(const int_t iChunk, const reg_t &qubits, Rng
 }
 
 template <class statevec_t>
-std::pair<uint_t, double>
-State<statevec_t>::sample_measure_with_prob(const int_t iChunk, const reg_t &qubits,
-                                            RngEngine &rng) {
+std::pair<uint_t, double> State<statevec_t>::sample_measure_with_prob(
+    const int_t iChunk, const reg_t &qubits, RngEngine &rng) {
   rvector_t probs = measure_probs(iChunk, qubits);
   // Randomly pick outcome and return pair
   uint_t outcome = rng.rand_int(probs);
@@ -1882,11 +1967,11 @@ State<statevec_t>::sample_measure_with_prob(const int_t iChunk, const reg_t &qub
 }
 
 template <class statevec_t>
-void State<statevec_t>::measure_reset_update(const int_t iChunk, const std::vector<uint_t> &qubits,
+void State<statevec_t>::measure_reset_update(const int_t iChunk,
+                                             const std::vector<uint_t> &qubits,
                                              const uint_t final_state,
                                              const uint_t meas_state,
-                                             const double meas_prob) 
-{
+                                             const double meas_prob) {
   // Update a state vector based on an outcome pair [m, p] from
   // sample_measure_with_prob function, and a desired post-measurement
   // final_state
@@ -1897,19 +1982,20 @@ void State<statevec_t>::measure_reset_update(const int_t iChunk, const std::vect
     cvector_t mdiag(2, 0.);
     mdiag[meas_state] = 1. / std::sqrt(meas_prob);
 
-    if(!BaseState::multi_chunk_distribution_)
+    if (!BaseState::multi_chunk_distribution_)
       BaseState::qregs_[iChunk].apply_diagonal_matrix(qubits, mdiag);
-    else{
-      if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1){
-#pragma omp parallel for  
-        for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-          for(int_t ic = BaseState::top_chunk_of_group_[ig];ic < BaseState::top_chunk_of_group_[ig + 1];ic++)
+    else {
+      if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1) {
+#pragma omp parallel for
+        for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+          for (int_t ic = BaseState::top_chunk_of_group_[ig];
+               ic < BaseState::top_chunk_of_group_[ig + 1]; ic++)
             apply_diagonal_matrix(ic, qubits, mdiag);
         }
-      }
-      else{
-        for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-          for(int_t ic = BaseState::top_chunk_of_group_[ig];ic < BaseState::top_chunk_of_group_[ig + 1];ic++)
+      } else {
+        for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+          for (int_t ic = BaseState::top_chunk_of_group_[ig];
+               ic < BaseState::top_chunk_of_group_[ig + 1]; ic++)
             apply_diagonal_matrix(ic, qubits, mdiag);
         }
       }
@@ -1917,7 +2003,7 @@ void State<statevec_t>::measure_reset_update(const int_t iChunk, const std::vect
 
     // If it doesn't agree with the reset state update
     if (final_state != meas_state) {
-      if(!BaseState::multi_chunk_distribution_)
+      if (!BaseState::multi_chunk_distribution_)
         BaseState::qregs_[iChunk].apply_mcx(qubits);
       else
         BaseState::apply_chunk_x(qubits[0]);
@@ -1930,19 +2016,20 @@ void State<statevec_t>::measure_reset_update(const int_t iChunk, const std::vect
     cvector_t mdiag(dim, 0.);
     mdiag[meas_state] = 1. / std::sqrt(meas_prob);
 
-    if(!BaseState::multi_chunk_distribution_)
+    if (!BaseState::multi_chunk_distribution_)
       BaseState::qregs_[iChunk].apply_diagonal_matrix(qubits, mdiag);
-    else{
-      if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1){
-#pragma omp parallel for 
-        for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-          for(int_t ic = BaseState::top_chunk_of_group_[ig];ic < BaseState::top_chunk_of_group_[ig + 1];ic++)
+    else {
+      if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1) {
+#pragma omp parallel for
+        for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+          for (int_t ic = BaseState::top_chunk_of_group_[ig];
+               ic < BaseState::top_chunk_of_group_[ig + 1]; ic++)
             apply_diagonal_matrix(ic, qubits, mdiag);
         }
-      }
-      else{
-        for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-          for(int_t ic = BaseState::top_chunk_of_group_[ig];ic < BaseState::top_chunk_of_group_[ig + 1];ic++)
+      } else {
+        for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+          for (int_t ic = BaseState::top_chunk_of_group_[ig];
+               ic < BaseState::top_chunk_of_group_[ig + 1]; ic++)
             apply_diagonal_matrix(ic, qubits, mdiag);
         }
       }
@@ -1954,9 +2041,11 @@ void State<statevec_t>::measure_reset_update(const int_t iChunk, const std::vect
       reg_t qubits_in_chunk;
       reg_t qubits_out_chunk;
 
-      BaseState::qubits_inout(qubits,qubits_in_chunk,qubits_out_chunk);
+      BaseState::qubits_inout(qubits, qubits_in_chunk, qubits_out_chunk);
 
-      if(!BaseState::multi_chunk_distribution_ || qubits_in_chunk.size() == qubits.size()){   //all bits are inside chunk
+      if (!BaseState::multi_chunk_distribution_ ||
+          qubits_in_chunk.size() ==
+              qubits.size()) { // all bits are inside chunk
         // build vectorized permutation matrix
         cvector_t perm(dim * dim, 0.);
         perm[final_state * dim + meas_state] = 1.;
@@ -1967,10 +2056,9 @@ void State<statevec_t>::measure_reset_update(const int_t iChunk, const std::vect
         }
         // apply permutation to swap state
         apply_matrix(iChunk, qubits, perm);
-      }
-      else{
-        for(int_t i=0;i<qubits.size();i++){
-          if(((final_state >> i) & 1) != ((meas_state >> i) & 1)){
+      } else {
+        for (int_t i = 0; i < qubits.size(); i++) {
+          if (((final_state >> i) & 1) != ((meas_state >> i) & 1)) {
             BaseState::apply_chunk_x(qubits[i]);
           }
         }
@@ -1982,38 +2070,40 @@ void State<statevec_t>::measure_reset_update(const int_t iChunk, const std::vect
 template <class statevec_t>
 std::vector<reg_t> State<statevec_t>::sample_measure(const reg_t &qubits,
                                                      uint_t shots,
-                                                     RngEngine &rng) 
-{
-  int_t i,j;
+                                                     RngEngine &rng) {
+  int_t i, j;
   // Generate flat register for storing
   std::vector<double> rnds;
   rnds.reserve(shots);
-  reg_t allbit_samples(shots,0);
+  reg_t allbit_samples(shots, 0);
 
   for (i = 0; i < shots; ++i)
     rnds.push_back(rng.rand(0, 1));
 
-  if(!BaseState::multi_chunk_distribution_)
+  if (!BaseState::multi_chunk_distribution_)
     allbit_samples = BaseState::qregs_[0].sample_measure(rnds);
-  else{
-    std::vector<double> chunkSum(BaseState::qregs_.size()+1,0);
-    double sum,localSum;
-
-    //calculate per chunk sum
-    if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1){
-#pragma omp parallel for 
-      for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-        for(int_t ic = BaseState::top_chunk_of_group_[ig];ic < BaseState::top_chunk_of_group_[ig + 1];ic++){
-          bool batched = BaseState::qregs_[ic].enable_batch(true);   //return sum of all chunks in group
+  else {
+    std::vector<double> chunkSum(BaseState::qregs_.size() + 1, 0);
+    double sum, localSum;
+
+    // calculate per chunk sum
+    if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1) {
+#pragma omp parallel for
+      for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+        for (int_t ic = BaseState::top_chunk_of_group_[ig];
+             ic < BaseState::top_chunk_of_group_[ig + 1]; ic++) {
+          bool batched = BaseState::qregs_[ic].enable_batch(
+              true); // return sum of all chunks in group
           chunkSum[ic] = BaseState::qregs_[ic].norm();
           BaseState::qregs_[ic].enable_batch(batched);
         }
       }
-    }
-    else{
-      for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-        for(int_t ic = BaseState::top_chunk_of_group_[ig];ic < BaseState::top_chunk_of_group_[ig + 1];ic++){
-          bool batched = BaseState::qregs_[ic].enable_batch(true);   //return sum of all chunks in group
+    } else {
+      for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+        for (int_t ic = BaseState::top_chunk_of_group_[ig];
+             ic < BaseState::top_chunk_of_group_[ig + 1]; ic++) {
+          bool batched = BaseState::qregs_[ic].enable_batch(
+              true); // return sum of all chunks in group
           chunkSum[ic] = BaseState::qregs_[ic].norm();
           BaseState::qregs_[ic].enable_batch(batched);
         }
@@ -2021,7 +2111,7 @@ std::vector<reg_t> State<statevec_t>::sample_measure(const reg_t &qubits,
     }
 
     localSum = 0.0;
-    for(i=0;i<BaseState::qregs_.size();i++){
+    for (i = 0; i < BaseState::qregs_.size(); i++) {
       sum = localSum;
       localSum += chunkSum[i];
       chunkSum[i] = sum;
@@ -2029,48 +2119,50 @@ std::vector<reg_t> State<statevec_t>::sample_measure(const reg_t &qubits,
     chunkSum[BaseState::qregs_.size()] = localSum;
 
     double globalSum = 0.0;
-    if(BaseState::nprocs_ > 1){
+    if (BaseState::nprocs_ > 1) {
       std::vector<double> procTotal(BaseState::nprocs_);
 
-      for(i=0;i<BaseState::nprocs_;i++){
+      for (i = 0; i < BaseState::nprocs_; i++) {
         procTotal[i] = localSum;
       }
 
       BaseState::gather_value(procTotal);
 
-      for(i=0;i<BaseState::myrank_;i++){
+      for (i = 0; i < BaseState::myrank_; i++) {
         globalSum += procTotal[i];
       }
     }
 
-    reg_t local_samples(shots,0);
+    reg_t local_samples(shots, 0);
 
-    //get rnds positions for each chunk
-    for(i=0;i<BaseState::qregs_.size();i++){
+    // get rnds positions for each chunk
+    for (i = 0; i < BaseState::qregs_.size(); i++) {
       uint_t nIn;
       std::vector<uint_t> vIdx;
       std::vector<double> vRnd;
 
-      //find rnds in this chunk
+      // find rnds in this chunk
       nIn = 0;
-      for(j=0;j<shots;j++){
-        if(rnds[j] >= chunkSum[i] + globalSum && rnds[j] < chunkSum[i+1] + globalSum){
+      for (j = 0; j < shots; j++) {
+        if (rnds[j] >= chunkSum[i] + globalSum &&
+            rnds[j] < chunkSum[i + 1] + globalSum) {
           vRnd.push_back(rnds[j] - (globalSum + chunkSum[i]));
           vIdx.push_back(j);
           nIn++;
         }
       }
 
-      if(nIn > 0){
+      if (nIn > 0) {
         auto chunkSamples = BaseState::qregs_[i].sample_measure(vRnd);
 
-        for(j=0;j<chunkSamples.size();j++){
-          local_samples[vIdx[j]] = ((BaseState::global_chunk_index_ + i) << BaseState::chunk_bits_) + chunkSamples[j];
+        for (j = 0; j < chunkSamples.size(); j++) {
+          local_samples[vIdx[j]] =
+              ((BaseState::global_chunk_index_ + i) << BaseState::chunk_bits_) +
+              chunkSamples[j];
         }
       }
     }
 
-
 #ifdef AER_MPI
     BaseState::reduce_sum(local_samples);
 #endif
@@ -2094,10 +2186,10 @@ std::vector<reg_t> State<statevec_t>::sample_measure(const reg_t &qubits,
 }
 
 template <class statevec_t>
-void State<statevec_t>::apply_initialize(const int_t iChunk, const reg_t &qubits,
+void State<statevec_t>::apply_initialize(const int_t iChunk,
+                                         const reg_t &qubits,
                                          const cvector_t &params,
-                                         RngEngine &rng) 
-{
+                                         RngEngine &rng) {
   auto sorted_qubits = qubits;
   std::sort(sorted_qubits.begin(), sorted_qubits.end());
   if (qubits.size() == BaseState::num_qubits_) {
@@ -2112,120 +2204,139 @@ void State<statevec_t>::apply_initialize(const int_t iChunk, const reg_t &qubits
   apply_reset(iChunk, qubits, rng);
 
   // Apply initialize_component
-  if(!BaseState::multi_chunk_distribution_)
+  if (!BaseState::multi_chunk_distribution_)
     BaseState::qregs_[iChunk].initialize_component(qubits, params);
-  else{
+  else {
     reg_t qubits_in_chunk;
     reg_t qubits_out_chunk;
-    BaseState::qubits_inout(qubits,qubits_in_chunk,qubits_out_chunk);
+    BaseState::qubits_inout(qubits, qubits_in_chunk, qubits_out_chunk);
 
-    if(qubits_out_chunk.size() == 0){   //no qubits outside of chunk
-      if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0){
-#pragma omp parallel for 
-        for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-          for(int_t i = BaseState::top_chunk_of_group_[ig];i < BaseState::top_chunk_of_group_[ig + 1];i++)
+    if (qubits_out_chunk.size() == 0) { // no qubits outside of chunk
+      if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0) {
+#pragma omp parallel for
+        for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+          for (int_t i = BaseState::top_chunk_of_group_[ig];
+               i < BaseState::top_chunk_of_group_[ig + 1]; i++)
             BaseState::qregs_[i].initialize_component(qubits, params);
         }
-      }
-      else{
-        for(int_t i=0;i<BaseState::qregs_.size();i++)
+      } else {
+        for (int_t i = 0; i < BaseState::qregs_.size(); i++)
           BaseState::qregs_[i].initialize_component(qubits, params);
       }
-    }
-    else{
-      //scatter base states
-      if(qubits_in_chunk.size() > 0){
-        //scatter inside chunks
+    } else {
+      // scatter base states
+      if (qubits_in_chunk.size() > 0) {
+        // scatter inside chunks
         const size_t dim = 1ULL << qubits_in_chunk.size();
         cvector_t perm(dim * dim, 0.);
-        for(int_t i=0;i<dim;i++){
+        for (int_t i = 0; i < dim; i++) {
           perm[i] = 1.0;
         }
 
-        if(BaseState::chunk_omp_parallel_){
-#pragma omp parallel for 
-          for(int_t i=0;i<BaseState::qregs_.size();i++)
-            apply_matrix(i, qubits_in_chunk, perm );
-        }
-        else{
-          for(int_t i=0;i<BaseState::qregs_.size();i++)
-            apply_matrix(i, qubits_in_chunk, perm );
+        if (BaseState::chunk_omp_parallel_) {
+#pragma omp parallel for
+          for (int_t i = 0; i < BaseState::qregs_.size(); i++)
+            apply_matrix(i, qubits_in_chunk, perm);
+        } else {
+          for (int_t i = 0; i < BaseState::qregs_.size(); i++)
+            apply_matrix(i, qubits_in_chunk, perm);
         }
       }
-      if(qubits_out_chunk.size() > 0){
-        //then scatter outside chunk
+      if (qubits_out_chunk.size() > 0) {
+        // then scatter outside chunk
         auto sorted_qubits_out = qubits_out_chunk;
         std::sort(sorted_qubits_out.begin(), sorted_qubits_out.end());
 
-        for(int_t i=0;i<(1ull << (BaseState::num_qubits_ - BaseState::chunk_bits_ - qubits_out_chunk.size()));i++){
+        for (int_t i = 0;
+             i < (1ull << (BaseState::num_qubits_ - BaseState::chunk_bits_ -
+                           qubits_out_chunk.size()));
+             i++) {
           uint_t baseChunk = 0;
-          uint_t j,ii,t;
+          uint_t j, ii, t;
           ii = i;
-          for(j=0;j<qubits_out_chunk.size();j++){
-            t = ii & ((1ull << qubits_out_chunk[j])-1);
+          for (j = 0; j < qubits_out_chunk.size(); j++) {
+            t = ii & ((1ull << qubits_out_chunk[j]) - 1);
             baseChunk += t;
             ii = (ii - t) << 1;
           }
           baseChunk += ii;
           baseChunk >>= BaseState::chunk_bits_;
 
-          for(j=1;j<(1ull << qubits_out_chunk.size());j++){
+          for (j = 1; j < (1ull << qubits_out_chunk.size()); j++) {
             int_t ic = baseChunk;
-            for(t=0;t<qubits_out_chunk.size();t++){
-              if((j >> t) & 1)
+            for (t = 0; t < qubits_out_chunk.size(); t++) {
+              if ((j >> t) & 1)
                 ic += (1ull << (qubits_out_chunk[t] - BaseState::chunk_bits_));
             }
 
-            if(ic >= BaseState::chunk_index_begin_[BaseState::distributed_rank_] && ic < BaseState::chunk_index_end_[BaseState::distributed_rank_]){    //on this process
-              if(baseChunk >= BaseState::chunk_index_begin_[BaseState::distributed_rank_] && baseChunk < BaseState::chunk_index_end_[BaseState::distributed_rank_]){    //base chunk is on this process
-                BaseState::qregs_[ic].initialize_from_data(BaseState::qregs_[baseChunk].data(),1ull << BaseState::chunk_bits_);
-              }
-              else{
-                BaseState::recv_chunk(ic,baseChunk);
-                //using swap chunk function to release send/recv buffers for Thrust
+            if (ic >= BaseState::chunk_index_begin_
+                          [BaseState::distributed_rank_] &&
+                ic < BaseState::chunk_index_end_
+                         [BaseState::distributed_rank_]) { // on this process
+              if (baseChunk >= BaseState::chunk_index_begin_
+                                   [BaseState::distributed_rank_] &&
+                  baseChunk <
+                      BaseState::chunk_index_end_
+                          [BaseState::distributed_rank_]) { // base chunk is on
+                                                            // this process
+                BaseState::qregs_[ic].initialize_from_data(
+                    BaseState::qregs_[baseChunk].data(),
+                    1ull << BaseState::chunk_bits_);
+              } else {
+                BaseState::recv_chunk(ic, baseChunk);
+                // using swap chunk function to release send/recv buffers for
+                // Thrust
                 reg_t swap(2);
                 swap[0] = BaseState::chunk_bits_;
                 swap[1] = BaseState::chunk_bits_;
-                BaseState::qregs_[ic].apply_chunk_swap(swap,baseChunk);
+                BaseState::qregs_[ic].apply_chunk_swap(swap, baseChunk);
               }
-            }
-            else if(baseChunk >= BaseState::chunk_index_begin_[BaseState::distributed_rank_] && baseChunk < BaseState::chunk_index_end_[BaseState::distributed_rank_]){    //base chunk is on this process
-              BaseState::send_chunk(baseChunk - BaseState::global_chunk_index_,ic);
+            } else if (baseChunk >= BaseState::chunk_index_begin_
+                                        [BaseState::distributed_rank_] &&
+                       baseChunk <
+                           BaseState::chunk_index_end_
+                               [BaseState::distributed_rank_]) { // base chunk
+                                                                 // is on this
+                                                                 // process
+              BaseState::send_chunk(baseChunk - BaseState::global_chunk_index_,
+                                    ic);
             }
           }
         }
       }
 
-      //initialize by params
-      if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0){
-#pragma omp parallel for 
-        for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-          for(int_t i = BaseState::top_chunk_of_group_[ig];i < BaseState::top_chunk_of_group_[ig + 1];i++)
-            apply_diagonal_matrix(i, qubits,params );
+      // initialize by params
+      if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0) {
+#pragma omp parallel for
+        for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+          for (int_t i = BaseState::top_chunk_of_group_[ig];
+               i < BaseState::top_chunk_of_group_[ig + 1]; i++)
+            apply_diagonal_matrix(i, qubits, params);
         }
-      }
-      else{
-        for(int_t i=0;i<BaseState::qregs_.size();i++)
-          apply_diagonal_matrix(i, qubits,params );
+      } else {
+        for (int_t i = 0; i < BaseState::qregs_.size(); i++)
+          apply_diagonal_matrix(i, qubits, params);
       }
     }
   }
 }
 
 template <class statevec_t>
-void State<statevec_t>::initialize_from_vector(const int_t iChunk, const cvector_t &params)
-{
-  if(!BaseState::multi_chunk_distribution_)
+void State<statevec_t>::initialize_from_vector(const int_t iChunk,
+                                               const cvector_t &params) {
+  if (!BaseState::multi_chunk_distribution_)
     BaseState::qregs_[iChunk].initialize_from_vector(params);
-  else{   //multi-chunk distribution
-    uint_t local_offset = BaseState::global_chunk_index_ << BaseState::chunk_bits_;
+  else { // multi-chunk distribution
+    uint_t local_offset = BaseState::global_chunk_index_
+                          << BaseState::chunk_bits_;
 
-#pragma omp parallel for if(BaseState::chunk_omp_parallel_)
-    for(int_t i=0;i<BaseState::qregs_.size();i++){
-      //copy part of state for this chunk
+#pragma omp parallel for if (BaseState::chunk_omp_parallel_)
+    for (int_t i = 0; i < BaseState::qregs_.size(); i++) {
+      // copy part of state for this chunk
       cvector_t tmp(1ull << BaseState::chunk_bits_);
       std::copy(params.begin() + local_offset + (i << BaseState::chunk_bits_),
-                params.begin() + local_offset + ((i+1) << BaseState::chunk_bits_),
+                params.begin() + local_offset +
+                    ((i + 1) << BaseState::chunk_bits_),
                 tmp.begin());
       BaseState::qregs_[i].initialize_from_vector(tmp);
     }
@@ -2237,7 +2348,8 @@ void State<statevec_t>::initialize_from_vector(const int_t iChunk, const cvector
 //=========================================================================
 
 template <class statevec_t>
-void State<statevec_t>::apply_multiplexer(const int_t iChunk, const reg_t &control_qubits,
+void State<statevec_t>::apply_multiplexer(const int_t iChunk,
+                                          const reg_t &control_qubits,
                                           const reg_t &target_qubits,
                                           const std::vector<cmatrix_t> &mmat) {
   // (1) Pack vector of matrices into single (stacked) matrix ... note: matrix
@@ -2254,8 +2366,7 @@ void State<statevec_t>::apply_multiplexer(const int_t iChunk, const reg_t &contr
 template <class statevec_t>
 void State<statevec_t>::apply_kraus(const int_t iChunk, const reg_t &qubits,
                                     const std::vector<cmatrix_t> &kmats,
-                                    RngEngine &rng) 
-{
+                                    RngEngine &rng) {
   // Check edge case for empty Kraus set (this shouldn't happen)
   if (kmats.empty())
     return; // end function early
@@ -2277,21 +2388,20 @@ void State<statevec_t>::apply_kraus(const int_t iChunk, const reg_t &qubits,
     // Calculate probability
     cvector_t vmat = Utils::vectorize_matrix(kmats[j]);
 
-    if(!BaseState::multi_chunk_distribution_){
+    if (!BaseState::multi_chunk_distribution_) {
       p = BaseState::qregs_[iChunk].norm(qubits, vmat);
       accum += p;
-    }
-    else{
+    } else {
       p = 0.0;
-      if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0){
-#pragma omp parallel for reduction(+:p)
-        for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-          for(int_t i = BaseState::top_chunk_of_group_[ig];i < BaseState::top_chunk_of_group_[ig + 1];i++)
+      if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0) {
+#pragma omp parallel for reduction(+ : p)
+        for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+          for (int_t i = BaseState::top_chunk_of_group_[ig];
+               i < BaseState::top_chunk_of_group_[ig + 1]; i++)
             p += BaseState::qregs_[i].norm(qubits, vmat);
         }
-      }
-      else{
-        for(int_t i=0;i<BaseState::qregs_.size();i++)
+      } else {
+        for (int_t i = 0; i < BaseState::qregs_.size(); i++)
           p += BaseState::qregs_[i].norm(qubits, vmat);
       }
 
@@ -2306,19 +2416,20 @@ void State<statevec_t>::apply_kraus(const int_t iChunk, const reg_t &qubits,
       // rescale vmat so projection is normalized
       Utils::scalar_multiply_inplace(vmat, 1 / std::sqrt(p));
       // apply Kraus projection operator
-      if(!BaseState::multi_chunk_distribution_)
+      if (!BaseState::multi_chunk_distribution_)
         apply_matrix(iChunk, qubits, vmat);
-      else{
-        if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1){
-#pragma omp parallel for 
-          for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-            for(int_t ic = BaseState::top_chunk_of_group_[ig];ic < BaseState::top_chunk_of_group_[ig + 1];ic++)
+      else {
+        if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1) {
+#pragma omp parallel for
+          for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+            for (int_t ic = BaseState::top_chunk_of_group_[ig];
+                 ic < BaseState::top_chunk_of_group_[ig + 1]; ic++)
               apply_matrix(ic, qubits, vmat);
           }
-        }
-        else{
-          for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-            for(int_t ic = BaseState::top_chunk_of_group_[ig];ic < BaseState::top_chunk_of_group_[ig + 1];ic++)
+        } else {
+          for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+            for (int_t ic = BaseState::top_chunk_of_group_[ig];
+                 ic < BaseState::top_chunk_of_group_[ig + 1]; ic++)
               apply_matrix(ic, qubits, vmat);
           }
         }
@@ -2333,19 +2444,20 @@ void State<statevec_t>::apply_kraus(const int_t iChunk, const reg_t &qubits,
     // Compute probability from accumulated
     complex_t renorm = 1 / std::sqrt(1. - accum);
     auto vmat = Utils::vectorize_matrix(renorm * kmats.back());
-    if(!BaseState::multi_chunk_distribution_)
+    if (!BaseState::multi_chunk_distribution_)
       apply_matrix(iChunk, qubits, vmat);
-    else{
-      if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1){
-#pragma omp parallel for 
-        for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-          for(int_t ic = BaseState::top_chunk_of_group_[ig];ic < BaseState::top_chunk_of_group_[ig + 1];ic++)
+    else {
+      if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 1) {
+#pragma omp parallel for
+        for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+          for (int_t ic = BaseState::top_chunk_of_group_[ig];
+               ic < BaseState::top_chunk_of_group_[ig + 1]; ic++)
             apply_matrix(ic, qubits, vmat);
         }
-      }
-      else{
-        for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-          for(int_t ic = BaseState::top_chunk_of_group_[ig];ic < BaseState::top_chunk_of_group_[ig + 1];ic++)
+      } else {
+        for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+          for (int_t ic = BaseState::top_chunk_of_group_[ig];
+               ic < BaseState::top_chunk_of_group_[ig + 1]; ic++)
             apply_matrix(ic, qubits, vmat);
         }
       }
@@ -2353,7 +2465,6 @@ void State<statevec_t>::apply_kraus(const int_t iChunk, const reg_t &qubits,
   }
 }
 
-
 //-------------------------------------------------------------------------
 } // namespace Statevector
 //-------------------------------------------------------------------------
diff --git a/src/simulators/statevector/transformer.hpp b/src/simulators/statevector/transformer.hpp
old mode 100755
new mode 100644
index 02a973aab8..c9b43a2a78
--- a/src/simulators/statevector/transformer.hpp
+++ b/src/simulators/statevector/transformer.hpp
@@ -28,7 +28,6 @@ template <typename Container, typename data_t = double> class Transformer {
   // TODO: This class should have the indexes.hpp moved inside it
 
 public:
-
   virtual ~Transformer() {}
   //-----------------------------------------------------------------------
   // Apply Matrices
@@ -39,13 +38,14 @@ template <typename Container, typename data_t = double> class Transformer {
   // matrix.
 
   virtual void apply_matrix(Container &data, size_t data_size, int threads,
-                           const reg_t &qubits, const cvector_t<double> &mat) const;
+                            const reg_t &qubits,
+                            const cvector_t<double> &mat) const;
 
   // Apply a N-qubit diagonal matrix to a array container
   // The matrix is input as vector of the matrix diagonal.
   virtual void apply_diagonal_matrix(Container &data, size_t data_size,
-                                    int threads, const reg_t &qubits,
-                                    const cvector_t<double> &diag) const;
+                                     int threads, const reg_t &qubits,
+                                     const cvector_t<double> &diag) const;
 
 protected:
   // Apply a N-qubit matrix to the state vector.
@@ -53,16 +53,16 @@ template <typename Container, typename data_t = double> class Transformer {
   // matrix.
   template <size_t N>
   void apply_matrix_n(Container &data, size_t data_size, int threads,
-                             const reg_t &qubits, const cvector_t<double> &mat) const;
+                      const reg_t &qubits, const cvector_t<double> &mat) const;
 
   // Specialized single qubit apply matrix function
   void apply_matrix_1(Container &data, size_t data_size, int threads,
-                             const uint_t qubit, const cvector_t<double> &mat) const;
+                      const uint_t qubit, const cvector_t<double> &mat) const;
 
   // Specialized single qubit apply matrix function
-  void apply_diagonal_matrix_1(Container &data, size_t data_size,
-                                      int threads, const uint_t qubit,
-                                      const cvector_t<double> &mat) const;
+  void apply_diagonal_matrix_1(Container &data, size_t data_size, int threads,
+                               const uint_t qubit,
+                               const cvector_t<double> &mat) const;
 
   // Convert a matrix to a different type
   // TODO: this makes an unnecessary copy when data_t = double.
@@ -76,7 +76,8 @@ template <typename Container, typename data_t = double> class Transformer {
  ******************************************************************************/
 
 template <typename Container, typename data_t>
-cvector_t<data_t> Transformer<Container, data_t>::convert(const cvector_t<double> &v) const {
+cvector_t<data_t>
+Transformer<Container, data_t>::convert(const cvector_t<double> &v) const {
   cvector_t<data_t> ret(v.size());
   for (size_t i = 0; i < v.size(); ++i)
     ret[i] = v[i];
@@ -84,63 +85,63 @@ cvector_t<data_t> Transformer<Container, data_t>::convert(const cvector_t<double
 }
 
 template <typename Container, typename data_t>
-void Transformer<Container, data_t>::apply_matrix(Container &data, size_t data_size,
-                                       int threads, const reg_t &qubits,
-                                       const cvector_t<double> &mat) const {
+void Transformer<Container, data_t>::apply_matrix(
+    Container &data, size_t data_size, int threads, const reg_t &qubits,
+    const cvector_t<double> &mat) const {
   // Static array optimized lambda functions
   switch (qubits.size()) {
-    case 1:
-      return apply_matrix_1(data, data_size, threads, qubits[0], mat);
-    case 2:
-      return apply_matrix_n<2>(data, data_size, threads, qubits, mat);
-    case 3:
-      return apply_matrix_n<3>(data, data_size, threads, qubits, mat);
-    case 4:
-      return apply_matrix_n<4>(data, data_size, threads, qubits, mat);
-    case 5:
-      return apply_matrix_n<5>(data, data_size, threads, qubits, mat);
-    case 6:
-      return apply_matrix_n<6>(data, data_size, threads, qubits, mat);
-    case 7:
-      return apply_matrix_n<7>(data, data_size, threads, qubits, mat);
-    case 8:
-      return apply_matrix_n<8>(data, data_size, threads, qubits, mat);
-    case 9:
-      return apply_matrix_n<9>(data, data_size, threads, qubits, mat);
-    case 10:
-      return apply_matrix_n<10>(data, data_size, threads, qubits, mat);
-    case 11:
-      return apply_matrix_n<11>(data, data_size, threads, qubits, mat);
-    case 12:
-      return apply_matrix_n<12>(data, data_size, threads, qubits, mat);
-    case 13:
-      return apply_matrix_n<13>(data, data_size, threads, qubits, mat);
-    case 14:
-      return apply_matrix_n<14>(data, data_size, threads, qubits, mat);
-    case 15:
-      return apply_matrix_n<15>(data, data_size, threads, qubits, mat);
-    case 16:
-      return apply_matrix_n<16>(data, data_size, threads, qubits, mat);
-    case 17:
-      return apply_matrix_n<17>(data, data_size, threads, qubits, mat);
-    case 18:
-      return apply_matrix_n<18>(data, data_size, threads, qubits, mat);
-    case 19:
-      return apply_matrix_n<19>(data, data_size, threads, qubits, mat);
-    case 20:
-      return apply_matrix_n<20>(data, data_size, threads, qubits, mat);
-    default: {
-      throw std::runtime_error(
-          "Maximum size of apply matrix is a 20-qubit matrix.");
-    }
+  case 1:
+    return apply_matrix_1(data, data_size, threads, qubits[0], mat);
+  case 2:
+    return apply_matrix_n<2>(data, data_size, threads, qubits, mat);
+  case 3:
+    return apply_matrix_n<3>(data, data_size, threads, qubits, mat);
+  case 4:
+    return apply_matrix_n<4>(data, data_size, threads, qubits, mat);
+  case 5:
+    return apply_matrix_n<5>(data, data_size, threads, qubits, mat);
+  case 6:
+    return apply_matrix_n<6>(data, data_size, threads, qubits, mat);
+  case 7:
+    return apply_matrix_n<7>(data, data_size, threads, qubits, mat);
+  case 8:
+    return apply_matrix_n<8>(data, data_size, threads, qubits, mat);
+  case 9:
+    return apply_matrix_n<9>(data, data_size, threads, qubits, mat);
+  case 10:
+    return apply_matrix_n<10>(data, data_size, threads, qubits, mat);
+  case 11:
+    return apply_matrix_n<11>(data, data_size, threads, qubits, mat);
+  case 12:
+    return apply_matrix_n<12>(data, data_size, threads, qubits, mat);
+  case 13:
+    return apply_matrix_n<13>(data, data_size, threads, qubits, mat);
+  case 14:
+    return apply_matrix_n<14>(data, data_size, threads, qubits, mat);
+  case 15:
+    return apply_matrix_n<15>(data, data_size, threads, qubits, mat);
+  case 16:
+    return apply_matrix_n<16>(data, data_size, threads, qubits, mat);
+  case 17:
+    return apply_matrix_n<17>(data, data_size, threads, qubits, mat);
+  case 18:
+    return apply_matrix_n<18>(data, data_size, threads, qubits, mat);
+  case 19:
+    return apply_matrix_n<19>(data, data_size, threads, qubits, mat);
+  case 20:
+    return apply_matrix_n<20>(data, data_size, threads, qubits, mat);
+  default: {
+    throw std::runtime_error(
+        "Maximum size of apply matrix is a 20-qubit matrix.");
+  }
   }
 }
 
 template <typename Container, typename data_t>
 template <size_t N>
-void Transformer<Container, data_t>::apply_matrix_n(Container &data, size_t data_size,
-                                         int threads, const reg_t &qs,
-                                         const cvector_t<double> &mat) const {
+void Transformer<Container, data_t>::apply_matrix_n(
+    Container &data, size_t data_size, int threads, const reg_t &qs,
+    const cvector_t<double> &mat) const {
   const size_t DIM = 1ULL << N;
   auto func = [&](const areg_t<1UL << N> &inds,
                   const cvector_t<data_t> &_mat) -> void {
@@ -161,9 +162,9 @@ void Transformer<Container, data_t>::apply_matrix_n(Container &data, size_t data
 }
 
 template <typename Container, typename data_t>
-void Transformer<Container, data_t>::apply_matrix_1(Container &data, size_t data_size,
-                                         int threads, const uint_t qubit,
-                                         const cvector_t<double> &mat) const {
+void Transformer<Container, data_t>::apply_matrix_1(
+    Container &data, size_t data_size, int threads, const uint_t qubit,
+    const cvector_t<double> &mat) const {
 
   // Check if matrix is diagonal and if so use optimized lambda
   if (mat[1] == 0.0 && mat[2] == 0.0) {
@@ -229,10 +230,9 @@ void Transformer<Container, data_t>::apply_matrix_1(Container &data, size_t data
 }
 
 template <typename Container, typename data_t>
-void Transformer<Container, data_t>::apply_diagonal_matrix(Container &data,
-                                                size_t data_size, int threads,
-                                                const reg_t &qubits,
-                                                const cvector_t<double> &diag) const {
+void Transformer<Container, data_t>::apply_diagonal_matrix(
+    Container &data, size_t data_size, int threads, const reg_t &qubits,
+    const cvector_t<double> &diag) const {
   if (qubits.size() == 1) {
     apply_diagonal_matrix_1(data, data_size, threads, qubits[0], diag);
     return;
@@ -256,7 +256,7 @@ void Transformer<Container, data_t>::apply_diagonal_matrix(Container &data,
 }
 
 template <typename Container, typename data_t>
-void Transformer<Container, data_t>::apply_diagonal_matrix_1 (
+void Transformer<Container, data_t>::apply_diagonal_matrix_1(
     Container &data, size_t data_size, int threads, const uint_t qubit,
     const cvector_t<double> &diag) const {
   // TODO: This should be changed so it isn't checking doubles with ==
diff --git a/src/simulators/statevector/transformer_avx2.hpp b/src/simulators/statevector/transformer_avx2.hpp
old mode 100755
new mode 100644
index 5faf3b8b4c..0048b82990
--- a/src/simulators/statevector/transformer_avx2.hpp
+++ b/src/simulators/statevector/transformer_avx2.hpp
@@ -35,11 +35,12 @@ class TransformerAVX2 : public Transformer<Container, data_t> {
   // The matrix is input as vector of the column-major vectorized N-qubit
   // matrix.
   void apply_matrix(Container &data, size_t data_size, int threads,
-                           const reg_t &qubits, const cvector_t<double> &mat) const override;
+                    const reg_t &qubits,
+                    const cvector_t<double> &mat) const override;
 
   void apply_diagonal_matrix(Container &data, size_t data_size, int threads,
-                            const reg_t &qubits, const cvector_t<double> &diag) const override;
-
+                             const reg_t &qubits,
+                             const cvector_t<double> &diag) const override;
 };
 
 /*******************************************************************************
@@ -53,9 +54,9 @@ class TransformerAVX2 : public Transformer<Container, data_t> {
 #if defined(_MSC_VER) || defined(GNUC_AVX2)
 
 template <typename Container, typename data_t>
-void TransformerAVX2<Container, data_t>::apply_matrix(Container &data, size_t data_size,
-                                           int threads, const reg_t &qubits,
-                                           const cvector_t<double> &mat) const{
+void TransformerAVX2<Container, data_t>::apply_matrix(
+    Container &data, size_t data_size, int threads, const reg_t &qubits,
+    const cvector_t<double> &mat) const {
 
   if (qubits.size() == 1 &&
       ((mat[1] == 0.0 && mat[2] == 0.0) || (mat[0] == 0.0 && mat[3] == 0.0))) {
@@ -72,13 +73,10 @@ void TransformerAVX2<Container, data_t>::apply_matrix(Container &data, size_t da
   Base::apply_matrix(data, data_size, threads, qubits, mat);
 }
 
-
 template <typename Container, typename data_t>
-void TransformerAVX2<Container, data_t>::apply_diagonal_matrix(Container &data,
-                                                               size_t data_size,
-                                                               int threads,
-                                                               const reg_t &qubits,
-                                                               const cvector_t<double> &diag) const {
+void TransformerAVX2<Container, data_t>::apply_diagonal_matrix(
+    Container &data, size_t data_size, int threads, const reg_t &qubits,
+    const cvector_t<double> &diag) const {
 
   if (apply_diagonal_matrix_avx<data_t>(
           reinterpret_cast<data_t *>(data), data_size, qubits.data(),
@@ -90,7 +88,6 @@ void TransformerAVX2<Container, data_t>::apply_diagonal_matrix(Container &data,
   Base::apply_diagonal_matrix(data, data_size, threads, qubits, diag);
 }
 
-
 #endif // AVX2 Code
 
 //------------------------------------------------------------------------------
diff --git a/src/simulators/superoperator/superoperator.hpp b/src/simulators/superoperator/superoperator.hpp
old mode 100755
new mode 100644
index 20b671768d..a09d61e219
--- a/src/simulators/superoperator/superoperator.hpp
+++ b/src/simulators/superoperator/superoperator.hpp
@@ -15,7 +15,6 @@
 #ifndef _qv_superoperator_hpp_
 #define _qv_superoperator_hpp_
 
-
 #include "framework/utils.hpp"
 #include "simulators/density_matrix/densitymatrix.hpp"
 
@@ -26,7 +25,7 @@ namespace QV {
 // Superoperator class
 //============================================================================
 
-// This class is derived from the DensityMatrix class and stores an N-qubit 
+// This class is derived from the DensityMatrix class and stores an N-qubit
 // superoperator as a 2 * N-qubit vector.
 // The vector is formed using column-stacking vectorization of the
 // superoperator (itself with respect to column-stacking vectorization).
@@ -44,20 +43,20 @@ class Superoperator : public DensityMatrix<data_t> {
   // Constructors and Destructor
   //-----------------------------------------------------------------------
 
-  Superoperator() : Superoperator(0) {};
+  Superoperator() : Superoperator(0){};
   explicit Superoperator(size_t num_qubits);
-  Superoperator(const Superoperator& obj) {};
-  Superoperator &operator=(const Superoperator& obj) {};
+  Superoperator(const Superoperator &obj){};
+  Superoperator &operator=(const Superoperator &obj){};
 
   //-----------------------------------------------------------------------
   // Utility functions
   //-----------------------------------------------------------------------
-  
+
   // Set the size of the vector in terms of qubit number
   void set_num_qubits(size_t num_qubits);
 
   // Returns the number of qubits for the superoperator
-  virtual uint_t num_qubits() const override {return num_qubits_;}
+  virtual uint_t num_qubits() const override { return num_qubits_; }
 
   // Initialize to the identity superoperator
   void initialize();
@@ -80,7 +79,6 @@ class Superoperator : public DensityMatrix<data_t> {
  *
  ******************************************************************************/
 
-
 //------------------------------------------------------------------------------
 // Constructors & Destructor
 //------------------------------------------------------------------------------
@@ -102,17 +100,15 @@ void Superoperator<data_t>::set_num_qubits(size_t num_qubits) {
   BaseDensity::set_num_qubits(2 * num_qubits);
 }
 
-
-template <typename data_t>
-void Superoperator<data_t>::initialize() {
+template <typename data_t> void Superoperator<data_t>::initialize() {
   // Set underlying unitary matrix to identity
   BaseUnitary::initialize();
 }
 
-
 template <class data_t>
 template <typename T>
-void Superoperator<data_t>::initialize_from_matrix(const matrix<std::complex<T>> &mat) {
+void Superoperator<data_t>::initialize_from_matrix(
+    const matrix<std::complex<T>> &mat) {
   if (AER::Utils::is_square(mat)) {
     const size_t nrows = mat.GetRows();
     if (nrows == BaseUnitary::rows_) {
@@ -124,23 +120,22 @@ void Superoperator<data_t>::initialize_from_matrix(const matrix<std::complex<T>>
       // If the input matrix has half the number of rows we assume it is
       // A unitary matrix input so we convert to a superoperator
       BaseUnitary::initialize_from_matrix(
-        AER::Utils::tensor_product(AER::Utils::conjugate(mat), mat)
-      );
+          AER::Utils::tensor_product(AER::Utils::conjugate(mat), mat));
       return;
     }
   }
   // Throw an exception if the input matrix is the wrong size for
   // unitary or superoperator input
-  throw std::runtime_error(
-    "Superoperator::initial matrix is wrong size (" +
-    std::to_string(BaseUnitary::rows_) + "," +
-    std::to_string(BaseUnitary::rows_) + ")!=(" +
-    std::to_string(mat.GetRows()) + "," + std::to_string(mat.GetColumns()) + ")."
-  );
+  throw std::runtime_error("Superoperator::initial matrix is wrong size (" +
+                           std::to_string(BaseUnitary::rows_) + "," +
+                           std::to_string(BaseUnitary::rows_) + ")!=(" +
+                           std::to_string(mat.GetRows()) + "," +
+                           std::to_string(mat.GetColumns()) + ").");
 }
 
 template <class data_t>
-void Superoperator<data_t>::initialize_from_matrix(matrix<std::complex<data_t>> &&mat) {
+void Superoperator<data_t>::initialize_from_matrix(
+    matrix<std::complex<data_t>> &&mat) {
   if (AER::Utils::is_square(mat)) {
     const size_t nrows = mat.GetRows();
     if (nrows == BaseUnitary::rows_) {
@@ -152,23 +147,19 @@ void Superoperator<data_t>::initialize_from_matrix(matrix<std::complex<data_t>>
       // If the input matrix has half the number of rows we assume it is
       // A unitary matrix input so we convert to a superoperator
       BaseUnitary::initialize_from_matrix(
-        AER::Utils::tensor_product(AER::Utils::conjugate(mat), mat)
-      );
+          AER::Utils::tensor_product(AER::Utils::conjugate(mat), mat));
       return;
     }
   }
   // Throw an exception if the input matrix is the wrong size for
   // unitary or superoperator input
-  throw std::runtime_error(
-    "Superoperator::initial matrix is wrong size (" +
-    std::to_string(BaseUnitary::rows_) + "," +
-    std::to_string(BaseUnitary::rows_) + ")!=(" +
-    std::to_string(mat.GetRows()) + "," + std::to_string(mat.GetColumns()) + ")."
-  );
+  throw std::runtime_error("Superoperator::initial matrix is wrong size (" +
+                           std::to_string(BaseUnitary::rows_) + "," +
+                           std::to_string(BaseUnitary::rows_) + ")!=(" +
+                           std::to_string(mat.GetRows()) + "," +
+                           std::to_string(mat.GetColumns()) + ").");
 }
 
-
-
 //------------------------------------------------------------------------------
 } // end namespace QV
 } // end namespace AER
@@ -176,11 +167,11 @@ void Superoperator<data_t>::initialize_from_matrix(matrix<std::complex<data_t>>
 
 // ostream overload for templated qubitvector
 template <typename data_t>
-inline std::ostream &operator<<(std::ostream &out, const AER::QV::Superoperator<data_t>&m) {
+inline std::ostream &operator<<(std::ostream &out,
+                                const AER::QV::Superoperator<data_t> &m) {
   out << m.copy_to_matrix();
   return out;
 }
 
 //------------------------------------------------------------------------------
 #endif // end module
-
diff --git a/src/simulators/superoperator/superoperator_state.hpp b/src/simulators/superoperator/superoperator_state.hpp
old mode 100755
new mode 100644
index a1ee9cb2b6..e9ddbe5935
--- a/src/simulators/superoperator/superoperator_state.hpp
+++ b/src/simulators/superoperator/superoperator_state.hpp
@@ -35,27 +35,52 @@ const Operations::OpSet StateOpSet(
     // Op types
     {Operations::OpType::gate, Operations::OpType::reset,
      Operations::OpType::snapshot, Operations::OpType::barrier,
-     Operations::OpType::qerror_loc,
-     Operations::OpType::bfunc, Operations::OpType::roerror,
-     Operations::OpType::matrix, Operations::OpType::diagonal_matrix,
-     Operations::OpType::kraus, Operations::OpType::superop,
-     Operations::OpType::save_state, Operations::OpType::save_superop,
-     Operations::OpType::set_unitary,
-     Operations::OpType::set_superop,
-     Operations::OpType::jump, Operations::OpType::mark
-    },
+     Operations::OpType::qerror_loc, Operations::OpType::bfunc,
+     Operations::OpType::roerror, Operations::OpType::matrix,
+     Operations::OpType::diagonal_matrix, Operations::OpType::kraus,
+     Operations::OpType::superop, Operations::OpType::save_state,
+     Operations::OpType::save_superop, Operations::OpType::set_unitary,
+     Operations::OpType::set_superop, Operations::OpType::jump,
+     Operations::OpType::mark},
     // Gates
-    {"U",    "CX",  "u1", "u2",  "u3", "u",   "cx",   "cy",  "cz",
-     "swap", "id",  "x",  "y",   "z",  "h",   "s",    "sdg", "t",
-     "tdg",  "ccx", "r",  "rx",  "ry", "rz",  "rxx",  "ryy", "rzz",
+    {"U",    "CX",  "u1", "u2",  "u3", "u",    "cx",  "cy",    "cz",
+     "swap", "id",  "x",  "y",   "z",  "h",    "s",   "sdg",   "t",
+     "tdg",  "ccx", "r",  "rx",  "ry", "rz",   "rxx", "ryy",   "rzz",
      "rzx",  "p",   "cp", "cu1", "sx", "sxdg", "x90", "delay", "pauli"},
     // Snapshots
     {"superop"});
 
 // Allowed gates enum class
 enum class Gates {
-  u2, u1, u3, id, x, y, z, h, s, sdg, sx, sxdg, t, tdg, r, rx, ry, rz,
-  cx, cy, cz, cp, swap, rxx, ryy, rzz, rzx, ccx, pauli
+  u2,
+  u1,
+  u3,
+  id,
+  x,
+  y,
+  z,
+  h,
+  s,
+  sdg,
+  sx,
+  sxdg,
+  t,
+  tdg,
+  r,
+  rx,
+  ry,
+  rz,
+  cx,
+  cy,
+  cz,
+  cp,
+  swap,
+  rxx,
+  ryy,
+  rzz,
+  rzx,
+  ccx,
+  pauli
 };
 
 // Allowed snapshots enum class
@@ -82,10 +107,8 @@ class State : public QuantumState::State<data_t> {
 
   // Apply an operation
   // If the op is not in allowed_ops an exeption will be raised.
-  virtual void apply_op(const Operations::Op &op,
-                        ExperimentResult &result,
-                        RngEngine &rng,
-                        bool final_op = false) override;
+  virtual void apply_op(const Operations::Op &op, ExperimentResult &result,
+                        RngEngine &rng, bool final_op = false) override;
 
   // Initializes an n-qubit unitary to the identity matrix
   virtual void initialize_qreg(uint_t num_qubits) override;
@@ -102,7 +125,8 @@ class State : public QuantumState::State<data_t> {
   // Config: {"omp_qubit_threshold": 3}
   virtual void set_config(const json_t &config) override;
 
-  virtual bool allocate(uint_t num_qubits,uint_t block_bits,uint_t num_parallel_shots = 1) override;
+  virtual bool allocate(uint_t num_qubits, uint_t block_bits,
+                        uint_t num_parallel_shots = 1) override;
 
   //-----------------------------------------------------------------------
   // Additional methods
@@ -111,10 +135,8 @@ class State : public QuantumState::State<data_t> {
   // Initialize OpenMP settings for the underlying QubitVector class
   void initialize_omp();
 
-  auto move_to_matrix()
-  {
-    return BaseState::qreg_.move_to_matrix();
-  }
+  auto move_to_matrix() { return BaseState::qreg_.move_to_matrix(); }
+
 protected:
   //-----------------------------------------------------------------------
   // Apply Instructions
@@ -127,7 +149,8 @@ class State : public QuantumState::State<data_t> {
 
   // Apply a supported snapshot instruction
   // If the input is not in allowed_snapshots an exeption will be raised.
-  virtual void apply_snapshot(const Operations::Op &op, ExperimentResult &result);
+  virtual void apply_snapshot(const Operations::Op &op,
+                              ExperimentResult &result);
 
   // Apply a matrix to given qubits (identity on all other qubits)
   void apply_matrix(const reg_t &qubits, const cmatrix_t &mat);
@@ -161,14 +184,13 @@ class State : public QuantumState::State<data_t> {
   //-----------------------------------------------------------------------
 
   // Save the current superop matrix
-  void apply_save_state(const Operations::Op &op,
-                        ExperimentResult &result,
+  void apply_save_state(const Operations::Op &op, ExperimentResult &result,
                         bool last_op = false);
 
   // Helper function for computing expectation value
   virtual double expval_pauli(const reg_t &qubits,
-                              const std::string& pauli) override;
-    
+                              const std::string &pauli) override;
+
   //-----------------------------------------------------------------------
   // Config Settings
   //-----------------------------------------------------------------------
@@ -190,29 +212,29 @@ class State : public QuantumState::State<data_t> {
 template <class data_t>
 const stringmap_t<Gates> State<data_t>::gateset_({
     // Single qubit gates
-    {"delay", Gates::id},// Delay gate
-    {"id", Gates::id},   // Pauli-Identity gate
-    {"x", Gates::x},     // Pauli-X gate
-    {"y", Gates::y},     // Pauli-Y gate
-    {"z", Gates::z},     // Pauli-Z gate
-    {"s", Gates::s},     // Phase gate (aka sqrt(Z) gate)
-    {"sdg", Gates::sdg}, // Conjugate-transpose of Phase gate
-    {"h", Gates::h},     // Hadamard gate (X + Z / sqrt(2))
-    {"t", Gates::t},     // T-gate (sqrt(S))
-    {"tdg", Gates::tdg}, // Conjguate-transpose of T gate
-    {"x90", Gates::sx},  // Pi/2 X (equiv to Sqrt(X) gate)
-    {"sx", Gates::sx},   // Sqrt(X) gate
-    {"sxdg", Gates::sxdg},// Sqrt(X)^hc gate
-    {"r", Gates::r},     // R rotation gate
-    {"rx", Gates::rx},   // Pauli-X rotation gate
-    {"ry", Gates::ry},   // Pauli-Y rotation gate
-    {"rz", Gates::rz},   // Pauli-Z rotation gate
+    {"delay", Gates::id},  // Delay gate
+    {"id", Gates::id},     // Pauli-Identity gate
+    {"x", Gates::x},       // Pauli-X gate
+    {"y", Gates::y},       // Pauli-Y gate
+    {"z", Gates::z},       // Pauli-Z gate
+    {"s", Gates::s},       // Phase gate (aka sqrt(Z) gate)
+    {"sdg", Gates::sdg},   // Conjugate-transpose of Phase gate
+    {"h", Gates::h},       // Hadamard gate (X + Z / sqrt(2))
+    {"t", Gates::t},       // T-gate (sqrt(S))
+    {"tdg", Gates::tdg},   // Conjguate-transpose of T gate
+    {"x90", Gates::sx},    // Pi/2 X (equiv to Sqrt(X) gate)
+    {"sx", Gates::sx},     // Sqrt(X) gate
+    {"sxdg", Gates::sxdg}, // Sqrt(X)^hc gate
+    {"r", Gates::r},       // R rotation gate
+    {"rx", Gates::rx},     // Pauli-X rotation gate
+    {"ry", Gates::ry},     // Pauli-Y rotation gate
+    {"rz", Gates::rz},     // Pauli-Z rotation gate
     // Waltz Gates
     {"p", Gates::u1},  // Phase gate
     {"u1", Gates::u1}, // zero-X90 pulse waltz gate
     {"u2", Gates::u2}, // single-X90 pulse waltz gate
     {"u3", Gates::u3}, // two X90 pulse waltz gate
-    {"u", Gates::u3}, // two X90 pulse waltz gate
+    {"u", Gates::u3},  // two X90 pulse waltz gate
     {"U", Gates::u3},  // two X90 pulse waltz gate
     // Two-qubit gates
     {"CX", Gates::cx},     // Controlled-X gate (CNOT)
@@ -227,8 +249,8 @@ const stringmap_t<Gates> State<data_t>::gateset_({
     {"rzz", Gates::rzz},   // Pauli-ZZ rotation gate
     {"rzx", Gates::rzx},   // Pauli-ZX rotation gate
     // Three-qubit gates
-    {"ccx", Gates::ccx}, // Controlled-CX gate (Toffoli)
-    {"pauli", Gates::pauli}  // Multiple pauli operations at once
+    {"ccx", Gates::ccx},    // Controlled-CX gate (Toffoli)
+    {"pauli", Gates::pauli} // Multiple pauli operations at once
 });
 
 //============================================================================
@@ -236,55 +258,53 @@ const stringmap_t<Gates> State<data_t>::gateset_({
 //============================================================================
 
 template <class data_t>
-void State<data_t>::apply_op(const Operations::Op &op,
-                             ExperimentResult &result,
-                             RngEngine &rng,
-                             bool final_op) {
+void State<data_t>::apply_op(const Operations::Op &op, ExperimentResult &result,
+                             RngEngine &rng, bool final_op) {
   if (BaseState::creg().check_conditional(op)) {
     switch (op.type) {
-      case Operations::OpType::barrier:
-      case Operations::OpType::qerror_loc:
-        break;
-      case Operations::OpType::gate:
-        apply_gate(op);
-        break;
-      case Operations::OpType::bfunc:
-          BaseState::creg().apply_bfunc(op);
-        break;
-      case Operations::OpType::roerror:
-          BaseState::creg().apply_roerror(op, rng);
-        break;
-      case Operations::OpType::reset:
-        apply_reset(op.qubits);
-        break;
-      case Operations::OpType::matrix:
-        apply_matrix(op.qubits, op.mats[0]);
-        break;
-      case Operations::OpType::diagonal_matrix:
-        BaseState::qreg_.apply_diagonal_matrix(op.qubits, op.params);
-        break;
-      case Operations::OpType::kraus:
-        apply_kraus(op.qubits, op.mats);
-        break;
-      case Operations::OpType::superop:
-        BaseState::qreg_.apply_superop_matrix(
-            op.qubits, Utils::vectorize_matrix(op.mats[0]));
-        break;
-      case Operations::OpType::set_unitary:
-      case Operations::OpType::set_superop:
-        BaseState::qreg_.initialize_from_matrix(op.mats[0]);
-        break;
-      case Operations::OpType::snapshot:
-        apply_snapshot(op, result);
-        break;
-      case Operations::OpType::save_state:
-      case Operations::OpType::save_superop:
-        apply_save_state(op, result, final_op);
-        break;
-      default:
-        throw std::invalid_argument(
-            "QubitSuperoperator::State::invalid instruction \'" + op.name +
-            "\'.");
+    case Operations::OpType::barrier:
+    case Operations::OpType::qerror_loc:
+      break;
+    case Operations::OpType::gate:
+      apply_gate(op);
+      break;
+    case Operations::OpType::bfunc:
+      BaseState::creg().apply_bfunc(op);
+      break;
+    case Operations::OpType::roerror:
+      BaseState::creg().apply_roerror(op, rng);
+      break;
+    case Operations::OpType::reset:
+      apply_reset(op.qubits);
+      break;
+    case Operations::OpType::matrix:
+      apply_matrix(op.qubits, op.mats[0]);
+      break;
+    case Operations::OpType::diagonal_matrix:
+      BaseState::qreg_.apply_diagonal_matrix(op.qubits, op.params);
+      break;
+    case Operations::OpType::kraus:
+      apply_kraus(op.qubits, op.mats);
+      break;
+    case Operations::OpType::superop:
+      BaseState::qreg_.apply_superop_matrix(
+          op.qubits, Utils::vectorize_matrix(op.mats[0]));
+      break;
+    case Operations::OpType::set_unitary:
+    case Operations::OpType::set_superop:
+      BaseState::qreg_.initialize_from_matrix(op.mats[0]);
+      break;
+    case Operations::OpType::snapshot:
+      apply_snapshot(op, result);
+      break;
+    case Operations::OpType::save_state:
+    case Operations::OpType::save_superop:
+      apply_save_state(op, result, final_op);
+      break;
+    default:
+      throw std::invalid_argument(
+          "QubitSuperoperator::State::invalid instruction \'" + op.name +
+          "\'.");
     }
   }
 }
@@ -324,8 +344,8 @@ template <class data_t> void State<data_t>::initialize_omp() {
 }
 
 template <class data_t>
-bool State<data_t>::allocate(uint_t num_qubits, uint_t block_bits,uint_t num_parallel_shots)
-{
+bool State<data_t>::allocate(uint_t num_qubits, uint_t block_bits,
+                             uint_t num_parallel_shots) {
   return BaseState::qreg_.chunk_setup(num_qubits * 4, num_qubits * 4, 0, 1);
 }
 
@@ -365,101 +385,102 @@ void State<data_t>::apply_gate(const Operations::Op &op) {
     throw std::invalid_argument("Unitary::State::invalid gate instruction \'" +
                                 op.name + "\'.");
   switch (it->second) {
-    case Gates::u3:
-      apply_gate_u3(op.qubits[0], std::real(op.params[0]),
-                    std::real(op.params[1]), std::real(op.params[2]));
-      break;
-    case Gates::u2:
-      apply_gate_u3(op.qubits[0], M_PI / 2., std::real(op.params[0]),
-                    std::real(op.params[1]));
-      break;
-    case Gates::u1:
-      BaseState::qreg_.apply_phase(op.qubits[0], std::exp(complex_t(0., 1.) * op.params[0]));
-      break;
-    case Gates::r:
-      apply_matrix(op.qubits, Linalg::VMatrix::r(op.params[0], op.params[1]));
-      break;
-    case Gates::rx:
-      apply_matrix(op.qubits, Linalg::VMatrix::rx(op.params[0]));
-      break;
-    case Gates::ry:
-      apply_matrix(op.qubits, Linalg::VMatrix::ry(op.params[0]));
-      break;
-    case Gates::rz:
-      apply_matrix(op.qubits, Linalg::VMatrix::rz_diag(op.params[0]));
-      break;
-    case Gates::rxx:
-      apply_matrix(op.qubits, Linalg::VMatrix::rxx(op.params[0]));
-      break;
-    case Gates::ryy:
-      apply_matrix(op.qubits, Linalg::VMatrix::ryy(op.params[0]));
-      break;
-    case Gates::rzz:
-      apply_matrix(op.qubits, Linalg::VMatrix::rzz_diag(op.params[0]));
-      break;
-    case Gates::rzx:
-      apply_matrix(op.qubits, Linalg::VMatrix::rzx(op.params[0]));
-      break;
-    case Gates::cx:
-      BaseState::qreg_.apply_cnot(op.qubits[0], op.qubits[1]);
-      break;
-    case Gates::cy:
-      apply_matrix(op.qubits, Linalg::VMatrix::CY);
-      break;
-    case Gates::cz:
-      BaseState::qreg_.apply_cphase(op.qubits[0], op.qubits[1], -1);
-      break;
-    case Gates::cp:
-      BaseState::qreg_.apply_cphase(op.qubits[0], op.qubits[1],
-                                    std::exp(complex_t(0., 1.) * op.params[0]));
-      break;
-    case Gates::id:
-      break;
-    case Gates::x:
-      BaseState::qreg_.apply_x(op.qubits[0]);
-      break;
-    case Gates::y:
-      BaseState::qreg_.apply_y(op.qubits[0]);
-      break;
-    case Gates::z:
-      BaseState::qreg_.apply_phase(op.qubits[0], -1);
-      break;
-    case Gates::h:
-      apply_gate_u3(op.qubits[0], M_PI / 2., 0., M_PI);
-      break;
-    case Gates::s:
-      BaseState::qreg_.apply_phase(op.qubits[0], complex_t(0., 1.));
-      break;
-    case Gates::sdg:
-      BaseState::qreg_.apply_phase(op.qubits[0], complex_t(0., -1.));
-      break;
-    case Gates::sx:
-      BaseState::qreg_.apply_unitary_matrix(op.qubits, Linalg::VMatrix::SX);
-      break;
-    case Gates::sxdg:
-      BaseState::qreg_.apply_unitary_matrix(op.qubits, Linalg::VMatrix::SXDG);
-      break;
-    case Gates::t: {
-      const double isqrt2{1. / std::sqrt(2)};
-      BaseState::qreg_.apply_phase(op.qubits[0], complex_t(isqrt2, isqrt2));
-    } break;
-    case Gates::tdg: {
-      const double isqrt2{1. / std::sqrt(2)};
-      BaseState::qreg_.apply_phase(op.qubits[0], complex_t(isqrt2, -isqrt2));
-    } break;
-    case Gates::swap: {
-      BaseState::qreg_.apply_swap(op.qubits[0], op.qubits[1]);
-    } break;
-    case Gates::ccx:
-      BaseState::qreg_.apply_toffoli(op.qubits[0], op.qubits[1], op.qubits[2]);
-      break;
-    case Gates::pauli:
-      apply_pauli(op.qubits, op.string_params[0]);
-      break;
-    default:
-      // We shouldn't reach here unless there is a bug in gateset
-      throw std::invalid_argument(
-          "Superoperator::State::invalid gate instruction \'" + op.name + "\'.");
+  case Gates::u3:
+    apply_gate_u3(op.qubits[0], std::real(op.params[0]),
+                  std::real(op.params[1]), std::real(op.params[2]));
+    break;
+  case Gates::u2:
+    apply_gate_u3(op.qubits[0], M_PI / 2., std::real(op.params[0]),
+                  std::real(op.params[1]));
+    break;
+  case Gates::u1:
+    BaseState::qreg_.apply_phase(op.qubits[0],
+                                 std::exp(complex_t(0., 1.) * op.params[0]));
+    break;
+  case Gates::r:
+    apply_matrix(op.qubits, Linalg::VMatrix::r(op.params[0], op.params[1]));
+    break;
+  case Gates::rx:
+    apply_matrix(op.qubits, Linalg::VMatrix::rx(op.params[0]));
+    break;
+  case Gates::ry:
+    apply_matrix(op.qubits, Linalg::VMatrix::ry(op.params[0]));
+    break;
+  case Gates::rz:
+    apply_matrix(op.qubits, Linalg::VMatrix::rz_diag(op.params[0]));
+    break;
+  case Gates::rxx:
+    apply_matrix(op.qubits, Linalg::VMatrix::rxx(op.params[0]));
+    break;
+  case Gates::ryy:
+    apply_matrix(op.qubits, Linalg::VMatrix::ryy(op.params[0]));
+    break;
+  case Gates::rzz:
+    apply_matrix(op.qubits, Linalg::VMatrix::rzz_diag(op.params[0]));
+    break;
+  case Gates::rzx:
+    apply_matrix(op.qubits, Linalg::VMatrix::rzx(op.params[0]));
+    break;
+  case Gates::cx:
+    BaseState::qreg_.apply_cnot(op.qubits[0], op.qubits[1]);
+    break;
+  case Gates::cy:
+    apply_matrix(op.qubits, Linalg::VMatrix::CY);
+    break;
+  case Gates::cz:
+    BaseState::qreg_.apply_cphase(op.qubits[0], op.qubits[1], -1);
+    break;
+  case Gates::cp:
+    BaseState::qreg_.apply_cphase(op.qubits[0], op.qubits[1],
+                                  std::exp(complex_t(0., 1.) * op.params[0]));
+    break;
+  case Gates::id:
+    break;
+  case Gates::x:
+    BaseState::qreg_.apply_x(op.qubits[0]);
+    break;
+  case Gates::y:
+    BaseState::qreg_.apply_y(op.qubits[0]);
+    break;
+  case Gates::z:
+    BaseState::qreg_.apply_phase(op.qubits[0], -1);
+    break;
+  case Gates::h:
+    apply_gate_u3(op.qubits[0], M_PI / 2., 0., M_PI);
+    break;
+  case Gates::s:
+    BaseState::qreg_.apply_phase(op.qubits[0], complex_t(0., 1.));
+    break;
+  case Gates::sdg:
+    BaseState::qreg_.apply_phase(op.qubits[0], complex_t(0., -1.));
+    break;
+  case Gates::sx:
+    BaseState::qreg_.apply_unitary_matrix(op.qubits, Linalg::VMatrix::SX);
+    break;
+  case Gates::sxdg:
+    BaseState::qreg_.apply_unitary_matrix(op.qubits, Linalg::VMatrix::SXDG);
+    break;
+  case Gates::t: {
+    const double isqrt2{1. / std::sqrt(2)};
+    BaseState::qreg_.apply_phase(op.qubits[0], complex_t(isqrt2, isqrt2));
+  } break;
+  case Gates::tdg: {
+    const double isqrt2{1. / std::sqrt(2)};
+    BaseState::qreg_.apply_phase(op.qubits[0], complex_t(isqrt2, -isqrt2));
+  } break;
+  case Gates::swap: {
+    BaseState::qreg_.apply_swap(op.qubits[0], op.qubits[1]);
+  } break;
+  case Gates::ccx:
+    BaseState::qreg_.apply_toffoli(op.qubits[0], op.qubits[1], op.qubits[2]);
+    break;
+  case Gates::pauli:
+    apply_pauli(op.qubits, op.string_params[0]);
+    break;
+  default:
+    // We shouldn't reach here unless there is a bug in gateset
+    throw std::invalid_argument(
+        "Superoperator::State::invalid gate instruction \'" + op.name + "\'.");
   }
 }
 
@@ -505,41 +526,37 @@ void State<statevec_t>::apply_pauli(const reg_t &qubits,
                                     const std::string &pauli) {
   // Pauli as a superoperator is (-1)^num_y P\otimes P
   complex_t coeff = (std::count(pauli.begin(), pauli.end(), 'Y') % 2) ? -1 : 1;
-  BaseState::qreg_.apply_pauli(
-      BaseState::qreg_.superop_qubits(qubits), pauli + pauli, coeff);
+  BaseState::qreg_.apply_pauli(BaseState::qreg_.superop_qubits(qubits),
+                               pauli + pauli, coeff);
 }
 
-
 template <class statevec_t>
 void State<statevec_t>::apply_save_state(const Operations::Op &op,
-                                        ExperimentResult &result,
-                                        bool last_op) {
+                                         ExperimentResult &result,
+                                         bool last_op) {
   if (op.qubits.size() != BaseState::qreg_.num_qubits()) {
-    throw std::invalid_argument(
-        op.name + " was not applied to all qubits."
-        " Only the full state can be saved.");
+    throw std::invalid_argument(op.name + " was not applied to all qubits."
+                                          " Only the full state can be saved.");
   }
   // Default key
-  std::string key = (op.string_params[0] == "_method_")
-                      ? "superop"
-                      : op.string_params[0];
+  std::string key =
+      (op.string_params[0] == "_method_") ? "superop" : op.string_params[0];
   if (last_op) {
     result.save_data_pershot(BaseState::creg(), key,
                              BaseState::qreg_.move_to_matrix(),
-                             Operations::OpType::save_superop,
-                             op.save_type);
+                             Operations::OpType::save_superop, op.save_type);
   } else {
     result.save_data_pershot(BaseState::creg(), key,
                              BaseState::qreg_.copy_to_matrix(),
-                             Operations::OpType::save_superop,
-                             op.save_type);
+                             Operations::OpType::save_superop, op.save_type);
   }
 }
 
 template <class data_t>
-double  State<data_t>::expval_pauli(const reg_t &qubits,
-                                    const std::string& pauli) {
-  throw std::runtime_error("SuperOp simulator does not support Pauli expectation values.");
+double State<data_t>::expval_pauli(const reg_t &qubits,
+                                   const std::string &pauli) {
+  throw std::runtime_error(
+      "SuperOp simulator does not support Pauli expectation values.");
 }
 
 //------------------------------------------------------------------------------
diff --git a/src/simulators/superoperator/superoperator_thrust.hpp b/src/simulators/superoperator/superoperator_thrust.hpp
old mode 100755
new mode 100644
index 9e97bd3b36..d4f57b792a
--- a/src/simulators/superoperator/superoperator_thrust.hpp
+++ b/src/simulators/superoperator/superoperator_thrust.hpp
@@ -15,7 +15,6 @@
 #ifndef _qv_superoperator_thrust_hpp_
 #define _qv_superoperator_thrust_hpp_
 
-
 #include "framework/utils.hpp"
 #include "simulators/density_matrix/densitymatrix_thrust.hpp"
 
@@ -26,7 +25,7 @@ namespace QV {
 // Superoperator class
 //============================================================================
 
-// This class is derived from the DensityMatrix class and stores an N-qubit 
+// This class is derived from the DensityMatrix class and stores an N-qubit
 // superoperator as a 2 * N-qubit vector.
 // The vector is formed using column-stacking vectorization of the
 // superoperator (itself with respect to column-stacking vectorization).
@@ -44,20 +43,20 @@ class SuperoperatorThrust : public DensityMatrixThrust<data_t> {
   // Constructors and Destructor
   //-----------------------------------------------------------------------
 
-  SuperoperatorThrust() : SuperoperatorThrust(0) {};
+  SuperoperatorThrust() : SuperoperatorThrust(0){};
   explicit SuperoperatorThrust(size_t num_qubits);
-  SuperoperatorThrust(const SuperoperatorThrust& obj) = delete;
-  SuperoperatorThrust &operator=(const SuperoperatorThrust& obj) = delete;
+  SuperoperatorThrust(const SuperoperatorThrust &obj) = delete;
+  SuperoperatorThrust &operator=(const SuperoperatorThrust &obj) = delete;
 
   //-----------------------------------------------------------------------
   // Utility functions
   //-----------------------------------------------------------------------
-  
+
   // Set the size of the vector in terms of qubit number
   void set_num_qubits(size_t num_qubits);
 
   // Returns the number of qubits for the superoperator
-  virtual uint_t num_qubits() const override {return num_qubits_;}
+  virtual uint_t num_qubits() const override { return num_qubits_; }
 
   // Initialize to the identity superoperator
   void initialize();
@@ -80,7 +79,6 @@ class SuperoperatorThrust : public DensityMatrixThrust<data_t> {
  *
  ******************************************************************************/
 
-
 //------------------------------------------------------------------------------
 // Constructors & Destructor
 //------------------------------------------------------------------------------
@@ -102,17 +100,15 @@ void SuperoperatorThrust<data_t>::set_num_qubits(size_t num_qubits) {
   BaseDensity::set_num_qubits(2 * num_qubits);
 }
 
-
-template <typename data_t>
-void SuperoperatorThrust<data_t>::initialize() {
+template <typename data_t> void SuperoperatorThrust<data_t>::initialize() {
   // Set underlying unitary matrix to identity
   BaseUnitary::initialize();
 }
 
-
 template <class data_t>
 template <typename T>
-void SuperoperatorThrust<data_t>::initialize_from_matrix(const matrix<std::complex<T>> &mat) {
+void SuperoperatorThrust<data_t>::initialize_from_matrix(
+    const matrix<std::complex<T>> &mat) {
   if (AER::Utils::is_square(mat)) {
     const size_t nrows = mat.GetRows();
     if (nrows == BaseUnitary::rows_) {
@@ -124,23 +120,22 @@ void SuperoperatorThrust<data_t>::initialize_from_matrix(const matrix<std::compl
       // If the input matrix has half the number of rows we assume it is
       // A unitary matrix input so we convert to a superoperator
       BaseUnitary::initialize_from_matrix(
-        AER::Utils::tensor_product(AER::Utils::conjugate(mat), mat)
-      );
+          AER::Utils::tensor_product(AER::Utils::conjugate(mat), mat));
       return;
     }
   }
   // Throw an exception if the input matrix is the wrong size for
   // unitary or superoperator input
-  throw std::runtime_error(
-    "Superoperator::initial matrix is wrong size (" +
-    std::to_string(BaseUnitary::rows_) + "," +
-    std::to_string(BaseUnitary::rows_) + ")!=(" +
-    std::to_string(mat.GetRows()) + "," + std::to_string(mat.GetColumns()) + ")."
-  );
+  throw std::runtime_error("Superoperator::initial matrix is wrong size (" +
+                           std::to_string(BaseUnitary::rows_) + "," +
+                           std::to_string(BaseUnitary::rows_) + ")!=(" +
+                           std::to_string(mat.GetRows()) + "," +
+                           std::to_string(mat.GetColumns()) + ").");
 }
 
 template <class data_t>
-void SuperoperatorThrust<data_t>::initialize_from_matrix(matrix<std::complex<data_t>> &&mat) {
+void SuperoperatorThrust<data_t>::initialize_from_matrix(
+    matrix<std::complex<data_t>> &&mat) {
   if (AER::Utils::is_square(mat)) {
     const size_t nrows = mat.GetRows();
     if (nrows == BaseUnitary::rows_) {
@@ -152,23 +147,19 @@ void SuperoperatorThrust<data_t>::initialize_from_matrix(matrix<std::complex<dat
       // If the input matrix has half the number of rows we assume it is
       // A unitary matrix input so we convert to a superoperator
       BaseUnitary::initialize_from_matrix(
-        AER::Utils::tensor_product(AER::Utils::conjugate(mat), mat)
-      );
+          AER::Utils::tensor_product(AER::Utils::conjugate(mat), mat));
       return;
     }
   }
   // Throw an exception if the input matrix is the wrong size for
   // unitary or superoperator input
-  throw std::runtime_error(
-    "Superoperator::initial matrix is wrong size (" +
-    std::to_string(BaseUnitary::rows_) + "," +
-    std::to_string(BaseUnitary::rows_) + ")!=(" +
-    std::to_string(mat.GetRows()) + "," + std::to_string(mat.GetColumns()) + ")."
-  );
+  throw std::runtime_error("Superoperator::initial matrix is wrong size (" +
+                           std::to_string(BaseUnitary::rows_) + "," +
+                           std::to_string(BaseUnitary::rows_) + ")!=(" +
+                           std::to_string(mat.GetRows()) + "," +
+                           std::to_string(mat.GetColumns()) + ").");
 }
 
-
-
 //------------------------------------------------------------------------------
 } // end namespace QV
 } // end namespace AER
@@ -176,11 +167,11 @@ void SuperoperatorThrust<data_t>::initialize_from_matrix(matrix<std::complex<dat
 
 // ostream overload for templated qubitvector
 template <typename data_t>
-inline std::ostream &operator<<(std::ostream &out, const AER::QV::SuperoperatorThrust<data_t>&m) {
+inline std::ostream &operator<<(std::ostream &out,
+                                const AER::QV::SuperoperatorThrust<data_t> &m) {
   out << m.copy_to_matrix();
   return out;
 }
 
 //------------------------------------------------------------------------------
 #endif // end module
-
diff --git a/src/simulators/unitary/unitary_state.hpp b/src/simulators/unitary/unitary_state.hpp
old mode 100755
new mode 100644
index 325e011e6b..592d04d3ca
--- a/src/simulators/unitary/unitary_state.hpp
+++ b/src/simulators/unitary/unitary_state.hpp
@@ -17,12 +17,12 @@
 
 #include <algorithm>
 #define _USE_MATH_DEFINES
-#include <math.h>
-#include "simulators/state.hpp"
 #include "framework/json.hpp"
 #include "framework/utils.hpp"
+#include "simulators/state.hpp"
 #include "simulators/state_chunk.hpp"
 #include "unitarymatrix.hpp"
+#include <math.h>
 #ifdef AER_THRUST_SUPPORTED
 #include "unitarymatrix_thrust.hpp"
 #endif
@@ -36,28 +36,50 @@ const Operations::OpSet StateOpSet(
     // Op types
     {Operations::OpType::gate, Operations::OpType::barrier,
      Operations::OpType::bfunc, Operations::OpType::roerror,
-     Operations::OpType::qerror_loc,
-     Operations::OpType::matrix, Operations::OpType::diagonal_matrix,
-     Operations::OpType::snapshot, Operations::OpType::save_unitary,
-     Operations::OpType::save_state, Operations::OpType::set_unitary,
-     Operations::OpType::jump, Operations::OpType::mark
-    },
+     Operations::OpType::qerror_loc, Operations::OpType::matrix,
+     Operations::OpType::diagonal_matrix, Operations::OpType::snapshot,
+     Operations::OpType::save_unitary, Operations::OpType::save_state,
+     Operations::OpType::set_unitary, Operations::OpType::jump,
+     Operations::OpType::mark},
     // Gates
-    {"u1",     "u2",      "u3",  "u",    "U",    "CX",   "cx",   "cz",
-     "cy",     "cp",      "cu1", "cu2",  "cu3",  "swap", "id",   "p",
-     "x",      "y",       "z",   "h",    "s",    "sdg",  "t",    "tdg",
-     "r",      "rx",      "ry",  "rz",   "rxx",  "ryy",  "rzz",  "rzx",
-     "ccx",    "cswap",   "mcx", "mcy",  "mcz",  "mcu1", "mcu2", "mcu3",
-     "mcswap", "mcphase", "mcr", "mcrx", "mcry", "mcry", "sx",   "sxdg", "csx",
-     "mcsx",   "csxdg", "mcsxdg", "delay", "pauli", "cu",   "mcu", "mcp"},
+    {"u1",     "u2",      "u3",    "u",      "U",     "CX",    "cx",   "cz",
+     "cy",     "cp",      "cu1",   "cu2",    "cu3",   "swap",  "id",   "p",
+     "x",      "y",       "z",     "h",      "s",     "sdg",   "t",    "tdg",
+     "r",      "rx",      "ry",    "rz",     "rxx",   "ryy",   "rzz",  "rzx",
+     "ccx",    "cswap",   "mcx",   "mcy",    "mcz",   "mcu1",  "mcu2", "mcu3",
+     "mcswap", "mcphase", "mcr",   "mcrx",   "mcry",  "mcry",  "sx",   "sxdg",
+     "csx",    "mcsx",    "csxdg", "mcsxdg", "delay", "pauli", "cu",   "mcu",
+     "mcp"},
     // Snapshots
     {"unitary"});
 
 // Allowed gates enum class
 enum class Gates {
-  id, h, s, sdg, t, tdg, rxx, ryy, rzz, rzx,
-  mcx, mcy, mcz, mcr, mcrx, mcry, mcrz, mcp,
-  mcu2, mcu3, mcu, mcswap, mcsx, mcsxdg, pauli,
+  id,
+  h,
+  s,
+  sdg,
+  t,
+  tdg,
+  rxx,
+  ryy,
+  rzz,
+  rzx,
+  mcx,
+  mcy,
+  mcz,
+  mcr,
+  mcrx,
+  mcry,
+  mcrz,
+  mcp,
+  mcu2,
+  mcu3,
+  mcu,
+  mcswap,
+  mcsx,
+  mcsxdg,
+  pauli,
 };
 
 //=========================================================================
@@ -82,8 +104,7 @@ class State : public virtual QuantumState::StateChunk<unitary_matrix_t> {
   // Apply an operation
   // If the op is not in allowed_ops an exeption will be raised.
   virtual void apply_op(const int_t iChunk, const Operations::Op &op,
-                        ExperimentResult &result,
-                        RngEngine &rng,
+                        ExperimentResult &result, RngEngine &rng,
                         bool final_op = false) override;
 
   // Initializes an n-qubit unitary to the identity matrix
@@ -113,15 +134,16 @@ class State : public virtual QuantumState::StateChunk<unitary_matrix_t> {
 
   auto move_to_matrix(const int_t iChunk);
   auto copy_to_matrix(const int_t iChunk);
+
 protected:
   //-----------------------------------------------------------------------
   // Apply Instructions
   //-----------------------------------------------------------------------
-  //apply op to multiple shots , return flase if op is not supported to execute in a batch
+  // apply op to multiple shots , return flase if op is not supported to execute
+  // in a batch
   bool apply_batched_op(const int_t iChunk, const Operations::Op &op,
-                                ExperimentResult &result,
-                                std::vector<RngEngine> &rng,
-                                bool final_op = false) override;
+                        ExperimentResult &result, std::vector<RngEngine> &rng,
+                        bool final_op = false) override;
 
   // Applies a Gate operation to the state class.
   // This should support all and only the operations defined in
@@ -130,18 +152,22 @@ class State : public virtual QuantumState::StateChunk<unitary_matrix_t> {
 
   // Apply a supported snapshot instruction
   // If the input is not in allowed_snapshots an exeption will be raised.
-  virtual void apply_snapshot(const int_t iChunk, const Operations::Op &op, ExperimentResult &result);
+  virtual void apply_snapshot(const int_t iChunk, const Operations::Op &op,
+                              ExperimentResult &result);
 
   // Apply a matrix to given qubits (identity on all other qubits)
-  void apply_matrix(const int_t iChunk, const reg_t &qubits, const cmatrix_t &mat);
+  void apply_matrix(const int_t iChunk, const reg_t &qubits,
+                    const cmatrix_t &mat);
 
   // Apply a matrix to given qubits (identity on all other qubits)
-  void apply_matrix(const int_t iChunk, const reg_t &qubits, const cvector_t &vmat);
+  void apply_matrix(const int_t iChunk, const reg_t &qubits,
+                    const cvector_t &vmat);
 
   // Apply a diagonal matrix
-  void apply_diagonal_matrix(const int_t iChunk, const reg_t &qubits, const cvector_t &diag);
+  void apply_diagonal_matrix(const int_t iChunk, const reg_t &qubits,
+                             const cvector_t &diag);
 
-  //swap between chunks
+  // swap between chunks
   virtual void apply_chunk_swap(const reg_t &qubits) override;
 
   //-----------------------------------------------------------------------
@@ -149,9 +175,11 @@ class State : public virtual QuantumState::StateChunk<unitary_matrix_t> {
   //-----------------------------------------------------------------------
 
   // Optimize phase gate with diagonal [1, phase]
-  void apply_gate_phase(const int_t iChunk, const uint_t qubit, const complex_t phase);
+  void apply_gate_phase(const int_t iChunk, const uint_t qubit,
+                        const complex_t phase);
 
-  void apply_gate_phase(const int_t iChunk, const reg_t& qubits, const complex_t phase);
+  void apply_gate_phase(const int_t iChunk, const reg_t &qubits,
+                        const complex_t phase);
 
   //-----------------------------------------------------------------------
   // Multi-controlled u
@@ -169,12 +197,11 @@ class State : public virtual QuantumState::StateChunk<unitary_matrix_t> {
 
   // Save the unitary matrix for the simulator
   void apply_save_unitary(const int_t iChunk, const Operations::Op &op,
-                          ExperimentResult &result,
-                          bool last_op);
+                          ExperimentResult &result, bool last_op);
 
   // Helper function for computing expectation value
   virtual double expval_pauli(const int_t iChunk, const reg_t &qubits,
-                              const std::string& pauli) override;
+                              const std::string &pauli) override;
 
   //-----------------------------------------------------------------------
   // Config Settings
@@ -192,12 +219,10 @@ class State : public virtual QuantumState::StateChunk<unitary_matrix_t> {
   // Table of allowed gate names to gate enum class members
   const static stringmap_t<Gates> gateset_;
 
-  //scale for unitary = 2
-  //this function is used in the base class to scale chunk qubits for multi-chunk distribution
-  int qubit_scale(void) override
-  {
-    return 2;
-  }
+  // scale for unitary = 2
+  // this function is used in the base class to scale chunk qubits for
+  // multi-chunk distribution
+  int qubit_scale(void) override { return 2; }
 };
 
 //============================================================================
@@ -207,18 +232,18 @@ class State : public virtual QuantumState::StateChunk<unitary_matrix_t> {
 template <class unitary_matrix_t>
 const stringmap_t<Gates> State<unitary_matrix_t>::gateset_({
     // Single qubit gates
-    {"delay", Gates::id},// Delay gate
-    {"id", Gates::id},   // Pauli-Identity gate
-    {"x", Gates::mcx},   // Pauli-X gate
-    {"y", Gates::mcy},   // Pauli-Y gate
-    {"z", Gates::mcz},   // Pauli-Z gate
-    {"s", Gates::s},     // Phase gate (aka sqrt(Z) gate)
-    {"sdg", Gates::sdg}, // Conjugate-transpose of Phase gate
-    {"h", Gates::h},     // Hadamard gate (X + Z / sqrt(2))
-    {"t", Gates::t},     // T-gate (sqrt(S))
-    {"tdg", Gates::tdg}, // Conjguate-transpose of T gate
-    {"p", Gates::mcp},   // Parameterized phase gate
-    {"sx", Gates::mcsx}, // Sqrt(X) gate
+    {"delay", Gates::id},    // Delay gate
+    {"id", Gates::id},       // Pauli-Identity gate
+    {"x", Gates::mcx},       // Pauli-X gate
+    {"y", Gates::mcy},       // Pauli-Y gate
+    {"z", Gates::mcz},       // Pauli-Z gate
+    {"s", Gates::s},         // Phase gate (aka sqrt(Z) gate)
+    {"sdg", Gates::sdg},     // Conjugate-transpose of Phase gate
+    {"h", Gates::h},         // Hadamard gate (X + Z / sqrt(2))
+    {"t", Gates::t},         // T-gate (sqrt(S))
+    {"tdg", Gates::tdg},     // Conjguate-transpose of T gate
+    {"p", Gates::mcp},       // Parameterized phase gate
+    {"sx", Gates::mcsx},     // Sqrt(X) gate
     {"sxdg", Gates::mcsxdg}, // Sqrt(X)^hc gate
     // 1-qubit rotation Gates
     {"r", Gates::mcr},   // R rotation gate
@@ -226,51 +251,51 @@ const stringmap_t<Gates> State<unitary_matrix_t>::gateset_({
     {"ry", Gates::mcry}, // Pauli-Y rotation gate
     {"rz", Gates::mcrz}, // Pauli-Z rotation gate
     // Waltz Gates
-    {"p", Gates::mcp},   // Parameterized phase gate 
-    {"u1", Gates::mcp}, // zero-X90 pulse waltz gate
+    {"p", Gates::mcp},   // Parameterized phase gate
+    {"u1", Gates::mcp},  // zero-X90 pulse waltz gate
     {"u2", Gates::mcu2}, // single-X90 pulse waltz gate
     {"u3", Gates::mcu3}, // two X90 pulse waltz gate
-    {"u", Gates::mcu3}, // two X90 pulse waltz gate
-    {"U", Gates::mcu3}, // two X90 pulse waltz gate
+    {"u", Gates::mcu3},  // two X90 pulse waltz gate
+    {"U", Gates::mcu3},  // two X90 pulse waltz gate
     // Two-qubit gates
-    {"CX", Gates::mcx},      // Controlled-X gate (CNOT)
-    {"cx", Gates::mcx},      // Controlled-X gate (CNOT)
-    {"cy", Gates::mcy},      // Controlled-Z gate
-    {"cz", Gates::mcz},      // Controlled-Z gate
-    {"cp", Gates::mcp},      // Controlled-Phase gate 
-    {"cu1", Gates::mcp},     // Controlled-u1 gate
-    {"cu2", Gates::mcu2},    // Controlled-u2 gate
-    {"cu3", Gates::mcu3},    // Controlled-u3 gate
-    {"cu", Gates::mcu},      // Controlled-u4 gate
-    {"cp", Gates::mcp},      // Controlled-Phase gate 
-    {"swap", Gates::mcswap}, // SWAP gate
-    {"rxx", Gates::rxx},     // Pauli-XX rotation gate
-    {"ryy", Gates::ryy},     // Pauli-YY rotation gate
-    {"rzz", Gates::rzz},     // Pauli-ZZ rotation gate
-    {"rzx", Gates::rzx},     // Pauli-ZX rotation gate
-    {"csx", Gates::mcsx},    // Controlled-Sqrt(X) gate
-    {"csxdg", Gates::mcsxdg},// Controlled-Sqrt(X)dg gate
+    {"CX", Gates::mcx},       // Controlled-X gate (CNOT)
+    {"cx", Gates::mcx},       // Controlled-X gate (CNOT)
+    {"cy", Gates::mcy},       // Controlled-Z gate
+    {"cz", Gates::mcz},       // Controlled-Z gate
+    {"cp", Gates::mcp},       // Controlled-Phase gate
+    {"cu1", Gates::mcp},      // Controlled-u1 gate
+    {"cu2", Gates::mcu2},     // Controlled-u2 gate
+    {"cu3", Gates::mcu3},     // Controlled-u3 gate
+    {"cu", Gates::mcu},       // Controlled-u4 gate
+    {"cp", Gates::mcp},       // Controlled-Phase gate
+    {"swap", Gates::mcswap},  // SWAP gate
+    {"rxx", Gates::rxx},      // Pauli-XX rotation gate
+    {"ryy", Gates::ryy},      // Pauli-YY rotation gate
+    {"rzz", Gates::rzz},      // Pauli-ZZ rotation gate
+    {"rzx", Gates::rzx},      // Pauli-ZX rotation gate
+    {"csx", Gates::mcsx},     // Controlled-Sqrt(X) gate
+    {"csxdg", Gates::mcsxdg}, // Controlled-Sqrt(X)dg gate
     // Three-qubit gates
     {"ccx", Gates::mcx},      // Controlled-CX gate (Toffoli)
     {"cswap", Gates::mcswap}, // Controlled-SWAP gate (Fredkin)
     // Multi-qubit controlled gates
-    {"mcx", Gates::mcx},      // Multi-controlled-X gate
-    {"mcy", Gates::mcy},      // Multi-controlled-Y gate
-    {"mcz", Gates::mcz},      // Multi-controlled-Z gate
-    {"mcr", Gates::mcr},      // Multi-controlled R-rotation gate
-    {"mcrx", Gates::mcrx},    // Multi-controlled X-rotation gate
-    {"mcry", Gates::mcry},    // Multi-controlled Y-rotation gate
-    {"mcrz", Gates::mcrz},    // Multi-controlled Z-rotation gate
-    {"mcphase", Gates::mcp},  // Multi-controlled-Phase gate 
-    {"mcu1", Gates::mcp},    // Multi-controlled-u1
-    {"mcu2", Gates::mcu2},    // Multi-controlled-u2
-    {"mcu3", Gates::mcu3},    // Multi-controlled-u3
-    {"mcu", Gates::mcu},      // Multi-controlled-u4
-    {"mcp", Gates::mcp},      // Multi-controlled-Phase gate 
-    {"mcswap", Gates::mcswap},// Multi-controlled SWAP gate
-    {"mcsx", Gates::mcsx},    // Multi-controlled-Sqrt(X) gate
-    {"mcsxdg", Gates::mcsxdg},    // Multi-controlled-Sqrt(X)dg gate
-    {"pauli", Gates::pauli}  // Multiple pauli operations at once
+    {"mcx", Gates::mcx},       // Multi-controlled-X gate
+    {"mcy", Gates::mcy},       // Multi-controlled-Y gate
+    {"mcz", Gates::mcz},       // Multi-controlled-Z gate
+    {"mcr", Gates::mcr},       // Multi-controlled R-rotation gate
+    {"mcrx", Gates::mcrx},     // Multi-controlled X-rotation gate
+    {"mcry", Gates::mcry},     // Multi-controlled Y-rotation gate
+    {"mcrz", Gates::mcrz},     // Multi-controlled Z-rotation gate
+    {"mcphase", Gates::mcp},   // Multi-controlled-Phase gate
+    {"mcu1", Gates::mcp},      // Multi-controlled-u1
+    {"mcu2", Gates::mcu2},     // Multi-controlled-u2
+    {"mcu3", Gates::mcu3},     // Multi-controlled-u3
+    {"mcu", Gates::mcu},       // Multi-controlled-u4
+    {"mcp", Gates::mcp},       // Multi-controlled-Phase gate
+    {"mcswap", Gates::mcswap}, // Multi-controlled SWAP gate
+    {"mcsx", Gates::mcsx},     // Multi-controlled-Sqrt(X) gate
+    {"mcsxdg", Gates::mcsxdg}, // Multi-controlled-Sqrt(X)dg gate
+    {"pauli", Gates::pauli}    // Multiple pauli operations at once
 });
 
 //============================================================================
@@ -278,83 +303,82 @@ const stringmap_t<Gates> State<unitary_matrix_t>::gateset_({
 //============================================================================
 
 template <class unitary_matrix_t>
-void State<unitary_matrix_t>::apply_op(const int_t iChunk, 
-    const Operations::Op &op, ExperimentResult &result,
-    RngEngine &rng, bool final_op)
-{
-  if(BaseState::check_conditional(iChunk, op)) {
+void State<unitary_matrix_t>::apply_op(const int_t iChunk,
+                                       const Operations::Op &op,
+                                       ExperimentResult &result, RngEngine &rng,
+                                       bool final_op) {
+  if (BaseState::check_conditional(iChunk, op)) {
     switch (op.type) {
-      case Operations::OpType::barrier:
-      case Operations::OpType::qerror_loc:
-        break;
-      case Operations::OpType::bfunc:
-        BaseState::cregs_[0].apply_bfunc(op);
-        break;
-      case Operations::OpType::roerror:
-        BaseState::cregs_[0].apply_roerror(op, rng);
-        break;
-      case Operations::OpType::gate:
-        apply_gate(iChunk, op);
-        break;
-      case Operations::OpType::set_unitary:
-        BaseState::initialize_from_matrix(iChunk, op.mats[0]);
-        break;
-      case Operations::OpType::save_state:
-      case Operations::OpType::save_unitary:
-        apply_save_unitary(iChunk, op, result, final_op);
-        break;
-      case Operations::OpType::snapshot:
-        apply_snapshot(iChunk, op, result);
-        break;
-      case Operations::OpType::matrix:
-        apply_matrix(iChunk, op.qubits, op.mats[0]);
-        break;
-      case Operations::OpType::diagonal_matrix:
-        apply_diagonal_matrix(iChunk, op.qubits, op.params);
-        break;
-      default:
-        throw std::invalid_argument(
-            "QubitUnitary::State::invalid instruction \'" + op.name + "\'.");
-    }
-  }
-}
-
-template <class densmat_t>
-bool State<densmat_t>::apply_batched_op(const int_t iChunk, const Operations::Op &op,
-                                  ExperimentResult &result,
-                                  std::vector<RngEngine> &rng,
-                                  bool final_ops) 
-{
-  if(op.conditional)
-    BaseState::qregs_[iChunk].set_conditional(op.conditional_reg);
-
-  switch (op.type) {
     case Operations::OpType::barrier:
-    case Operations::OpType::nop:
     case Operations::OpType::qerror_loc:
       break;
     case Operations::OpType::bfunc:
-      BaseState::qregs_[iChunk].apply_bfunc(op);
+      BaseState::cregs_[0].apply_bfunc(op);
       break;
     case Operations::OpType::roerror:
-      BaseState::qregs_[iChunk].apply_roerror(op, rng);
+      BaseState::cregs_[0].apply_roerror(op, rng);
       break;
     case Operations::OpType::gate:
       apply_gate(iChunk, op);
       break;
+    case Operations::OpType::set_unitary:
+      BaseState::initialize_from_matrix(iChunk, op.mats[0]);
+      break;
+    case Operations::OpType::save_state:
+    case Operations::OpType::save_unitary:
+      apply_save_unitary(iChunk, op, result, final_op);
+      break;
+    case Operations::OpType::snapshot:
+      apply_snapshot(iChunk, op, result);
+      break;
     case Operations::OpType::matrix:
       apply_matrix(iChunk, op.qubits, op.mats[0]);
       break;
     case Operations::OpType::diagonal_matrix:
-      BaseState::qregs_[iChunk].apply_diagonal_matrix(op.qubits, op.params);
+      apply_diagonal_matrix(iChunk, op.qubits, op.params);
       break;
     default:
-      //other operations should be called to indivisual chunks by apply_op
-      return false;
+      throw std::invalid_argument(
+          "QubitUnitary::State::invalid instruction \'" + op.name + "\'.");
+    }
   }
-  return true;
 }
 
+template <class densmat_t>
+bool State<densmat_t>::apply_batched_op(const int_t iChunk,
+                                        const Operations::Op &op,
+                                        ExperimentResult &result,
+                                        std::vector<RngEngine> &rng,
+                                        bool final_ops) {
+  if (op.conditional)
+    BaseState::qregs_[iChunk].set_conditional(op.conditional_reg);
+
+  switch (op.type) {
+  case Operations::OpType::barrier:
+  case Operations::OpType::nop:
+  case Operations::OpType::qerror_loc:
+    break;
+  case Operations::OpType::bfunc:
+    BaseState::qregs_[iChunk].apply_bfunc(op);
+    break;
+  case Operations::OpType::roerror:
+    BaseState::qregs_[iChunk].apply_roerror(op, rng);
+    break;
+  case Operations::OpType::gate:
+    apply_gate(iChunk, op);
+    break;
+  case Operations::OpType::matrix:
+    apply_matrix(iChunk, op.qubits, op.mats[0]);
+    break;
+  case Operations::OpType::diagonal_matrix:
+    BaseState::qregs_[iChunk].apply_diagonal_matrix(op.qubits, op.params);
+    break;
+  default:
+    // other operations should be called to indivisual chunks by apply_op
+    return false;
+  }
+  return true;
+}
 
 template <class unitary_matrix_t>
 size_t State<unitary_matrix_t>::required_memory_mb(
@@ -368,8 +392,7 @@ size_t State<unitary_matrix_t>::required_memory_mb(
 }
 
 template <class unitary_matrix_t>
-void State<unitary_matrix_t>::set_config(const json_t &config) 
-{
+void State<unitary_matrix_t>::set_config(const json_t &config) {
   BaseState::set_config(config);
 
   // Set OMP threshold for state update functions
@@ -378,52 +401,54 @@ void State<unitary_matrix_t>::set_config(const json_t &config)
   // Set threshold for truncating snapshots
   JSON::get_value(json_chop_threshold_, "zero_threshold", config);
 
-  for(int_t i=0;i<BaseState::qregs_.size();i++)
+  for (int_t i = 0; i < BaseState::qregs_.size(); i++)
     BaseState::qregs_[i].set_json_chop_threshold(json_chop_threshold_);
 }
 
 template <class unitary_matrix_t>
-void State<unitary_matrix_t>::initialize_qreg(uint_t num_qubits) 
-{
-  if(BaseState::qregs_.size() == 0)
-    BaseState::allocate(num_qubits,num_qubits,1);
+void State<unitary_matrix_t>::initialize_qreg(uint_t num_qubits) {
+  if (BaseState::qregs_.size() == 0)
+    BaseState::allocate(num_qubits, num_qubits, 1);
 
   initialize_omp();
 
   int_t iChunk;
-  for(iChunk=0;iChunk<BaseState::qregs_.size();iChunk++){
+  for (iChunk = 0; iChunk < BaseState::qregs_.size(); iChunk++) {
     BaseState::qregs_[iChunk].set_num_qubits(BaseState::chunk_bits_);
   }
 
-  if(BaseState::multi_chunk_distribution_){
-    if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0){
-#pragma omp parallel for private(iChunk) 
-      for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-        for(iChunk = BaseState::top_chunk_of_group_[ig];iChunk < BaseState::top_chunk_of_group_[ig + 1];iChunk++){
-          uint_t irow,icol;
-          irow = (BaseState::global_chunk_index_ + iChunk) >> ((BaseState::num_qubits_ - BaseState::chunk_bits_));
-          icol = (BaseState::global_chunk_index_ + iChunk) - (irow << ((BaseState::num_qubits_ - BaseState::chunk_bits_)));
-          if(irow == icol)
+  if (BaseState::multi_chunk_distribution_) {
+    if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0) {
+#pragma omp parallel for private(iChunk)
+      for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+        for (iChunk = BaseState::top_chunk_of_group_[ig];
+             iChunk < BaseState::top_chunk_of_group_[ig + 1]; iChunk++) {
+          uint_t irow, icol;
+          irow = (BaseState::global_chunk_index_ + iChunk) >>
+                 ((BaseState::num_qubits_ - BaseState::chunk_bits_));
+          icol = (BaseState::global_chunk_index_ + iChunk) -
+                 (irow << ((BaseState::num_qubits_ - BaseState::chunk_bits_)));
+          if (irow == icol)
             BaseState::qregs_[iChunk].initialize();
           else
             BaseState::qregs_[iChunk].zero();
         }
       }
-    }
-    else{
-      for(iChunk=0;iChunk<BaseState::qregs_.size();iChunk++){
-        uint_t irow,icol;
-        irow = (BaseState::global_chunk_index_ + iChunk) >> ((BaseState::num_qubits_ - BaseState::chunk_bits_));
-        icol = (BaseState::global_chunk_index_ + iChunk) - (irow << ((BaseState::num_qubits_ - BaseState::chunk_bits_)));
-        if(irow == icol)
+    } else {
+      for (iChunk = 0; iChunk < BaseState::qregs_.size(); iChunk++) {
+        uint_t irow, icol;
+        irow = (BaseState::global_chunk_index_ + iChunk) >>
+               ((BaseState::num_qubits_ - BaseState::chunk_bits_));
+        icol = (BaseState::global_chunk_index_ + iChunk) -
+               (irow << ((BaseState::num_qubits_ - BaseState::chunk_bits_)));
+        if (irow == icol)
           BaseState::qregs_[iChunk].initialize();
         else
           BaseState::qregs_[iChunk].zero();
       }
     }
-  }
-  else{
-    for(iChunk=0;iChunk<BaseState::qregs_.size();iChunk++){
+  } else {
+    for (iChunk = 0; iChunk < BaseState::qregs_.size(); iChunk++) {
       BaseState::qregs_[iChunk].initialize();
     }
   }
@@ -432,96 +457,106 @@ void State<unitary_matrix_t>::initialize_qreg(uint_t num_qubits)
 
 template <class unitary_matrix_t>
 void State<unitary_matrix_t>::initialize_qreg(uint_t num_qubits,
-                                              const cmatrix_t &unitary) 
-{
+                                              const cmatrix_t &unitary) {
   // Check dimension of unitary
   if (unitary.size() != 1ULL << (2 * num_qubits)) {
     throw std::invalid_argument(
         "Unitary::State::initialize: initial state does not match qubit "
         "number");
   }
-  if(BaseState::qregs_.size() == 0)
-    BaseState::allocate(num_qubits,num_qubits,1);
+  if (BaseState::qregs_.size() == 0)
+    BaseState::allocate(num_qubits, num_qubits, 1);
   initialize_omp();
 
   int_t iChunk;
-  for(iChunk=0;iChunk<BaseState::qregs_.size();iChunk++)
+  for (iChunk = 0; iChunk < BaseState::qregs_.size(); iChunk++)
     BaseState::qregs_[iChunk].set_num_qubits(BaseState::chunk_bits_);
 
-  if(BaseState::multi_chunk_distribution_){
+  if (BaseState::multi_chunk_distribution_) {
     uint_t mask = (1ull << (BaseState::chunk_bits_)) - 1;
-    for(iChunk=0;iChunk<BaseState::qregs_.size();iChunk++){
-      //this function should be called in-order
+    for (iChunk = 0; iChunk < BaseState::qregs_.size(); iChunk++) {
+      // this function should be called in-order
       BaseState::qregs_[iChunk].set_num_qubits(BaseState::chunk_bits_);
     }
 
-    if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0){
-#pragma omp parallel for private(iChunk) 
-      for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-        for(iChunk = BaseState::top_chunk_of_group_[ig];iChunk < BaseState::top_chunk_of_group_[ig + 1];iChunk++){
-          uint_t irow_chunk = ((iChunk + BaseState::global_chunk_index_) >> ((BaseState::num_qubits_ - BaseState::chunk_bits_)));
-          uint_t icol_chunk = ((iChunk + BaseState::global_chunk_index_) & ((1ull << ((BaseState::num_qubits_ - BaseState::chunk_bits_)))-1));
-
-          //copy part of state for this chunk
-          uint_t i,row,col;
+    if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0) {
+#pragma omp parallel for private(iChunk)
+      for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+        for (iChunk = BaseState::top_chunk_of_group_[ig];
+             iChunk < BaseState::top_chunk_of_group_[ig + 1]; iChunk++) {
+          uint_t irow_chunk =
+              ((iChunk + BaseState::global_chunk_index_) >>
+               ((BaseState::num_qubits_ - BaseState::chunk_bits_)));
+          uint_t icol_chunk =
+              ((iChunk + BaseState::global_chunk_index_) &
+               ((1ull << ((BaseState::num_qubits_ - BaseState::chunk_bits_))) -
+                1));
+
+          // copy part of state for this chunk
+          uint_t i, row, col;
           cvector_t tmp(1ull << BaseState::chunk_bits_);
-          for(i=0;i<(1ull << BaseState::chunk_bits_);i++){
+          for (i = 0; i < (1ull << BaseState::chunk_bits_); i++) {
             uint_t icol = i >> (BaseState::chunk_bits_);
             uint_t irow = i & mask;
-            uint_t idx = ((icol+(irow_chunk << BaseState::chunk_bits_)) << (BaseState::num_qubits_)) + (icol_chunk << BaseState::chunk_bits_) + irow;
+            uint_t idx = ((icol + (irow_chunk << BaseState::chunk_bits_))
+                          << (BaseState::num_qubits_)) +
+                         (icol_chunk << BaseState::chunk_bits_) + irow;
             tmp[i] = unitary[idx];
           }
           BaseState::qregs_[iChunk].initialize_from_vector(tmp);
         }
       }
-    }
-    else{
-      for(iChunk=0;iChunk<BaseState::qregs_.size();iChunk++){
-        uint_t irow_chunk = ((iChunk + BaseState::global_chunk_index_) >> ((BaseState::num_qubits_ - BaseState::chunk_bits_)));
-        uint_t icol_chunk = ((iChunk + BaseState::global_chunk_index_) & ((1ull << ((BaseState::num_qubits_ - BaseState::chunk_bits_)))-1));
-
-        //copy part of state for this chunk
-        uint_t i,row,col;
+    } else {
+      for (iChunk = 0; iChunk < BaseState::qregs_.size(); iChunk++) {
+        uint_t irow_chunk =
+            ((iChunk + BaseState::global_chunk_index_) >>
+             ((BaseState::num_qubits_ - BaseState::chunk_bits_)));
+        uint_t icol_chunk =
+            ((iChunk + BaseState::global_chunk_index_) &
+             ((1ull << ((BaseState::num_qubits_ - BaseState::chunk_bits_))) -
+              1));
+
+        // copy part of state for this chunk
+        uint_t i, row, col;
         cvector_t tmp(1ull << BaseState::chunk_bits_);
-        for(i=0;i<(1ull << BaseState::chunk_bits_);i++){
+        for (i = 0; i < (1ull << BaseState::chunk_bits_); i++) {
           uint_t icol = i >> (BaseState::chunk_bits_);
           uint_t irow = i & mask;
-          uint_t idx = ((icol+(irow_chunk << BaseState::chunk_bits_)) << (BaseState::num_qubits_)) + (icol_chunk << BaseState::chunk_bits_) + irow;
+          uint_t idx = ((icol + (irow_chunk << BaseState::chunk_bits_))
+                        << (BaseState::num_qubits_)) +
+                       (icol_chunk << BaseState::chunk_bits_) + irow;
           tmp[i] = unitary[idx];
         }
         BaseState::qregs_[iChunk].initialize_from_vector(tmp);
       }
     }
-  }
-  else{
+  } else {
     BaseState::qregs_[iChunk].initialize_from_matrix(unitary);
   }
   apply_global_phase();
 }
 
 template <class unitary_matrix_t>
-void State<unitary_matrix_t>::initialize_omp() 
-{
+void State<unitary_matrix_t>::initialize_omp() {
   uint_t i;
-  for(i=0;i<BaseState::qregs_.size();i++){
+  for (i = 0; i < BaseState::qregs_.size(); i++) {
     BaseState::qregs_[i].set_omp_threshold(omp_qubit_threshold_);
     if (BaseState::threads_ > 0)
-      BaseState::qregs_[i].set_omp_threads(BaseState::threads_); // set allowed OMP threads in qubitvector
+      BaseState::qregs_[i].set_omp_threads(
+          BaseState::threads_); // set allowed OMP threads in qubitvector
   }
 }
 
 template <class unitary_matrix_t>
-auto State<unitary_matrix_t>::move_to_matrix(const int_t iChunk)
-{
-  if(!BaseState::multi_chunk_distribution_)
+auto State<unitary_matrix_t>::move_to_matrix(const int_t iChunk) {
+  if (!BaseState::multi_chunk_distribution_)
     return BaseState::qregs_[iChunk].move_to_matrix();
   return BaseState::apply_to_matrix(false);
 }
 
 template <class unitary_matrix_t>
-auto State<unitary_matrix_t>::copy_to_matrix(const int_t iChunk)
-{
-  if(!BaseState::multi_chunk_distribution_)
+auto State<unitary_matrix_t>::copy_to_matrix(const int_t iChunk) {
+  if (!BaseState::multi_chunk_distribution_)
     return BaseState::qregs_[iChunk].copy_to_matrix();
   return BaseState::apply_to_matrix(true);
 }
@@ -531,18 +566,19 @@ auto State<unitary_matrix_t>::copy_to_matrix(const int_t iChunk)
 //=========================================================================
 
 template <class unitary_matrix_t>
-void State<unitary_matrix_t>::apply_gate(const int_t iChunk, const Operations::Op &op) 
-{
-  if(!BaseState::global_chunk_indexing_){
-    reg_t qubits_in,qubits_out;
-    BaseState::get_inout_ctrl_qubits(op,qubits_out,qubits_in);
-    if(qubits_out.size() > 0){
+void State<unitary_matrix_t>::apply_gate(const int_t iChunk,
+                                         const Operations::Op &op) {
+  if (!BaseState::global_chunk_indexing_) {
+    reg_t qubits_in, qubits_out;
+    BaseState::get_inout_ctrl_qubits(op, qubits_out, qubits_in);
+    if (qubits_out.size() > 0) {
       uint_t mask = 0;
-      for(int i=0;i<qubits_out.size();i++){
+      for (int i = 0; i < qubits_out.size(); i++) {
         mask |= (1ull << (qubits_out[i] - BaseState::chunk_bits_));
       }
-      if(((BaseState::global_chunk_index_ + iChunk) & mask) == mask){
-        Operations::Op new_op = BaseState::remake_gate_in_chunk_qubits(op,qubits_in);
+      if (((BaseState::global_chunk_index_ + iChunk) & mask) == mask) {
+        Operations::Op new_op =
+            BaseState::remake_gate_in_chunk_qubits(op, qubits_in);
         apply_gate(iChunk, new_op);
       }
       return;
@@ -556,115 +592,124 @@ void State<unitary_matrix_t>::apply_gate(const int_t iChunk, const Operations::O
                                 op.name + "\'.");
   Gates g = it->second;
   switch (g) {
-    case Gates::mcx:
-      // Includes X, CX, CCX, etc
-      BaseState::qregs_[iChunk].apply_mcx(op.qubits);
-      break;
-    case Gates::mcy:
-      // Includes Y, CY, CCY, etc
-      BaseState::qregs_[iChunk].apply_mcy(op.qubits);
-      break;
-    case Gates::mcz:
-      // Includes Z, CZ, CCZ, etc
-      BaseState::qregs_[iChunk].apply_mcphase(op.qubits, -1);
-      break;
-    case Gates::mcr:
-      BaseState::qregs_[iChunk].apply_mcu(op.qubits, Linalg::VMatrix::r(op.params[0], op.params[1]));
-      break;
-    case Gates::mcrx:
-      BaseState::qregs_[iChunk].apply_mcu(op.qubits, Linalg::VMatrix::rx(op.params[0]));
-      break;
-    case Gates::mcry:
-      BaseState::qregs_[iChunk].apply_mcu(op.qubits, Linalg::VMatrix::ry(op.params[0]));
-      break;
-    case Gates::mcrz:
-      BaseState::qregs_[iChunk].apply_mcu(op.qubits, Linalg::VMatrix::rz(op.params[0]));
-      break;
-    case Gates::rxx:
-      BaseState::qregs_[iChunk].apply_matrix(op.qubits, Linalg::VMatrix::rxx(op.params[0]));
-      break;
-    case Gates::ryy:
-      BaseState::qregs_[iChunk].apply_matrix(op.qubits, Linalg::VMatrix::ryy(op.params[0]));
-      break;
-    case Gates::rzz:
-      apply_diagonal_matrix(iChunk, op.qubits, Linalg::VMatrix::rzz_diag(op.params[0]));
-      break;
-    case Gates::rzx:
-      BaseState::qregs_[iChunk].apply_matrix(op.qubits, Linalg::VMatrix::rzx(op.params[0]));
-      break;
-    case Gates::id:
-      break;
-    case Gates::h:
-      apply_gate_mcu(iChunk, op.qubits, M_PI / 2., 0., M_PI, 0.);
-      break;
-    case Gates::s:
-      apply_gate_phase(iChunk, op.qubits[0], complex_t(0., 1.));
-      break;
-    case Gates::sdg:
-      apply_gate_phase(iChunk, op.qubits[0], complex_t(0., -1.));
-      break;
-    case Gates::pauli:
-        BaseState::qregs_[iChunk].apply_pauli(op.qubits, op.string_params[0]);
-        break;
-    case Gates::t: {
-      const double isqrt2{1. / std::sqrt(2)};
-      apply_gate_phase(iChunk, op.qubits[0], complex_t(isqrt2, isqrt2));
-    } break;
-    case Gates::tdg: {
-      const double isqrt2{1. / std::sqrt(2)};
-      apply_gate_phase(iChunk, op.qubits[0], complex_t(isqrt2, -isqrt2));
-    } break;
-    case Gates::mcswap:
-      // Includes SWAP, CSWAP, etc
-      BaseState::qregs_[iChunk].apply_mcswap(op.qubits);
-      break;
-    case Gates::mcu3:
-      // Includes u3, cu3, etc
-      apply_gate_mcu(iChunk, op.qubits, std::real(op.params[0]), std::real(op.params[1]),
-                      std::real(op.params[2]), 0.);
-      break;
-    case Gates::mcu:
-      // Includes u, cu, etc
-      apply_gate_mcu(iChunk, op.qubits, std::real(op.params[0]), std::real(op.params[1]),
-                      std::real(op.params[2]), std::real(op.params[3]));
-      break;
-    case Gates::mcu2:
-      // Includes u2, cu2, etc
-      apply_gate_mcu(iChunk, op.qubits, M_PI / 2., std::real(op.params[0]),
-                     std::real(op.params[1]), 0.);
-      break;
-    case Gates::mcp:
-      // Includes u1, cu1, p, cp, mcp, etc
-      BaseState::qregs_[iChunk].apply_mcphase(op.qubits,
-                                     std::exp(complex_t(0, 1) * op.params[0]));
-      break;
-    case Gates::mcsx:
-      // Includes sx, csx, mcsx etc
-      BaseState::qregs_[iChunk].apply_mcu(op.qubits, Linalg::VMatrix::SX);
-      break;
-     case Gates::mcsxdg:
-      BaseState::qregs_[iChunk].apply_mcu(op.qubits, Linalg::VMatrix::SXDG);
-      break;
-    default:
-      // We shouldn't reach here unless there is a bug in gateset
-      throw std::invalid_argument("Unitary::State::invalid gate instruction \'" +
-                                  op.name + "\'.");
+  case Gates::mcx:
+    // Includes X, CX, CCX, etc
+    BaseState::qregs_[iChunk].apply_mcx(op.qubits);
+    break;
+  case Gates::mcy:
+    // Includes Y, CY, CCY, etc
+    BaseState::qregs_[iChunk].apply_mcy(op.qubits);
+    break;
+  case Gates::mcz:
+    // Includes Z, CZ, CCZ, etc
+    BaseState::qregs_[iChunk].apply_mcphase(op.qubits, -1);
+    break;
+  case Gates::mcr:
+    BaseState::qregs_[iChunk].apply_mcu(
+        op.qubits, Linalg::VMatrix::r(op.params[0], op.params[1]));
+    break;
+  case Gates::mcrx:
+    BaseState::qregs_[iChunk].apply_mcu(op.qubits,
+                                        Linalg::VMatrix::rx(op.params[0]));
+    break;
+  case Gates::mcry:
+    BaseState::qregs_[iChunk].apply_mcu(op.qubits,
+                                        Linalg::VMatrix::ry(op.params[0]));
+    break;
+  case Gates::mcrz:
+    BaseState::qregs_[iChunk].apply_mcu(op.qubits,
+                                        Linalg::VMatrix::rz(op.params[0]));
+    break;
+  case Gates::rxx:
+    BaseState::qregs_[iChunk].apply_matrix(op.qubits,
+                                           Linalg::VMatrix::rxx(op.params[0]));
+    break;
+  case Gates::ryy:
+    BaseState::qregs_[iChunk].apply_matrix(op.qubits,
+                                           Linalg::VMatrix::ryy(op.params[0]));
+    break;
+  case Gates::rzz:
+    apply_diagonal_matrix(iChunk, op.qubits,
+                          Linalg::VMatrix::rzz_diag(op.params[0]));
+    break;
+  case Gates::rzx:
+    BaseState::qregs_[iChunk].apply_matrix(op.qubits,
+                                           Linalg::VMatrix::rzx(op.params[0]));
+    break;
+  case Gates::id:
+    break;
+  case Gates::h:
+    apply_gate_mcu(iChunk, op.qubits, M_PI / 2., 0., M_PI, 0.);
+    break;
+  case Gates::s:
+    apply_gate_phase(iChunk, op.qubits[0], complex_t(0., 1.));
+    break;
+  case Gates::sdg:
+    apply_gate_phase(iChunk, op.qubits[0], complex_t(0., -1.));
+    break;
+  case Gates::pauli:
+    BaseState::qregs_[iChunk].apply_pauli(op.qubits, op.string_params[0]);
+    break;
+  case Gates::t: {
+    const double isqrt2{1. / std::sqrt(2)};
+    apply_gate_phase(iChunk, op.qubits[0], complex_t(isqrt2, isqrt2));
+  } break;
+  case Gates::tdg: {
+    const double isqrt2{1. / std::sqrt(2)};
+    apply_gate_phase(iChunk, op.qubits[0], complex_t(isqrt2, -isqrt2));
+  } break;
+  case Gates::mcswap:
+    // Includes SWAP, CSWAP, etc
+    BaseState::qregs_[iChunk].apply_mcswap(op.qubits);
+    break;
+  case Gates::mcu3:
+    // Includes u3, cu3, etc
+    apply_gate_mcu(iChunk, op.qubits, std::real(op.params[0]),
+                   std::real(op.params[1]), std::real(op.params[2]), 0.);
+    break;
+  case Gates::mcu:
+    // Includes u, cu, etc
+    apply_gate_mcu(iChunk, op.qubits, std::real(op.params[0]),
+                   std::real(op.params[1]), std::real(op.params[2]),
+                   std::real(op.params[3]));
+    break;
+  case Gates::mcu2:
+    // Includes u2, cu2, etc
+    apply_gate_mcu(iChunk, op.qubits, M_PI / 2., std::real(op.params[0]),
+                   std::real(op.params[1]), 0.);
+    break;
+  case Gates::mcp:
+    // Includes u1, cu1, p, cp, mcp, etc
+    BaseState::qregs_[iChunk].apply_mcphase(
+        op.qubits, std::exp(complex_t(0, 1) * op.params[0]));
+    break;
+  case Gates::mcsx:
+    // Includes sx, csx, mcsx etc
+    BaseState::qregs_[iChunk].apply_mcu(op.qubits, Linalg::VMatrix::SX);
+    break;
+  case Gates::mcsxdg:
+    BaseState::qregs_[iChunk].apply_mcu(op.qubits, Linalg::VMatrix::SXDG);
+    break;
+  default:
+    // We shouldn't reach here unless there is a bug in gateset
+    throw std::invalid_argument("Unitary::State::invalid gate instruction \'" +
+                                op.name + "\'.");
   }
 }
 
 template <class unitary_matrix_t>
-void State<unitary_matrix_t>::apply_matrix(const int_t iChunk, const reg_t &qubits,
-                                           const cmatrix_t &mat) 
-{
+void State<unitary_matrix_t>::apply_matrix(const int_t iChunk,
+                                           const reg_t &qubits,
+                                           const cmatrix_t &mat) {
   if (qubits.empty() == false && mat.size() > 0) {
     apply_matrix(iChunk, qubits, Utils::vectorize_matrix(mat));
   }
 }
 
 template <class unitary_matrix_t>
-void State<unitary_matrix_t>::apply_matrix(const int_t iChunk, const reg_t &qubits,
-                                           const cvector_t &vmat) 
-{
+void State<unitary_matrix_t>::apply_matrix(const int_t iChunk,
+                                           const reg_t &qubits,
+                                           const cvector_t &vmat) {
   // Check if diagonal matrix
   if (vmat.size() == 1ULL << qubits.size()) {
     apply_diagonal_matrix(iChunk, qubits, vmat);
@@ -674,30 +719,32 @@ void State<unitary_matrix_t>::apply_matrix(const int_t iChunk, const reg_t &qubi
 }
 
 template <class unitary_matrix_t>
-void State<unitary_matrix_t>::apply_diagonal_matrix(const int_t iChunk, const reg_t &qubits, const cvector_t &diag)
-{
-  if(BaseState::global_chunk_indexing_ || !BaseState::multi_chunk_distribution_){
-    //GPU computes all chunks in one kernel, so pass qubits and diagonal matrix as is
+void State<unitary_matrix_t>::apply_diagonal_matrix(const int_t iChunk,
+                                                    const reg_t &qubits,
+                                                    const cvector_t &diag) {
+  if (BaseState::global_chunk_indexing_ ||
+      !BaseState::multi_chunk_distribution_) {
+    // GPU computes all chunks in one kernel, so pass qubits and diagonal matrix
+    // as is
     reg_t qubits_chunk = qubits;
-    for(uint_t i=0;i<qubits.size();i++){
-      if(qubits_chunk[i] >= BaseState::chunk_bits_){
+    for (uint_t i = 0; i < qubits.size(); i++) {
+      if (qubits_chunk[i] >= BaseState::chunk_bits_) {
         qubits_chunk[i] += BaseState::chunk_bits_;
       }
     }
-    BaseState::qregs_[iChunk].apply_diagonal_matrix(qubits_chunk,diag);
-  }
-  else{
+    BaseState::qregs_[iChunk].apply_diagonal_matrix(qubits_chunk, diag);
+  } else {
     reg_t qubits_in = qubits;
     cvector_t diag_in = diag;
 
-    BaseState::block_diagonal_matrix(iChunk,qubits_in,diag_in);
-    BaseState::qregs_[iChunk].apply_diagonal_matrix(qubits_in,diag_in);
+    BaseState::block_diagonal_matrix(iChunk, qubits_in, diag_in);
+    BaseState::qregs_[iChunk].apply_diagonal_matrix(qubits_in, diag_in);
   }
 }
 
 template <class unitary_matrix_t>
-void State<unitary_matrix_t>::apply_gate_phase(const int_t iChunk, uint_t qubit, complex_t phase) 
-{
+void State<unitary_matrix_t>::apply_gate_phase(const int_t iChunk, uint_t qubit,
+                                               complex_t phase) {
   cvector_t diag(2);
   diag[0] = 1.0;
   diag[1] = phase;
@@ -705,29 +752,31 @@ void State<unitary_matrix_t>::apply_gate_phase(const int_t iChunk, uint_t qubit,
 }
 
 template <class unitary_matrix_t>
-void State<unitary_matrix_t>::apply_gate_phase(const int_t iChunk, const reg_t& qubits, complex_t phase)
-{
-  cvector_t diag((1 << qubits.size()),1.0);
+void State<unitary_matrix_t>::apply_gate_phase(const int_t iChunk,
+                                               const reg_t &qubits,
+                                               complex_t phase) {
+  cvector_t diag((1 << qubits.size()), 1.0);
   diag[(1 << qubits.size()) - 1] = phase;
   apply_diagonal_matrix(iChunk, qubits, diag);
 }
 
 template <class unitary_matrix_t>
-void State<unitary_matrix_t>::apply_gate_mcu(const int_t iChunk, const reg_t &qubits, double theta,
-                                              double phi, double lambda, double gamma) 
-{
+void State<unitary_matrix_t>::apply_gate_mcu(const int_t iChunk,
+                                             const reg_t &qubits, double theta,
+                                             double phi, double lambda,
+                                             double gamma) {
   const auto u4 = Linalg::Matrix::u4(theta, phi, lambda, gamma);
   BaseState::qregs_[iChunk].apply_mcu(qubits, Utils::vectorize_matrix(u4));
 }
 
 template <class unitary_matrix_t>
-void State<unitary_matrix_t>::apply_snapshot(const int_t iChunk, const Operations::Op &op,
-                                             ExperimentResult &result) 
-{
+void State<unitary_matrix_t>::apply_snapshot(const int_t iChunk,
+                                             const Operations::Op &op,
+                                             ExperimentResult &result) {
   // Look for snapshot type in snapshotset
   if (op.name == "unitary" || op.name == "state") {
     result.legacy_data.add_pershot_snapshot("unitary", op.string_params[0],
-                              copy_to_matrix(iChunk));
+                                            copy_to_matrix(iChunk));
     BaseState::snapshot_state(iChunk, op, result);
   } else {
     throw std::invalid_argument(
@@ -736,67 +785,69 @@ void State<unitary_matrix_t>::apply_snapshot(const int_t iChunk, const Operation
 }
 
 template <class unitary_matrix_t>
-void State<unitary_matrix_t>::apply_global_phase() 
-{
+void State<unitary_matrix_t>::apply_global_phase() {
   if (BaseState::has_global_phase_) {
-    if(BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0){
-#pragma omp parallel for 
-      for(int_t ig=0;ig<BaseState::num_groups_;ig++){
-        for(int_t i = BaseState::top_chunk_of_group_[ig];i < BaseState::top_chunk_of_group_[ig + 1];i++)
-          apply_diagonal_matrix(i, {0}, {BaseState::global_phase_, BaseState::global_phase_});
+    if (BaseState::chunk_omp_parallel_ && BaseState::num_groups_ > 0) {
+#pragma omp parallel for
+      for (int_t ig = 0; ig < BaseState::num_groups_; ig++) {
+        for (int_t i = BaseState::top_chunk_of_group_[ig];
+             i < BaseState::top_chunk_of_group_[ig + 1]; i++)
+          apply_diagonal_matrix(
+              i, {0}, {BaseState::global_phase_, BaseState::global_phase_});
       }
-    }
-    else{
-      for(int_t i=0;i<BaseState::qregs_.size();i++)
-        apply_diagonal_matrix(i, {0}, {BaseState::global_phase_, BaseState::global_phase_});
+    } else {
+      for (int_t i = 0; i < BaseState::qregs_.size(); i++)
+        apply_diagonal_matrix(
+            i, {0}, {BaseState::global_phase_, BaseState::global_phase_});
     }
   }
 }
 
 template <class unitary_matrix_t>
-void State<unitary_matrix_t>::apply_save_unitary(const int_t iChunk, const Operations::Op &op,
+void State<unitary_matrix_t>::apply_save_unitary(const int_t iChunk,
+                                                 const Operations::Op &op,
                                                  ExperimentResult &result,
-                                                 bool last_op) 
-{
+                                                 bool last_op) {
   if (op.qubits.size() != BaseState::num_qubits_) {
-    throw std::invalid_argument(
-        op.name + " was not applied to all qubits."
-        " Only the full unitary can be saved.");
+    throw std::invalid_argument(op.name +
+                                " was not applied to all qubits."
+                                " Only the full unitary can be saved.");
   }
-  std::string key = (op.string_params[0] == "_method_") ? "unitary" : op.string_params[0];
+  std::string key =
+      (op.string_params[0] == "_method_") ? "unitary" : op.string_params[0];
 
   if (last_op) {
-    result.save_data_pershot(BaseState::chunk_creg(iChunk), key, move_to_matrix(iChunk),
-                                 Operations::OpType::save_unitary,
-                                 op.save_type);
+    result.save_data_pershot(BaseState::chunk_creg(iChunk), key,
+                             move_to_matrix(iChunk),
+                             Operations::OpType::save_unitary, op.save_type);
   } else {
-    result.save_data_pershot(BaseState::chunk_creg(iChunk), key, copy_to_matrix(iChunk),
-                                 Operations::OpType::save_unitary,
-                                 op.save_type);
+    result.save_data_pershot(BaseState::chunk_creg(iChunk), key,
+                             copy_to_matrix(iChunk),
+                             Operations::OpType::save_unitary, op.save_type);
   }
 }
 
 template <class unitary_matrix_t>
-double  State<unitary_matrix_t>::expval_pauli(const int_t iChunk, const reg_t &qubits,
-                                              const std::string& pauli) 
-{
-  throw std::runtime_error("Unitary simulator does not support Pauli expectation values.");
+double State<unitary_matrix_t>::expval_pauli(const int_t iChunk,
+                                             const reg_t &qubits,
+                                             const std::string &pauli) {
+  throw std::runtime_error(
+      "Unitary simulator does not support Pauli expectation values.");
 }
 
-//swap between chunks
+// swap between chunks
 template <class unitary_matrix_t>
-void State<unitary_matrix_t>::apply_chunk_swap(const reg_t &qubits)
-{
-  uint_t q0,q1;
+void State<unitary_matrix_t>::apply_chunk_swap(const reg_t &qubits) {
+  uint_t q0, q1;
   q0 = qubits[0];
   q1 = qubits[1];
 
-  std::swap(BaseState::qubit_map_[q0],BaseState::qubit_map_[q1]);
+  std::swap(BaseState::qubit_map_[q0], BaseState::qubit_map_[q1]);
 
-  if(qubits[0] >= BaseState::chunk_bits_){
+  if (qubits[0] >= BaseState::chunk_bits_) {
     q0 += BaseState::chunk_bits_;
   }
-  if(qubits[1] >= BaseState::chunk_bits_){
+  if (qubits[1] >= BaseState::chunk_bits_) {
     q1 += BaseState::chunk_bits_;
   }
   reg_t qs0 = {{q0, q1}};
diff --git a/src/simulators/unitary/unitarymatrix.hpp b/src/simulators/unitary/unitarymatrix.hpp
old mode 100755
new mode 100644
index 2416122be7..cc47bfaed0
--- a/src/simulators/unitary/unitarymatrix.hpp
+++ b/src/simulators/unitary/unitarymatrix.hpp
@@ -15,7 +15,6 @@
 #ifndef _qv_unitary_matrix_hpp_
 #define _qv_unitary_matrix_hpp_
 
-
 #include "framework/utils.hpp"
 #include "simulators/statevector/qubitvector.hpp"
 namespace AER {
@@ -42,10 +41,10 @@ class UnitaryMatrix : public QubitVector<data_t> {
   // Constructors and Destructor
   //-----------------------------------------------------------------------
 
-  UnitaryMatrix() : UnitaryMatrix(0) {};
+  UnitaryMatrix() : UnitaryMatrix(0){};
   explicit UnitaryMatrix(size_t num_qubits);
-  UnitaryMatrix(const UnitaryMatrix& obj){}
-  UnitaryMatrix &operator=(const UnitaryMatrix& obj){}
+  UnitaryMatrix(const UnitaryMatrix &obj) {}
+  UnitaryMatrix &operator=(const UnitaryMatrix &obj) {}
 
   //-----------------------------------------------------------------------
   // Utility functions
@@ -55,10 +54,10 @@ class UnitaryMatrix : public QubitVector<data_t> {
   void set_num_qubits(size_t num_qubits);
 
   // Return the number of rows in the matrix
-  size_t num_rows() const {return rows_;}
+  size_t num_rows() const { return rows_; }
 
   // Returns the number of qubits for the current vector
-  virtual uint_t num_qubits() const override { return num_qubits_;}
+  virtual uint_t num_qubits() const override { return num_qubits_; }
 
   // Copy the internal data array to a complex matrix
   matrix<std::complex<data_t>> copy_to_matrix() const;
@@ -86,7 +85,7 @@ class UnitaryMatrix : public QubitVector<data_t> {
   //-----------------------------------------------------------------------
   // Identity checking
   //-----------------------------------------------------------------------
-  
+
   // Return pair (True, theta) if the current matrix is equal to
   // exp(i * theta) * identity matrix. Otherwise return (False, 0).
   // The phase is returned as a parameter between -Pi and Pi.
@@ -98,10 +97,9 @@ class UnitaryMatrix : public QubitVector<data_t> {
   }
 
   // Get the threshold for verify_identity
-  double get_check_identity_threshold() {return identity_threshold_;}
+  double get_check_identity_threshold() { return identity_threshold_; }
 
 protected:
-
   //-----------------------------------------------------------------------
   // Protected data members
   //-----------------------------------------------------------------------
@@ -111,7 +109,7 @@ class UnitaryMatrix : public QubitVector<data_t> {
   //-----------------------------------------------------------------------
   // Additional config settings
   //-----------------------------------------------------------------------
-  
+
   double identity_threshold_ = 1e-10; // Threshold for verifying if the
                                       // internal matrix is identity up to
                                       // global phase
@@ -132,50 +130,54 @@ inline void to_json(json_t &js, const UnitaryMatrix<data_t> &qmat) {
   js = qmat.json();
 }
 
-template <class data_t>
-json_t UnitaryMatrix<data_t>::json() const {
+template <class data_t> json_t UnitaryMatrix<data_t>::json() const {
   const int_t nrows = rows_;
   // Initialize empty matrix
   const json_t ZERO = std::complex<double>(0.0, 0.0);
   json_t js = json_t(nrows, json_t(nrows, ZERO));
-  
+
   if (BaseVector::json_chop_threshold_ > 0) {
-    #pragma omp parallel if (BaseVector::num_qubits_ > BaseVector::omp_threshold_ && BaseVector::omp_threads_ > 1) num_threads(BaseVector::omp_threads_)
+#pragma omp parallel if (BaseVector::num_qubits_ >                             \
+                             BaseVector::omp_threshold_ &&                     \
+                         BaseVector::omp_threads_ > 1)                         \
+    num_threads(BaseVector::omp_threads_)
     {
-    #ifdef _WIN32
-      #pragma omp for
-    #else
-      #pragma omp for collapse(2)
-    #endif
-    for (int_t i=0; i < nrows; i++)
-      for (int_t j=0; j < nrows; j++) {
-        const auto val = BaseVector::data_[i + nrows * j];
-        if (std::abs(val.real()) > BaseVector::json_chop_threshold_)
-          js[i][j][0] = val.real();
-        if (std::abs(val.imag()) > BaseVector::json_chop_threshold_)
-          js[i][j][1] = val.imag();
-      }
+#ifdef _WIN32
+#pragma omp for
+#else
+#pragma omp for collapse(2)
+#endif
+      for (int_t i = 0; i < nrows; i++)
+        for (int_t j = 0; j < nrows; j++) {
+          const auto val = BaseVector::data_[i + nrows * j];
+          if (std::abs(val.real()) > BaseVector::json_chop_threshold_)
+            js[i][j][0] = val.real();
+          if (std::abs(val.imag()) > BaseVector::json_chop_threshold_)
+            js[i][j][1] = val.imag();
+        }
     }
   } else {
-    #pragma omp parallel if (BaseVector::num_qubits_ > BaseVector::omp_threshold_ && BaseVector::omp_threads_ > 1) num_threads(BaseVector::omp_threads_)
+#pragma omp parallel if (BaseVector::num_qubits_ >                             \
+                             BaseVector::omp_threshold_ &&                     \
+                         BaseVector::omp_threads_ > 1)                         \
+    num_threads(BaseVector::omp_threads_)
     {
-    #ifdef _WIN32
-      #pragma omp for
-    #else
-      #pragma omp for collapse(2)
-    #endif
-    for (int_t i=0; i < nrows; i++)
-      for (int_t j=0; j < nrows; j++) {
-        const auto val = BaseVector::data_[i + nrows * j];
-        js[i][j][0] = val.real();
-        js[i][j][1] = val.imag();
-      }
+#ifdef _WIN32
+#pragma omp for
+#else
+#pragma omp for collapse(2)
+#endif
+      for (int_t i = 0; i < nrows; i++)
+        for (int_t j = 0; j < nrows; j++) {
+          const auto val = BaseVector::data_[i + nrows * j];
+          js[i][j][0] = val.real();
+          js[i][j][1] = val.imag();
+        }
     }
   }
   return js;
 }
 
-
 //------------------------------------------------------------------------------
 // Constructors & Destructor
 //------------------------------------------------------------------------------
@@ -191,12 +193,14 @@ UnitaryMatrix<data_t>::UnitaryMatrix(size_t num_qubits) {
 
 template <class data_t>
 matrix<std::complex<data_t>> UnitaryMatrix<data_t>::copy_to_matrix() const {
-  return matrix<std::complex<data_t>>::copy_from_buffer(rows_, rows_, BaseVector::data_);
+  return matrix<std::complex<data_t>>::copy_from_buffer(rows_, rows_,
+                                                        BaseVector::data_);
 }
 
 template <class data_t>
 matrix<std::complex<data_t>> UnitaryMatrix<data_t>::move_to_matrix() {
-  const auto ret = matrix<std::complex<data_t>>::move_from_buffer(rows_, rows_, BaseVector::data_);
+  const auto ret = matrix<std::complex<data_t>>::move_from_buffer(
+      rows_, rows_, BaseVector::data_);
   BaseVector::data_ = nullptr;
   return ret;
 }
@@ -205,13 +209,15 @@ matrix<std::complex<data_t>> UnitaryMatrix<data_t>::move_to_matrix() {
 // Utility
 //------------------------------------------------------------------------------
 
-template <class data_t>
-void UnitaryMatrix<data_t>::initialize() {
+template <class data_t> void UnitaryMatrix<data_t>::initialize() {
   // Zero the underlying vector
   BaseVector::zero();
   // Set to be identity matrix
-  const int_t nrows = rows_;    // end for k loop
- #pragma omp parallel if (BaseVector::num_qubits_ > BaseVector::omp_threshold_ && BaseVector::omp_threads_ > 1) num_threads(BaseVector::omp_threads_)
+  const int_t nrows = rows_; // end for k loop
+#pragma omp parallel if (BaseVector::num_qubits_ >                             \
+                             BaseVector::omp_threshold_ &&                     \
+                         BaseVector::omp_threads_ > 1)                         \
+    num_threads(BaseVector::omp_threads_)
   for (int_t k = 0; k < nrows; ++k) {
     BaseVector::data_[k * (nrows + 1)] = 1.0;
   }
@@ -219,34 +225,39 @@ void UnitaryMatrix<data_t>::initialize() {
 
 template <class data_t>
 template <typename T>
-void UnitaryMatrix<data_t>::initialize_from_matrix(const matrix<std::complex<T>> &mat) {
-  const int_t nrows = rows_;    // end for k loop
+void UnitaryMatrix<data_t>::initialize_from_matrix(
+    const matrix<std::complex<T>> &mat) {
+  const int_t nrows = rows_; // end for k loop
   if (nrows != static_cast<int_t>(mat.GetRows()) ||
       nrows != static_cast<int_t>(mat.GetColumns())) {
     throw std::runtime_error(
-      "UnitaryMatrix::initialize input matrix is incorrect shape (" +
-      std::to_string(nrows) + "," + std::to_string(nrows) + ")!=(" +
-      std::to_string(mat.GetRows()) + "," + std::to_string(mat.GetColumns()) + ")."
-    );
+        "UnitaryMatrix::initialize input matrix is incorrect shape (" +
+        std::to_string(nrows) + "," + std::to_string(nrows) + ")!=(" +
+        std::to_string(mat.GetRows()) + "," + std::to_string(mat.GetColumns()) +
+        ").");
   }
 
-#pragma omp parallel if (BaseVector::num_qubits_ > BaseVector::omp_threshold_ && BaseVector::omp_threads_ > 1) num_threads(BaseVector::omp_threads_)
+#pragma omp parallel if (BaseVector::num_qubits_ >                             \
+                             BaseVector::omp_threshold_ &&                     \
+                         BaseVector::omp_threads_ > 1)                         \
+    num_threads(BaseVector::omp_threads_)
   for (int_t row = 0; row < nrows; ++row)
-    for  (int_t col = 0; col < nrows; ++col) {
+    for (int_t col = 0; col < nrows; ++col) {
       BaseVector::data_[row + nrows * col] = mat(row, col);
     }
 }
 
 template <class data_t>
-void UnitaryMatrix<data_t>::initialize_from_matrix(matrix<std::complex<data_t>> &&mat) {
-  const int_t nrows = rows_;    // end for k loop
+void UnitaryMatrix<data_t>::initialize_from_matrix(
+    matrix<std::complex<data_t>> &&mat) {
+  const int_t nrows = rows_; // end for k loop
   if (nrows != static_cast<int_t>(mat.GetRows()) ||
       nrows != static_cast<int_t>(mat.GetColumns())) {
     throw std::runtime_error(
-      "UnitaryMatrix::initialize input matrix is incorrect shape (" +
-      std::to_string(nrows) + "," + std::to_string(nrows) + ")!=(" +
-      std::to_string(mat.GetRows()) + "," + std::to_string(mat.GetColumns()) + ")."
-    );
+        "UnitaryMatrix::initialize input matrix is incorrect shape (" +
+        std::to_string(nrows) + "," + std::to_string(nrows) + ")!=(" +
+        std::to_string(mat.GetRows()) + "," + std::to_string(mat.GetColumns()) +
+        ").");
   }
   BaseVector::free_mem();
   BaseVector::data_ = mat.move_to_buffer();
@@ -270,15 +281,14 @@ std::complex<double> UnitaryMatrix<data_t>::trace() const {
 #pragma omp parallel reduction(+:val_re, val_im) if (BaseVector::num_qubits_ > BaseVector::omp_threshold_ && BaseVector::omp_threads_ > 1) num_threads(BaseVector::omp_threads_)
   {
 #pragma omp for
-  for (int_t k = 0; k < NROWS; ++k) {
-    val_re += std::real(BaseVector::data_[k * DIAG]);
-    val_im += std::imag(BaseVector::data_[k * DIAG]);
-  }
+    for (int_t k = 0; k < NROWS; ++k) {
+      val_re += std::real(BaseVector::data_[k * DIAG]);
+      val_im += std::imag(BaseVector::data_[k * DIAG]);
+    }
   }
   return std::complex<double>(val_re, val_im);
 }
 
-
 //------------------------------------------------------------------------------
 // Check Identity
 //------------------------------------------------------------------------------
@@ -288,7 +298,7 @@ std::pair<bool, double> UnitaryMatrix<data_t>::check_identity() const {
   // To check if identity we first check we check that:
   // 1. U(0, 0) = exp(i * theta)
   // 2. U(i, i) = U(0, 0)
-  // 3. U(i, j) = 0 for j != i 
+  // 3. U(i, j) = 0 for j != i
   auto failed = std::make_pair(false, 0.0);
 
   // Check condition 1.
@@ -300,10 +310,10 @@ std::pair<bool, double> UnitaryMatrix<data_t>::check_identity() const {
 
   // Check conditions 2 and 3
   double delta = 0.;
-  for (size_t i=0; i < rows_; i++) {
-    for (size_t j=0; j < rows_; j++) {
-      auto val = (i==j) ? std::norm(BaseVector::data_[i + rows_ * j] - u00)
-                        : std::norm(BaseVector::data_[i + rows_ * j]);
+  for (size_t i = 0; i < rows_; i++) {
+    for (size_t j = 0; j < rows_; j++) {
+      auto val = (i == j) ? std::norm(BaseVector::data_[i + rows_ * j] - u00)
+                          : std::norm(BaseVector::data_[i + rows_ * j]);
       if (val > identity_threshold_) {
         return failed; // fail fast if single entry differs
       } else
@@ -325,7 +335,8 @@ std::pair<bool, double> UnitaryMatrix<data_t>::check_identity() const {
 
 // ostream overload for templated qubitvector
 template <class data_t>
-inline std::ostream &operator<<(std::ostream &out, const AER::QV::UnitaryMatrix<data_t>&m) {
+inline std::ostream &operator<<(std::ostream &out,
+                                const AER::QV::UnitaryMatrix<data_t> &m) {
   out << m.copy_to_matrix();
   return out;
 }
diff --git a/src/simulators/unitary/unitarymatrix_thrust.hpp b/src/simulators/unitary/unitarymatrix_thrust.hpp
old mode 100755
new mode 100644
index 9c17562203..804751b010
--- a/src/simulators/unitary/unitarymatrix_thrust.hpp
+++ b/src/simulators/unitary/unitarymatrix_thrust.hpp
@@ -15,7 +15,6 @@
 #ifndef _qv_unitary_matrix_thrust_hpp_
 #define _qv_unitary_matrix_thrust_hpp_
 
-
 #include "framework/utils.hpp"
 #include "simulators/statevector/qubitvector_thrust.hpp"
 
@@ -43,7 +42,7 @@ class UnitaryMatrixThrust : public QubitVectorThrust<data_t> {
   // Constructors and Destructor
   //-----------------------------------------------------------------------
 
-  UnitaryMatrixThrust() : UnitaryMatrixThrust(0) {};
+  UnitaryMatrixThrust() : UnitaryMatrixThrust(0){};
   explicit UnitaryMatrixThrust(size_t num_qubits);
 
   //-----------------------------------------------------------------------
@@ -52,19 +51,19 @@ class UnitaryMatrixThrust : public QubitVectorThrust<data_t> {
 
   // Return the string name of the class
 #ifdef AER_THRUST_CUDA
-  static std::string name() {return "unitary_gpu";}
+  static std::string name() { return "unitary_gpu"; }
 #else
-  static std::string name() {return "unitary_thrust";}
+  static std::string name() { return "unitary_thrust"; }
 #endif
 
   // Set the size of the vector in terms of qubit number
   void set_num_qubits(size_t num_qubits) override;
 
   // Return the number of rows in the matrix
-  size_t num_rows() const {return rows_;}
+  size_t num_rows() const { return rows_; }
 
   // Returns the number of qubits for the current vector
-  virtual uint_t num_qubits() const override { return num_qubits_;}
+  virtual uint_t num_qubits() const override { return num_qubits_; }
 
   // Copy the internal data array to a complex matrix
   matrix<std::complex<data_t>> copy_to_matrix() const;
@@ -93,7 +92,7 @@ class UnitaryMatrixThrust : public QubitVectorThrust<data_t> {
   //-----------------------------------------------------------------------
   // Identity checking
   //-----------------------------------------------------------------------
-  
+
   // Return pair (True, theta) if the current matrix is equal to
   // exp(i * theta) * identity matrix. Otherwise return (False, 0).
   // The phase is returned as a parameter between -Pi and Pi.
@@ -105,10 +104,9 @@ class UnitaryMatrixThrust : public QubitVectorThrust<data_t> {
   }
 
   // Get the threshold for verify_identity
-  double get_check_identity_threshold() {return identity_threshold_;}
+  double get_check_identity_threshold() { return identity_threshold_; }
 
 protected:
-
   //-----------------------------------------------------------------------
   // Protected data members
   //-----------------------------------------------------------------------
@@ -118,7 +116,7 @@ class UnitaryMatrixThrust : public QubitVectorThrust<data_t> {
   //-----------------------------------------------------------------------
   // Additional config settings
   //-----------------------------------------------------------------------
-  
+
   double identity_threshold_ = 1e-10; // Threshold for verifying if the
                                       // internal matrix is identity up to
                                       // global phase
@@ -139,19 +137,20 @@ inline void to_json(json_t &js, const UnitaryMatrixThrust<data_t> &qmat) {
   js = qmat.json();
 }
 
-template <class data_t>
-json_t UnitaryMatrixThrust<data_t>::json() const 
-{
+template <class data_t> json_t UnitaryMatrixThrust<data_t>::json() const {
   const int_t nrows = rows_;
   int iPlace;
   int_t i, irow, icol;
   uint_t csize = BaseVector::data_size_;
   cvector_t<data_t> tmp(csize);
 
-  const json_t ZERO = std::complex < data_t > (0.0, 0.0);
+  const json_t ZERO = std::complex<data_t>(0.0, 0.0);
   json_t js = json_t(nrows, json_t(nrows, ZERO));
 
-#pragma omp parallel private(i,irow,icol) if (BaseVector::num_qubits_ > BaseVector::omp_threshold_ && BaseVector::omp_threads_ > 1) num_threads(BaseVector::omp_threads_)
+#pragma omp parallel private(                                                  \
+    i, irow, icol) if (BaseVector::num_qubits_ > BaseVector::omp_threshold_ && \
+                       BaseVector::omp_threads_ > 1)                           \
+    num_threads(BaseVector::omp_threads_)
   {
     if (BaseVector::json_chop_threshold_ > 0) {
 #pragma omp for
@@ -179,16 +178,16 @@ json_t UnitaryMatrixThrust<data_t>::json() const
   return js;
 }
 
-
 //------------------------------------------------------------------------------
 // Constructors & Destructor
 //------------------------------------------------------------------------------
 
 template <class data_t>
-UnitaryMatrixThrust<data_t>::UnitaryMatrixThrust(size_t num_qubits) : QubitVectorThrust<data_t>(num_qubits) {
-	if(num_qubits > 0){
-		set_num_qubits(num_qubits);
-	}
+UnitaryMatrixThrust<data_t>::UnitaryMatrixThrust(size_t num_qubits)
+    : QubitVectorThrust<data_t>(num_qubits) {
+  if (num_qubits > 0) {
+    set_num_qubits(num_qubits);
+  }
 }
 
 //------------------------------------------------------------------------------
@@ -196,8 +195,8 @@ UnitaryMatrixThrust<data_t>::UnitaryMatrixThrust(size_t num_qubits) : QubitVecto
 //------------------------------------------------------------------------------
 
 template <class data_t>
-matrix<std::complex<data_t>> UnitaryMatrixThrust<data_t>::copy_to_matrix() const 
-{
+matrix<std::complex<data_t>>
+UnitaryMatrixThrust<data_t>::copy_to_matrix() const {
   const int_t nrows = rows_;
   matrix<std::complex<data_t>> ret(nrows, nrows);
   uint_t csize = BaseVector::data_size_;
@@ -206,20 +205,21 @@ matrix<std::complex<data_t>> UnitaryMatrixThrust<data_t>::copy_to_matrix() const
 
   int_t i;
   uint_t irow, icol;
-#pragma omp parallel for private(i,irow,icol) if (BaseVector::num_qubits_ > BaseVector::omp_threshold_ && BaseVector::omp_threads_ > 1) num_threads(BaseVector::omp_threads_)
+#pragma omp parallel for private(                                              \
+    i, irow, icol) if (BaseVector::num_qubits_ > BaseVector::omp_threshold_ && \
+                       BaseVector::omp_threads_ > 1)                           \
+    num_threads(BaseVector::omp_threads_)
   for (i = 0; i < csize; i++) {
     ret[i] = qreg[i];
   }
-	return ret;
+  return ret;
 }
-	
+
 //------------------------------------------------------------------------------
 // Utility
 //------------------------------------------------------------------------------
 
-template <class data_t>
-void UnitaryMatrixThrust<data_t>::initialize() 
-{
+template <class data_t> void UnitaryMatrixThrust<data_t>::initialize() {
   const int_t nrows = rows_;
   std::complex<data_t> one = 1.0;
   // Zero the underlying vector
@@ -229,45 +229,51 @@ void UnitaryMatrixThrust<data_t>::initialize()
   uint_t idx;
   int_t i;
 
-#pragma omp parallel private(idx) if (BaseVector::num_qubits_ > BaseVector::omp_threshold_ && BaseVector::omp_threads_ > 1) num_threads(BaseVector::omp_threads_)
-  for(i=0;i<nrows;i++){
+#pragma omp parallel private(idx) if (BaseVector::num_qubits_ >                \
+                                          BaseVector::omp_threshold_ &&        \
+                                      BaseVector::omp_threads_ > 1)            \
+    num_threads(BaseVector::omp_threads_)
+  for (i = 0; i < nrows; i++) {
     idx = i * (nrows + 1);
-    BaseVector::set_state(idx,one);
+    BaseVector::set_state(idx, one);
   }
 }
 
 template <class data_t>
 template <typename T>
-void UnitaryMatrixThrust<data_t>::initialize_from_matrix(const matrix<std::complex<T>> &mat)
-{
-  const int_t nrows = rows_;    // end for k loop
+void UnitaryMatrixThrust<data_t>::initialize_from_matrix(
+    const matrix<std::complex<T>> &mat) {
+  const int_t nrows = rows_; // end for k loop
   if (nrows < static_cast<int_t>(mat.GetRows()) ||
       nrows < static_cast<int_t>(mat.GetColumns())) {
     throw std::runtime_error(
-      "UnitaryMatrix::initialize input matrix is incorrect shape (" +
-      std::to_string(nrows) + "," + std::to_string(nrows) + ")!=(" +
-      std::to_string(mat.GetRows()) + "," + std::to_string(mat.GetColumns()) + ")."
-    );
+        "UnitaryMatrix::initialize input matrix is incorrect shape (" +
+        std::to_string(nrows) + "," + std::to_string(nrows) + ")!=(" +
+        std::to_string(mat.GetRows()) + "," + std::to_string(mat.GetColumns()) +
+        ").");
   }
   if (AER::Utils::is_unitary(mat, 1e-10) == false) {
     throw std::runtime_error(
-      "UnitaryMatrix::initialize input matrix is not unitary."
-    );
+        "UnitaryMatrix::initialize input matrix is not unitary.");
   }
 
-  matrix<std::complex<data_t>> tmp(nrows,nrows);
+  matrix<std::complex<data_t>> tmp(nrows, nrows);
 
-#pragma omp parallel for if (BaseVector::num_qubits_ > BaseVector::omp_threshold_ && BaseVector::omp_threads_ > 1) num_threads(BaseVector::omp_threads_)
+#pragma omp parallel for if (BaseVector::num_qubits_ >                         \
+                                 BaseVector::omp_threshold_ &&                 \
+                             BaseVector::omp_threads_ > 1)                     \
+    num_threads(BaseVector::omp_threads_)
   for (int_t row = 0; row < nrows; ++row)
-    for  (int_t col = 0; col < nrows; ++col) {
-      tmp(row,col) = mat(row, col);
+    for (int_t col = 0; col < nrows; ++col) {
+      tmp(row, col) = mat(row, col);
     }
 
   BaseVector::initialize_from_data(tmp.data(), tmp.size());
 }
 
 template <class data_t>
-void UnitaryMatrixThrust<data_t>::initialize_from_matrix(const matrix<std::complex<data_t>> &mat) {
+void UnitaryMatrixThrust<data_t>::initialize_from_matrix(
+    const matrix<std::complex<data_t>> &mat) {
   BaseVector::initialize_from_data(mat.data(), mat.size());
 }
 
@@ -280,22 +286,19 @@ void UnitaryMatrixThrust<data_t>::set_num_qubits(size_t num_qubits) {
   BaseVector::set_num_qubits(2 * num_qubits);
 }
 
-
 template <class data_t>
-std::complex<double> UnitaryMatrixThrust<data_t>::trace() const 
-{
+std::complex<double> UnitaryMatrixThrust<data_t>::trace() const {
   thrust::complex<double> sum;
 
   sum = BaseVector::chunk_.trace(rows_, 1);
 
 #ifdef AER_DEBUG
-  BaseVector::DebugMsg("trace",sum);
+  BaseVector::DebugMsg("trace", sum);
 #endif
 
   return sum;
 }
 
-
 //------------------------------------------------------------------------------
 // Check Identity
 //------------------------------------------------------------------------------
@@ -305,11 +308,11 @@ std::pair<bool, double> UnitaryMatrixThrust<data_t>::check_identity() const {
   // To check if identity we first check we check that:
   // 1. U(0, 0) = exp(i * theta)
   // 2. U(i, i) = U(0, 0)
-  // 3. U(i, j) = 0 for j != i 
+  // 3. U(i, j) = 0 for j != i
   auto failed = std::make_pair(false, 0.0);
 
   // Check condition 1.
-	const auto u00 = BaseVector::get_state(0);
+  const auto u00 = BaseVector::get_state(0);
   if (std::norm(std::abs(u00) - 1.0) > identity_threshold_) {
     return failed;
   }
@@ -317,31 +320,29 @@ std::pair<bool, double> UnitaryMatrixThrust<data_t>::check_identity() const {
 
   // Check conditions 2 and 3
   double delta = 0.;
-	int iPlace;
-	uint_t i,irow,icol,ic,nc;
-	uint_t pos = 0;
-	uint_t csize = BaseVector::data_size_;
-	cvector_t<data_t> tmp(csize);
+  int iPlace;
+  uint_t i, irow, icol, ic, nc;
+  uint_t pos = 0;
+  uint_t csize = BaseVector::data_size_;
+  cvector_t<data_t> tmp(csize);
 
-  BaseVector::chunk_.CopyOut((thrust::complex<data_t>*)&tmp[0]);
+  BaseVector::chunk_.CopyOut((thrust::complex<data_t> *)&tmp[0]);
 
   uint_t offset = BaseVector::chunk_index_ << BaseVector::num_qubits_;
   uint_t err_count = 0;
 #pragma omp parallel for private(i,irow,icol) reduction(+:delta,err_count) if (BaseVector::num_qubits_ > BaseVector::omp_threshold_ && BaseVector::omp_threads_ > 1) num_threads(BaseVector::omp_threads_)
-  for(i=0;i<csize;i++){
+  for (i = 0; i < csize; i++) {
     irow = ((i + offset) >> num_qubits_);
     icol = (i + offset) - (irow << num_qubits_);
 
-    auto val = (irow==icol) ? std::norm(tmp[i] - u00)
-                            : std::norm(tmp[i]);
+    auto val = (irow == icol) ? std::norm(tmp[i] - u00) : std::norm(tmp[i]);
     if (val > identity_threshold_) {
       err_count++;
-    }
-    else{
+    } else {
       delta += val; // accumulate difference
     }
   }
-  if(err_count > 0){
+  if (err_count > 0) {
     return failed;
   }
 
@@ -360,7 +361,8 @@ std::pair<bool, double> UnitaryMatrixThrust<data_t>::check_identity() const {
 
 // ostream overload for templated qubitvector
 template <class data_t>
-inline std::ostream &operator<<(std::ostream &out, const AER::QV::UnitaryMatrixThrust<data_t>&m) {
+inline std::ostream &operator<<(std::ostream &out,
+                                const AER::QV::UnitaryMatrixThrust<data_t> &m) {
   out << m.copy_to_matrix();
   return out;
 }
diff --git a/src/transpile/basic_opts.hpp b/src/transpile/basic_opts.hpp
index 23c36e445f..ce18d6cc10 100644
--- a/src/transpile/basic_opts.hpp
+++ b/src/transpile/basic_opts.hpp
@@ -22,14 +22,12 @@ namespace Transpile {
 
 class ReduceBarrier : public CircuitOptimization {
 public:
-  void optimize_circuit(Circuit& circ,
-                        Noise::NoiseModel& noise,
+  void optimize_circuit(Circuit &circ, Noise::NoiseModel &noise,
                         const opset_t &opset,
                         ExperimentResult &result) const override;
 };
 
-void ReduceBarrier::optimize_circuit(Circuit& circ,
-                                     Noise::NoiseModel& noise,
+void ReduceBarrier::optimize_circuit(Circuit &circ, Noise::NoiseModel &noise,
                                      const opset_t &allowed_opset,
                                      ExperimentResult &result) const {
   // Position of first sampling op
@@ -54,14 +52,12 @@ void ReduceBarrier::optimize_circuit(Circuit& circ,
 
 class Debug : public CircuitOptimization {
 public:
-  void optimize_circuit(Circuit& circ,
-                        Noise::NoiseModel& noise,
+  void optimize_circuit(Circuit &circ, Noise::NoiseModel &noise,
                         const opset_t &opset,
                         ExperimentResult &result) const override;
 };
 
-void Debug::optimize_circuit(Circuit& circ,
-                             Noise::NoiseModel& noise,
+void Debug::optimize_circuit(Circuit &circ, Noise::NoiseModel &noise,
                              const opset_t &allowed_opset,
                              ExperimentResult &result) const {
 
@@ -72,7 +68,6 @@ void Debug::optimize_circuit(Circuit& circ,
   }
 }
 
-
 //-------------------------------------------------------------------------
 } // end namespace Transpile
 } // end namespace AER
diff --git a/src/transpile/cacheblocking.hpp b/src/transpile/cacheblocking.hpp
index 3cba252adc..724ee8fa88 100644
--- a/src/transpile/cacheblocking.hpp
+++ b/src/transpile/cacheblocking.hpp
@@ -12,78 +12,62 @@
  * that they have been altered from the originals.
  */
 
-
 /*
 
 The input 3 qubits circuit is transpiled with cache blocking 2 qbuits
 
 0 --H--.--H-----------O--H--
-       |              |   
+       |              |
 1 -----O--H--.--H--O--.--H--
              |     |
 2------------O--H--.--------
 
-The output circuit, 2 (noiseless) swap gates are inserted and there is no gate on qubit 2
+The output circuit, 2 (noiseless) swap gates are inserted and there is no gate
+on qubit 2
 
 0 --H--.--H--x--O--H--.--x--O--H--
-       |     |  |     |  |     |   
+       |     |  |     |  |     |
 1 -----O--H--|--.--H--O--|--.--H--
              |           |
 2------------x-----------x--------
 
 */
 
-
 #ifndef _aer_cache_blocking_hpp_
 #define _aer_cache_blocking_hpp_
 
-#include "transpile/circuitopt.hpp"
 #include "framework/utils.hpp"
-
+#include "transpile/circuitopt.hpp"
 
 namespace AER {
 namespace Transpile {
 
 class CacheBlocking : public CircuitOptimization {
 public:
-  CacheBlocking() : block_bits_(0), blocking_enabled_(false), memory_blocking_bits_(0) {}
-  ~CacheBlocking(){}
+  CacheBlocking()
+      : block_bits_(0), blocking_enabled_(false), memory_blocking_bits_(0) {}
+  ~CacheBlocking() {}
 
-  void optimize_circuit(Circuit& circ,
-                        Noise::NoiseModel& noise,
+  void optimize_circuit(Circuit &circ, Noise::NoiseModel &noise,
                         const opset_t &allowed_opset,
                         ExperimentResult &result) const override;
 
   void set_config(const json_t &config) override;
-  bool enabled()
-  {
-    return blocking_enabled_;
-  }
-  int block_bits()
-  {
-    return block_bits_;
-  }
+  bool enabled() { return blocking_enabled_; }
+  int block_bits() { return block_bits_; }
 
-  void set_sample_measure(bool enabled)
-  {
-    sample_measure_ = enabled;
-  }
+  void set_sample_measure(bool enabled) { sample_measure_ = enabled; }
 
-  void set_save_state(bool enabled)
-  {
-    save_state_ = enabled;
-  }
+  void set_save_state(bool enabled) { save_state_ = enabled; }
 
-  //setting blocking parameters automatically
-  void set_blocking(int bits, size_t min_memory, uint_t n_place, const size_t complex_size, bool is_matrix = false);
+  // setting blocking parameters automatically
+  void set_blocking(int bits, size_t min_memory, uint_t n_place,
+                    const size_t complex_size, bool is_matrix = false);
 
-  void set_num_processes(int np)
-  {
-    num_processes_ = np;
-  }
+  void set_num_processes(int np) { num_processes_ = np; }
 
 protected:
-  mutable int block_bits_;    //qubits less than this will be blocked
+  mutable int block_bits_; // qubits less than this will be blocked
   mutable int qubits_;
   mutable reg_t qubitMap_;
   mutable reg_t qubitSwapped_;
@@ -94,91 +78,102 @@ class CacheBlocking : public CircuitOptimization {
   bool density_matrix_ = false;
   int num_processes_ = 1;
 
-  bool block_circuit(Circuit& circ,bool doSwap) const;
+  bool block_circuit(Circuit &circ, bool doSwap) const;
 
-  void put_nongate_ops(std::vector<Operations::Op>& out,std::vector<Operations::Op>& queue,std::vector<Operations::Op>& input,bool doSwap) const;
+  void put_nongate_ops(std::vector<Operations::Op> &out,
+                       std::vector<Operations::Op> &queue,
+                       std::vector<Operations::Op> &input, bool doSwap) const;
 
-  uint_t add_ops(std::vector<Operations::Op>& ops,std::vector<Operations::Op>& out,std::vector<Operations::Op>& queue,bool doSwap,bool first,bool crossQubitOnly) const;
+  uint_t add_ops(std::vector<Operations::Op> &ops,
+                 std::vector<Operations::Op> &out,
+                 std::vector<Operations::Op> &queue, bool doSwap, bool first,
+                 bool crossQubitOnly) const;
 
-  void restore_qubits_order(std::vector<Operations::Op>& ops) const;
+  void restore_qubits_order(std::vector<Operations::Op> &ops) const;
 
-  bool is_cross_qubits_op(Operations::Op& op) const;
+  bool is_cross_qubits_op(Operations::Op &op) const;
 
-  bool is_diagonal_op(Operations::Op& op) const;
+  bool is_diagonal_op(Operations::Op &op) const;
 
-  void insert_swap(std::vector<Operations::Op>& ops,uint_t bit0,uint_t bit1,bool chunk) const;
-  void insert_sim_op(std::vector<Operations::Op>& ops,char* name,const reg_t& qubits) const;
-  void insert_pauli(std::vector<Operations::Op>& ops,reg_t& qubits,std::string& pauli) const;
+  void insert_swap(std::vector<Operations::Op> &ops, uint_t bit0, uint_t bit1,
+                   bool chunk) const;
+  void insert_sim_op(std::vector<Operations::Op> &ops, char *name,
+                     const reg_t &qubits) const;
+  void insert_pauli(std::vector<Operations::Op> &ops, reg_t &qubits,
+                    std::string &pauli) const;
 
-  void define_blocked_qubits(std::vector<Operations::Op>& ops,reg_t& blockedQubits,bool crossQubitOnly) const;
+  void define_blocked_qubits(std::vector<Operations::Op> &ops,
+                             reg_t &blockedQubits, bool crossQubitOnly) const;
 
-  bool can_block(Operations::Op& ops,reg_t& blockedQubits) const;
-  bool can_reorder(Operations::Op& ops,std::vector<Operations::Op>& waiting_ops) const;
+  bool can_block(Operations::Op &ops, reg_t &blockedQubits) const;
+  bool can_reorder(Operations::Op &ops,
+                   std::vector<Operations::Op> &waiting_ops) const;
 
-  bool split_pauli(const Operations::Op& op, const reg_t blockedQubits, std::vector<Operations::Op>& out,std::vector<Operations::Op>& queue) const;
+  bool split_pauli(const Operations::Op &op, const reg_t blockedQubits,
+                   std::vector<Operations::Op> &out,
+                   std::vector<Operations::Op> &queue) const;
 
-  bool split_op(const Operations::Op& op,const reg_t blockedQubits,std::vector<Operations::Op>& out,std::vector<Operations::Op>& queue) const;
+  bool split_op(const Operations::Op &op, const reg_t blockedQubits,
+                std::vector<Operations::Op> &out,
+                std::vector<Operations::Op> &queue) const;
 
-  bool is_blockable_operation(Operations::Op& op) const;
+  bool is_blockable_operation(Operations::Op &op) const;
 
-  void target_qubits(Operations::Op& op, reg_t& targets) const;
+  void target_qubits(Operations::Op &op, reg_t &targets) const;
 };
 
-void CacheBlocking::set_config(const json_t &config)
-{
+void CacheBlocking::set_config(const json_t &config) {
   CircuitOptimization::set_config(config);
 
   if (JSON::check_key("blocking_qubits", config_))
     JSON::get_value(block_bits_, "blocking_qubits", config_);
 
-  if(block_bits_ >= 1){
+  if (block_bits_ >= 1) {
     blocking_enabled_ = true;
   }
 
-  if (JSON::check_key("memory_blocking_bits", config_)){
+  if (JSON::check_key("memory_blocking_bits", config_)) {
     JSON::get_value(memory_blocking_bits_, "memory_blocking_bits", config_);
-    if(memory_blocking_bits_ >= 10){   //blocking qubit should be <=10
+    if (memory_blocking_bits_ >= 10) { // blocking qubit should be <=10
       memory_blocking_bits_ = 10;
     }
   }
 
   std::string method;
   if (JSON::get_value(method, "method", config)) {
-    if(method.find("density_matrix") != std::string::npos){
+    if (method.find("density_matrix") != std::string::npos) {
       density_matrix_ = true;
     }
   }
-
 }
 
-
-void CacheBlocking::set_blocking(int bits, size_t min_memory, uint_t n_place, size_t complex_size, bool is_matrix)
-{
+void CacheBlocking::set_blocking(int bits, size_t min_memory, uint_t n_place,
+                                 size_t complex_size, bool is_matrix) {
   int chunk_bits = bits;
   uint_t scale = is_matrix ? 2 : 1;
   size_t size;
 
-  //get largest possible chunk bits
-  while((complex_size << (scale*chunk_bits)) > min_memory){
+  // get largest possible chunk bits
+  while ((complex_size << (scale * chunk_bits)) > min_memory) {
     chunk_bits--;
-    if(chunk_bits < 1){
+    if (chunk_bits < 1) {
       break;
     }
   }
 
-  if(chunk_bits == 0){
+  if (chunk_bits == 0) {
     throw std::runtime_error("CacheBlocking : Auto blocking configure failed");
   }
 
-  //divide chunks so that chunks can be distributed on all memory space
-  while( (1ull << (bits - chunk_bits)) < n_place){
+  // divide chunks so that chunks can be distributed on all memory space
+  while ((1ull << (bits - chunk_bits)) < n_place) {
     chunk_bits--;
-    if(chunk_bits < 1){
+    if (chunk_bits < 1) {
       break;
     }
   }
 
-  if(chunk_bits == 0){
+  if (chunk_bits == 0) {
     throw std::runtime_error("CacheBlocking : Auto blocking configure failed");
   }
 
@@ -186,21 +181,21 @@ void CacheBlocking::set_blocking(int bits, size_t min_memory, uint_t n_place, si
   block_bits_ = chunk_bits;
 }
 
-void CacheBlocking::insert_swap(std::vector<Operations::Op>& ops,uint_t bit0,uint_t bit1,bool chunk) const
-{
+void CacheBlocking::insert_swap(std::vector<Operations::Op> &ops, uint_t bit0,
+                                uint_t bit1, bool chunk) const {
   Operations::Op sgate;
   sgate.type = Operations::OpType::gate;
-  if(chunk)
+  if (chunk)
     sgate.name = "swap_chunk";
   else
     sgate.name = "swap";
-  sgate.qubits = {bit0,bit1};
+  sgate.qubits = {bit0, bit1};
   sgate.string_params = {sgate.name};
   ops.push_back(sgate);
 }
 
-void CacheBlocking::insert_sim_op(std::vector<Operations::Op>& ops,char* name,const reg_t& qubits) const
-{
+void CacheBlocking::insert_sim_op(std::vector<Operations::Op> &ops, char *name,
+                                  const reg_t &qubits) const {
   Operations::Op op;
   op.type = Operations::OpType::sim_op;
   op.name = name;
@@ -209,50 +204,53 @@ void CacheBlocking::insert_sim_op(std::vector<Operations::Op>& ops,char* name,co
   ops.push_back(op);
 }
 
-
-void CacheBlocking::optimize_circuit(Circuit& circ,
-                                Noise::NoiseModel& noise,
-                                const opset_t &allowed_opset,
-                                ExperimentResult &result) const 
-{
-  if(!blocking_enabled_ && memory_blocking_bits_ == 0){
+void CacheBlocking::optimize_circuit(Circuit &circ, Noise::NoiseModel &noise,
+                                     const opset_t &allowed_opset,
+                                     ExperimentResult &result) const {
+  if (!blocking_enabled_ && memory_blocking_bits_ == 0) {
     return;
   }
 
-  if(blocking_enabled_){
+  if (blocking_enabled_) {
     qubits_ = circ.num_qubits;
 
-    //loop over operations to find max number of parameters for cross-qubits operations
+    // loop over operations to find max number of parameters for cross-qubits
+    // operations
     int_t max_params = 1;
-    for(uint_t i=0;i<circ.ops.size();i++){
-      if(is_blockable_operation(circ.ops[i]) && is_cross_qubits_op(circ.ops[i])){
+    for (uint_t i = 0; i < circ.ops.size(); i++) {
+      if (is_blockable_operation(circ.ops[i]) &&
+          is_cross_qubits_op(circ.ops[i])) {
         reg_t targets;
-        target_qubits(circ.ops[i],targets);
-        if(targets.size() > max_params)
+        target_qubits(circ.ops[i], targets);
+        if (targets.size() > max_params)
           max_params = targets.size();
       }
     }
-    if(block_bits_ < max_params){
-      block_bits_ = max_params;   //change blocking qubits so that we can put op with many params
+    if (block_bits_ < max_params) {
+      block_bits_ = max_params; // change blocking qubits so that we can put op
+                                // with many params
     }
 
-    if(num_processes_ > 1){
-      if(block_bits_ >= qubits_){
+    if (num_processes_ > 1) {
+      if (block_bits_ >= qubits_) {
         blocking_enabled_ = false;
-        std::string error = "cache blocking : there are gates operation can not cache blocked in blocking_qubits = " + std::to_string(block_bits_);
+        std::string error = "cache blocking : there are gates operation can "
+                            "not cache blocked in blocking_qubits = " +
+                            std::to_string(block_bits_);
         throw std::runtime_error(error);
         return;
       }
-      if((1ull << (qubits_ - block_bits_)) < num_processes_){
-        //not enough distribution
+      if ((1ull << (qubits_ - block_bits_)) < num_processes_) {
+        // not enough distribution
         blocking_enabled_ = false;
-        std::string error = "cache blocking : blocking_qubits is to large to parallelize with " + std::to_string(num_processes_) +
-                            " processes ";
+        std::string error = "cache blocking : blocking_qubits is to large to "
+                            "parallelize with " +
+                            std::to_string(num_processes_) + " processes ";
         throw std::runtime_error(error);
         return;
       }
     }
-    if(block_bits_ >= qubits_){
+    if (block_bits_ >= qubits_) {
       blocking_enabled_ = false;
       return;
     }
@@ -260,28 +258,28 @@ void CacheBlocking::optimize_circuit(Circuit& circ,
     qubitMap_.resize(qubits_);
     qubitSwapped_.resize(qubits_);
 
-    for(uint_t i=0;i<qubits_;i++){
+    for (uint_t i = 0; i < qubits_; i++) {
       qubitMap_[i] = i;
       qubitSwapped_[i] = i;
     }
 
-    blocking_enabled_ = block_circuit(circ,true);
+    blocking_enabled_ = block_circuit(circ, true);
 
-    if(blocking_enabled_){
+    if (blocking_enabled_) {
       result.metadata.add(true, "cacheblocking", "enabled");
       result.metadata.add(block_bits_, "cacheblocking", "block_bits");
     }
   }
 
-  if(memory_blocking_bits_ > 0){
-    if(memory_blocking_bits_ >= qubits_){
+  if (memory_blocking_bits_ > 0) {
+    if (memory_blocking_bits_ >= qubits_) {
       return;
     }
 
     qubitMap_.resize(qubits_);
     qubitSwapped_.resize(qubits_);
 
-    for(uint_t i=0;i<qubits_;i++){
+    for (uint_t i = 0; i < qubits_; i++) {
       qubitMap_[i] = i;
       qubitSwapped_[i] = i;
     }
@@ -289,119 +287,118 @@ void CacheBlocking::optimize_circuit(Circuit& circ,
     uint_t bit_backup = block_bits_;
     block_bits_ = memory_blocking_bits_;
 
-    block_circuit(circ,false);
+    block_circuit(circ, false);
 
     block_bits_ = bit_backup;
 
     result.metadata.add(true, "gpu_blocking", "enabled");
-    result.metadata.add(memory_blocking_bits_, "gpu_blocking", "gpu_block_bits");
+    result.metadata.add(memory_blocking_bits_, "gpu_blocking",
+                        "gpu_block_bits");
   }
 
   circ.set_params();
 }
 
-void CacheBlocking::define_blocked_qubits(std::vector<Operations::Op>& ops,reg_t& blockedQubits,bool crossQubitOnly) const
-{
-  uint_t i,j,iq;
-  int nq,nb;
+void CacheBlocking::define_blocked_qubits(std::vector<Operations::Op> &ops,
+                                          reg_t &blockedQubits,
+                                          bool crossQubitOnly) const {
+  uint_t i, j, iq;
+  int nq, nb;
   bool exist;
-  for(i=0;i<ops.size();i++){
-    if(blockedQubits.size() >= block_bits_)
+  for (i = 0; i < ops.size(); i++) {
+    if (blockedQubits.size() >= block_bits_)
       break;
 
     reg_t targets;
-    target_qubits(ops[i],targets);
+    target_qubits(ops[i], targets);
 
     reg_t blockedQubits_add;
 
     nq = blockedQubits.size();
-    for(iq=0;iq<targets.size();iq++){
+    for (iq = 0; iq < targets.size(); iq++) {
       exist = false;
-      for(j=0;j<nq;j++){
-        if(targets[iq] == blockedQubits[j]){
+      for (j = 0; j < nq; j++) {
+        if (targets[iq] == blockedQubits[j]) {
           exist = true;
           break;
         }
       }
-      if(!exist)
+      if (!exist)
         blockedQubits_add.push_back(targets[iq]);
     }
-    //only if all the qubits of gate can be added
-    if(blockedQubits_add.size() + nq <= block_bits_){
-      blockedQubits.insert(blockedQubits.end(),blockedQubits_add.begin(),blockedQubits_add.end());
+    // only if all the qubits of gate can be added
+    if (blockedQubits_add.size() + nq <= block_bits_) {
+      blockedQubits.insert(blockedQubits.end(), blockedQubits_add.begin(),
+                           blockedQubits_add.end());
     }
   }
 }
 
-
-bool CacheBlocking::can_block(Operations::Op& op,reg_t& blockedQubits) const
-{
-  //check if the operation can be blocked in cache
+bool CacheBlocking::can_block(Operations::Op &op, reg_t &blockedQubits) const {
+  // check if the operation can be blocked in cache
   reg_t targets;
-  target_qubits(op,targets);
+  target_qubits(op, targets);
 
-  if(targets.size() > block_bits_){
+  if (targets.size() > block_bits_) {
     return false;
   }
 
-  uint_t j,iq,nq,nb;
+  uint_t j, iq, nq, nb;
   nq = blockedQubits.size();
   nb = 0;
-  for(iq=0;iq<targets.size();iq++){
-    for(j=0;j<nq;j++){
-      if(targets[iq] == blockedQubits[j]){
+  for (iq = 0; iq < targets.size(); iq++) {
+    for (j = 0; j < nq; j++) {
+      if (targets[iq] == blockedQubits[j]) {
         nb++;
         break;
       }
     }
   }
-  if(nb == targets.size())
+  if (nb == targets.size())
     return true;
   return false;
 }
 
-bool CacheBlocking::can_reorder(Operations::Op& op,std::vector<Operations::Op>& waiting_ops) const
-{
-  //check if the operation can be reordered in front of waiting queue
-  uint_t j,iq,jq;
+bool CacheBlocking::can_reorder(
+    Operations::Op &op, std::vector<Operations::Op> &waiting_ops) const {
+  // check if the operation can be reordered in front of waiting queue
+  uint_t j, iq, jq;
 
-  //only blockable ops can be reordered
-  if(!is_blockable_operation(op))
+  // only blockable ops can be reordered
+  if (!is_blockable_operation(op))
     return false;
 
-  for(j=0;j<waiting_ops.size();j++){
-    if(is_blockable_operation(waiting_ops[j])){
-      for(iq=0;iq<op.qubits.size();iq++){
-        for(jq=0;jq<waiting_ops[j].qubits.size();jq++){
-          if(op.qubits[iq] == waiting_ops[j].qubits[jq]){
+  for (j = 0; j < waiting_ops.size(); j++) {
+    if (is_blockable_operation(waiting_ops[j])) {
+      for (iq = 0; iq < op.qubits.size(); iq++) {
+        for (jq = 0; jq < waiting_ops[j].qubits.size(); jq++) {
+          if (op.qubits[iq] == waiting_ops[j].qubits[jq]) {
             return false;
           }
         }
       }
-    }
-    else{
+    } else {
       return false;
     }
   }
   return true;
 }
 
-bool CacheBlocking::block_circuit(Circuit& circ,bool doSwap) const
-{
-  uint_t i,n;
+bool CacheBlocking::block_circuit(Circuit &circ, bool doSwap) const {
+  uint_t i, n;
   std::vector<Operations::Op> out;
   std::vector<Operations::Op> queue;
   std::vector<Operations::Op> queue_next;
   bool crossQubits = false;
 
-  n = add_ops(circ.ops,out,queue,doSwap,true,crossQubits);
-  while(queue.size() > 0){
-    n = add_ops(queue,out,queue_next,doSwap,false,crossQubits);
+  n = add_ops(circ.ops, out, queue, doSwap, true, crossQubits);
+  while (queue.size() > 0) {
+    n = add_ops(queue, out, queue_next, doSwap, false, crossQubits);
 
     queue = queue_next;
     queue_next.clear();
-    if(n == 0){
-      if(queue.size() > 0 && crossQubits == false){
+    if (n == 0) {
+      if (queue.size() > 0 && crossQubits == false) {
         crossQubits = true;
         continue;
       }
@@ -410,11 +407,11 @@ bool CacheBlocking::block_circuit(Circuit& circ,bool doSwap) const
     crossQubits = false;
   }
 
-  if(queue.size() > 0){
+  if (queue.size() > 0) {
     return false;
   }
 
-  if(doSwap && save_state_)
+  if (doSwap && save_state_)
     restore_qubits_order(out);
 
   circ.ops = out;
@@ -422,26 +419,26 @@ bool CacheBlocking::block_circuit(Circuit& circ,bool doSwap) const
   return true;
 }
 
-void CacheBlocking::restore_qubits_order(std::vector<Operations::Op>& ops) const
-{
-  uint_t i,j,t;
+void CacheBlocking::restore_qubits_order(
+    std::vector<Operations::Op> &ops) const {
+  uint_t i, j, t;
 
-  //insert swap gates to restore original qubit order
+  // insert swap gates to restore original qubit order
   int nInBlock = 0;
-  //at first, find pair of qubits can be swapped in the cache block
-  for(i=0;i<block_bits_;i++){
-    if(qubitMap_[i] != i && qubitMap_[i] < block_bits_){
-      if(nInBlock == 0){
+  // at first, find pair of qubits can be swapped in the cache block
+  for (i = 0; i < block_bits_; i++) {
+    if (qubitMap_[i] != i && qubitMap_[i] < block_bits_) {
+      if (nInBlock == 0) {
         uint_t last = ops.size() - 1;
-        if(ops[last].type == Operations::OpType::sim_op && ops[last].name == "end_blocking"){
+        if (ops[last].type == Operations::OpType::sim_op &&
+            ops[last].name == "end_blocking") {
           ops.pop_back();
           nInBlock = 1;
-        }
-        else{
-          insert_sim_op(ops,"begin_blocking",qubitMap_);
+        } else {
+          insert_sim_op(ops, "begin_blocking", qubitMap_);
         }
       }
-      insert_swap(ops,i,qubitMap_[i],false);
+      insert_swap(ops, i, qubitMap_[i], false);
 
       j = qubitMap_[i];
       qubitMap_[qubitSwapped_[i]] = j;
@@ -454,22 +451,22 @@ void CacheBlocking::restore_qubits_order(std::vector<Operations::Op>& ops) const
     }
   }
 
-  //second, find pair of qubits inside cache block
-  for(i=0;i<block_bits_;i++){
-    if(qubitMap_[i] != i){
+  // second, find pair of qubits inside cache block
+  for (i = 0; i < block_bits_; i++) {
+    if (qubitMap_[i] != i) {
       j = qubitMap_[qubitMap_[i]];
-      if(j != i && j < block_bits_){
-        if(nInBlock == 0){
+      if (j != i && j < block_bits_) {
+        if (nInBlock == 0) {
           uint_t last = ops.size() - 1;
-          if(ops[last].type == Operations::OpType::sim_op && ops[last].name == "end_blocking"){
+          if (ops[last].type == Operations::OpType::sim_op &&
+              ops[last].name == "end_blocking") {
             ops.pop_back();
             nInBlock = 1;
-          }
-          else{
-            insert_sim_op(ops,"begin_blocking",qubitMap_);
+          } else {
+            insert_sim_op(ops, "begin_blocking", qubitMap_);
           }
         }
-        insert_swap(ops,i,j,false);
+        insert_swap(ops, i, j, false);
 
         qubitMap_[qubitSwapped_[i]] = j;
         qubitMap_[qubitSwapped_[j]] = i;
@@ -482,17 +479,18 @@ void CacheBlocking::restore_qubits_order(std::vector<Operations::Op>& ops) const
       }
     }
   }
-  if(nInBlock > 0){
-    insert_sim_op(ops,"end_blocking",qubitMap_);
+  if (nInBlock > 0) {
+    insert_sim_op(ops, "end_blocking", qubitMap_);
   }
 
-  //finally find all pair of remaining qubits so that we can restore initial qubits
+  // finally find all pair of remaining qubits so that we can restore initial
+  // qubits
   uint_t count;
-  do{
+  do {
     count = 0;
-    for(i=0;i<qubits_;i++){
-      if(qubitMap_[i] != i){
-        insert_swap(ops,i,qubitMap_[i],true);
+    for (i = 0; i < qubits_; i++) {
+      if (qubitMap_[i] != i) {
+        insert_swap(ops, i, qubitMap_[i], true);
 
         j = qubitMap_[i];
         qubitMap_[qubitSwapped_[i]] = j;
@@ -503,80 +501,81 @@ void CacheBlocking::restore_qubits_order(std::vector<Operations::Op>& ops) const
         count++;
       }
     }
-  }while(count != 0);
+  } while (count != 0);
 }
 
-bool CacheBlocking::is_blockable_operation(Operations::Op& op) const
-{
-  if(op.type == Operations::OpType::gate || op.type == Operations::OpType::matrix || 
-     op.type == Operations::OpType::diagonal_matrix || op.type == Operations::OpType::multiplexer ||
-     op.type == Operations::OpType::superop){
+bool CacheBlocking::is_blockable_operation(Operations::Op &op) const {
+  if (op.type == Operations::OpType::gate ||
+      op.type == Operations::OpType::matrix ||
+      op.type == Operations::OpType::diagonal_matrix ||
+      op.type == Operations::OpType::multiplexer ||
+      op.type == Operations::OpType::superop) {
     return true;
   }
-  if(density_matrix_ && op.type == Operations::OpType::reset){
+  if (density_matrix_ && op.type == Operations::OpType::reset) {
     return true;
   }
 
   return false;
 }
 
-uint_t CacheBlocking::add_ops(std::vector<Operations::Op>& ops,std::vector<Operations::Op>& out,std::vector<Operations::Op>& queue,bool doSwap,bool first,bool crossQubitOnly) const
-{
-  uint_t i,j,iq;
+uint_t CacheBlocking::add_ops(std::vector<Operations::Op> &ops,
+                              std::vector<Operations::Op> &out,
+                              std::vector<Operations::Op> &queue, bool doSwap,
+                              bool first, bool crossQubitOnly) const {
+  uint_t i, j, iq;
 
   int nqubitUsed = 0;
   reg_t blockedQubits;
   int nq;
   bool exist;
-  uint_t pos_begin,num_gates_added;
+  uint_t pos_begin, num_gates_added;
   bool end_block_inserted;
 
   pos_begin = out.size();
   num_gates_added = 0;
 
-  //find qubits to be blocked
-  if(first && doSwap){
-    //use lower bits for initialization
-    for(i=0;i<block_bits_;i++){
+  // find qubits to be blocked
+  if (first && doSwap) {
+    // use lower bits for initialization
+    for (i = 0; i < block_bits_; i++) {
       blockedQubits.push_back(i);
     }
-  }
-  else{
-    if(crossQubitOnly){
-      //add multi-qubits gate at first
-      define_blocked_qubits(ops,blockedQubits,true);
+  } else {
+    if (crossQubitOnly) {
+      // add multi-qubits gate at first
+      define_blocked_qubits(ops, blockedQubits, true);
 
-      //not enough qubits are blocked, then add one qubit gate
-      if(blockedQubits.size() < block_bits_)
-        define_blocked_qubits(ops,blockedQubits,false);
-    }
-    else{
-      define_blocked_qubits(ops,blockedQubits,false);
+      // not enough qubits are blocked, then add one qubit gate
+      if (blockedQubits.size() < block_bits_)
+        define_blocked_qubits(ops, blockedQubits, false);
+    } else {
+      define_blocked_qubits(ops, blockedQubits, false);
     }
   }
 
   pos_begin = out.size();
   num_gates_added = 0;
 
-  if(doSwap){
-    //insert swap gates to block operations
+  if (doSwap) {
+    // insert swap gates to block operations
     reg_t swap(block_bits_);
-    std::vector<bool> mapped(block_bits_,false);
+    std::vector<bool> mapped(block_bits_, false);
     nq = blockedQubits.size();
-    for(i=0;i<nq;i++){
-      swap[i] = qubits_;  //not defined
-      for(j=0;j<block_bits_;j++){
-        if(blockedQubits[i] == qubitSwapped_[j]){
+    for (i = 0; i < nq; i++) {
+      swap[i] = qubits_; // not defined
+      for (j = 0; j < block_bits_; j++) {
+        if (blockedQubits[i] == qubitSwapped_[j]) {
           swap[i] = j;
           mapped[j] = true;
           break;
         }
       }
     }
-    for(i=0;i<nq;i++){
-      if(swap[i] == qubits_){
-        for(j=0;j<block_bits_;j++){
-          if(!mapped[j]){
+    for (i = 0; i < nq; i++) {
+      if (swap[i] == qubits_) {
+        for (j = 0; j < block_bits_; j++) {
+          if (!mapped[j]) {
             swap[i] = j;
             mapped[j] = true;
             break;
@@ -584,13 +583,13 @@ uint_t CacheBlocking::add_ops(std::vector<Operations::Op>& ops,std::vector<Opera
         }
       }
     }
-    for(i=0;i<nq;i++){
-      if(qubitSwapped_[swap[i]] != blockedQubits[i]){ //need swap gate
-        if(!first){   //swap gate is not required for initial state
-          insert_swap(out,swap[i],qubitMap_[blockedQubits[i]],true);
+    for (i = 0; i < nq; i++) {
+      if (qubitSwapped_[swap[i]] != blockedQubits[i]) { // need swap gate
+        if (!first) { // swap gate is not required for initial state
+          insert_swap(out, swap[i], qubitMap_[blockedQubits[i]], true);
         }
 
-        //swap map
+        // swap map
         j = qubitMap_[blockedQubits[i]];
         qubitMap_[qubitSwapped_[swap[i]]] = j;
         qubitMap_[blockedQubits[i]] = swap[i];
@@ -601,92 +600,100 @@ uint_t CacheBlocking::add_ops(std::vector<Operations::Op>& ops,std::vector<Opera
     }
   }
 
-  if(doSwap)
-    insert_sim_op(out,"begin_blocking",blockedQubits);
+  if (doSwap)
+    insert_sim_op(out, "begin_blocking", blockedQubits);
   else
-    insert_sim_op(out,"begin_memory_blocking",blockedQubits);
+    insert_sim_op(out, "begin_memory_blocking", blockedQubits);
   end_block_inserted = false;
 
-  //gather blocked gates
-  for(i=0;i<ops.size();i++){
-    if(is_blockable_operation(ops[i])){
-      if(!end_block_inserted){
-        if(is_diagonal_op(ops[i]) || can_block(ops[i],blockedQubits)){
-          if(can_reorder(ops[i],queue)){
-            //mapping swapped qubits
-            for(iq=0;iq<ops[i].qubits.size();iq++){
+  // gather blocked gates
+  for (i = 0; i < ops.size(); i++) {
+    if (is_blockable_operation(ops[i])) {
+      if (!end_block_inserted) {
+        if (is_diagonal_op(ops[i]) || can_block(ops[i], blockedQubits)) {
+          if (can_reorder(ops[i], queue)) {
+            // mapping swapped qubits
+            for (iq = 0; iq < ops[i].qubits.size(); iq++) {
               ops[i].qubits[iq] = qubitMap_[ops[i].qubits[iq]];
             }
             out.push_back(ops[i]);
             num_gates_added++;
             continue;
           }
-        }
-        else if(ops[i].name == "pauli"){
-          if(can_reorder(ops[i],queue)){
-            if(split_pauli(ops[i],blockedQubits,out,queue))
+        } else if (ops[i].name == "pauli") {
+          if (can_reorder(ops[i], queue)) {
+            if (split_pauli(ops[i], blockedQubits, out, queue))
               num_gates_added++;
             continue;
           }
-        }
-        else if(ops[i].type == Operations::OpType::reset){    //reset for density matrix can be cache blocked
-          if(can_reorder(ops[i],queue)){
-            if(split_op(ops[i],blockedQubits,out,queue))
+        } else if (ops[i].type ==
+                   Operations::OpType::reset) { // reset for density matrix can
+                                                // be cache blocked
+          if (can_reorder(ops[i], queue)) {
+            if (split_op(ops[i], blockedQubits, out, queue))
               num_gates_added++;
             continue;
           }
         }
       }
-    }
-    else{
-      if(queue.size() == 0){          //if queue is empty, apply op here
+    } else {
+      if (queue.size() == 0) { // if queue is empty, apply op here
         bool restore_qubits = false;
-        if(ops[i].type == Operations::OpType::kraus){
-          if(ops[i].qubits.size() > block_bits_){
-            throw std::runtime_error("CacheBlocking : Kraus operator, number of qubits should be smaller than chunk qubit size");
+        if (ops[i].type == Operations::OpType::kraus) {
+          if (ops[i].qubits.size() > block_bits_) {
+            throw std::runtime_error(
+                "CacheBlocking : Kraus operator, number of qubits should be "
+                "smaller than chunk qubit size");
             break;
           }
-          if(!can_block(ops[i],blockedQubits)){  //if some qubits are out of chunk, queued for next step
+          if (!can_block(ops[i],
+                         blockedQubits)) { // if some qubits are out of chunk,
+                                           // queued for next step
             queue.push_back(ops[i]);
             continue;
           }
-        }
-        else if(ops[i].type == Operations::OpType::initialize){
-          if(ops[i].qubits.size() <= block_bits_){
-            if(!can_block(ops[i],blockedQubits)){  //if some qubits are out of chunk, queued for next step
+        } else if (ops[i].type == Operations::OpType::initialize) {
+          if (ops[i].qubits.size() <= block_bits_) {
+            if (!can_block(ops[i],
+                           blockedQubits)) { // if some qubits are out of chunk,
+                                             // queued for next step
               queue.push_back(ops[i]);
               continue;
             }
           }
-          //otherwise StateChunk have to parallelize initialize operation
-        }
-        else if(sample_measure_ && ops[i].type == Operations::OpType::measure){
-          //currently sampling should be done with original qubit mapping (TO DO : sampling without inserting swaps)
+          // otherwise StateChunk have to parallelize initialize operation
+        } else if (sample_measure_ &&
+                   ops[i].type == Operations::OpType::measure) {
+          // currently sampling should be done with original qubit mapping (TO
+          // DO : sampling without inserting swaps)
           restore_qubits = true;
-        }
-        else if(ops[i].type != Operations::OpType::measure && ops[i].type != Operations::OpType::reset && 
-                ops[i].type != Operations::OpType::save_amps && ops[i].type != Operations::OpType::save_amps_sq &&
-                ops[i].type != Operations::OpType::save_densmat && ops[i].type != Operations::OpType::bfunc){
-          if(!(ops[i].type == Operations::OpType::snapshot && ops[i].name == "density_matrix")){
+        } else if (ops[i].type != Operations::OpType::measure &&
+                   ops[i].type != Operations::OpType::reset &&
+                   ops[i].type != Operations::OpType::save_amps &&
+                   ops[i].type != Operations::OpType::save_amps_sq &&
+                   ops[i].type != Operations::OpType::save_densmat &&
+                   ops[i].type != Operations::OpType::bfunc) {
+          if (!(ops[i].type == Operations::OpType::snapshot &&
+                ops[i].name == "density_matrix")) {
             restore_qubits = true;
           }
         }
 
-        if(num_gates_added > 0 && !end_block_inserted){  //insert end of block to synchronize chunks
-          if(doSwap)
-            insert_sim_op(out,"end_blocking",blockedQubits);
+        if (num_gates_added > 0 &&
+            !end_block_inserted) { // insert end of block to synchronize chunks
+          if (doSwap)
+            insert_sim_op(out, "end_blocking", blockedQubits);
           else
-            insert_sim_op(out,"end_memory_blocking",blockedQubits);
-        }
-        else if(!end_block_inserted){
+            insert_sim_op(out, "end_memory_blocking", blockedQubits);
+        } else if (!end_block_inserted) {
           out.pop_back();
         }
-        if(restore_qubits && doSwap)
+        if (restore_qubits && doSwap)
           restore_qubits_order(out);
 
-        //mapping swapped qubits
-        if(doSwap){
-          for(iq=0;iq<ops[i].qubits.size();iq++){
+        // mapping swapped qubits
+        if (doSwap) {
+          for (iq = 0; iq < ops[i].qubits.size(); iq++) {
             ops[i].qubits[iq] = qubitMap_[ops[i].qubits[iq]];
           }
         }
@@ -701,16 +708,15 @@ uint_t CacheBlocking::add_ops(std::vector<Operations::Op>& ops,std::vector<Opera
     queue.push_back(ops[i]);
   }
 
-  if(!end_block_inserted){
-    if(num_gates_added > 0){
-      if(doSwap)
-        insert_sim_op(out,"end_blocking",blockedQubits);
+  if (!end_block_inserted) {
+    if (num_gates_added > 0) {
+      if (doSwap)
+        insert_sim_op(out, "end_blocking", blockedQubits);
       else
-        insert_sim_op(out,"end_memory_blocking",blockedQubits);
-    }
-    else{
-      //pop unnecessary operations
-      while(out.size() > pos_begin){
+        insert_sim_op(out, "end_memory_blocking", blockedQubits);
+    } else {
+      // pop unnecessary operations
+      while (out.size() > pos_begin) {
         out.pop_back();
       }
     }
@@ -719,80 +725,73 @@ uint_t CacheBlocking::add_ops(std::vector<Operations::Op>& ops,std::vector<Opera
   return num_gates_added;
 }
 
-
-bool CacheBlocking::is_cross_qubits_op(Operations::Op& op) const
-{
-  if(is_diagonal_op(op)){
+bool CacheBlocking::is_cross_qubits_op(Operations::Op &op) const {
+  if (is_diagonal_op(op)) {
     return false;
   }
 
-  if(op.type == Operations::OpType::gate){
-    if(op.name == "swap")
+  if (op.type == Operations::OpType::gate) {
+    if (op.name == "swap")
       return true;
-    else if(op.name == "pauli")
-      return false;   //pauli operation can be splited into non-cross-qubit ops
-    else if(op.qubits.size() > 1)
+    else if (op.name == "pauli")
+      return false; // pauli operation can be splited into non-cross-qubit ops
+    else if (op.qubits.size() > 1)
       return true;
-  }
-  else if(op.type == Operations::OpType::matrix || op.type == Operations::OpType::multiplexer || op.type == Operations::OpType::superop){
-    if(op.qubits.size() > 1)
+  } else if (op.type == Operations::OpType::matrix ||
+             op.type == Operations::OpType::multiplexer ||
+             op.type == Operations::OpType::superop) {
+    if (op.qubits.size() > 1)
       return true;
   }
-  if(op.type == Operations::OpType::kraus){
+  if (op.type == Operations::OpType::kraus) {
     return true;
   }
 
   return false;
 }
 
-bool CacheBlocking::is_diagonal_op(Operations::Op& op) const
-{
-  if(op.type == Operations::OpType::gate){
-    if(op.name == "u1")
+bool CacheBlocking::is_diagonal_op(Operations::Op &op) const {
+  if (op.type == Operations::OpType::gate) {
+    if (op.name == "u1")
       return true;
-    else if(op.name == "z")
+    else if (op.name == "z")
       return true;
-    else if(op.name == "s" || op.name == "sdg")
+    else if (op.name == "s" || op.name == "sdg")
       return true;
-    else if(op.name == "t" || op.name == "tdg")
+    else if (op.name == "t" || op.name == "tdg")
       return true;
-  }
-  else if(op.type == Operations::OpType::matrix){
-    if (Utils::is_diagonal(op.mats[0], .0)){
+  } else if (op.type == Operations::OpType::matrix) {
+    if (Utils::is_diagonal(op.mats[0], .0)) {
       return true;
     }
-  }
-  else if(op.type == Operations::OpType::diagonal_matrix){
+  } else if (op.type == Operations::OpType::diagonal_matrix) {
     return true;
   }
   return false;
 }
 
-void CacheBlocking::target_qubits(Operations::Op& op, reg_t& targets) const
-{
-  if(op.type == Operations::OpType::gate){
+void CacheBlocking::target_qubits(Operations::Op &op, reg_t &targets) const {
+  if (op.type == Operations::OpType::gate) {
     bool swap = false;
-    if(op.name.find("swap") != std::string::npos){
+    if (op.name.find("swap") != std::string::npos) {
       swap = true;
     }
 
-    if(op.name[0] == 'c' || op.name.find("mc") == 0){
-      //multi control gates
-      if(swap)
+    if (op.name[0] == 'c' || op.name.find("mc") == 0) {
+      // multi control gates
+      if (swap)
         targets.push_back(op.qubits[op.qubits.size() - 2]);
       targets.push_back(op.qubits[op.qubits.size() - 1]);
-    }
-    else{
+    } else {
       targets = op.qubits;
     }
-  }
-  else{
+  } else {
     targets = op.qubits;
   }
 }
 
-void CacheBlocking::insert_pauli(std::vector<Operations::Op>& ops,reg_t& qubits,std::string& pauli) const
-{
+void CacheBlocking::insert_pauli(std::vector<Operations::Op> &ops,
+                                 reg_t &qubits, std::string &pauli) const {
   Operations::Op op;
   op.type = Operations::OpType::gate;
   op.name = "pauli";
@@ -801,92 +800,94 @@ void CacheBlocking::insert_pauli(std::vector<Operations::Op>& ops,reg_t& qubits,
   ops.push_back(op);
 }
 
-//split 1 pauli gate to 2 pauli gates (inside and outside)
-bool CacheBlocking::split_pauli(const Operations::Op& op,const reg_t blockedQubits,std::vector<Operations::Op>& out,std::vector<Operations::Op>& queue) const
-{
+// split 1 pauli gate to 2 pauli gates (inside and outside)
+bool CacheBlocking::split_pauli(const Operations::Op &op,
+                                const reg_t blockedQubits,
+                                std::vector<Operations::Op> &out,
+                                std::vector<Operations::Op> &queue) const {
   reg_t qubits_in_chunk;
   reg_t qubits_out_chunk;
   std::string pauli_in_chunk;
   std::string pauli_out_chunk;
-  int_t i,j,n;
+  int_t i, j, n;
   bool inside;
 
-  //get inner/outer chunk pauli string
+  // get inner/outer chunk pauli string
   n = op.qubits.size();
-  for(i=0;i<n;i++){
-    if(op.string_params[0][n - 1 - i] == 'I')
-      continue;   //remove I
+  for (i = 0; i < n; i++) {
+    if (op.string_params[0][n - 1 - i] == 'I')
+      continue; // remove I
 
     inside = false;
-    for(j=0;j<blockedQubits.size();j++){
-      if(op.qubits[i] == blockedQubits[j]){
+    for (j = 0; j < blockedQubits.size(); j++) {
+      if (op.qubits[i] == blockedQubits[j]) {
         inside = true;
         break;
       }
     }
-    if(inside){
+    if (inside) {
       qubits_in_chunk.push_back(op.qubits[i]);
-      pauli_in_chunk.push_back(op.string_params[0][n-i-1]);
-    }
-    else{
+      pauli_in_chunk.push_back(op.string_params[0][n - i - 1]);
+    } else {
       qubits_out_chunk.push_back(op.qubits[i]);
-      pauli_out_chunk.push_back(op.string_params[0][n-i-1]);
+      pauli_out_chunk.push_back(op.string_params[0][n - i - 1]);
     }
   }
 
-  if(qubits_out_chunk.size() > 0){  //save in queue
-    std::reverse(pauli_out_chunk.begin(),pauli_out_chunk.end());
-    insert_pauli(queue,qubits_out_chunk,pauli_out_chunk);
+  if (qubits_out_chunk.size() > 0) { // save in queue
+    std::reverse(pauli_out_chunk.begin(), pauli_out_chunk.end());
+    insert_pauli(queue, qubits_out_chunk, pauli_out_chunk);
   }
 
-  if(qubits_in_chunk.size() > 0){
-    std::reverse(pauli_in_chunk.begin(),pauli_in_chunk.end());
-    //mapping swapped qubits
-    for(i=0;i<qubits_in_chunk.size();i++){
+  if (qubits_in_chunk.size() > 0) {
+    std::reverse(pauli_in_chunk.begin(), pauli_in_chunk.end());
+    // mapping swapped qubits
+    for (i = 0; i < qubits_in_chunk.size(); i++) {
       qubits_in_chunk[i] = qubitMap_[qubits_in_chunk[i]];
     }
-    insert_pauli(out,qubits_in_chunk,pauli_in_chunk);
+    insert_pauli(out, qubits_in_chunk, pauli_in_chunk);
     return true;
   }
 
   return false;
 }
 
-//split op to inside op and outside op
-bool CacheBlocking::split_op(const Operations::Op& op,const reg_t blockedQubits,std::vector<Operations::Op>& out,std::vector<Operations::Op>& queue) const
-{
+// split op to inside op and outside op
+bool CacheBlocking::split_op(const Operations::Op &op,
+                             const reg_t blockedQubits,
+                             std::vector<Operations::Op> &out,
+                             std::vector<Operations::Op> &queue) const {
   reg_t qubits_in_chunk;
   reg_t qubits_out_chunk;
-  int_t i,j,n;
+  int_t i, j, n;
   bool inside;
 
   n = op.qubits.size();
-  for(i=0;i<n;i++){
+  for (i = 0; i < n; i++) {
     inside = false;
-    for(j=0;j<blockedQubits.size();j++){
-      if(op.qubits[i] == blockedQubits[j]){
+    for (j = 0; j < blockedQubits.size(); j++) {
+      if (op.qubits[i] == blockedQubits[j]) {
         inside = true;
         break;
       }
     }
-    if(inside){
+    if (inside) {
       qubits_in_chunk.push_back(op.qubits[i]);
-    }
-    else{
+    } else {
       qubits_out_chunk.push_back(op.qubits[i]);
     }
   }
 
-  if(qubits_out_chunk.size() > 0){  //save in queue
+  if (qubits_out_chunk.size() > 0) { // save in queue
     Operations::Op op_out = op;
     op_out.qubits = qubits_out_chunk;
     queue.push_back(op_out);
   }
 
-  if(qubits_in_chunk.size() > 0){
+  if (qubits_in_chunk.size() > 0) {
     Operations::Op op_in = op;
-    //mapping swapped qubits
-    for(i=0;i<qubits_in_chunk.size();i++){
+    // mapping swapped qubits
+    for (i = 0; i < qubits_in_chunk.size(); i++) {
       qubits_in_chunk[i] = qubitMap_[qubits_in_chunk[i]];
     }
     op_in.qubits = qubits_in_chunk;
@@ -897,7 +898,6 @@ bool CacheBlocking::split_op(const Operations::Op& op,const reg_t blockedQubits,
   return false;
 }
 
-
 //-------------------------------------------------------------------------
 } // end namespace Transpile
 } // end namespace AER
diff --git a/src/transpile/circuitopt.hpp b/src/transpile/circuitopt.hpp
index 268ea0354d..dacd94069f 100644
--- a/src/transpile/circuitopt.hpp
+++ b/src/transpile/circuitopt.hpp
@@ -15,13 +15,12 @@
 #ifndef _aer_circuit_optimization_hpp_
 #define _aer_circuit_optimization_hpp_
 
-#include <vector>
 #include <algorithm>
+#include <vector>
 
 #include "framework/opset.hpp"
 #include "noise/noise_model.hpp"
 
-
 namespace AER {
 namespace Transpile {
 
@@ -33,12 +32,10 @@ using reg_t = std::vector<uint_t>;
 
 class CircuitOptimization {
 public:
-
   CircuitOptimization() = default;
   virtual ~CircuitOptimization() = default;
 
-  virtual void optimize_circuit(Circuit& circ,
-                                Noise::NoiseModel& noise,
+  virtual void optimize_circuit(Circuit &circ, Noise::NoiseModel &noise,
                                 const Operations::OpSet &opset,
                                 ExperimentResult &result) const = 0;
 
@@ -48,9 +45,7 @@ class CircuitOptimization {
   json_t config_;
 };
 
-void CircuitOptimization::set_config(const json_t& config) {
-  config_ = config;
-}
+void CircuitOptimization::set_config(const json_t &config) { config_ = config; }
 
 //-------------------------------------------------------------------------
 } // end namespace Transpile
diff --git a/src/transpile/fusion.hpp b/src/transpile/fusion.hpp
index a5922d23d1..e123c0338d 100644
--- a/src/transpile/fusion.hpp
+++ b/src/transpile/fusion.hpp
@@ -17,15 +17,14 @@
 
 #include <chrono>
 
-#include "transpile/circuitopt.hpp"
 #include "framework/avx2_detect.hpp"
-#include "simulators/unitary/unitary_state.hpp"
 #include "simulators/superoperator/superoperator_state.hpp"
+#include "simulators/unitary/unitary_state.hpp"
+#include "transpile/circuitopt.hpp"
 
 namespace AER {
 namespace Transpile {
 
-
 class FusionMethod {
 public:
   // Return name of method
@@ -34,9 +33,10 @@ class FusionMethod {
   virtual bool support_diagonal() const = 0;
 
   // Aggregate a subcircuit of operations into a single operation
-  virtual op_t generate_operation(std::vector<op_t>& fusioned_ops, bool diagonal = false) const {
+  virtual op_t generate_operation(std::vector<op_t> &fusioned_ops,
+                                  bool diagonal = false) const {
     std::set<uint_t> fusioned_qubits;
-    for (auto & op: fusioned_ops)
+    for (auto &op : fusioned_ops)
       fusioned_qubits.insert(op.qubits.begin(), op.qubits.end());
 
     reg_t remapped2orig(fusioned_qubits.begin(), fusioned_qubits.end());
@@ -49,7 +49,7 @@ class FusionMethod {
     }
 
     // Remap qubits
-    for (auto & op: fusioned_ops)
+    for (auto &op : fusioned_ops)
       for (size_t i = 0; i < op.qubits.size(); i++)
         op.qubits[i] = orig2remapped[op.qubits[i]];
 
@@ -64,35 +64,37 @@ class FusionMethod {
       vec.assign((1UL << fusioned_op.qubits.size()), 0);
       for (size_t i = 0; i < vec.size(); ++i)
         vec[i] = fusioned_op.mats[0](i, i);
-      fusioned_op = Operations::make_diagonal(fusioned_op.qubits, std::move(vec), std::string("fusion"));
+      fusioned_op = Operations::make_diagonal(
+          fusioned_op.qubits, std::move(vec), std::string("fusion"));
     }
 
     return fusioned_op;
   };
 
-  virtual op_t generate_operation_internal(const std::vector<op_t>& fusioned_ops,
-                                           const reg_t &fusioned_qubits) const = 0;
+  virtual op_t
+  generate_operation_internal(const std::vector<op_t> &fusioned_ops,
+                              const reg_t &fusioned_qubits) const = 0;
 
-  virtual bool can_apply(const op_t& op, uint_t max_fused_qubits) const = 0;
+  virtual bool can_apply(const op_t &op, uint_t max_fused_qubits) const = 0;
 
-  virtual bool can_ignore(const op_t& op) const {
+  virtual bool can_ignore(const op_t &op) const {
     switch (op.type) {
-      case optype_t::barrier:
-        return true;
-      case optype_t::gate:
-        return op.name == "id" || op.name == "u0";
-      default:
-        return false;
+    case optype_t::barrier:
+      return true;
+    case optype_t::gate:
+      return op.name == "id" || op.name == "u0";
+    default:
+      return false;
     }
   }
 
-  static FusionMethod& find_method(const Circuit& circ,
-                                  const opset_t &allowed_opset,
-                                  const bool allow_superop,
-                                  const bool allow_kraus);
+  static FusionMethod &find_method(const Circuit &circ,
+                                   const opset_t &allowed_opset,
+                                   const bool allow_superop,
+                                   const bool allow_kraus);
 
-  static bool exist_non_unitary(const std::vector<op_t>& fusioned_ops) {
-    for (auto & op: fusioned_ops)
+  static bool exist_non_unitary(const std::vector<op_t> &fusioned_ops) {
+    for (auto &op : fusioned_ops)
       if (noise_opset_.contains(op.type))
         return true;
     return false;
@@ -102,12 +104,10 @@ class FusionMethod {
   const static Operations::OpSet noise_opset_;
 };
 
-const Operations::OpSet FusionMethod::noise_opset_(
-  {Operations::OpType::kraus,
-   Operations::OpType::superop,
-   Operations::OpType::reset},
-  {}, {}
-);
+const Operations::OpSet FusionMethod::noise_opset_({Operations::OpType::kraus,
+                                                    Operations::OpType::superop,
+                                                    Operations::OpType::reset},
+                                                   {}, {});
 
 class UnitaryFusion : public FusionMethod {
 public:
@@ -115,8 +115,9 @@ class UnitaryFusion : public FusionMethod {
 
   virtual bool support_diagonal() const override { return true; }
 
-  virtual op_t generate_operation_internal (const std::vector<op_t>& fusioned_ops,
-                                           const reg_t &qubits) const override {
+  virtual op_t
+  generate_operation_internal(const std::vector<op_t> &fusioned_ops,
+                              const reg_t &qubits) const override {
     // Run simulation
     RngEngine dummy_rng;
     ExperimentResult dummy_result;
@@ -124,26 +125,28 @@ class UnitaryFusion : public FusionMethod {
     // Unitary simulation
     QubitUnitary::State<> unitary_simulator;
     unitary_simulator.initialize_qreg(qubits.size());
-    unitary_simulator.apply_ops(fusioned_ops.cbegin(), fusioned_ops.cend(), dummy_result, dummy_rng);
-    return Operations::make_unitary(qubits, unitary_simulator.qreg().move_to_matrix(),
+    unitary_simulator.apply_ops(fusioned_ops.cbegin(), fusioned_ops.cend(),
+                                dummy_result, dummy_rng);
+    return Operations::make_unitary(qubits,
+                                    unitary_simulator.qreg().move_to_matrix(),
                                     std::string("fusion"));
   };
 
-  virtual bool can_apply(const op_t& op, uint_t max_fused_qubits) const {
+  virtual bool can_apply(const op_t &op, uint_t max_fused_qubits) const {
     if (op.conditional)
       return false;
     switch (op.type) {
-      case optype_t::matrix:
-        return op.mats.size() == 1 && op.qubits.size() <= max_fused_qubits;
-      case optype_t::diagonal_matrix:
-        return op.qubits.size() <= max_fused_qubits;
-      case optype_t::gate: {
-        if (op.qubits.size() > max_fused_qubits)
-          return false;
-        return QubitUnitary::StateOpSet.contains_gates(op.name);
-      }
-      default:
+    case optype_t::matrix:
+      return op.mats.size() == 1 && op.qubits.size() <= max_fused_qubits;
+    case optype_t::diagonal_matrix:
+      return op.qubits.size() <= max_fused_qubits;
+    case optype_t::gate: {
+      if (op.qubits.size() > max_fused_qubits)
         return false;
+      return QubitUnitary::StateOpSet.contains_gates(op.name);
+    }
+    default:
+      return false;
     }
   };
 };
@@ -154,8 +157,9 @@ class SuperOpFusion : public UnitaryFusion {
 
   virtual bool support_diagonal() const override { return false; }
 
-  virtual op_t generate_operation_internal(const std::vector<op_t>& fusioned_ops,
-                                           const reg_t &qubits) const override {
+  virtual op_t
+  generate_operation_internal(const std::vector<op_t> &fusioned_ops,
+                              const reg_t &qubits) const override {
 
     if (!exist_non_unitary(fusioned_ops))
       return UnitaryFusion::generate_operation_internal(fusioned_ops, qubits);
@@ -168,28 +172,29 @@ class SuperOpFusion : public UnitaryFusion {
     // simulator
     QubitSuperoperator::State<> superop_simulator;
     superop_simulator.initialize_qreg(qubits.size());
-    superop_simulator.apply_ops(fusioned_ops.cbegin(), fusioned_ops.cend(), dummy_result, dummy_rng);
+    superop_simulator.apply_ops(fusioned_ops.cbegin(), fusioned_ops.cend(),
+                                dummy_result, dummy_rng);
     auto superop = superop_simulator.qreg().move_to_matrix();
 
     return Operations::make_superop(qubits, std::move(superop));
   };
 
-  virtual bool can_apply(const op_t& op, uint_t max_fused_qubits) const {
+  virtual bool can_apply(const op_t &op, uint_t max_fused_qubits) const {
     if (op.conditional)
       return false;
     switch (op.type) {
-      case optype_t::kraus:
-      case optype_t::reset:
-      case optype_t::superop: {
-        return op.qubits.size() <= max_fused_qubits;
-      }
-      case optype_t::gate: {
-        if (op.qubits.size() > max_fused_qubits)
-          return false;
-        return QubitSuperoperator::StateOpSet.contains_gates(op.name);
-      }
-      default:
-        return UnitaryFusion::can_apply(op, max_fused_qubits);
+    case optype_t::kraus:
+    case optype_t::reset:
+    case optype_t::superop: {
+      return op.qubits.size() <= max_fused_qubits;
+    }
+    case optype_t::gate: {
+      if (op.qubits.size() > max_fused_qubits)
+        return false;
+      return QubitSuperoperator::StateOpSet.contains_gates(op.name);
+    }
+    default:
+      return UnitaryFusion::can_apply(op, max_fused_qubits);
     }
   };
 };
@@ -200,8 +205,9 @@ class KrausFusion : public UnitaryFusion {
 
   virtual bool support_diagonal() const override { return false; }
 
-  virtual op_t generate_operation_internal(const std::vector<op_t>& fusioned_ops,
-                                           const reg_t &qubits) const override {
+  virtual op_t
+  generate_operation_internal(const std::vector<op_t> &fusioned_ops,
+                              const reg_t &qubits) const override {
 
     if (!exist_non_unitary(fusioned_ops))
       return UnitaryFusion::generate_operation_internal(fusioned_ops, qubits);
@@ -214,7 +220,8 @@ class KrausFusion : public UnitaryFusion {
     // simulator
     QubitSuperoperator::State<> superop_simulator;
     superop_simulator.initialize_qreg(qubits.size());
-    superop_simulator.apply_ops(fusioned_ops.cbegin(), fusioned_ops.cend(), dummy_result, dummy_rng);
+    superop_simulator.apply_ops(fusioned_ops.cbegin(), fusioned_ops.cend(),
+                                dummy_result, dummy_rng);
     auto superop = superop_simulator.qreg().move_to_matrix();
 
     // If Kraus method we convert superop to canonical Kraus representation
@@ -222,42 +229,42 @@ class KrausFusion : public UnitaryFusion {
     return Operations::make_kraus(qubits, Utils::superop2kraus(superop, dim));
   };
 
-  virtual bool can_apply(const op_t& op, uint_t max_fused_qubits) const {
+  virtual bool can_apply(const op_t &op, uint_t max_fused_qubits) const {
     if (op.conditional)
       return false;
     switch (op.type) {
-      case optype_t::kraus:
-      case optype_t::reset:
-      case optype_t::superop: {
-        return op.qubits.size() <= max_fused_qubits;
-      }
-      case optype_t::gate: {
-        if (op.qubits.size() > max_fused_qubits)
-          return false;
-        return QubitSuperoperator::StateOpSet.contains_gates(op.name);
-      }
-      default:
-        return UnitaryFusion::can_apply(op, max_fused_qubits);
+    case optype_t::kraus:
+    case optype_t::reset:
+    case optype_t::superop: {
+      return op.qubits.size() <= max_fused_qubits;
+    }
+    case optype_t::gate: {
+      if (op.qubits.size() > max_fused_qubits)
+        return false;
+      return QubitSuperoperator::StateOpSet.contains_gates(op.name);
+    }
+    default:
+      return UnitaryFusion::can_apply(op, max_fused_qubits);
     }
   };
 };
 
-FusionMethod& FusionMethod::find_method(const Circuit& circ,
-                                       const opset_t &allowed_opset,
-                                       const bool allow_superop,
-                                       const bool allow_kraus) {
+FusionMethod &FusionMethod::find_method(const Circuit &circ,
+                                        const opset_t &allowed_opset,
+                                        const bool allow_superop,
+                                        const bool allow_kraus) {
   static UnitaryFusion unitary;
   static SuperOpFusion superOp;
   static KrausFusion kraus;
 
   if (allow_superop && allowed_opset.contains(optype_t::superop) &&
-      (circ.opset().contains(optype_t::kraus)
-       || circ.opset().contains(optype_t::superop)
-       || circ.opset().contains(optype_t::reset))) {
+      (circ.opset().contains(optype_t::kraus) ||
+       circ.opset().contains(optype_t::superop) ||
+       circ.opset().contains(optype_t::reset))) {
     return superOp;
   } else if (allow_kraus && allowed_opset.contains(optype_t::kraus) &&
-      (circ.opset().contains(optype_t::kraus)
-       || circ.opset().contains(optype_t::superop))) {
+             (circ.opset().contains(optype_t::kraus) ||
+              circ.opset().contains(optype_t::superop))) {
     return kraus;
   } else {
     return unitary;
@@ -270,41 +277,37 @@ class Fuser {
 
   virtual void set_config(const json_t &config) = 0;
 
-  virtual void set_metadata(ExperimentResult &result) const { }; //nop
+  virtual void set_metadata(ExperimentResult &result) const {}; // nop
 
-  virtual bool aggregate_operations(oplist_t& ops,
-                                    const int fusion_start,
+  virtual bool aggregate_operations(oplist_t &ops, const int fusion_start,
                                     const int fusion_end,
                                     const uint_t max_fused_qubits,
-                                    const FusionMethod& method) const = 0;
+                                    const FusionMethod &method) const = 0;
 
-  virtual void allocate_new_operation(oplist_t& ops,
-                                      const uint_t idx,
-                                      const std::vector<uint_t>& fusioned_ops_idxs,
-                                      const FusionMethod& method,
-                                      const bool diagonal = false) const;
+  virtual void
+  allocate_new_operation(oplist_t &ops, const uint_t idx,
+                         const std::vector<uint_t> &fusioned_ops_idxs,
+                         const FusionMethod &method,
+                         const bool diagonal = false) const;
 };
 
-void Fuser::allocate_new_operation(oplist_t& ops,
-                                   const uint_t idx,
-                                   const std::vector<uint_t>& idxs,
-                                   const FusionMethod& method,
+void Fuser::allocate_new_operation(oplist_t &ops, const uint_t idx,
+                                   const std::vector<uint_t> &idxs,
+                                   const FusionMethod &method,
                                    const bool diagonal) const {
 
   oplist_t fusing_ops;
-  for (uint_t i: idxs)
+  for (uint_t i : idxs)
     fusing_ops.push_back(ops[i]);
   ops[idx] = method.generate_operation(fusing_ops, diagonal);
-  for (auto i: idxs)
+  for (auto i : idxs)
     if (i != idx)
       ops[i].type = optype_t::nop;
 }
 
 class CostBasedFusion : public Fuser {
 public:
-  CostBasedFusion() {
-    std::fill_n(costs_, 64, -1);
-  };
+  CostBasedFusion() { std::fill_n(costs_, 64, -1); };
 
   virtual std::string name() const override { return "cost_base"; };
 
@@ -312,22 +315,19 @@ class CostBasedFusion : public Fuser {
 
   virtual void set_metadata(ExperimentResult &result) const override;
 
-  virtual bool aggregate_operations(oplist_t& ops,
-                                    const int fusion_start,
+  virtual bool aggregate_operations(oplist_t &ops, const int fusion_start,
                                     const int fusion_end,
                                     const uint_t max_fused_qubits,
-                                    const FusionMethod& method) const override;
+                                    const FusionMethod &method) const override;
 
 private:
-  bool is_diagonal(const oplist_t& ops,
-                   const uint_t from,
+  bool is_diagonal(const oplist_t &ops, const uint_t from,
                    const uint_t until) const;
 
-  double estimate_cost(const oplist_t& ops,
-                       const uint_t from,
+  double estimate_cost(const oplist_t &ops, const uint_t from,
                        const uint_t until) const;
 
-  void add_fusion_qubits(reg_t& fusion_qubits, const op_t& op) const;
+  void add_fusion_qubits(reg_t &fusion_qubits, const op_t &op) const;
 
 private:
   bool active = true;
@@ -335,27 +335,24 @@ class CostBasedFusion : public Fuser {
   double costs_[64];
 };
 
-template<size_t N>
-class NQubitFusion : public Fuser {
+template <size_t N> class NQubitFusion : public Fuser {
 public:
-  NQubitFusion(): opt_name(std::to_string(N) + "_qubits"),
-                  activate_prop_name("fusion_enable." + std::to_string(N) + "_qubits") {
-  }
+  NQubitFusion()
+      : opt_name(std::to_string(N) + "_qubits"),
+        activate_prop_name("fusion_enable." + std::to_string(N) + "_qubits") {}
 
   virtual void set_config(const json_t &config) override;
 
-  virtual std::string name() const override {
-    return opt_name;
-  };
+  virtual std::string name() const override { return opt_name; };
 
-  virtual bool aggregate_operations(oplist_t& ops,
-                                    const int fusion_start,
+  virtual bool aggregate_operations(oplist_t &ops, const int fusion_start,
                                     const int fusion_end,
                                     const uint_t max_fused_qubits,
-                                    const FusionMethod& method) const override;
+                                    const FusionMethod &method) const override;
+
+  bool exclude_escaped_qubits(std::vector<uint_t> &fusing_qubits,
+                              const op_t &tgt_op) const;
 
-  bool exclude_escaped_qubits(std::vector<uint_t>& fusing_qubits,
-                                const op_t& tgt_op) const;
 private:
   bool active = true;
   const std::string opt_name;
@@ -363,8 +360,7 @@ class NQubitFusion : public Fuser {
   uint_t qubit_threshold = 5;
 };
 
-template<size_t N>
-void NQubitFusion<N>::set_config(const json_t &config) {
+template <size_t N> void NQubitFusion<N>::set_config(const json_t &config) {
   if (JSON::check_key("fusion_enable.n_qubits", config))
     JSON::get_value(active, "fusion_enable.n_qubits", config);
 
@@ -372,30 +368,32 @@ void NQubitFusion<N>::set_config(const json_t &config) {
     JSON::get_value(active, activate_prop_name, config);
 }
 
-template<size_t N>
-bool NQubitFusion<N>::exclude_escaped_qubits(std::vector<uint_t>& fusing_qubits,
-                                             const op_t& tgt_op) const {
+template <size_t N>
+bool NQubitFusion<N>::exclude_escaped_qubits(std::vector<uint_t> &fusing_qubits,
+                                             const op_t &tgt_op) const {
   bool included = true;
-  for (const auto qubit: tgt_op.qubits)
-    included &= (std::find(fusing_qubits.begin(), fusing_qubits.end(), qubit) != fusing_qubits.end());
+  for (const auto qubit : tgt_op.qubits)
+    included &= (std::find(fusing_qubits.begin(), fusing_qubits.end(), qubit) !=
+                 fusing_qubits.end());
 
   if (included)
     return false;
 
-  for (const int op_qubit: tgt_op.qubits) {
-    auto found = std::find(fusing_qubits.begin(), fusing_qubits.end(), op_qubit);
+  for (const int op_qubit : tgt_op.qubits) {
+    auto found =
+        std::find(fusing_qubits.begin(), fusing_qubits.end(), op_qubit);
     if (found != fusing_qubits.end())
       fusing_qubits.erase(found);
   }
   return true;
 }
 
-template<size_t N>
-bool NQubitFusion<N>::aggregate_operations(oplist_t& ops,
+template <size_t N>
+bool NQubitFusion<N>::aggregate_operations(oplist_t &ops,
                                            const int fusion_start,
                                            const int fusion_end,
                                            const uint_t max_fused_qubits,
-                                           const FusionMethod& method) const {
+                                           const FusionMethod &method) const {
   if (!active)
     return false;
 
@@ -404,48 +402,55 @@ bool NQubitFusion<N>::aggregate_operations(oplist_t& ops,
 
   for (uint_t op_idx = fusion_start; op_idx < fusion_end; ++op_idx) {
     // skip operations to be ignored
-    if (!method.can_apply(ops[op_idx], max_fused_qubits) || ops[op_idx].type == optype_t::nop)
+    if (!method.can_apply(ops[op_idx], max_fused_qubits) ||
+        ops[op_idx].type == optype_t::nop)
       continue;
 
     // 1. find a N-qubit operation
     if (ops[op_idx].qubits.size() != N)
       continue;
 
-    std::vector<uint_t> fusing_op_idxs = { op_idx };
+    std::vector<uint_t> fusing_op_idxs = {op_idx};
 
     std::vector<uint_t> fusing_qubits;
-    fusing_qubits.insert(fusing_qubits.end(), ops[op_idx].qubits.begin(), ops[op_idx].qubits.end());
+    fusing_qubits.insert(fusing_qubits.end(), ops[op_idx].qubits.begin(),
+                         ops[op_idx].qubits.end());
 
     // 2. fuse operations with backwarding
-    for (int fusing_op_idx = op_idx - 1; fusing_op_idx >= fusion_start; --fusing_op_idx) {
-      auto& tgt_op = ops[fusing_op_idx];
+    for (int fusing_op_idx = op_idx - 1; fusing_op_idx >= fusion_start;
+         --fusing_op_idx) {
+      auto &tgt_op = ops[fusing_op_idx];
       if (tgt_op.type == optype_t::nop)
         continue;
       if (!method.can_apply(tgt_op, max_fused_qubits))
         break;
       // check all the qubits are in fusing_qubits
       if (!exclude_escaped_qubits(fusing_qubits, tgt_op))
-        fusing_op_idxs.push_back(fusing_op_idx); // All the qubits of tgt_op are in fusing_qubits
+        fusing_op_idxs.push_back(
+            fusing_op_idx); // All the qubits of tgt_op are in fusing_qubits
       else if (fusing_qubits.empty())
-          break;
+        break;
     }
 
     std::reverse(fusing_op_idxs.begin(), fusing_op_idxs.end());
     fusing_qubits.clear();
-    fusing_qubits.insert(fusing_qubits.end(), ops[op_idx].qubits.begin(), ops[op_idx].qubits.end());
+    fusing_qubits.insert(fusing_qubits.end(), ops[op_idx].qubits.begin(),
+                         ops[op_idx].qubits.end());
 
     // 3. fuse operations with forwarding
-    for (int fusing_op_idx = op_idx + 1; fusing_op_idx < fusion_end; ++fusing_op_idx) {
-      auto& tgt_op = ops[fusing_op_idx];
+    for (int fusing_op_idx = op_idx + 1; fusing_op_idx < fusion_end;
+         ++fusing_op_idx) {
+      auto &tgt_op = ops[fusing_op_idx];
       if (tgt_op.type == optype_t::nop)
         continue;
       if (!method.can_apply(tgt_op, max_fused_qubits))
         break;
       // check all the qubits are in fusing_qubits
       if (!exclude_escaped_qubits(fusing_qubits, tgt_op))
-        fusing_op_idxs.push_back(fusing_op_idx); // All the qubits of tgt_op are in fusing_qubits
+        fusing_op_idxs.push_back(
+            fusing_op_idx); // All the qubits of tgt_op are in fusing_qubits
       else if (fusing_qubits.empty())
-          break;
+        break;
     }
 
     if (fusing_op_idxs.size() <= 1)
@@ -470,16 +475,16 @@ class DiagonalFusion : public Fuser {
 
   virtual void set_config(const json_t &config) override;
 
-  virtual bool aggregate_operations(oplist_t& ops,
-                                    const int fusion_start,
+  virtual bool aggregate_operations(oplist_t &ops, const int fusion_start,
                                     const int fusion_end,
                                     const uint_t max_fused_qubits,
-                                    const FusionMethod& method) const override;
+                                    const FusionMethod &method) const override;
 
 private:
-  bool is_diagonal_op(const op_t& op) const;
+  bool is_diagonal_op(const op_t &op) const;
 
-  int get_next_diagonal_end(const oplist_t& ops, const int from, const int end, std::set<uint_t>& fusing_qubits) const;
+  int get_next_diagonal_end(const oplist_t &ops, const int from, const int end,
+                            std::set<uint_t> &fusing_qubits) const;
 
   const std::shared_ptr<FusionMethod> method_;
   uint_t min_qubit = 3;
@@ -493,17 +498,19 @@ void DiagonalFusion::set_config(const json_t &config) {
     JSON::get_value(min_qubit, "fusion_min_qubit.diagonal", config);
 }
 
-bool DiagonalFusion::is_diagonal_op(const op_t& op) const {
+bool DiagonalFusion::is_diagonal_op(const op_t &op) const {
 
   if (op.type == Operations::OpType::diagonal_matrix)
     return true;
 
   if (op.type == Operations::OpType::gate) {
-    if (op.name == "p" || op.name == "cp" || op.name == "u1" || op.name == "cu1"
-        || op.name == "mcu1" || op.name== "rz" || op.name== "rzz")
+    if (op.name == "p" || op.name == "cp" || op.name == "u1" ||
+        op.name == "cu1" || op.name == "mcu1" || op.name == "rz" ||
+        op.name == "rzz")
       return true;
     if (op.name == "u3")
-      return op.params[0] == std::complex<double>(0.) && op.params[1] == std::complex<double>(0.);
+      return op.params[0] == std::complex<double>(0.) &&
+             op.params[1] == std::complex<double>(0.);
     else
       return false;
   }
@@ -512,16 +519,16 @@ bool DiagonalFusion::is_diagonal_op(const op_t& op) const {
 }
 
 // Returns an index in `ops` or `-1`.
-// If gates from `from` to the returned index are fused to a gate, the fused gate is a diagonal gate.
-// The returned index is equal or more than `from` and is lower than `end`.
-// If -1 is returned, no pattern to generate a diagonal gate is identified from `from`.
-int DiagonalFusion::get_next_diagonal_end(const oplist_t& ops,
-                                          const int from,
-                                          const int end,
-                                          std::set<uint_t>& fusing_qubits) const {
+// If gates from `from` to the returned index are fused to a gate, the fused
+// gate is a diagonal gate. The returned index is equal or more than `from` and
+// is lower than `end`. If -1 is returned, no pattern to generate a diagonal
+// gate is identified from `from`.
+int DiagonalFusion::get_next_diagonal_end(
+    const oplist_t &ops, const int from, const int end,
+    std::set<uint_t> &fusing_qubits) const {
 
   if (is_diagonal_op(ops[from])) {
-    for (const auto qubit: ops[from].qubits)
+    for (const auto qubit : ops[from].qubits)
       fusing_qubits.insert(qubit);
     return from;
   }
@@ -589,9 +596,9 @@ int DiagonalFusion::get_next_diagonal_end(const oplist_t& ops,
 
   // find second cx list that is the reverse of the first
   for (; pos < end; ++pos) {
-    if (ops[pos].type == Operations::OpType::gate
-        && ops[pos].name == ops[cx_end].name
-        && ops[pos].qubits == ops[cx_end].qubits) {
+    if (ops[pos].type == Operations::OpType::gate &&
+        ops[pos].name == ops[cx_end].name &&
+        ops[pos].qubits == ops[cx_end].qubits) {
       if (cx_end == from)
         break;
       --cx_end;
@@ -614,18 +621,16 @@ int DiagonalFusion::get_next_diagonal_end(const oplist_t& ops,
   //        ■ [cx_end]                         ■ [u1_end]
 
   for (auto i = from; i < u1_end; ++i)
-    for (const auto qubit: ops[i].qubits)
+    for (const auto qubit : ops[i].qubits)
       fusing_qubits.insert(qubit);
 
   return pos;
-
 }
 
-bool DiagonalFusion::aggregate_operations(oplist_t& ops,
-                                          const int fusion_start,
+bool DiagonalFusion::aggregate_operations(oplist_t &ops, const int fusion_start,
                                           const int fusion_end,
                                           const uint_t max_fused_qubits,
-                                          const FusionMethod& method) const {
+                                          const FusionMethod &method) const {
 
   if (!active || !method.support_diagonal())
     return false;
@@ -635,7 +640,8 @@ bool DiagonalFusion::aggregate_operations(oplist_t& ops,
 
     // find instructions to generate a diagonal gate from op_idx
     std::set<uint_t> checking_qubits_set;
-    auto next_diagonal_end = get_next_diagonal_end(ops, op_idx, fusion_end, checking_qubits_set);
+    auto next_diagonal_end =
+        get_next_diagonal_end(ops, op_idx, fusion_end, checking_qubits_set);
 
     if (next_diagonal_end < 0)
       continue;
@@ -647,7 +653,8 @@ bool DiagonalFusion::aggregate_operations(oplist_t& ops,
     auto next_diagonal_start = next_diagonal_end + 1;
 
     while (true) {
-      auto nde = get_next_diagonal_end(ops, next_diagonal_start, fusion_end, checking_qubits_set);
+      auto nde = get_next_diagonal_end(ops, next_diagonal_start, fusion_end,
+                                       checking_qubits_set);
       if (nde < 0 || checking_qubits_set.size() > max_fused_qubits)
         break;
       next_diagonal_start = nde + 1;
@@ -657,7 +664,7 @@ bool DiagonalFusion::aggregate_operations(oplist_t& ops,
       continue;
 
     std::vector<uint_t> fusing_op_idxs;
-    while(op_idx < next_diagonal_start) {
+    while (op_idx < next_diagonal_start) {
       fusing_op_idxs.push_back(op_idx);
       ++op_idx;
     }
@@ -678,23 +685,24 @@ class Fusion : public CircuitOptimization {
    *       passes [Default: True]
    * - fusion_verbose (bool): Output gates generated in fusion optimization
    *       into metadata [Default: False]
-   * - fusion_max_qubit (int): Maximum number of qubits for a operation generated
-   *       in a fusion optimization [Default: 5]
+   * - fusion_max_qubit (int): Maximum number of qubits for a operation
+   * generated in a fusion optimization [Default: 5]
    * - fusion_threshold (int): Threshold that number of qubits must be greater
    *       than to enable fusion optimization [Default: 14]
    * - fusion_cost_factor (double): a cost function to estimate an aggregate
    *       gate [Default: 1.8]
    */
   Fusion();
-  
+
   void set_config(const json_t &config) override;
 
   virtual void set_parallelization(uint_t num) { parallelization_ = num; };
 
-  virtual void set_parallelization_threshold(uint_t num) { parallel_threshold_ = num; };
+  virtual void set_parallelization_threshold(uint_t num) {
+    parallel_threshold_ = num;
+  };
 
-  virtual void optimize_circuit(Circuit& circ,
-                                Noise::NoiseModel& noise,
+  virtual void optimize_circuit(Circuit &circ, Noise::NoiseModel &noise,
                                 const opset_t &allowed_opset,
                                 ExperimentResult &result) const override;
 
@@ -713,23 +721,23 @@ class Fusion : public CircuitOptimization {
   uint_t parallel_threshold_ = 10000;
 
 private:
-  void optimize_circuit(Circuit& circ,
-                        const Noise::NoiseModel& noise,
-                        const opset_t &allowed_opset,
-                        const uint_t ops_start,
+  void optimize_circuit(Circuit &circ, const Noise::NoiseModel &noise,
+                        const opset_t &allowed_opset, const uint_t ops_start,
                         const uint_t ops_end,
-                        const std::shared_ptr<Fuser>& fuser,
-                        const FusionMethod& method) const;
+                        const std::shared_ptr<Fuser> &fuser,
+                        const FusionMethod &method) const;
 
 #ifdef DEBUG
-  void dump(const Circuit& circuit) const {
-    auto& ops = circuit.ops;
+  void dump(const Circuit &circuit) const {
+    auto &ops = circuit.ops;
     for (uint_t op_idx = 0; op_idx < ops.size(); ++op_idx) {
       std::cout << std::setw(3) << op_idx << ": ";
       if (ops[op_idx].type == optype_t::nop) {
-        std::cout << std::setw(15) << "nop" << ": ";
+        std::cout << std::setw(15) << "nop"
+                  << ": ";
       } else {
-        std::cout << std::setw(15) << ops[op_idx].name << "-" << ops[op_idx].qubits.size() << ": ";
+        std::cout << std::setw(15) << ops[op_idx].name << "-"
+                  << ops[op_idx].qubits.size() << ": ";
         if (ops[op_idx].qubits.size() > 0) {
           auto qubits = ops[op_idx].qubits;
           std::sort(qubits.begin(), qubits.end());
@@ -776,7 +784,7 @@ void Fusion::set_config(const json_t &config) {
   if (JSON::check_key("fusion_threshold", config_))
     JSON::get_value(threshold, "fusion_threshold", config_);
 
-  for (std::shared_ptr<Fuser>& fuser: fusers)
+  for (std::shared_ptr<Fuser> &fuser : fusers)
     fuser->set_config(config_);
 
   if (JSON::check_key("fusion_allow_kraus", config))
@@ -786,17 +794,17 @@ void Fusion::set_config(const json_t &config) {
     JSON::get_value(allow_superop, "fusion_allow_superop", config);
 
   if (JSON::check_key("fusion_parallelization_threshold", config_))
-    JSON::get_value(parallel_threshold_, "fusion_parallelization_threshold", config_);
+    JSON::get_value(parallel_threshold_, "fusion_parallelization_threshold",
+                    config_);
 }
 
-void Fusion::optimize_circuit(Circuit& circ,
-                              Noise::NoiseModel& noise,
+void Fusion::optimize_circuit(Circuit &circ, Noise::NoiseModel &noise,
                               const opset_t &allowed_opset,
                               ExperimentResult &result) const {
 
 #ifdef DEBUG
-    std::cout << "original" << std::endl;
-    dump(circ);
+  std::cout << "original" << std::endl;
+  dump(circ);
 #endif
 
   // Start timer
@@ -820,15 +828,17 @@ void Fusion::optimize_circuit(Circuit& circ,
   }
 
   // Determine fusion method
-  FusionMethod& method = FusionMethod::find_method(circ, allowed_opset, allow_superop, allow_kraus);
+  FusionMethod &method = FusionMethod::find_method(circ, allowed_opset,
+                                                   allow_superop, allow_kraus);
   result.metadata.add(method.name(), "fusion", "method");
 
   bool applied = false;
-  for (const std::shared_ptr<Fuser>& fuser: fusers) {
+  for (const std::shared_ptr<Fuser> &fuser : fusers) {
     fuser->set_metadata(result);
 
     if (circ.ops.size() < parallel_threshold_ || parallelization_ <= 1) {
-      optimize_circuit(circ, noise, allowed_opset, 0, circ.ops.size(), fuser, method);
+      optimize_circuit(circ, noise, allowed_opset, 0, circ.ops.size(), fuser,
+                       method);
       result.metadata.add(1, "fusion", "parallelization");
     } else {
       // determine unit for each OMP thread
@@ -839,7 +849,7 @@ void Fusion::optimize_circuit(Circuit& circ,
 #pragma omp parallel for if (parallelization_ > 1) num_threads(parallelization_)
       for (int_t i = 0; i < parallelization_; i++) {
         int_t start = unit * i;
-        int_t end = std::min(start + unit, (int_t) circ.ops.size());
+        int_t end = std::min(start + unit, (int_t)circ.ops.size());
         optimize_circuit(circ, noise, allowed_opset, start, end, fuser, method);
       }
       result.metadata.add(parallelization_, "fusion", "parallelization");
@@ -864,31 +874,32 @@ void Fusion::optimize_circuit(Circuit& circ,
     std::cout << fuser->name() << std::endl;
     dump(circ);
 #endif
-
   }
   result.metadata.add(applied, "fusion", "applied");
   if (applied && verbose)
     result.metadata.add(circ.ops, "fusion", "output_ops");
 
   auto timer_stop = clock_t::now();
-  result.metadata.add(std::chrono::duration<double>(timer_stop - timer_start).count(), "fusion", "time_taken");
+  result.metadata.add(
+      std::chrono::duration<double>(timer_stop - timer_start).count(), "fusion",
+      "time_taken");
 }
 
-void Fusion::optimize_circuit(Circuit& circ,
-                              const Noise::NoiseModel& noise,
+void Fusion::optimize_circuit(Circuit &circ, const Noise::NoiseModel &noise,
                               const opset_t &allowed_opset,
-                              const uint_t ops_start,
-                              const uint_t ops_end,
-                              const std::shared_ptr<Fuser>& fuser,
-                              const FusionMethod& method) const {
+                              const uint_t ops_start, const uint_t ops_end,
+                              const std::shared_ptr<Fuser> &fuser,
+                              const FusionMethod &method) const {
 
   uint_t fusion_start = ops_start;
   uint_t op_idx;
   for (op_idx = ops_start; op_idx < ops_end; ++op_idx) {
     if (method.can_ignore(circ.ops[op_idx]))
       continue;
-    if (!method.can_apply(circ.ops[op_idx], max_qubit) || op_idx == (ops_end - 1)) {
-      fuser->aggregate_operations(circ.ops, fusion_start, op_idx, max_qubit, method);
+    if (!method.can_apply(circ.ops[op_idx], max_qubit) ||
+        op_idx == (ops_end - 1)) {
+      fuser->aggregate_operations(circ.ops, fusion_start, op_idx, max_qubit,
+                                  method);
       fusion_start = op_idx + 1;
     }
   }
@@ -913,11 +924,11 @@ void CostBasedFusion::set_config(const json_t &config) {
   }
 }
 
-bool CostBasedFusion::aggregate_operations(oplist_t& ops,
-                                  const int fusion_start,
-                                  const int fusion_end,
-                                  const uint_t max_fused_qubits,
-                                  const FusionMethod& method) const {
+bool CostBasedFusion::aggregate_operations(oplist_t &ops,
+                                           const int fusion_start,
+                                           const int fusion_end,
+                                           const uint_t max_fused_qubits,
+                                           const FusionMethod &method) const {
   if (!active)
     return false;
 
@@ -928,16 +939,18 @@ bool CostBasedFusion::aggregate_operations(oplist_t& ops,
 
   // set costs and fusion_to of fusion_start
   fusion_to.push_back(fusion_start);
-  costs.push_back(method.can_ignore(ops[fusion_start])? .0 : cost_factor);
+  costs.push_back(method.can_ignore(ops[fusion_start]) ? .0 : cost_factor);
 
   bool applied = false;
   // calculate the minimal path to each operation in the circuit
   for (int i = fusion_start + 1; i < fusion_end; ++i) {
     // init with fusion from i-th to i-th
     fusion_to.push_back(i);
-    costs.push_back(costs[i - fusion_start - 1] + (method.can_ignore(ops[i])? .0 : cost_factor));
+    costs.push_back(costs[i - fusion_start - 1] +
+                    (method.can_ignore(ops[i]) ? .0 : cost_factor));
 
-    for (int num_fusion = 2; num_fusion <=  static_cast<int> (max_fused_qubits); ++num_fusion) {
+    for (int num_fusion = 2; num_fusion <= static_cast<int>(max_fused_qubits);
+         ++num_fusion) {
       // calculate cost if {num_fusion}-qubit fusion is applied
       reg_t fusion_qubits;
       add_fusion_qubits(fusion_qubits, ops[i]);
@@ -945,11 +958,14 @@ bool CostBasedFusion::aggregate_operations(oplist_t& ops,
       for (int j = i - 1; j >= fusion_start; --j) {
         add_fusion_qubits(fusion_qubits, ops[j]);
 
-        if (static_cast<int> (fusion_qubits.size()) > num_fusion) // exceed the limit of fusion
+        if (static_cast<int>(fusion_qubits.size()) >
+            num_fusion) // exceed the limit of fusion
           break;
 
         // calculate a new cost of (i-th) by adding
-        double estimated_cost = estimate_cost(ops, (uint_t) j, i) // fusion gate from j-th to i-th, and
+        double estimated_cost =
+            estimate_cost(ops, (uint_t)j,
+                          i) // fusion gate from j-th to i-th, and
             + (j == 0 ? 0.0 : costs[j - 1 - fusion_start]); // cost of (j-1)-th
 
         // update cost
@@ -965,7 +981,8 @@ bool CostBasedFusion::aggregate_operations(oplist_t& ops,
   if (!applied)
     return false;
 
-  // generate a new circuit with the minimal path to the last operation in the circuit
+  // generate a new circuit with the minimal path to the last operation in the
+  // circuit
   for (int i = fusion_end - 1; i >= fusion_start;) {
     int to = fusion_to[i - fusion_start];
     if (to != i) {
@@ -984,9 +1001,8 @@ bool CostBasedFusion::aggregate_operations(oplist_t& ops,
 // Gate-swap optimized helper functions
 //------------------------------------------------------------------------------
 
-bool CostBasedFusion::is_diagonal(const std::vector<op_t>& ops,
-                         const uint_t from,
-                         const uint_t until) const {
+bool CostBasedFusion::is_diagonal(const std::vector<op_t> &ops,
+                                  const uint_t from, const uint_t until) const {
 
   // check unitary matrix of ops between "from" and "to" is a diagonal matrix
 
@@ -995,14 +1011,11 @@ bool CostBasedFusion::is_diagonal(const std::vector<op_t>& ops,
     //  ─┤ X ├┤ U1 ├┤ X ├
     //   └─┬─┘└────┘└─┬─┘
     //  ───■──────────■─-
-    if ((i + 2) <= until
-        && ops[i + 0].name == "cx"
-        && ops[i + 1].name == "u1"
-        && ops[i + 2].name == "cx"
-        && ops[i + 0].qubits[1] == ops[i + 1].qubits[0]
-        && ops[i + 1].qubits[0] == ops[i + 2].qubits[1]
-        && ops[i + 0].qubits[0] == ops[i + 2].qubits[0] )
-    {
+    if ((i + 2) <= until && ops[i + 0].name == "cx" &&
+        ops[i + 1].name == "u1" && ops[i + 2].name == "cx" &&
+        ops[i + 0].qubits[1] == ops[i + 1].qubits[0] &&
+        ops[i + 1].qubits[0] == ops[i + 2].qubits[1] &&
+        ops[i + 0].qubits[0] == ops[i + 2].qubits[0]) {
       i += 2;
       continue;
     }
@@ -1013,9 +1026,9 @@ bool CostBasedFusion::is_diagonal(const std::vector<op_t>& ops,
   return true;
 }
 
-double CostBasedFusion::estimate_cost(const std::vector<op_t>& ops,
-                             const uint_t from,
-                             const uint_t until) const {
+double CostBasedFusion::estimate_cost(const std::vector<op_t> &ops,
+                                      const uint_t from,
+                                      const uint_t until) const {
   if (is_diagonal(ops, from, until))
     return 1.0;
 
@@ -1027,26 +1040,30 @@ double CostBasedFusion::estimate_cost(const std::vector<op_t>& ops,
   if (configured_cost > 0)
     return configured_cost;
 
-  if(is_avx2_supported()){
+  if (is_avx2_supported()) {
     switch (fusion_qubits.size()) {
-      case 1:
-        // [[ falling through :) ]]
-      case 2:
-        return 1.0;
-      case 3:
-        return 1.1;
-      case 4:
-        return 3;
-      default:
-        return pow(cost_factor, (double) std::max(fusion_qubits.size() - 2, size_t(1)));
+    case 1:
+      // [[ falling through :) ]]
+    case 2:
+      return 1.0;
+    case 3:
+      return 1.1;
+    case 4:
+      return 3;
+    default:
+      return pow(cost_factor,
+                 (double)std::max(fusion_qubits.size() - 2, size_t(1)));
     }
   }
-  return pow(cost_factor, (double) std::max(fusion_qubits.size() - 1, size_t(1)));
+  return pow(cost_factor,
+             (double)std::max(fusion_qubits.size() - 1, size_t(1)));
 }
 
-void CostBasedFusion::add_fusion_qubits(reg_t& fusion_qubits, const op_t& op) const {
-  for (const auto &qubit: op.qubits){
-    if (find(fusion_qubits.begin(), fusion_qubits.end(), qubit) == fusion_qubits.end()){
+void CostBasedFusion::add_fusion_qubits(reg_t &fusion_qubits,
+                                        const op_t &op) const {
+  for (const auto &qubit : op.qubits) {
+    if (find(fusion_qubits.begin(), fusion_qubits.end(), qubit) ==
+        fusion_qubits.end()) {
       fusion_qubits.push_back(qubit);
     }
   }
diff --git a/test/asv.linux.conf.json b/test/asv.linux.conf.json
index 279a5b1773..b64ebbd0ba 100644
--- a/test/asv.linux.conf.json
+++ b/test/asv.linux.conf.json
@@ -1,191 +1,190 @@
 // To use this configuration for running the benchmarks, we have to run asv like this:
-// $ asv --connfig asv.linux.conf.json
-{
-    // The version of the config file format.  Do not change, unless
-    // you know what you are doing.
-    "version": 1,
-
-    // The name of the project being benchmarked
-    "project": "qiskit-aer",
-
-    // The project's homepage
-    "project_url": "http://qiskit.org/aer",
-
-    // The URL or local path of the source code repository for the
-    // project being benchmarked
-    "repo": "../",
-
-    // The Python project's subdirectory in your repo.  If missing or
-    // the empty string, the project is assumed to be located at the root
-    // of the repository.
-    // "repo_subdir": "",
-
-    // Customizable commands for building, installing, and
-    // uninstalling the project. See asv.conf.json documentation.
-    //
-    // "install_command": ["python -mpip install {wheel_file}"],
-    // "uninstall_command": ["return-code=any python -mpip uninstall -y {project}"],
-    // "build_command": [
-    //     "python setup.py build",
-    //     "PIP_NO_BUILD_ISOLATION=false python -mpip wheel --no-deps --no-index -w {build_cache_dir} {build_dir}"
-    // ],
-
-    "install_command": [
+    // $ asv --connfig asv.linux.conf.json
+    {
+      // The version of the config file format.  Do not change, unless
+      // you know what you are doing.
+      "version": 1,
+
+      // The name of the project being benchmarked
+      "project": "qiskit-aer",
+
+      // The project's homepage
+      "project_url": "http://qiskit.org/aer",
+
+      // The URL or local path of the source code repository for the
+      // project being benchmarked
+      "repo": "../",
+
+      // The Python project's subdirectory in your repo.  If missing or
+      // the empty string, the project is assumed to be located at the root
+      // of the repository.
+      // "repo_subdir": "",
+
+      // Customizable commands for building, installing, and
+      // uninstalling the project. See asv.conf.json documentation.
+      //
+      // "install_command": ["python -mpip install {wheel_file}"],
+      // "uninstall_command": ["return-code=any python -mpip uninstall -y {project}"],
+      // "build_command": [
+      //     "python setup.py build",
+      //     "PIP_NO_BUILD_ISOLATION=false python -mpip wheel --no-deps --no-index -w {build_cache_dir} {build_dir}"
+      // ],
+
+      "install_command": [
         "python -c \"import shutil; shutil.rmtree('{build_dir}/qiskit', True)\"",
         "python -c \"import shutil; shutil.rmtree('{build_dir}/qiskit_aer.egg-info', True)\"",
         "pip install git+https://github.com/Qiskit/qiskit-terra",
         "pip install git+https://github.com/Qiskit/qiskit-aqua",
         "python -mpip install {wheel_file}"
-    ],
-    "uninstall_command": [
+      ],
+      "uninstall_command": [
         "return-code=any python -mpip uninstall -y qiskit-terra",
         "return-code=any python -mpip uninstall -y qiskit-aqua",
         "return-code=any python -mpip uninstall -y {project}"
-    ],
-    "build_command": [
+      ],
+      "build_command": [
         "python -mpip install -U scikit-build",
         "pip install git+https://github.com/Qiskit/qiskit-terra",
         "pip install git+https://github.com/Qiskit/qiskit-aqua",
         "pip install pyscf",
         "pip install matplotlib",
         "python setup.py bdist_wheel --dist-dir={build_cache_dir} -- -DCMAKE_CXX_COMPILER=g++ -- -j"
-    ],
-
-    // List of branches to benchmark. If not provided, defaults to "main"
-    // (for git) or "default" (for mercurial).
-    // "branches": ["main"], // for git
-    // "branches": ["default"],    // for mercurial
-
-    // The DVCS being used.  If not set, it will be automatically
-    // determined from "repo" by looking at the protocol in the URL
-    // (if remote), or by looking for special directories, such as
-    // ".git" (if local).
-    // "dvcs": "git",
-
-    // The tool to use to create environments.  May be "conda",
-    // "virtualenv" or other value depending on the plugins in use.
-    // If missing or the empty string, the tool will be automatically
-    // determined by looking for tools on the PATH environment
-    // variable.
-    "environment_type": "conda",
-
-    // timeout in seconds for installing any dependencies in environment
-    // defaults to 10 min
-    //"install_timeout": 600,
-
-    // the base URL to show a commit for the project.
-    // "show_commit_url": "http://github.com/owner/project/commit/",
-
-    // The Pythons you'd like to test against.  If not provided, defaults
-    // to the current version of Python used to run `asv`.
-    // "pythons": ["3.7", "3.8", "3.9"],
-
-    // The list of conda channel names to be searched for benchmark
-    // dependency packages in the specified order
-    // "conda_channels": ["conda-forge", "defaults"]
-
-    // The matrix of dependencies to test.  Each key is the name of a
-    // package (in PyPI) and the values are version numbers.  An empty
-    // list or empty string indicates to just test against the default
-    // (latest) version. null indicates that the package is to not be
-    // installed. If the package to be tested is only available from
-    // PyPi, and the 'environment_type' is conda, then you can preface
-    // the package name by 'pip+', and the package will be installed via
-    // pip (with all the conda available packages installed first,
-    // followed by the pip installed packages).
-    //
-    // "matrix": {
-    //     "numpy": ["1.6", "1.7"],
-    //     "six": ["", null],        // test with and without six installed
-    //     "pip+emcee": [""],   // emcee is only available for install with pip.
-    // },
-
-    //"matrix": {
-    //    "pip+qiskit-terra": [""],
-    //},
-
-    // Combinations of libraries/python versions can be excluded/included
-    // from the set to test. Each entry is a dictionary containing additional
-    // key-value pairs to include/exclude.
-    //
-    // An exclude entry excludes entries where all values match. The
-    // values are regexps that should match the whole string.
-    //
-    // An include entry adds an environment. Only the packages listed
-    // are installed. The 'python' key is required. The exclude rules
-    // do not apply to includes.
-    //
-    // In addition to package names, the following keys are available:
-    //
-    // - python
-    //     Python version, as in the *pythons* variable above.
-    // - environment_type
-    //     Environment type, as above.
-    // - sys_platform
-    //     Platform, as in sys.platform. Possible values for the common
-    //     cases: 'linux2', 'win32', 'cygwin', 'darwin'.
-    //
-    // "exclude": [
-    //     {"python": "3.2", "sys_platform": "win32"}, // skip py3.2 on windows
-    //     {"environment_type": "conda", "six": null}, // don't run without six on conda
-    // ],
-    //
-    // "include": [
-    //     // additional env for python2.7
-    //     {"python": "2.7", "numpy": "1.8"},
-    //     // additional env if run on windows+conda
-    //     {"platform": "win32", "environment_type": "conda", "python": "2.7", "libpython": ""},
-    // ],
-
-    // The directory (relative to the current directory) that benchmarks are
-    // stored in.  If not provided, defaults to "benchmarks"
-    "benchmark_dir": "benchmark",
-
-
-    // The directory (relative to the current directory) to cache the Python
-    // environments in.  If not provided, defaults to "env"
-    // "env_dir": "env",
-    "env_dir": ".asv/envs",
-
-    // The directory (relative to the current directory) that raw benchmark
-    // results are stored in.  If not provided, defaults to "results".
-    // "results_dir": "results",
-    "results_dir": ".asv/results",
-
-    // The directory (relative to the current directory) that the html tree
-    // should be written to.  If not provided, defaults to "html".
-    // "html_dir": "html",
-    "html_dir": ".asv/html"
-
-    // The number of characters to retain in the commit hashes.
-    // "hash_length": 8,
-
-    // `asv` will cache results of the recent builds in each
-    // environment, making them faster to install next time.  This is
-    // the number of builds to keep, per environment.
-    // "build_cache_size": 2,
-
-    // The commits after which the regression search in `asv publish`
-    // should start looking for regressions. Dictionary whose keys are
-    // regexps matching to benchmark names, and values corresponding to
-    // the commit (exclusive) after which to start looking for
-    // regressions.  The default is to start from the first commit
-    // with results. If the commit is `null`, regression detection is
-    // skipped for the matching benchmark.
-    //
-    // "regressions_first_commits": {
-    //    "some_benchmark": "352cdf",  // Consider regressions only after this commit
-    //    "another_benchmark": null,   // Skip regression detection altogether
-    // },
-
-    // The thresholds for relative change in results, after which `asv
-    // publish` starts reporting regressions. Dictionary of the same
-    // form as in ``regressions_first_commits``, with values
-    // indicating the thresholds.  If multiple entries match, the
-    // maximum is taken. If no entry matches, the default is 5%.
-    //
-    // "regressions_thresholds": {
-    //    "some_benchmark": 0.01,     // Threshold of 1%
-    //    "another_benchmark": 0.5,   // Threshold of 50%
-    // },
-}
+      ],
+
+      // List of branches to benchmark. If not provided, defaults to "main"
+      // (for git) or "default" (for mercurial).
+      // "branches": ["main"], // for git
+      // "branches": ["default"],    // for mercurial
+
+      // The DVCS being used.  If not set, it will be automatically
+      // determined from "repo" by looking at the protocol in the URL
+      // (if remote), or by looking for special directories, such as
+      // ".git" (if local).
+      // "dvcs": "git",
+
+      // The tool to use to create environments.  May be "conda",
+      // "virtualenv" or other value depending on the plugins in use.
+      // If missing or the empty string, the tool will be automatically
+      // determined by looking for tools on the PATH environment
+      // variable.
+      "environment_type": "conda",
+
+      // timeout in seconds for installing any dependencies in environment
+      // defaults to 10 min
+      //"install_timeout": 600,
+
+      // the base URL to show a commit for the project.
+      // "show_commit_url": "http://github.com/owner/project/commit/",
+
+      // The Pythons you'd like to test against.  If not provided, defaults
+      // to the current version of Python used to run `asv`.
+      // "pythons": ["3.7", "3.8", "3.9"],
+
+      // The list of conda channel names to be searched for benchmark
+      // dependency packages in the specified order
+      // "conda_channels": ["conda-forge", "defaults"]
+
+      // The matrix of dependencies to test.  Each key is the name of a
+      // package (in PyPI) and the values are version numbers.  An empty
+      // list or empty string indicates to just test against the default
+      // (latest) version. null indicates that the package is to not be
+      // installed. If the package to be tested is only available from
+      // PyPi, and the 'environment_type' is conda, then you can preface
+      // the package name by 'pip+', and the package will be installed via
+      // pip (with all the conda available packages installed first,
+      // followed by the pip installed packages).
+      //
+      // "matrix": {
+      //     "numpy": ["1.6", "1.7"],
+      //     "six": ["", null],        // test with and without six installed
+      //     "pip+emcee": [""],   // emcee is only available for install with pip.
+      // },
+
+      //"matrix": {
+      //    "pip+qiskit-terra": [""],
+      //},
+
+      // Combinations of libraries/python versions can be excluded/included
+      // from the set to test. Each entry is a dictionary containing additional
+      // key-value pairs to include/exclude.
+      //
+      // An exclude entry excludes entries where all values match. The
+      // values are regexps that should match the whole string.
+      //
+      // An include entry adds an environment. Only the packages listed
+      // are installed. The 'python' key is required. The exclude rules
+      // do not apply to includes.
+      //
+      // In addition to package names, the following keys are available:
+      //
+      // - python
+      //     Python version, as in the *pythons* variable above.
+      // - environment_type
+      //     Environment type, as above.
+      // - sys_platform
+      //     Platform, as in sys.platform. Possible values for the common
+      //     cases: 'linux2', 'win32', 'cygwin', 'darwin'.
+      //
+      // "exclude": [
+      //     {"python": "3.2", "sys_platform": "win32"}, // skip py3.2 on windows
+      //     {"environment_type": "conda", "six": null}, // don't run without six on conda
+      // ],
+      //
+      // "include": [
+      //     // additional env for python2.7
+      //     {"python": "2.7", "numpy": "1.8"},
+      //     // additional env if run on windows+conda
+      //     {"platform": "win32", "environment_type": "conda", "python": "2.7", "libpython": ""},
+      // ],
+
+      // The directory (relative to the current directory) that benchmarks are
+      // stored in.  If not provided, defaults to "benchmarks"
+      "benchmark_dir": "benchmark",
+
+      // The directory (relative to the current directory) to cache the Python
+      // environments in.  If not provided, defaults to "env"
+      // "env_dir": "env",
+      "env_dir": ".asv/envs",
+
+      // The directory (relative to the current directory) that raw benchmark
+      // results are stored in.  If not provided, defaults to "results".
+      // "results_dir": "results",
+      "results_dir": ".asv/results",
+
+      // The directory (relative to the current directory) that the html tree
+      // should be written to.  If not provided, defaults to "html".
+      // "html_dir": "html",
+      "html_dir": ".asv/html"
+
+      // The number of characters to retain in the commit hashes.
+      // "hash_length": 8,
+
+      // `asv` will cache results of the recent builds in each
+      // environment, making them faster to install next time.  This is
+      // the number of builds to keep, per environment.
+      // "build_cache_size": 2,
+
+      // The commits after which the regression search in `asv publish`
+      // should start looking for regressions. Dictionary whose keys are
+      // regexps matching to benchmark names, and values corresponding to
+      // the commit (exclusive) after which to start looking for
+      // regressions.  The default is to start from the first commit
+      // with results. If the commit is `null`, regression detection is
+      // skipped for the matching benchmark.
+      //
+      // "regressions_first_commits": {
+      //    "some_benchmark": "352cdf",  // Consider regressions only after this commit
+      //    "another_benchmark": null,   // Skip regression detection altogether
+      // },
+
+      // The thresholds for relative change in results, after which `asv
+      // publish` starts reporting regressions. Dictionary of the same
+      // form as in ``regressions_first_commits``, with values
+      // indicating the thresholds.  If multiple entries match, the
+      // maximum is taken. If no entry matches, the default is 5%.
+      //
+      // "regressions_thresholds": {
+      //    "some_benchmark": 0.01,     // Threshold of 1%
+      //    "another_benchmark": 0.5,   // Threshold of 50%
+      // },
+    }
diff --git a/test/asv.linux.cuda.conf.json b/test/asv.linux.cuda.conf.json
index d034764dcd..5937bf78f2 100644
--- a/test/asv.linux.cuda.conf.json
+++ b/test/asv.linux.cuda.conf.json
@@ -1,191 +1,190 @@
 // To use this configuration for running the benchmarks, we have to run asv like this:
-// $ asv --connfig asv.linux.conf.json
-{
-    // The version of the config file format.  Do not change, unless
-    // you know what you are doing.
-    "version": 1,
-
-    // The name of the project being benchmarked
-    "project": "qiskit-aer",
-
-    // The project's homepage
-    "project_url": "http://qiskit.org/aer",
-
-    // The URL or local path of the source code repository for the
-    // project being benchmarked
-    "repo": "../",
-
-    // The Python project's subdirectory in your repo.  If missing or
-    // the empty string, the project is assumed to be located at the root
-    // of the repository.
-    // "repo_subdir": "",
-
-    // Customizable commands for building, installing, and
-    // uninstalling the project. See asv.conf.json documentation.
-    //
-    // "install_command": ["python -mpip install {wheel_file}"],
-    // "uninstall_command": ["return-code=any python -mpip uninstall -y {project}"],
-    // "build_command": [
-    //     "python setup.py build",
-    //     "PIP_NO_BUILD_ISOLATION=false python -mpip wheel --no-deps --no-index -w {build_cache_dir} {build_dir}"
-    // ],
-
-    "install_command": [
+    // $ asv --connfig asv.linux.conf.json
+    {
+      // The version of the config file format.  Do not change, unless
+      // you know what you are doing.
+      "version": 1,
+
+      // The name of the project being benchmarked
+      "project": "qiskit-aer",
+
+      // The project's homepage
+      "project_url": "http://qiskit.org/aer",
+
+      // The URL or local path of the source code repository for the
+      // project being benchmarked
+      "repo": "../",
+
+      // The Python project's subdirectory in your repo.  If missing or
+      // the empty string, the project is assumed to be located at the root
+      // of the repository.
+      // "repo_subdir": "",
+
+      // Customizable commands for building, installing, and
+      // uninstalling the project. See asv.conf.json documentation.
+      //
+      // "install_command": ["python -mpip install {wheel_file}"],
+      // "uninstall_command": ["return-code=any python -mpip uninstall -y {project}"],
+      // "build_command": [
+      //     "python setup.py build",
+      //     "PIP_NO_BUILD_ISOLATION=false python -mpip wheel --no-deps --no-index -w {build_cache_dir} {build_dir}"
+      // ],
+
+      "install_command": [
         "python -c \"import shutil; shutil.rmtree('{build_dir}/qiskit', True)\"",
         "python -c \"import shutil; shutil.rmtree('{build_dir}/qiskit_aer.egg-info', True)\"",
         "pip install git+https://github.com/Qiskit/qiskit-terra",
         "pip install git+https://github.com/Qiskit/qiskit-aqua",
         "python -mpip install {wheel_file}"
-    ],
-    "uninstall_command": [
+      ],
+      "uninstall_command": [
         "return-code=any python -mpip uninstall -y qiskit-terra",
         "return-code=any python -mpip uninstall -y qiskit-aqua",
         "return-code=any python -mpip uninstall -y {project}"
-    ],
-    "build_command": [
+      ],
+      "build_command": [
         "python -mpip install -U scikit-build",
         "pip install git+https://github.com/Qiskit/qiskit-terra",
         "pip install git+https://github.com/Qiskit/qiskit-aqua",
         "pip install pyscf",
         "pip install matplotlib",
         "python setup.py bdist_wheel --dist-dir={build_cache_dir} -- -DCMAKE_CXX_COMPILER=g++ -DAER_THRUST_BACKEND=CUDA -- -j"
-    ],
-
-    // List of branches to benchmark. If not provided, defaults to "main"
-    // (for git) or "default" (for mercurial).
-    // "branches": ["main"], // for git
-    // "branches": ["default"],    // for mercurial
-
-    // The DVCS being used.  If not set, it will be automatically
-    // determined from "repo" by looking at the protocol in the URL
-    // (if remote), or by looking for special directories, such as
-    // ".git" (if local).
-    // "dvcs": "git",
-
-    // The tool to use to create environments.  May be "conda",
-    // "virtualenv" or other value depending on the plugins in use.
-    // If missing or the empty string, the tool will be automatically
-    // determined by looking for tools on the PATH environment
-    // variable.
-    "environment_type": "conda",
-
-    // timeout in seconds for installing any dependencies in environment
-    // defaults to 10 min
-    //"install_timeout": 600,
-
-    // the base URL to show a commit for the project.
-    // "show_commit_url": "http://github.com/owner/project/commit/",
-
-    // The Pythons you'd like to test against.  If not provided, defaults
-    // to the current version of Python used to run `asv`.
-    // "pythons": ["2.7", "3.6"],
-
-    // The list of conda channel names to be searched for benchmark
-    // dependency packages in the specified order
-    // "conda_channels": ["conda-forge", "defaults"]
-
-    // The matrix of dependencies to test.  Each key is the name of a
-    // package (in PyPI) and the values are version numbers.  An empty
-    // list or empty string indicates to just test against the default
-    // (latest) version. null indicates that the package is to not be
-    // installed. If the package to be tested is only available from
-    // PyPi, and the 'environment_type' is conda, then you can preface
-    // the package name by 'pip+', and the package will be installed via
-    // pip (with all the conda available packages installed first,
-    // followed by the pip installed packages).
-    //
-    // "matrix": {
-    //     "numpy": ["1.6", "1.7"],
-    //     "six": ["", null],        // test with and without six installed
-    //     "pip+emcee": [""],   // emcee is only available for install with pip.
-    // },
-
-    //"matrix": {
-    //    "pip+qiskit-terra": [""],
-    //},
-
-    // Combinations of libraries/python versions can be excluded/included
-    // from the set to test. Each entry is a dictionary containing additional
-    // key-value pairs to include/exclude.
-    //
-    // An exclude entry excludes entries where all values match. The
-    // values are regexps that should match the whole string.
-    //
-    // An include entry adds an environment. Only the packages listed
-    // are installed. The 'python' key is required. The exclude rules
-    // do not apply to includes.
-    //
-    // In addition to package names, the following keys are available:
-    //
-    // - python
-    //     Python version, as in the *pythons* variable above.
-    // - environment_type
-    //     Environment type, as above.
-    // - sys_platform
-    //     Platform, as in sys.platform. Possible values for the common
-    //     cases: 'linux2', 'win32', 'cygwin', 'darwin'.
-    //
-    // "exclude": [
-    //     {"python": "3.2", "sys_platform": "win32"}, // skip py3.2 on windows
-    //     {"environment_type": "conda", "six": null}, // don't run without six on conda
-    // ],
-    //
-    // "include": [
-    //     // additional env for python2.7
-    //     {"python": "2.7", "numpy": "1.8"},
-    //     // additional env if run on windows+conda
-    //     {"platform": "win32", "environment_type": "conda", "python": "2.7", "libpython": ""},
-    // ],
-
-    // The directory (relative to the current directory) that benchmarks are
-    // stored in.  If not provided, defaults to "benchmarks"
-    "benchmark_dir": "benchmark",
-
-
-    // The directory (relative to the current directory) to cache the Python
-    // environments in.  If not provided, defaults to "env"
-    // "env_dir": "env",
-    "env_dir": ".asv/envs",
-
-    // The directory (relative to the current directory) that raw benchmark
-    // results are stored in.  If not provided, defaults to "results".
-    // "results_dir": "results",
-    "results_dir": ".asv/results",
-
-    // The directory (relative to the current directory) that the html tree
-    // should be written to.  If not provided, defaults to "html".
-    // "html_dir": "html",
-    "html_dir": ".asv/html"
-
-    // The number of characters to retain in the commit hashes.
-    // "hash_length": 8,
-
-    // `asv` will cache results of the recent builds in each
-    // environment, making them faster to install next time.  This is
-    // the number of builds to keep, per environment.
-    // "build_cache_size": 2,
-
-    // The commits after which the regression search in `asv publish`
-    // should start looking for regressions. Dictionary whose keys are
-    // regexps matching to benchmark names, and values corresponding to
-    // the commit (exclusive) after which to start looking for
-    // regressions.  The default is to start from the first commit
-    // with results. If the commit is `null`, regression detection is
-    // skipped for the matching benchmark.
-    //
-    // "regressions_first_commits": {
-    //    "some_benchmark": "352cdf",  // Consider regressions only after this commit
-    //    "another_benchmark": null,   // Skip regression detection altogether
-    // },
-
-    // The thresholds for relative change in results, after which `asv
-    // publish` starts reporting regressions. Dictionary of the same
-    // form as in ``regressions_first_commits``, with values
-    // indicating the thresholds.  If multiple entries match, the
-    // maximum is taken. If no entry matches, the default is 5%.
-    //
-    // "regressions_thresholds": {
-    //    "some_benchmark": 0.01,     // Threshold of 1%
-    //    "another_benchmark": 0.5,   // Threshold of 50%
-    // },
-}
+      ],
+
+      // List of branches to benchmark. If not provided, defaults to "main"
+      // (for git) or "default" (for mercurial).
+      // "branches": ["main"], // for git
+      // "branches": ["default"],    // for mercurial
+
+      // The DVCS being used.  If not set, it will be automatically
+      // determined from "repo" by looking at the protocol in the URL
+      // (if remote), or by looking for special directories, such as
+      // ".git" (if local).
+      // "dvcs": "git",
+
+      // The tool to use to create environments.  May be "conda",
+      // "virtualenv" or other value depending on the plugins in use.
+      // If missing or the empty string, the tool will be automatically
+      // determined by looking for tools on the PATH environment
+      // variable.
+      "environment_type": "conda",
+
+      // timeout in seconds for installing any dependencies in environment
+      // defaults to 10 min
+      //"install_timeout": 600,
+
+      // the base URL to show a commit for the project.
+      // "show_commit_url": "http://github.com/owner/project/commit/",
+
+      // The Pythons you'd like to test against.  If not provided, defaults
+      // to the current version of Python used to run `asv`.
+      // "pythons": ["2.7", "3.6"],
+
+      // The list of conda channel names to be searched for benchmark
+      // dependency packages in the specified order
+      // "conda_channels": ["conda-forge", "defaults"]
+
+      // The matrix of dependencies to test.  Each key is the name of a
+      // package (in PyPI) and the values are version numbers.  An empty
+      // list or empty string indicates to just test against the default
+      // (latest) version. null indicates that the package is to not be
+      // installed. If the package to be tested is only available from
+      // PyPi, and the 'environment_type' is conda, then you can preface
+      // the package name by 'pip+', and the package will be installed via
+      // pip (with all the conda available packages installed first,
+      // followed by the pip installed packages).
+      //
+      // "matrix": {
+      //     "numpy": ["1.6", "1.7"],
+      //     "six": ["", null],        // test with and without six installed
+      //     "pip+emcee": [""],   // emcee is only available for install with pip.
+      // },
+
+      //"matrix": {
+      //    "pip+qiskit-terra": [""],
+      //},
+
+      // Combinations of libraries/python versions can be excluded/included
+      // from the set to test. Each entry is a dictionary containing additional
+      // key-value pairs to include/exclude.
+      //
+      // An exclude entry excludes entries where all values match. The
+      // values are regexps that should match the whole string.
+      //
+      // An include entry adds an environment. Only the packages listed
+      // are installed. The 'python' key is required. The exclude rules
+      // do not apply to includes.
+      //
+      // In addition to package names, the following keys are available:
+      //
+      // - python
+      //     Python version, as in the *pythons* variable above.
+      // - environment_type
+      //     Environment type, as above.
+      // - sys_platform
+      //     Platform, as in sys.platform. Possible values for the common
+      //     cases: 'linux2', 'win32', 'cygwin', 'darwin'.
+      //
+      // "exclude": [
+      //     {"python": "3.2", "sys_platform": "win32"}, // skip py3.2 on windows
+      //     {"environment_type": "conda", "six": null}, // don't run without six on conda
+      // ],
+      //
+      // "include": [
+      //     // additional env for python2.7
+      //     {"python": "2.7", "numpy": "1.8"},
+      //     // additional env if run on windows+conda
+      //     {"platform": "win32", "environment_type": "conda", "python": "2.7", "libpython": ""},
+      // ],
+
+      // The directory (relative to the current directory) that benchmarks are
+      // stored in.  If not provided, defaults to "benchmarks"
+      "benchmark_dir": "benchmark",
+
+      // The directory (relative to the current directory) to cache the Python
+      // environments in.  If not provided, defaults to "env"
+      // "env_dir": "env",
+      "env_dir": ".asv/envs",
+
+      // The directory (relative to the current directory) that raw benchmark
+      // results are stored in.  If not provided, defaults to "results".
+      // "results_dir": "results",
+      "results_dir": ".asv/results",
+
+      // The directory (relative to the current directory) that the html tree
+      // should be written to.  If not provided, defaults to "html".
+      // "html_dir": "html",
+      "html_dir": ".asv/html"
+
+      // The number of characters to retain in the commit hashes.
+      // "hash_length": 8,
+
+      // `asv` will cache results of the recent builds in each
+      // environment, making them faster to install next time.  This is
+      // the number of builds to keep, per environment.
+      // "build_cache_size": 2,
+
+      // The commits after which the regression search in `asv publish`
+      // should start looking for regressions. Dictionary whose keys are
+      // regexps matching to benchmark names, and values corresponding to
+      // the commit (exclusive) after which to start looking for
+      // regressions.  The default is to start from the first commit
+      // with results. If the commit is `null`, regression detection is
+      // skipped for the matching benchmark.
+      //
+      // "regressions_first_commits": {
+      //    "some_benchmark": "352cdf",  // Consider regressions only after this commit
+      //    "another_benchmark": null,   // Skip regression detection altogether
+      // },
+
+      // The thresholds for relative change in results, after which `asv
+      // publish` starts reporting regressions. Dictionary of the same
+      // form as in ``regressions_first_commits``, with values
+      // indicating the thresholds.  If multiple entries match, the
+      // maximum is taken. If no entry matches, the default is 5%.
+      //
+      // "regressions_thresholds": {
+      //    "some_benchmark": 0.01,     // Threshold of 1%
+      //    "another_benchmark": 0.5,   // Threshold of 50%
+      // },
+    }
diff --git a/test/data/qobj_snapshot_expval_matrix.json b/test/data/qobj_snapshot_expval_matrix.json
index 0b93c534f7..ac35e50717 100644
--- a/test/data/qobj_snapshot_expval_matrix.json
+++ b/test/data/qobj_snapshot_expval_matrix.json
@@ -1,57 +1,218 @@
 {
-    "qobj_id": "matrix_observable_snapshot_example",
-    "schema_version": "1.0.0",
-    "type": "QASM",
-    "experiments": [
-        {   
-            "config": {
-                "shots": 1000,
-                "memory_slots": 2,
-                "n_qubits": 2
-            },
-            "instructions": [
-                {"name": "h", "qubits": [0]},
-                {"name": "cx", "qubits": [0, 1]},
-                {
-                    "name": "snapshot",
-                    "type": "expectation_value_matrix",
-                    "label": "<ZZ>pre_measure",
-                    "params": [
-                        [1, [[[0], [[1, 0], [0, -1]]],
-                             [[1], [[1,  0], [0, -1]]]]
-                        ]
-                    ]
-                },
-                {
-                    "name": "snapshot",
-                    "type": "expectation_value_matrix",
-                    "label": "<ZI+IZ>pre_measure",
-                    "params": [
-                        [1, [[[0], [[1, 0], [0, -1]]]]],
-                        [1, [[[1], [[1, 0], [0, -1]]]]]
-                    ]
-                },
-                {"name": "measure", "qubits": [0, 1], "memory": [0, 1]},
-                {
-                    "name": "snapshot",
-                    "type": "expectation_value_matrix",
-                    "label": "<ZZ>post_measure",
-                    "params": [
-                        [1, [[[0], [[1, 0], [0, -1]]],
-                             [[1], [[1, 0], [0, -1]]]]
-                        ]
-                    ]
-                },
-                {
-                    "name": "snapshot",
-                    "type": "expectation_value_matrix",
-                    "label": "<ZI+IZ>post_measure",
-                    "params": [
-                        [1, [[[0], [[1, 0], [0, -1]]]]],
-                        [1, [[[1], [[1, 0], [0, -1]]]]]
-                    ]
-                }
+  "qobj_id": "matrix_observable_snapshot_example",
+  "schema_version": "1.0.0",
+  "type": "QASM",
+  "experiments": [
+    {
+      "config": {
+        "shots": 1000,
+        "memory_slots": 2,
+        "n_qubits": 2
+      },
+      "instructions": [
+        {
+          "name": "h",
+          "qubits": [
+            0
+          ]
+        },
+        {
+          "name": "cx",
+          "qubits": [
+            0,
+            1
+          ]
+        },
+        {
+          "name": "snapshot",
+          "type": "expectation_value_matrix",
+          "label": "<ZZ>pre_measure",
+          "params": [
+            [
+              1,
+              [
+                [
+                  [
+                    0
+                  ],
+                  [
+                    [
+                      1,
+                      0
+                    ],
+                    [
+                      0,
+                      -1
+                    ]
+                  ]
+                ],
+                [
+                  [
+                    1
+                  ],
+                  [
+                    [
+                      1,
+                      0
+                    ],
+                    [
+                      0,
+                      -1
+                    ]
+                  ]
+                ]
+              ]
+            ]
+          ]
+        },
+        {
+          "name": "snapshot",
+          "type": "expectation_value_matrix",
+          "label": "<ZI+IZ>pre_measure",
+          "params": [
+            [
+              1,
+              [
+                [
+                  [
+                    0
+                  ],
+                  [
+                    [
+                      1,
+                      0
+                    ],
+                    [
+                      0,
+                      -1
+                    ]
+                  ]
+                ]
+              ]
+            ],
+            [
+              1,
+              [
+                [
+                  [
+                    1
+                  ],
+                  [
+                    [
+                      1,
+                      0
+                    ],
+                    [
+                      0,
+                      -1
+                    ]
+                  ]
+                ]
+              ]
+            ]
+          ]
+        },
+        {
+          "name": "measure",
+          "qubits": [
+            0,
+            1
+          ],
+          "memory": [
+            0,
+            1
+          ]
+        },
+        {
+          "name": "snapshot",
+          "type": "expectation_value_matrix",
+          "label": "<ZZ>post_measure",
+          "params": [
+            [
+              1,
+              [
+                [
+                  [
+                    0
+                  ],
+                  [
+                    [
+                      1,
+                      0
+                    ],
+                    [
+                      0,
+                      -1
+                    ]
+                  ]
+                ],
+                [
+                  [
+                    1
+                  ],
+                  [
+                    [
+                      1,
+                      0
+                    ],
+                    [
+                      0,
+                      -1
+                    ]
+                  ]
+                ]
+              ]
+            ]
+          ]
+        },
+        {
+          "name": "snapshot",
+          "type": "expectation_value_matrix",
+          "label": "<ZI+IZ>post_measure",
+          "params": [
+            [
+              1,
+              [
+                [
+                  [
+                    0
+                  ],
+                  [
+                    [
+                      1,
+                      0
+                    ],
+                    [
+                      0,
+                      -1
+                    ]
+                  ]
+                ]
+              ]
+            ],
+            [
+              1,
+              [
+                [
+                  [
+                    1
+                  ],
+                  [
+                    [
+                      1,
+                      0
+                    ],
+                    [
+                      0,
+                      -1
+                    ]
+                  ]
+                ]
+              ]
             ]
+          ]
         }
-    ]
+      ]
+    }
+  ]
 }
\ No newline at end of file
diff --git a/test/data/qobj_snapshot_expval_pauli.json b/test/data/qobj_snapshot_expval_pauli.json
index ef0c1fb5f5..c5c2127226 100644
--- a/test/data/qobj_snapshot_expval_pauli.json
+++ b/test/data/qobj_snapshot_expval_pauli.json
@@ -1,48 +1,140 @@
 {
-    "qobj_id": "pauli_observable_snapshot_example",
-    "schema_version": "1.0.0",
-    "type": "QASM",
-    "experiments": [
-        {   
-            "config": {
-                "shots": 1000,
-                "memory_slots": 2,
-                "n_qubits": 2
-            },
-            "instructions": [
-                {"name": "h", "qubits": [0]},
-                {"name": "cx", "qubits": [0, 1]},
-                {
-                    "name": "snapshot",
-                    "type": "expectation_value_pauli",
-                    "label": "<ZZ>pre_measure",
-                    "qubits": [0, 1],
-                    "params": [[[1, 0] , "ZZ"]]
-                },
-                {
-                    "name": "snapshot",
-                    "type": "expectation_value_pauli",
-                    "label": "<ZI+IZ>pre_measure",
-                    "qubits": [0, 1],
-                    "params": [[[1, 0] , "ZI"], [[1, 0], "IZ"]]
-                },
-                {"name": "measure", "qubits": [0], "memory": [0]},
-                {"name": "measure", "qubits": [0], "memory": [1]},
-                {
-                    "name": "snapshot",
-                    "type": "expectation_value_pauli",
-                    "label": "<ZZ>post_measure",
-                    "qubits": [0, 1],
-                    "params": [[[1, 0] , "ZI"], [[1, 0], "ZZ"]]
-                },
-                {
-                    "name": "snapshot",
-                    "type": "expectation_value_pauli",
-                    "label": "<ZI+IZ>post_measure",
-                    "qubits": [0, 1],
-                    "params": [[[1, 0] , "ZI"], [[1, 0], "IZ"]]
-                }
+  "qobj_id": "pauli_observable_snapshot_example",
+  "schema_version": "1.0.0",
+  "type": "QASM",
+  "experiments": [
+    {
+      "config": {
+        "shots": 1000,
+        "memory_slots": 2,
+        "n_qubits": 2
+      },
+      "instructions": [
+        {
+          "name": "h",
+          "qubits": [
+            0
+          ]
+        },
+        {
+          "name": "cx",
+          "qubits": [
+            0,
+            1
+          ]
+        },
+        {
+          "name": "snapshot",
+          "type": "expectation_value_pauli",
+          "label": "<ZZ>pre_measure",
+          "qubits": [
+            0,
+            1
+          ],
+          "params": [
+            [
+              [
+                1,
+                0
+              ],
+              "ZZ"
             ]
+          ]
+        },
+        {
+          "name": "snapshot",
+          "type": "expectation_value_pauli",
+          "label": "<ZI+IZ>pre_measure",
+          "qubits": [
+            0,
+            1
+          ],
+          "params": [
+            [
+              [
+                1,
+                0
+              ],
+              "ZI"
+            ],
+            [
+              [
+                1,
+                0
+              ],
+              "IZ"
+            ]
+          ]
+        },
+        {
+          "name": "measure",
+          "qubits": [
+            0
+          ],
+          "memory": [
+            0
+          ]
+        },
+        {
+          "name": "measure",
+          "qubits": [
+            0
+          ],
+          "memory": [
+            1
+          ]
+        },
+        {
+          "name": "snapshot",
+          "type": "expectation_value_pauli",
+          "label": "<ZZ>post_measure",
+          "qubits": [
+            0,
+            1
+          ],
+          "params": [
+            [
+              [
+                1,
+                0
+              ],
+              "ZI"
+            ],
+            [
+              [
+                1,
+                0
+              ],
+              "ZZ"
+            ]
+          ]
+        },
+        {
+          "name": "snapshot",
+          "type": "expectation_value_pauli",
+          "label": "<ZI+IZ>post_measure",
+          "qubits": [
+            0,
+            1
+          ],
+          "params": [
+            [
+              [
+                1,
+                0
+              ],
+              "ZI"
+            ],
+            [
+              [
+                1,
+                0
+              ],
+              "IZ"
+            ]
+          ]
         }
-    ]
+      ]
+    }
+  ]
 }
\ No newline at end of file
diff --git a/test/data/qobj_snapshot_probs.json b/test/data/qobj_snapshot_probs.json
index 03faab580a..449a6e1aea 100644
--- a/test/data/qobj_snapshot_probs.json
+++ b/test/data/qobj_snapshot_probs.json
@@ -1,24 +1,65 @@
 {
-    "qobj_id": "probabilities_snapshot_example",
-    "schema_version": "1.0.0",
-    "type": "QASM",
-    "experiments": [
-        {   
-            "config": {
-                "shots": 1000,
-                "memory_slots": 2,
-                "n_qubits": 2
-            },
-            "instructions": [
-                {"name": "h", "qubits": [0]},
-                {"name": "cx", "qubits": [0, 1]},
-                {"name": "snapshot", "type": "probabilities",
-                    "label": "pre_measure", "qubits": [0, 1]},
-                {"name": "measure", "qubits": [0], "memory": [0]},
-                {"name": "measure", "qubits": [1], "memory": [1]},
-                {"name": "snapshot", "type": "probabilities",
-                    "label": "post_measure", "qubits": [0, 1]}
-            ]
+  "qobj_id": "probabilities_snapshot_example",
+  "schema_version": "1.0.0",
+  "type": "QASM",
+  "experiments": [
+    {
+      "config": {
+        "shots": 1000,
+        "memory_slots": 2,
+        "n_qubits": 2
+      },
+      "instructions": [
+        {
+          "name": "h",
+          "qubits": [
+            0
+          ]
+        },
+        {
+          "name": "cx",
+          "qubits": [
+            0,
+            1
+          ]
+        },
+        {
+          "name": "snapshot",
+          "type": "probabilities",
+          "label": "pre_measure",
+          "qubits": [
+            0,
+            1
+          ]
+        },
+        {
+          "name": "measure",
+          "qubits": [
+            0
+          ],
+          "memory": [
+            0
+          ]
+        },
+        {
+          "name": "measure",
+          "qubits": [
+            1
+          ],
+          "memory": [
+            1
+          ]
+        },
+        {
+          "name": "snapshot",
+          "type": "probabilities",
+          "label": "post_measure",
+          "qubits": [
+            0,
+            1
+          ]
         }
-    ]
+      ]
+    }
+  ]
 }
\ No newline at end of file
diff --git a/test/data/qobj_snapshot_statevector.json b/test/data/qobj_snapshot_statevector.json
index 1164a7d0ff..f6d4a30425 100644
--- a/test/data/qobj_snapshot_statevector.json
+++ b/test/data/qobj_snapshot_statevector.json
@@ -1,21 +1,44 @@
 {
-    "qobj_id": "state_snapshot_example",
-    "schema_version": "1.0.0",
-    "type": "QASM",
-    "experiments": [
-        {   
-            "config": {
-                "shots": 1,
-                "memory_slots": 0,
-                "n_qubits": 2
-            },
-            "instructions": [
-                {"name": "snapshot", "type": "statevector", "label": "initial"},
-                {"name": "h", "qubits": [0]},
-                {"name": "snapshot", "type": "statevector", "label": "middle"},
-                {"name": "cx", "qubits": [0, 1]},
-                {"name": "snapshot", "type": "statevector", "label": "final"}
-            ]
+  "qobj_id": "state_snapshot_example",
+  "schema_version": "1.0.0",
+  "type": "QASM",
+  "experiments": [
+    {
+      "config": {
+        "shots": 1,
+        "memory_slots": 0,
+        "n_qubits": 2
+      },
+      "instructions": [
+        {
+          "name": "snapshot",
+          "type": "statevector",
+          "label": "initial"
+        },
+        {
+          "name": "h",
+          "qubits": [
+            0
+          ]
+        },
+        {
+          "name": "snapshot",
+          "type": "statevector",
+          "label": "middle"
+        },
+        {
+          "name": "cx",
+          "qubits": [
+            0,
+            1
+          ]
+        },
+        {
+          "name": "snapshot",
+          "type": "statevector",
+          "label": "final"
         }
-    ]
+      ]
+    }
+  ]
 }
\ No newline at end of file
diff --git a/test/runtime/runtime_sample.c b/test/runtime/runtime_sample.c
index 461b01391a..0a645062e9 100644
--- a/test/runtime/runtime_sample.c
+++ b/test/runtime/runtime_sample.c
@@ -11,38 +11,38 @@
  * copyright notice, and modified files need to carry a notice indicating
  * that they have been altered from the originals.
  */
-#include <stdlib.h>
 #include <stdint.h>
 #include <stdio.h>
+#include <stdlib.h>
 
 #include <complex.h>
 
 #include "aer_runtime_api.h"
 
-typedef uint_fast64_t uint_t; 
+typedef uint_fast64_t uint_t;
 
 int main() {
   int num_of_qubits = 8;
 
   printf("%d-qubits GHZ\n", num_of_qubits);
 
-  void* state = aer_state();
+  void *state = aer_state();
 
   aer_state_configure(state, "method", "statevector");
   aer_state_configure(state, "device", "CPU");
   aer_state_configure(state, "precision", "double");
 
   int start_qubit = aer_allocate_qubits(state, num_of_qubits);
-  
+
   aer_state_initialize(state);
 
-  int* qubits = (int*) malloc(sizeof(int) * num_of_qubits);
+  int *qubits = (int *)malloc(sizeof(int) * num_of_qubits);
   for (int i = 0; i < num_of_qubits; ++i)
     qubits[i] = start_qubit + i;
 
   aer_apply_h(state, qubits[0]);
   for (int i = 0; i < num_of_qubits - 1; ++i)
-      aer_apply_cx(state, qubits[i], qubits[i + 1]);
+    aer_apply_cx(state, qubits[i], qubits[i + 1]);
 
   printf("non-zero probabilities and amplitudes:\n");
   for (uint_t i = 0; i < (1UL << num_of_qubits); ++i) {
@@ -52,11 +52,11 @@ int main() {
       printf("  %08lx %lf [%lf, %lf]\n", i, prob, creal(amp), cimag(amp));
     }
   }
-  
+
   printf("all the amplitudes:\n");
-  double complex* sv = aer_release_statevector(state);
+  double complex *sv = aer_release_statevector(state);
   for (uint_t i = 0; i < (1UL << num_of_qubits); ++i) {
-      printf("  %08lx [%lf, %lf]\n", i, creal(sv[i]), cimag(sv[i]));
+    printf("  %08lx [%lf, %lf]\n", i, creal(sv[i]), cimag(sv[i]));
   }
 
   aer_state_finalize(state);
diff --git a/test/src/test_linalg.cpp b/test/src/test_linalg.cpp
index 587737dc9d..3443c8cf21 100644
--- a/test/src/test_linalg.cpp
+++ b/test/src/test_linalg.cpp
@@ -13,16 +13,15 @@
  */
 
 #define _USE_MATH_DEFINES
-#include <math.h>
 #include <framework/stl_ostream.hpp>
 #include <map>
+#include <math.h>
 #include <type_traits>
 
 #include <framework/linalg/linalg.hpp>
 #include <framework/types.hpp>
 #include <framework/utils.hpp>
 
-
 #define CATCH_CONFIG_MAIN
 
 #include <catch2/catch.hpp>
@@ -35,329 +34,343 @@ namespace {
 // check if polar coordinates are almost equal
 // r -> (0,inf)
 // angle -> (-PI, PI)
-template <typename T>
-T eps() {
-    return std::numeric_limits<T>::epsilon();
-}
+template <typename T> T eps() { return std::numeric_limits<T>::epsilon(); }
 
-template<typename T>
-bool check_polar_coords(T r, T angle, T r_2, T angle_2, T max_diff = eps<T>(), T max_relative_diff = eps<T>());
+template <typename T>
+bool check_polar_coords(T r, T angle, T r_2, T angle_2, T max_diff = eps<T>(),
+                        T max_relative_diff = eps<T>());
 
-template<typename T>
+template <typename T>
 bool check_eigenvector(const std::vector<std::complex<T>> &expected_eigen,
                        const std::vector<std::complex<T>> &actual_eigen,
-                       T max_diff = eps<T>(),
-                       T max_relative_diff = eps<T>());
+                       T max_diff = eps<T>(), T max_relative_diff = eps<T>());
 
 // Sometimes eigenvectors differ by a factor and/or phase
 // This function compares them taking this into account
-template<typename T>
+template <typename T>
 bool check_all_eigenvectors(const matrix<std::complex<T>> &expected,
                             const matrix<std::complex<T>> &actual,
                             T max_diff = eps<T>(),
                             T max_relative_diff = eps<T>());
 
-template<typename T>
-using scenarioData = std::tuple<std::string, matrix<std::complex<T>>, matrix<std::complex<T>>, std::vector<T>>;
+template <typename T>
+using scenarioData = std::tuple<std::string, matrix<std::complex<T>>,
+                                matrix<std::complex<T>>, std::vector<T>>;
 
-template<typename T> matrix<std::complex<T>> herm_mat_2d();
-template<typename T> matrix<std::complex<T>> herm_mat_2d_eigenvectors();
-template<typename T> std::vector<T> herm_mat_2d_eigenvalues();
-template<typename T> scenarioData<T> get_herm_2d_scen();
+template <typename T> matrix<std::complex<T>> herm_mat_2d();
+template <typename T> matrix<std::complex<T>> herm_mat_2d_eigenvectors();
+template <typename T> std::vector<T> herm_mat_2d_eigenvalues();
+template <typename T> scenarioData<T> get_herm_2d_scen();
 
-template<typename T> matrix<std::complex<T>> psd_mat_2d();
-template<typename T> matrix<std::complex<T>> psd_mat_2d_eigenvectors();
-template<typename T> std::vector<T> psd_mat_2d_eigenvalues();
-template<typename T> scenarioData<T> get_psd_2d_scen();
+template <typename T> matrix<std::complex<T>> psd_mat_2d();
+template <typename T> matrix<std::complex<T>> psd_mat_2d_eigenvectors();
+template <typename T> std::vector<T> psd_mat_2d_eigenvalues();
+template <typename T> scenarioData<T> get_psd_2d_scen();
 
-template<typename T> matrix<std::complex<T>> psd_mat_2d_with_zero();
-template<typename T> matrix<std::complex<T>> psd_mat_2d_wiht_zero_eigenvectors();
-template<typename T> std::vector<T> psd_mat_2d_wiht_zero_eigenvalues();
-template<typename T> scenarioData<T> get_psd_mat_2d_wiht_zero_scen();
-}
+template <typename T> matrix<std::complex<T>> psd_mat_2d_with_zero();
+template <typename T>
+matrix<std::complex<T>> psd_mat_2d_wiht_zero_eigenvectors();
+template <typename T> std::vector<T> psd_mat_2d_wiht_zero_eigenvalues();
+template <typename T> scenarioData<T> get_psd_mat_2d_wiht_zero_scen();
+} // namespace
 
 TEST_CASE("Basic Matrix Ops", "[matrix]") {
-    auto mat = matrix<std::complex<double>>(2,2);
-    mat(0,0) = std::complex<double>(1.0, 0.0);
-    mat(0,1) = std::complex<double>(1.0, -2.0);
-    mat(1,0) = std::complex<double>(1.0, 2.0);
-    mat(1,1) = std::complex<double>(0.5, 0.0);
-
-    SECTION("matrix - col_index") {
-        std::vector<std::complex<double>> col0{ {1.0, 0.0}, {1.0, 2.0} };
-        std::vector<std::complex<double>> col1{ {1.0, -2.0}, {0.5, 0.0} };
-
-        REQUIRE(compare(col0, mat.col_index(0)));
-        REQUIRE(compare(col1, mat.col_index(1)));
-    }
-
-    SECTION("matrix - col_index") {
-        std::vector<std::complex<double>> row0{ {1.0, 0.0}, {1.0, -2.0} };
-        std::vector<std::complex<double>> row1{ {1.0, 2.0}, {0.5, 0.0} };
-
-        REQUIRE(compare(row0, mat.row_index(0)));
-        REQUIRE(compare(row1, mat.row_index(1)));
-    }
-}
- 
-TEMPLATE_TEST_CASE("Linear Algebra utilities", "[eigen_hermitian]", float, double) {
-    std::string scenario_name;
-    matrix<std::complex<TestType>> herm_mat;
-    matrix<std::complex<TestType>> expected_eigenvectors;
-    std::vector<TestType> expected_eigenvalues;
-    std::tie(scenario_name, herm_mat, expected_eigenvectors, expected_eigenvalues) =
-        GENERATE(get_herm_2d_scen<TestType>(), get_psd_2d_scen<TestType>(), get_psd_mat_2d_wiht_zero_scen<TestType>());
-
-    // We are checking results from a numerical method so we allow for some room in comparisons
-    TestType eps_threshold = 5 * eps<TestType>();
-
-    SECTION(scenario_name + ": zheevx") {
-        SECTION("sanity check - eigenvals/vecs should recreate original") {
-            // sanity check
-            matrix<std::complex<TestType>> sanity_value(herm_mat.GetRows(), herm_mat.GetColumns());
-            for (size_t j=0; j < expected_eigenvalues.size(); j++) {
-                sanity_value += expected_eigenvalues[j] * AER::Utils::projector(expected_eigenvectors.col_index(j));
-            }
-            REQUIRE(compare(herm_mat, sanity_value, eps_threshold, eps_threshold));
-        }
-        SECTION("actual check - heevx returns correctly") {
-            std::vector<TestType> eigenvalues;
-            matrix<std::complex<TestType>> eigenvectors;
-            eigensystem_hermitian(herm_mat, eigenvalues, eigenvectors);
-
-            // test equality
-            REQUIRE(check_all_eigenvectors(expected_eigenvectors, eigenvectors,
-                                           eps_threshold, eps_threshold));
-            REQUIRE(compare(expected_eigenvalues, eigenvalues, eps_threshold, eps_threshold));
-            // test reconstruction
-            matrix<std::complex<TestType>> value(herm_mat.GetRows(), herm_mat.GetColumns());
-            for (size_t j=0; j < eigenvalues.size(); j++) {
-                value += AER::Utils::projector(eigenvectors.col_index(j)) * eigenvalues[j];
-            }
-            REQUIRE(compare(herm_mat, value, eps_threshold, eps_threshold));
-        }
-    }
+  auto mat = matrix<std::complex<double>>(2, 2);
+  mat(0, 0) = std::complex<double>(1.0, 0.0);
+  mat(0, 1) = std::complex<double>(1.0, -2.0);
+  mat(1, 0) = std::complex<double>(1.0, 2.0);
+  mat(1, 1) = std::complex<double>(0.5, 0.0);
+
+  SECTION("matrix - col_index") {
+    std::vector<std::complex<double>> col0{{1.0, 0.0}, {1.0, 2.0}};
+    std::vector<std::complex<double>> col1{{1.0, -2.0}, {0.5, 0.0}};
+
+    REQUIRE(compare(col0, mat.col_index(0)));
+    REQUIRE(compare(col1, mat.col_index(1)));
+  }
+
+  SECTION("matrix - col_index") {
+    std::vector<std::complex<double>> row0{{1.0, 0.0}, {1.0, -2.0}};
+    std::vector<std::complex<double>> row1{{1.0, 2.0}, {0.5, 0.0}};
+
+    REQUIRE(compare(row0, mat.row_index(0)));
+    REQUIRE(compare(row1, mat.row_index(1)));
+  }
 }
 
-
-TEST_CASE( "Framework Utilities", "[almost_equal]" ) {
-    SECTION( "The maximum difference between two scalars over 1.0 is greater than epsilon, so they are amlmost equal" ) {
-        double first = 1.0 + eps<double>();
-        double actual = 1.0;
-        // Because the max_diff param is bigger than epsilon, this should be almost equal
-        REQUIRE(AER::Linalg::almost_equal(first, actual)); //, 1e-15, 1e-15));
-    }
-
-    SECTION( "The difference between two scalars really close to 0 should say are almost equal" ) {
-        double first = 5e-323; // Really close to the min magnitude of double
-        double actual = 6e-323;
-        REQUIRE(AER::Linalg::almost_equal(first, actual)); //, 1e-323, 1e-323));
-    }
-
-    SECTION( "The maximum difference between two complex of doubles over 1.0 is greater than epsilon, so they are almost equal" ) {
-        std::complex<double> first = { eps<double>() + double(1.0), eps<double>() + double(1.0)};
-        std::complex<double> actual {1.0, 1.0};
-        // Because the max_diff param is bigger than epsilon, this should be almost equal
-        REQUIRE(AER::Linalg::almost_equal(first, actual)); //, 1e-15, 1e-15));
+TEMPLATE_TEST_CASE("Linear Algebra utilities", "[eigen_hermitian]", float,
+                   double) {
+  std::string scenario_name;
+  matrix<std::complex<TestType>> herm_mat;
+  matrix<std::complex<TestType>> expected_eigenvectors;
+  std::vector<TestType> expected_eigenvalues;
+  std::tie(scenario_name, herm_mat, expected_eigenvectors,
+           expected_eigenvalues) =
+      GENERATE(get_herm_2d_scen<TestType>(), get_psd_2d_scen<TestType>(),
+               get_psd_mat_2d_wiht_zero_scen<TestType>());
+
+  // We are checking results from a numerical method so we allow for some room
+  // in comparisons
+  TestType eps_threshold = 5 * eps<TestType>();
+
+  SECTION(scenario_name + ": zheevx") {
+    SECTION("sanity check - eigenvals/vecs should recreate original") {
+      // sanity check
+      matrix<std::complex<TestType>> sanity_value(herm_mat.GetRows(),
+                                                  herm_mat.GetColumns());
+      for (size_t j = 0; j < expected_eigenvalues.size(); j++) {
+        sanity_value +=
+            expected_eigenvalues[j] *
+            AER::Utils::projector(expected_eigenvectors.col_index(j));
+      }
+      REQUIRE(compare(herm_mat, sanity_value, eps_threshold, eps_threshold));
     }
-
-    SECTION( "The difference between two complex of doubles really close to 0 should say are almost equal" ) {
-        std::complex<double> first = {5e-323, 5e-323}; // Really close to the min magnitude of double
-        std::complex<double> actual = {6e-323, 6e-323};
-
-        REQUIRE(AER::Linalg::almost_equal(first, actual)); // 1e-323, 1e-323));
+    SECTION("actual check - heevx returns correctly") {
+      std::vector<TestType> eigenvalues;
+      matrix<std::complex<TestType>> eigenvectors;
+      eigensystem_hermitian(herm_mat, eigenvalues, eigenvectors);
+
+      // test equality
+      REQUIRE(check_all_eigenvectors(expected_eigenvectors, eigenvectors,
+                                     eps_threshold, eps_threshold));
+      REQUIRE(compare(expected_eigenvalues, eigenvalues, eps_threshold,
+                      eps_threshold));
+      // test reconstruction
+      matrix<std::complex<TestType>> value(herm_mat.GetRows(),
+                                           herm_mat.GetColumns());
+      for (size_t j = 0; j < eigenvalues.size(); j++) {
+        value +=
+            AER::Utils::projector(eigenvectors.col_index(j)) * eigenvalues[j];
+      }
+      REQUIRE(compare(herm_mat, value, eps_threshold, eps_threshold));
     }
+  }
 }
 
-TEST_CASE( "Test_utils", "[check_polar_coords]" ) {
-    auto r = 1.0;
-    auto angle = M_PI_2;
-    auto r_2 = 1.0 + eps<double>();
-    auto angle_2 = M_PI_2 + eps<double>();
-
-    SECTION("Check 2 numbers that are equal"){
-        REQUIRE(check_polar_coords(r, angle, r_2, angle_2));
-    }
-
-    SECTION("Check 2 numbers that differ in absolute value"){
-        r_2 = r_2 + 1e3 * eps<double>();
-        REQUIRE(!check_polar_coords(r, angle, r_2, angle_2));
-    }
-
-    SECTION("Check 2 numbers that differ in absolute value"){
-        angle_2 = angle_2 + 1e3 * eps<double>();
-        REQUIRE(!check_polar_coords(r, angle, r_2, angle_2));
-    }
-
-    SECTION("Check corner case: close to +/-0 angles"){
-        angle = 0.0 - eps<double>()/2.;
-        angle_2 = -angle;
-        REQUIRE(check_polar_coords(r, angle, r_2, angle_2));
-    }
+TEST_CASE("Framework Utilities", "[almost_equal]") {
+  SECTION("The maximum difference between two scalars over 1.0 is greater than "
+          "epsilon, so they are amlmost equal") {
+    double first = 1.0 + eps<double>();
+    double actual = 1.0;
+    // Because the max_diff param is bigger than epsilon, this should be almost
+    // equal
+    REQUIRE(AER::Linalg::almost_equal(first, actual)); //, 1e-15, 1e-15));
+  }
+
+  SECTION("The difference between two scalars really close to 0 should say are "
+          "almost equal") {
+    double first = 5e-323; // Really close to the min magnitude of double
+    double actual = 6e-323;
+    REQUIRE(AER::Linalg::almost_equal(first, actual)); //, 1e-323, 1e-323));
+  }
+
+  SECTION("The maximum difference between two complex of doubles over 1.0 is "
+          "greater than epsilon, so they are almost equal") {
+    std::complex<double> first = {eps<double>() + double(1.0),
+                                  eps<double>() + double(1.0)};
+    std::complex<double> actual{1.0, 1.0};
+    // Because the max_diff param is bigger than epsilon, this should be almost
+    // equal
+    REQUIRE(AER::Linalg::almost_equal(first, actual)); //, 1e-15, 1e-15));
+  }
+
+  SECTION("The difference between two complex of doubles really close to 0 "
+          "should say are almost equal") {
+    std::complex<double> first = {
+        5e-323, 5e-323}; // Really close to the min magnitude of double
+    std::complex<double> actual = {6e-323, 6e-323};
+
+    REQUIRE(AER::Linalg::almost_equal(first, actual)); // 1e-323, 1e-323));
+  }
+}
 
-    SECTION("Check corner case: angle PI and angle -PI"){
-        angle = M_PI - eps<double>();
-        angle_2 = -angle;
-        REQUIRE(check_polar_coords(r, angle, r_2, angle_2));
-    }
+TEST_CASE("Test_utils", "[check_polar_coords]") {
+  auto r = 1.0;
+  auto angle = M_PI_2;
+  auto r_2 = 1.0 + eps<double>();
+  auto angle_2 = M_PI_2 + eps<double>();
+
+  SECTION("Check 2 numbers that are equal") {
+    REQUIRE(check_polar_coords(r, angle, r_2, angle_2));
+  }
+
+  SECTION("Check 2 numbers that differ in absolute value") {
+    r_2 = r_2 + 1e3 * eps<double>();
+    REQUIRE(!check_polar_coords(r, angle, r_2, angle_2));
+  }
+
+  SECTION("Check 2 numbers that differ in absolute value") {
+    angle_2 = angle_2 + 1e3 * eps<double>();
+    REQUIRE(!check_polar_coords(r, angle, r_2, angle_2));
+  }
+
+  SECTION("Check corner case: close to +/-0 angles") {
+    angle = 0.0 - eps<double>() / 2.;
+    angle_2 = -angle;
+    REQUIRE(check_polar_coords(r, angle, r_2, angle_2));
+  }
+
+  SECTION("Check corner case: angle PI and angle -PI") {
+    angle = M_PI - eps<double>();
+    angle_2 = -angle;
+    REQUIRE(check_polar_coords(r, angle, r_2, angle_2));
+  }
 }
 
 namespace {
-template<typename T>
-matrix<std::complex<T>> herm_mat_2d() {
-    auto mat = matrix<std::complex<T>>(2,2);
-    mat(0,0) = std::complex<T>(1.0,0.0);
-    mat(0,1) = std::complex<T>(1.0, 2.0);
-    mat(1,0) = std::complex<T>(1.0, -2.0);
-    mat(1,1) = std::complex<T>(0.5, 0.0);
-    return mat;
+template <typename T> matrix<std::complex<T>> herm_mat_2d() {
+  auto mat = matrix<std::complex<T>>(2, 2);
+  mat(0, 0) = std::complex<T>(1.0, 0.0);
+  mat(0, 1) = std::complex<T>(1.0, 2.0);
+  mat(1, 0) = std::complex<T>(1.0, -2.0);
+  mat(1, 1) = std::complex<T>(0.5, 0.0);
+  return mat;
 }
 
-template<typename T>
-matrix<std::complex<T>> herm_mat_2d_eigenvectors() {
-    auto mat = matrix<std::complex<T>>(2,2);
-    auto den = 3. * std::sqrt(5.);
-    mat(0,0) = std::complex<T>(-2/den, -4/den);
-    mat(1,0) = std::complex<T>(5/den, 0.0);
-    mat(0,1) = std::complex<T>(-1./3.,-2./3.);
-    mat(1,1) = std::complex<T>(-2./3.,0);
-    return mat;
+template <typename T> matrix<std::complex<T>> herm_mat_2d_eigenvectors() {
+  auto mat = matrix<std::complex<T>>(2, 2);
+  auto den = 3. * std::sqrt(5.);
+  mat(0, 0) = std::complex<T>(-2 / den, -4 / den);
+  mat(1, 0) = std::complex<T>(5 / den, 0.0);
+  mat(0, 1) = std::complex<T>(-1. / 3., -2. / 3.);
+  mat(1, 1) = std::complex<T>(-2. / 3., 0);
+  return mat;
 }
 
-
-template<typename T>
-std::vector<T> herm_mat_2d_eigenvalues(){
-    return { -1.5, 3.0 };
+template <typename T> std::vector<T> herm_mat_2d_eigenvalues() {
+  return {-1.5, 3.0};
 }
 
-template <typename T>
-scenarioData<T> get_herm_2d_scen(){
-    return {"Hermitian matrix 2x2", herm_mat_2d<T>(), herm_mat_2d_eigenvectors<T>(), herm_mat_2d_eigenvalues<T>()};
+template <typename T> scenarioData<T> get_herm_2d_scen() {
+  return {"Hermitian matrix 2x2", herm_mat_2d<T>(),
+          herm_mat_2d_eigenvectors<T>(), herm_mat_2d_eigenvalues<T>()};
 }
 
-template<typename T>
-matrix<std::complex<T>> psd_mat_2d(){
-    auto psd_matrix = matrix<std::complex<T>>(2, 2);
+template <typename T> matrix<std::complex<T>> psd_mat_2d() {
+  auto psd_matrix = matrix<std::complex<T>>(2, 2);
 
-    psd_matrix(0,0) = std::complex<T>(13., 0.);
-    psd_matrix(0,1) = std::complex<T>(0., 5.);
+  psd_matrix(0, 0) = std::complex<T>(13., 0.);
+  psd_matrix(0, 1) = std::complex<T>(0., 5.);
 
-    psd_matrix(1,0) = std::complex<T>(0., -5.);
-    psd_matrix(1,1) = std::complex<T>(2., 0.);
+  psd_matrix(1, 0) = std::complex<T>(0., -5.);
+  psd_matrix(1, 1) = std::complex<T>(2., 0.);
 
-    return psd_matrix;
+  return psd_matrix;
 }
 
-template<typename T>
-matrix<std::complex<T>> psd_mat_2d_eigenvectors(){
-    matrix<std::complex<T>> expected_eigenvectors(2, 2);
+template <typename T> matrix<std::complex<T>> psd_mat_2d_eigenvectors() {
+  matrix<std::complex<T>> expected_eigenvectors(2, 2);
 
-    expected_eigenvectors(0,0) = std::complex<T>(0,-0.3605966767761846214491);
-    expected_eigenvectors(0,1) = std::complex<T>(0,-0.9327218431547380506075);
+  expected_eigenvectors(0, 0) = std::complex<T>(0, -0.3605966767761846214491);
+  expected_eigenvectors(0, 1) = std::complex<T>(0, -0.9327218431547380506075);
 
-    expected_eigenvectors(1,0) = std::complex<T>(0.9327218431547380506075,0);
-    expected_eigenvectors(1,1) = std::complex<T>(-0.3605966767761846214491,0);
+  expected_eigenvectors(1, 0) = std::complex<T>(0.9327218431547380506075, 0);
+  expected_eigenvectors(1, 1) = std::complex<T>(-0.3605966767761846214491, 0);
 
-    return expected_eigenvectors;
+  return expected_eigenvectors;
 }
 
-template<typename T>
-std::vector<T> psd_mat_2d_eigenvalues(){
-    return {0.06696562634074720854471252, 14.93303437365925212532147};
+template <typename T> std::vector<T> psd_mat_2d_eigenvalues() {
+  return {0.06696562634074720854471252, 14.93303437365925212532147};
 }
 
-template <typename T>
-scenarioData<T> get_psd_2d_scen(){
-    return {"PSD matrix 2x2", psd_mat_2d<T>(), psd_mat_2d_eigenvectors<T>(), psd_mat_2d_eigenvalues<T>()};
+template <typename T> scenarioData<T> get_psd_2d_scen() {
+  return {"PSD matrix 2x2", psd_mat_2d<T>(), psd_mat_2d_eigenvectors<T>(),
+          psd_mat_2d_eigenvalues<T>()};
 }
 
-template<typename T>
-matrix<std::complex<T>> psd_mat_2d_with_zero(){
-    auto psd_matrix = matrix<std::complex<T>>(2, 2);
+template <typename T> matrix<std::complex<T>> psd_mat_2d_with_zero() {
+  auto psd_matrix = matrix<std::complex<T>>(2, 2);
 
-    psd_matrix(0,0) = std::complex<T>(1., 0.);
-    psd_matrix(0,1) = std::complex<T>(2., 0.);
+  psd_matrix(0, 0) = std::complex<T>(1., 0.);
+  psd_matrix(0, 1) = std::complex<T>(2., 0.);
 
-    psd_matrix(1,0) = std::complex<T>(2., 0.);
-    psd_matrix(1,1) = std::complex<T>(4., 0.);
+  psd_matrix(1, 0) = std::complex<T>(2., 0.);
+  psd_matrix(1, 1) = std::complex<T>(4., 0.);
 
-    return psd_matrix;
+  return psd_matrix;
 }
 
-template<typename T>
-matrix<std::complex<T>> psd_mat_2d_wiht_zero_eigenvectors(){
-    matrix<std::complex<T>> expected_eigenvectors(2, 2);
+template <typename T>
+matrix<std::complex<T>> psd_mat_2d_wiht_zero_eigenvectors() {
+  matrix<std::complex<T>> expected_eigenvectors(2, 2);
 
-    expected_eigenvectors(0,0) = std::complex<T>(-2./std::sqrt(5.),0);
-    expected_eigenvectors(0,1) = std::complex<T>(1./std::sqrt(5.),0);
+  expected_eigenvectors(0, 0) = std::complex<T>(-2. / std::sqrt(5.), 0);
+  expected_eigenvectors(0, 1) = std::complex<T>(1. / std::sqrt(5.), 0);
 
-    expected_eigenvectors(1,0) = std::complex<T>(1./std::sqrt(5.),0);
-    expected_eigenvectors(1,1) = std::complex<T>(2./std::sqrt(5.),0);
+  expected_eigenvectors(1, 0) = std::complex<T>(1. / std::sqrt(5.), 0);
+  expected_eigenvectors(1, 1) = std::complex<T>(2. / std::sqrt(5.), 0);
 
-    return expected_eigenvectors;
+  return expected_eigenvectors;
 }
 
-template<typename T>
-std::vector<T> psd_mat_2d_wiht_zero_eigenvalues(){
-    return {0.0, 5.0};
+template <typename T> std::vector<T> psd_mat_2d_wiht_zero_eigenvalues() {
+  return {0.0, 5.0};
 }
 
-template <typename T>
-scenarioData<T> get_psd_mat_2d_wiht_zero_scen(){
-    return {"PSD matrix 2x2 with a zero eigen value", psd_mat_2d_with_zero<T>(), psd_mat_2d_wiht_zero_eigenvectors<T>(), psd_mat_2d_wiht_zero_eigenvalues<T>()};
+template <typename T> scenarioData<T> get_psd_mat_2d_wiht_zero_scen() {
+  return {"PSD matrix 2x2 with a zero eigen value", psd_mat_2d_with_zero<T>(),
+          psd_mat_2d_wiht_zero_eigenvectors<T>(),
+          psd_mat_2d_wiht_zero_eigenvalues<T>()};
 }
 
 template <typename T>
-bool check_polar_coords(T r, T angle, T r_2, T angle_2, T max_diff, T max_relative_diff){
-    if(!AER::Linalg::almost_equal(r, r_2, max_diff, max_relative_diff)) return false;
-    if(!AER::Linalg::almost_equal(angle, angle_2, max_diff, max_relative_diff)){
-        // May be corner case with PI and -PI
-        T angle_plus = angle > 0. ? angle : angle + 2*M_PI;
-        T angle_2_plus = angle_2 > 0. ? angle_2 : angle_2 + 2 * M_PI;
-        if(!AER::Linalg::almost_equal(angle_plus, angle_2_plus, max_diff, max_relative_diff)) return false;
-    }
-    return true;
+bool check_polar_coords(T r, T angle, T r_2, T angle_2, T max_diff,
+                        T max_relative_diff) {
+  if (!AER::Linalg::almost_equal(r, r_2, max_diff, max_relative_diff))
+    return false;
+  if (!AER::Linalg::almost_equal(angle, angle_2, max_diff, max_relative_diff)) {
+    // May be corner case with PI and -PI
+    T angle_plus = angle > 0. ? angle : angle + 2 * M_PI;
+    T angle_2_plus = angle_2 > 0. ? angle_2 : angle_2 + 2 * M_PI;
+    if (!AER::Linalg::almost_equal(angle_plus, angle_2_plus, max_diff,
+                                   max_relative_diff))
+      return false;
+  }
+  return true;
 }
 
 template <typename T>
-bool check_eigenvector(const std::vector<std::complex<T>>& expected_eigen,
-                       const std::vector<std::complex<T>>& actual_eigen,
-                       T max_diff,
-                       T max_relative_diff){
-    auto div = expected_eigen[0] / actual_eigen[0];
-    T r = std::abs(div);
-    T angle = std::arg(div);
-    for (size_t j = 1; j < expected_eigen.size(); j++) {
-        auto div_2 = expected_eigen[j] / actual_eigen[j];
-        T r_2 = std::abs(div_2);
-        T angle_2 = std::arg(div_2);
-        // Check that factor is consistent across components
-        if (!check_polar_coords(r, angle, r_2, angle_2, max_diff, max_relative_diff)) {
-            return false;
-        }
+bool check_eigenvector(const std::vector<std::complex<T>> &expected_eigen,
+                       const std::vector<std::complex<T>> &actual_eigen,
+                       T max_diff, T max_relative_diff) {
+  auto div = expected_eigen[0] / actual_eigen[0];
+  T r = std::abs(div);
+  T angle = std::arg(div);
+  for (size_t j = 1; j < expected_eigen.size(); j++) {
+    auto div_2 = expected_eigen[j] / actual_eigen[j];
+    T r_2 = std::abs(div_2);
+    T angle_2 = std::arg(div_2);
+    // Check that factor is consistent across components
+    if (!check_polar_coords(r, angle, r_2, angle_2, max_diff,
+                            max_relative_diff)) {
+      return false;
     }
-    return true;
+  }
+  return true;
 }
 
 template <typename T>
-bool check_all_eigenvectors(const matrix<std::complex<T>>& expected,
-                            const matrix<std::complex<T>>& actual,
-                            T max_diff,
+bool check_all_eigenvectors(const matrix<std::complex<T>> &expected,
+                            const matrix<std::complex<T>> &actual, T max_diff,
                             T max_relative_diff) {
-    auto col_num = expected.GetColumns();
-    if (expected.size() != actual.size() || expected.GetColumns() != expected.GetColumns()) {
-        return false;
-    }
-    for (size_t i = 0; i < col_num; i++) {
-        auto expected_eigen = expected.col_index(i);
-        auto actual_eigen = actual.col_index(i);
-
-        if(!check_eigenvector(expected_eigen, actual_eigen, max_diff, max_relative_diff)){
-            std::cout << "Expected: " << std::setprecision(16) << expected << std::endl;
-            std::cout << "Actual: " << actual << std::endl;
-            return false;
-        }
+  auto col_num = expected.GetColumns();
+  if (expected.size() != actual.size() ||
+      expected.GetColumns() != expected.GetColumns()) {
+    return false;
+  }
+  for (size_t i = 0; i < col_num; i++) {
+    auto expected_eigen = expected.col_index(i);
+    auto actual_eigen = actual.col_index(i);
+
+    if (!check_eigenvector(expected_eigen, actual_eigen, max_diff,
+                           max_relative_diff)) {
+      std::cout << "Expected: " << std::setprecision(16) << expected
+                << std::endl;
+      std::cout << "Actual: " << actual << std::endl;
+      return false;
     }
-    return true;
+  }
+  return true;
 }
-}
\ No newline at end of file
+} // namespace
\ No newline at end of file
diff --git a/test/src/test_snapshot.cpp b/test/src/test_snapshot.cpp
index 68de70b71e..cd7d309b7d 100644
--- a/test/src/test_snapshot.cpp
+++ b/test/src/test_snapshot.cpp
@@ -1,46 +1,40 @@
 #define CATCH_CONFIG_MAIN
-#include <map>
 #include <catch2/catch.hpp>
+#include <map>
 
 #include <controllers/qasm_controller.hpp>
 
 #include "utils.hpp"
 
-namespace AER{
-namespace Test{
+namespace AER {
+namespace Test {
 
-TEST_CASE( "Simulators Snapshot", "[snaphot]" ) {
-    std::map<std::string, json_t> qobj_snapshots;
-    qobj_snapshots["state"] =
-        AER::Test::Utilities::load_qobj("../../test/data/qobj_snapshot_statevector.json");
-    qobj_snapshots["probs"] =
-        AER::Test::Utilities::load_qobj("../../test/data/qobj_snapshot_probs.json");
-    qobj_snapshots["pauli"] =
-        AER::Test::Utilities::load_qobj("../../test/data/qobj_snapshot_expval_pauli.json");
-    qobj_snapshots["matrix"] =
-        AER::Test::Utilities::load_qobj("../../test/data/qobj_snapshot_expval_matrix.json");
+TEST_CASE("Simulators Snapshot", "[snaphot]") {
+  std::map<std::string, json_t> qobj_snapshots;
+  qobj_snapshots["state"] = AER::Test::Utilities::load_qobj(
+      "../../test/data/qobj_snapshot_statevector.json");
+  qobj_snapshots["probs"] = AER::Test::Utilities::load_qobj(
+      "../../test/data/qobj_snapshot_probs.json");
+  qobj_snapshots["pauli"] = AER::Test::Utilities::load_qobj(
+      "../../test/data/qobj_snapshot_expval_pauli.json");
+  qobj_snapshots["matrix"] = AER::Test::Utilities::load_qobj(
+      "../../test/data/qobj_snapshot_expval_matrix.json");
 
-    AER::Simulator::QasmController sim{};
+  AER::Simulator::QasmController sim{};
 
-    SECTION( "State simulator snapshot" ) {
-        auto expected_result = R"({
+  SECTION("State simulator snapshot") {
+    auto expected_result = R"({
                 "final":[[[0.7071067811865476,0.0],[0.0,0.0],[0.0,0.0],[0.7071067811865475,0.0]]],
                 "initial":[[[1.0,0.0],[0.0,0.0],[0.0,0.0],[0.0,0.0]]],
                 "middle":[[[0.7071067811865476,0.0],[0.7071067811865475,0.0],[0.0,0.0],[0.0,0.0]]]
             })"_json;
-        auto result = sim.execute(qobj_snapshots["state"]);
-        result = result["results"][0]["data"]["snapshots"]["state"];
-        REQUIRE(result == expected_result);
-    }
-    SECTION( "Probs simulator snapshot" ) {
-        REQUIRE(false);
-    }
-    SECTION( "Pauli simulator snaphsot" ) {
-        REQUIRE(false);
-    }
-    SECTION( "Unitary simulator snapshot" ) {
-        REQUIRE(false);
-    }
+    auto result = sim.execute(qobj_snapshots["state"]);
+    result = result["results"][0]["data"]["snapshots"]["state"];
+    REQUIRE(result == expected_result);
+  }
+  SECTION("Probs simulator snapshot") { REQUIRE(false); }
+  SECTION("Pauli simulator snaphsot") { REQUIRE(false); }
+  SECTION("Unitary simulator snapshot") { REQUIRE(false); }
 }
 
 //------------------------------------------------------------------------------
diff --git a/test/src/test_snapshot_bdd.cpp b/test/src/test_snapshot_bdd.cpp
index b5537d0afa..b967831a0d 100644
--- a/test/src/test_snapshot_bdd.cpp
+++ b/test/src/test_snapshot_bdd.cpp
@@ -1,52 +1,45 @@
 #define CATCH_CONFIG_MAIN
-#include <map>
 #include <catch2/catch.hpp>
+#include <map>
 
 #include <controllers/qasm_controller.hpp>
 
 #include "utils.hpp"
 
-namespace AER{
-namespace Test{
+namespace AER {
+namespace Test {
 
 SCENARIO("We can get snapshots from different simulator types") {
-    GIVEN("A Qobj with snapshot information for every simulator type"){
-
-        std::map<std::string, json_t> qobj_snapshots;
-        qobj_snapshots["state"] =
-            AER::Test::Utilities::load_qobj("../../test/data/qobj_snapshot_statevector.json");
-        qobj_snapshots["probs"] =
-            AER::Test::Utilities::load_qobj("../../test/data/qobj_snapshot_probs.json");
-        qobj_snapshots["pauli"] =
-            AER::Test::Utilities::load_qobj("../../test/data/qobj_snapshot_expval_pauli.json");
-        qobj_snapshots["matrix"] =
-            AER::Test::Utilities::load_qobj("../../test/data/qobj_snapshot_expval_matrix.json");
-
-        AER::Simulator::QasmController sim{};
-
-        WHEN("we get the expected results"){
-            auto expected_result = R"({
+  GIVEN("A Qobj with snapshot information for every simulator type") {
+
+    std::map<std::string, json_t> qobj_snapshots;
+    qobj_snapshots["state"] = AER::Test::Utilities::load_qobj(
+        "../../test/data/qobj_snapshot_statevector.json");
+    qobj_snapshots["probs"] = AER::Test::Utilities::load_qobj(
+        "../../test/data/qobj_snapshot_probs.json");
+    qobj_snapshots["pauli"] = AER::Test::Utilities::load_qobj(
+        "../../test/data/qobj_snapshot_expval_pauli.json");
+    qobj_snapshots["matrix"] = AER::Test::Utilities::load_qobj(
+        "../../test/data/qobj_snapshot_expval_matrix.json");
+
+    AER::Simulator::QasmController sim{};
+
+    WHEN("we get the expected results") {
+      auto expected_result = R"({
                 "final":[[[0.7071067811865476,0.0],[0.0,0.0],[0.0,0.0],[0.7071067811865475,0.0]]],
                 "initial":[[[1.0,0.0],[0.0,0.0],[0.0,0.0],[0.0,0.0]]],
                 "middle":[[[0.7071067811865476,0.0],[0.7071067811865475,0.0],[0.0,0.0],[0.0,0.0]]]
             })"_json;
-            THEN("the state simulator should pass"){
-                auto result = sim.execute(qobj_snapshots["state"]);
-                result = result["results"][0]["data"]["snapshots"]["state"];
-                REQUIRE(result == expected_result);
-            }
-            THEN("the probs simulator should pass"){
-                REQUIRE(false);
-            }
-            THEN("the pauli simulator should pass"){
-                REQUIRE(false);
-            }
-            THEN("the unitary matrix simulator should pass"){
-                REQUIRE(false);
-            }
-        }
-
+      THEN("the state simulator should pass") {
+        auto result = sim.execute(qobj_snapshots["state"]);
+        result = result["results"][0]["data"]["snapshots"]["state"];
+        REQUIRE(result == expected_result);
+      }
+      THEN("the probs simulator should pass") { REQUIRE(false); }
+      THEN("the pauli simulator should pass") { REQUIRE(false); }
+      THEN("the unitary matrix simulator should pass") { REQUIRE(false); }
     }
+  }
 }
 
 //------------------------------------------------------------------------------
diff --git a/test/src/utils.hpp b/test/src/utils.hpp
index e7f659509c..ca60efa743 100644
--- a/test/src/utils.hpp
+++ b/test/src/utils.hpp
@@ -12,111 +12,115 @@
  * that they have been altered from the originals.
  */
 
-
-#include <string>
 #include "framework/json.hpp"
+#include <string>
 
 #include <catch2/catch.hpp>
 
 namespace Catch {
-    template <typename T>
-    std::string convertMyTypeToString(const std::vector<T> &value) {
-        std::stringstream oss;
-        oss << value;
-        return oss.str();
-    }
+template <typename T>
+std::string convertMyTypeToString(const std::vector<T> &value) {
+  std::stringstream oss;
+  oss << value;
+  return oss.str();
+}
 
-    template <typename T> struct StringMaker<std::vector<T>> {
-        static std::string convert(const std::vector<AER::complex_t> &value) {
-            return convertMyTypeToString(value);
-        }
-    };
+template <typename T> struct StringMaker<std::vector<T>> {
+  static std::string convert(const std::vector<AER::complex_t> &value) {
+    return convertMyTypeToString(value);
+  }
+};
 } // namespace Catch
 
-
-namespace AER{
-namespace Test{
+namespace AER {
+namespace Test {
 namespace Utilities {
-    inline json_t load_qobj(const std::string& filename){
-        return JSON::load(filename);
-    }
+inline json_t load_qobj(const std::string &filename) {
+  return JSON::load(filename);
+}
 
-    template<typename T>
-    T calculate_floats(T start, T decrement, int count){
-        for (int i = 0; i < count; ++i)
-            start -= decrement;
-        return start;
-    }
+template <typename T> T calculate_floats(T start, T decrement, int count) {
+  for (int i = 0; i < count; ++i)
+    start -= decrement;
+  return start;
+}
 
-    template<typename T, typename U>
-    bool _compare(const matrix<T> &lhs, const matrix<T> &rhs, U max_diff = std::numeric_limits<U>::epsilon(),
-                  U max_relative_diff = std::numeric_limits<U>::epsilon()) {
-        bool res = true;
-        std::ostringstream message;
-        if (lhs.size() != rhs.size()) {
-            res = false;
-        }
+template <typename T, typename U>
+bool _compare(const matrix<T> &lhs, const matrix<T> &rhs,
+              U max_diff = std::numeric_limits<U>::epsilon(),
+              U max_relative_diff = std::numeric_limits<U>::epsilon()) {
+  bool res = true;
+  std::ostringstream message;
+  if (lhs.size() != rhs.size()) {
+    res = false;
+  }
 
-        for (size_t i = 0; i < lhs.GetRows(); ++i) {
-            for (size_t j = 0; j < lhs.GetColumns(); ++j) {
-                if (!(AER::Linalg::almost_equal(lhs(i, j), rhs(i, j), max_diff, max_relative_diff))) {
-                    message << "Matrices differ at element: (" << i << ", " << j << ")"
-                            << std::setprecision(22) << ". [" << lhs(i, j)
-                            << "] != [" << rhs(i, j) << "]\n";
-                    res = false;
-                }
-            }
-        }
-        if (!res) {
-            message << "Matrices differ: " << lhs
-                    << " != " << rhs << std::endl;
-            std::cout << message.str();
-        }
-        return res;
+  for (size_t i = 0; i < lhs.GetRows(); ++i) {
+    for (size_t j = 0; j < lhs.GetColumns(); ++j) {
+      if (!(AER::Linalg::almost_equal(lhs(i, j), rhs(i, j), max_diff,
+                                      max_relative_diff))) {
+        message << "Matrices differ at element: (" << i << ", " << j << ")"
+                << std::setprecision(22) << ". [" << lhs(i, j) << "] != ["
+                << rhs(i, j) << "]\n";
+        res = false;
+      }
     }
+  }
+  if (!res) {
+    message << "Matrices differ: " << lhs << " != " << rhs << std::endl;
+    std::cout << message.str();
+  }
+  return res;
+}
 
-    template<typename T>
-    bool compare(const matrix<T> &lhs, const matrix<T> &rhs, T max_diff = std::numeric_limits<T>::epsilon(),
-                 T max_relative_diff = std::numeric_limits<T>::epsilon()) {
-        return _compare(lhs, rhs, max_diff, max_relative_diff);
-    }
+template <typename T>
+bool compare(const matrix<T> &lhs, const matrix<T> &rhs,
+             T max_diff = std::numeric_limits<T>::epsilon(),
+             T max_relative_diff = std::numeric_limits<T>::epsilon()) {
+  return _compare(lhs, rhs, max_diff, max_relative_diff);
+}
 
-    template<typename T>
-    bool compare(const matrix<std::complex<T>> &lhs, const matrix<std::complex<T>> &rhs,
-                 T max_diff = std::numeric_limits<T>::epsilon(),
-                 T max_relative_diff = std::numeric_limits<T>::epsilon()) {
-        return _compare(lhs, rhs, max_diff, max_relative_diff);
-    }
+template <typename T>
+bool compare(const matrix<std::complex<T>> &lhs,
+             const matrix<std::complex<T>> &rhs,
+             T max_diff = std::numeric_limits<T>::epsilon(),
+             T max_relative_diff = std::numeric_limits<T>::epsilon()) {
+  return _compare(lhs, rhs, max_diff, max_relative_diff);
+}
 
-    template<typename T, typename U>
-    bool _compare(const std::vector<T> &lhs, const std::vector<T> &rhs, U max_diff = std::numeric_limits<U>::epsilon(),
-                  U max_relative_diff = std::numeric_limits<U>::epsilon()) {
-        if (lhs.size() != rhs.size())
-            return false;
-        for (size_t i = 0; i < lhs.size(); ++i) {
-            if (!(AER::Linalg::almost_equal(lhs[i], rhs[i], max_diff, max_relative_diff))) {
-                std::cout << "Vectors differ at element: " << i << std::setprecision(22) << ". [" << lhs[i]
-                          << "] != [" << rhs[i] << "]\n";
-                std::cout << "Vectors differ: " << Catch::convertMyTypeToString(lhs)
-                          << " != " << Catch::convertMyTypeToString(rhs) << std::endl;
-                return false;
-            }
-        }
-        return true;
+template <typename T, typename U>
+bool _compare(const std::vector<T> &lhs, const std::vector<T> &rhs,
+              U max_diff = std::numeric_limits<U>::epsilon(),
+              U max_relative_diff = std::numeric_limits<U>::epsilon()) {
+  if (lhs.size() != rhs.size())
+    return false;
+  for (size_t i = 0; i < lhs.size(); ++i) {
+    if (!(AER::Linalg::almost_equal(lhs[i], rhs[i], max_diff,
+                                    max_relative_diff))) {
+      std::cout << "Vectors differ at element: " << i << std::setprecision(22)
+                << ". [" << lhs[i] << "] != [" << rhs[i] << "]\n";
+      std::cout << "Vectors differ: " << Catch::convertMyTypeToString(lhs)
+                << " != " << Catch::convertMyTypeToString(rhs) << std::endl;
+      return false;
     }
+  }
+  return true;
+}
 
-    template<typename T>
-    bool compare(const std::vector<T> &lhs, const std::vector<T> &rhs, T max_diff = std::numeric_limits<T>::epsilon(),
-                 T max_relative_diff = std::numeric_limits<T>::epsilon()) {
-        return _compare(lhs, rhs, max_diff, max_relative_diff);
-    }
+template <typename T>
+bool compare(const std::vector<T> &lhs, const std::vector<T> &rhs,
+             T max_diff = std::numeric_limits<T>::epsilon(),
+             T max_relative_diff = std::numeric_limits<T>::epsilon()) {
+  return _compare(lhs, rhs, max_diff, max_relative_diff);
+}
 
-    template<typename T>
-    bool compare(const std::vector<std::complex<T>> &lhs, const std::vector<std::complex<T>> &rhs,
-                 T max_diff = std::numeric_limits<T>::epsilon(),
-                 T max_relative_diff = std::numeric_limits<T>::epsilon()) {
-        return _compare(lhs, rhs, max_diff, max_relative_diff);
-    }
-} // End of Utilities namespace
-} // End of Test namespace
-} // End of AER namspace
\ No newline at end of file
+template <typename T>
+bool compare(const std::vector<std::complex<T>> &lhs,
+             const std::vector<std::complex<T>> &rhs,
+             T max_diff = std::numeric_limits<T>::epsilon(),
+             T max_relative_diff = std::numeric_limits<T>::epsilon()) {
+  return _compare(lhs, rhs, max_diff, max_relative_diff);
+}
+} // namespace Utilities
+} // namespace Test
+} // namespace AER
\ No newline at end of file