docs: def to_unitary_matrix(
              self,
              qubit_order: ops.QubitOrderOrList = ops.QubitOrder.DEFAULT,
              qubits_that_should_be_present: Iterable[ops.Qid] = (),
              ignore_terminal_measurements: bool = True,
              dtype: Type[np.number] = np.complex128) -> np.ndarray:
          """Converts the circuit into a unitary matrix, if possible.
  
          Args:
              qubit_order: Determines how qubits are ordered when passing matrices
                  into np.kron.
              qubits_that_should_be_present: Qubits that may or may not appear
                  in operations within the circuit, but that should be included
                  regardless when generating the matrix.
              ignore_terminal_measurements: When set, measurements at the end of
                  the circuit are ignored instead of causing the method to
                  fail.
              dtype: The numpy dtype for the returned unitary. Defaults to
                  np.complex128. Specifying np.complex64 will run faster at the
                  cost of precision. `dtype` must be a complex np.dtype, unless
                  all operations in the circuit have unitary matrices with
                  exclusively real coefficients (e.g. an H + TOFFOLI circuit).
  
          Returns:
              A (possibly gigantic) 2d numpy array corresponding to a matrix
              equivalent to the circuit's effect on a quantum state.
  
          Raises:
              ValueError: The circuit contains measurement gates that are not
                  ignored.
              TypeError: The circuit contains gates that don't have a known
                  unitary matrix, e.g. gates parameterized by a Symbol.
          """
  
          if not ignore_terminal_measurements and any(
                  protocols.is_measurement(op)
                  for op in self.all_operations()):
              raise ValueError('Circuit contains a measurement.')
  
          if not self.are_all_measurements_terminal():
              raise ValueError('Circuit contains a non-terminal measurement.')
  
          qs = ops.QubitOrder.as_qubit_order(qubit_order).order_for(
              self.all_qubits().union(qubits_that_should_be_present))
          n = len(qs)
  
          state = np.eye(1 << n, dtype=np.complex128)
          state.shape = (2,) * (2 * n)
  
          result = _apply_unitary_circuit(self, state, qs, dtype)
          return result.reshape((1 << n, 1 << n))