



import math

import numpy as np
import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute

def 	_lowerCAmelCase (    A__ = 3						):
      if isinstance(A__    ,	A__						):
            raise TypeError('number of qubits must be a integer.'						)
      if number_of_qubits <= 0:
            raise ValueError('number of qubits must be > 0.'						)
      if math.floor(A__						) != number_of_qubits:
            raise ValueError('number of qubits must be exact integer.'						)
      if number_of_qubits > 10:
            raise ValueError('number of qubits too large to simulate(>10).'						)

      lowercase__  =	QuantumRegister(A__    ,	'qr'						)
      lowercase__  =	ClassicalRegister(A__    ,	'cr'						)

      lowercase__  =	QuantumCircuit(A__    ,	A__						)

      lowercase__  =	number_of_qubits

      for i in range(A__						):
            quantum_circuit.h(number_of_qubits - i - 1						)
            counter -= 1
            for j in range(A__						):
                  quantum_circuit.cp(np.pi / 2 ** (counter - j)    ,	A__    ,	A__						)

      for k in range(number_of_qubits // 2						):
            quantum_circuit.swap(A__    ,	number_of_qubits - k - 1						)

      # measure all the qubits
      quantum_circuit.measure(A__    ,	A__						)
      # simulate with 10000 shots
      lowercase__  =	Aer.get_backend('qasm_simulator'						)
      lowercase__  =	execute(A__    ,	A__    ,	shots=10_000						)

      return job.result().get_counts(A__						)


if __name__ == "__main__":
       print(
           F'''Total count for quantum fourier transform state is: \
    {quantum_fourier_transform(3)}'''
       )





import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin



@skip_mps
class    UpperCAmelCase__(				lowerCamelCase  ,				lowerCamelCase  ,				unittest.TestCase						):

   '''simple docstring'''




   A     :	str												=     IFImgaImgSuperResolutionPipeline
   A     :	Dict												=     TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"width", "height"}
   A     :	Any												=     TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"original_image"}						)
   A     :	str												=     PipelineTesterMixin.required_optional_params - {"latents"}


   def       UpperCAmelCase		(    self	:      Dict)						->					Dict:




         """simple docstring"""

         return self._get_superresolution_dummy_components()


   def       UpperCAmelCase		(    self	:      Optional[Any]      ,					lowerCAmelCase	:      Tuple      ,					lowerCAmelCase	:      Union[str, Any]=0)						->					str:




         """simple docstring"""

         if str(lowerCAmelCase).startswith('mps'):
               lowercase__  =	torch.manual_seed(lowerCAmelCase)
         else:
               lowercase__  =	torch.Generator(device=lowerCAmelCase).manual_seed(lowerCAmelCase)

         lowercase__  =	floats_tensor((1, 3, 32, 32)      ,					rng=random.Random(lowerCAmelCase)).to(lowerCAmelCase)
         lowercase__  =	floats_tensor((1, 3, 16, 16)      ,					rng=random.Random(lowerCAmelCase)).to(lowerCAmelCase)

         lowercase__  =	{
             'prompt': 'A painting of a squirrel eating a burger',
             'image': image,
             'original_image': original_image,
             'generator': generator,
             'num_inference_steps': 2,
             'output_type': 'numpy',
         }

         return inputs


   @unittest.skipIf(
       torch_device != 'cuda' or not is_xformers_available()      ,					reason='XFormers attention is only available with CUDA and `xformers` installed'      ,					)
   def       UpperCAmelCase		(    self	:      str)						->					Dict:




         """simple docstring"""

         self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3)


   def       UpperCAmelCase		(    self	:      List[Any])						->					Dict:




         """simple docstring"""

         self._test_save_load_optional_components()


   @unittest.skipIf(torch_device != 'cuda'      ,					reason='float16 requires CUDA')
   def       UpperCAmelCase		(    self	:      Optional[Any])						->					List[Any]:




         """simple docstring"""

         super().test_save_load_floataa(expected_max_diff=1E-1)


   def       UpperCAmelCase		(    self	:      str)						->					Union[str, Any]:




         """simple docstring"""

         self._test_attention_slicing_forward_pass(expected_max_diff=1E-2)


   def       UpperCAmelCase		(    self	:      Tuple)						->					Tuple:




         """simple docstring"""

         self._test_save_load_local()



   def       UpperCAmelCase		(    self	:      List[str])						->					Tuple:




         """simple docstring"""

         self._test_inference_batch_single_identical(
             expected_max_diff=1E-2      ,					)
