Function to_chain_structure has a Cognitive Complexity of 141 (exceeds 20 allowed). Consider refactoring.

Open

def to_chain_structure(qc, setup="linear"):
    """
    Method to resolve 2 qubit gates with non-adjacent control/s or target/s
    in terms of gates with adjacent interactions for linear/circular spin
    chain system.

• Read up
  Read up

Function latex_code has a Cognitive Complexity of 95 (exceeds 20 allowed). Consider refactoring.

Open

    def latex_code(self):
        """
        Generate the latex code for the circuit.
 
        Returns

• Read up
  Read up

Function _regs_processor has a Cognitive Complexity of 50 (exceeds 20 allowed). Consider refactoring.

Open

    def _regs_processor(self, regs, reg_type):
        """
        Process register tokens: map them to the :class:`.QubitCircuit` indices
        of the respective registers.
 
 

• Read up
  Read up

Function adjacent_gates has a Cognitive Complexity of 41 (exceeds 20 allowed). Consider refactoring.

Open

    def adjacent_gates(self):
        """
        Method to resolve two qubit gates with non-adjacent control/s or
        target/s in terms of gates with adjacent interactions.
 
 

• Read up
  Read up

Function resolve_gates has a Cognitive Complexity of 39 (exceeds 20 allowed). Consider refactoring.

Open

    def resolve_gates(self, basis=["CNOT", "RX", "RY", "RZ"]):
        """
        Unitary matrix calculator for N qubits returning the individual
        steps as unitary matrices operating from left to right in the specified
        basis.

• Read up
  Read up

Function get_compact_qobj has a Cognitive Complexity of 34 (exceeds 20 allowed). Consider refactoring.

Open

    def get_compact_qobj(self):
        """
        Get the compact :class:`qutip.Qobj` representation of the gate
        operator, ignoring the controls and targets.
        In the unitary representation,

• Read up
  Read up

Function _initialize_pass has a Cognitive Complexity of 32 (exceeds 20 allowed). Consider refactoring.

Open

    def _initialize_pass(self):
        """
        Passes through the tokenized commands, create QasmGate objects for
        each user-defined gate, process register declarations.
        """

• Read up
  Read up

Function layout has a Cognitive Complexity of 30 (exceeds 20 allowed). Consider refactoring.

Open

    def layout(self):
        """
        Layout the circuit
        """
        self._add_wire_labels()

• Read up
  Read up

Function remove_gate_or_measurement has a Cognitive Complexity of 29 (exceeds 20 allowed). Consider refactoring.

Open

    def remove_gate_or_measurement(
        self, index=None, end=None, name=None, remove="first"
    ):
        """
        Remove a gate from a specific index or between two indexes or the

• Read up
  Read up

Function schedule has a Cognitive Complexity of 26 (exceeds 20 allowed). Consider refactoring.

Open

    def schedule(
        self,
        circuit,
        gates_schedule=False,
        return_cycles_list=False,

• Read up
  Read up

Function run_state has a Cognitive Complexity of 25 (exceeds 20 allowed). Consider refactoring.

Open

    def run_state(
        self,
        init_state=None,
        analytical=False,
        states=None,

• Read up
  Read up

Function canvas_plot has a Cognitive Complexity of 24 (exceeds 20 allowed). Consider refactoring.

Open

    def canvas_plot(self) -> None:
        """
        Plot the quantum circuit.
        """
 
 

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                    if (
                        N + start - end - i - i == 1
                        and (N - end + start + 1) % 2 == 0
                    ):
                        if end == gate.controls[0]:

Avoid deeply nested control flow statements.

Open

                        if end == gate.controls[0]:
                            temp.gates.append(
                                Gate(gate.name, targets=[i], controls=[i + 1])
                            )
                        else:

Avoid deeply nested control flow statements.

Open

                        if end == gate.controls[0]:
                            temp.gates.append(
                                Gate(
                                    gate.name,
                                    targets=[i + 1],

Function _update_qbridge has a Cognitive Complexity of 23 (exceeds 20 allowed). Consider refactoring.

Open

    def _update_qbridge(
        self,
        gate: Gate,
        wire_list_control: List[int],
        width: int,

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                    if (
                        N + start - end - i - i == 1
                        and (N - end + start + 1) % 2 == 0
                    ):
                        temp.add_gate(gate.name, [i, i + 1])

Avoid deeply nested control flow statements.

Open

                    if start + end - i - i == 1 and (end - start + 1) % 2 == 0:
                        # Apply required gate if control and target are
                        # adjacent to each other, provided |control-target|
                        # is even.
                        if end == gate.controls[0]:

Avoid deeply nested control flow statements.

Open

                    if j < N - end - 2:
                        if gate.name in ["CNOT", "CSIGN"]:
                            qc_t.add_gate(
                                gate.name,
                                end + gate.targets[0],

Avoid deeply nested control flow statements.

Open

                        if len(gate.targets) > 1:
                            if gate.name == "SWAP":
                                if _swap_processing:
                                    col.append(r" \qswap \qw")
                                    continue