Esempio n. 1
0
    def __str__(self) -> str:
        diagram = cirq.TextDiagramDrawer()

        qubits = cast(Set[cirq.GridQubit], self._metadata.qubit_set)

        # Don't print out extras newlines if the row/col doesn't start at 0
        min_col = min(q.col for q in qubits)
        min_row = min(q.row for q in qubits)

        for q in qubits:
            diagram.write(q.col - min_col, q.row - min_row, str(q))

        # Find pairs that are connected by two-qubit gates.
        Pair = Tuple[cirq.GridQubit, cirq.GridQubit]
        pairs = sorted(
            {cast(Pair, tuple(pair))
             for pair in self._metadata.qubit_pairs})

        # Draw lines between connected pairs. Limit to horizontal/vertical
        # lines since that is all the diagram drawer can handle.
        for q1, q2 in pairs:
            if q1.row == q2.row or q1.col == q2.col:
                diagram.grid_line(q1.col - min_col, q1.row - min_row,
                                  q2.col - min_col, q2.row - min_row)

        return diagram.render(horizontal_spacing=3,
                              vertical_spacing=2,
                              use_unicode_characters=True)
Esempio n. 2
0
    def __str__(self) -> str:
        # If all qubits are grid qubits, render an appropriate text diagram.
        if all(isinstance(q, cirq.GridQubit) for q in self.qubits):
            diagram = cirq.TextDiagramDrawer()

            qubits = cast(List[cirq.GridQubit], self.qubits)

            # Don't print out extras newlines if the row/col doesn't start at 0
            min_col = min(q.col for q in qubits)
            min_row = min(q.row for q in qubits)

            for q in qubits:
                diagram.write(q.col - min_col, q.row - min_row, str(q))

            # Find pairs that are connected by two-qubit gates.
            Pair = Tuple[cirq.GridQubit, cirq.GridQubit]
            pairs = {
                cast(Pair, pair)
                for gate_defs in self.gate_definitions.values()
                for gate_def in gate_defs if gate_def.number_of_qubits == 2
                for pair in gate_def.target_set if len(pair) == 2
            }

            # Draw lines between connected pairs. Limit to horizontal/vertical
            # lines since that is all the diagram drawer can handle.
            for q1, q2 in sorted(pairs):
                if q1.row == q2.row or q1.col == q2.col:
                    diagram.grid_line(q1.col - min_col, q1.row - min_row,
                                      q2.col - min_col, q2.row - min_row)

            return diagram.render(horizontal_spacing=3,
                                  vertical_spacing=2,
                                  use_unicode_characters=True)

        return super().__str__()
Esempio n. 3
0
    def __str__(self) -> str:
        diagram = cirq.TextDiagramDrawer()

        for q in self.qubits:
            diagram.write(q.col, q.row, str(q))
            for q2 in self.neighbors_of(q):
                diagram.grid_line(q.col, q.row, q2.col, q2.row)

        return diagram.render(horizontal_spacing=3, vertical_spacing=2, use_unicode_characters=True)
Esempio n. 4
0
    def __str__(self) -> str:
        diagram = cirq.TextDiagramDrawer()
        dx = min(q.col for q in self)
        dy = min(q.row for q in self)

        for q in self:
            diagram.write(q.col - dx, q.row - dy, str(q))

        for q1, q2 in zip(self, self[1:]):
            diagram.grid_line(q1.col - dx, q1.row - dy, q2.col - dx,
                              q2.row - dy, True)

        return diagram.render(horizontal_spacing=2,
                              vertical_spacing=1,
                              use_unicode_characters=True)
Esempio n. 5
0
def _draw_chains(up_qubits: List[cirq.GridQubit],
                 down_qubits: List[cirq.GridQubit],
                 interactions: List[Tuple[cirq.GridQubit, cirq.GridQubit]],
                 draw_grid_coords: bool) -> str:
    def qubit_coords(qubit: cirq.GridQubit) -> Tuple[int, int]:
        return qubit.col - min_col, qubit.row - min_row

    diagram = cirq.TextDiagramDrawer()

    min_col = min(qubit.col for qubit in up_qubits + down_qubits)
    min_row = min(qubit.row for qubit in up_qubits + down_qubits)

    last_col, last_row = None, None

    for index, qubit in enumerate(up_qubits):
        col, row = qubit_coords(qubit)
        label = f'{index + 1}↑'
        if draw_grid_coords:
            label += f' {str(qubit)}'
        diagram.write(col, row, label)
        if index:
            diagram.grid_line(last_col, last_row, col, row)
        last_col, last_row = col, row

    for index, qubit in enumerate(down_qubits):
        col, row = qubit_coords(qubit)
        label = f'{index + 1}↓'
        if draw_grid_coords:
            label += f' {str(qubit)}'
        diagram.write(col, row, label)
        if index:
            diagram.grid_line(last_col, last_row, col, row)
        last_col, last_row = col, row

    for a, b in interactions:
        diagram.grid_line(*qubit_coords(a), *qubit_coords(b), emphasize=True)

    return diagram.render(horizontal_spacing=3 if draw_grid_coords else 2,
                          vertical_spacing=2 if draw_grid_coords else 1,
                          use_unicode_characters=True)