






'''simple docstring'''





import mpmath  # for roots of unity
import numpy as np


class        __UpperCamelCase    :







	def __init__(  self      :							Union[str, Any]       ,				_lowerCAmelCase      :							List[Any]=None       ,				_lowerCAmelCase      :							Optional[Any]=None			)		-> Tuple:
		"""simple docstring"""







		__lowercase             =  list(poly_a or [0]			)[:]
		__lowercase             =  list(poly_b or [0]			)[:]

		# Remove leading zero coefficients
		while self.polyA[-1] == 0:
			self.polyA.pop()
		__lowercase             =  len(self.polyA			)

		while self.polyB[-1] == 0:
			self.polyB.pop()
		__lowercase             =  len(self.polyB			)

		# Add 0 to make lengths equal a power of 2
		__lowercase             =  int(
		    2 ** np.ceil(np.loga(len(self.polyA			) + len(self.polyB			) - 1			)			)			)

		while len(self.polyA			) < self.c_max_length:
			self.polyA.append(0			)
		while len(self.polyB			) < self.c_max_length:
			self.polyB.append(0			)
		# A complex root used for the fourier transform
		__lowercase             =  complex(mpmath.root(x=1       ,				n=self.c_max_length       ,				k=1			)			)

		# The product
		__lowercase             =  self.__multiply()







	def  _a   (  self      :							Union[str, Any]       ,				_lowerCAmelCase      :							Tuple			)		-> Tuple:
		"""simple docstring"""







		__lowercase             =  [[x] for x in self.polyA] if which == '''A''' else [[x] for x in self.polyB]
		# Corner case
		if len(UpperCAmelCase__			) <= 1:
			return dft[0]
		#
		__lowercase             =  self.c_max_length // 2
		while next_ncol > 0:
			__lowercase             =  [[] for i in range(UpperCAmelCase__			)]
			__lowercase             =  self.root**next_ncol

			# First half of next step
			__lowercase             =  1
			for j in range(self.c_max_length // (next_ncol * 2)			):
				for i in range(UpperCAmelCase__			):
					new_dft[i].append(dft[i][j] + current_root * dft[i + next_ncol][j]			)
				current_root *= root
			# Second half of next step
			__lowercase             =  1
			for j in range(self.c_max_length // (next_ncol * 2)			):
				for i in range(UpperCAmelCase__			):
					new_dft[i].append(dft[i][j] - current_root * dft[i + next_ncol][j]			)
				current_root *= root
			# Update
			__lowercase             =  new_dft
			__lowercase             =  next_ncol // 2
		return dft[0]







	def  _a   (  self      :							List[Any]			)		-> Dict:
		"""simple docstring"""







		__lowercase             =  self.__dft("""A"""			)
		__lowercase             =  self.__dft("""B"""			)
		__lowercase             =  [[dft_a[i] * dft_b[i] for i in range(self.c_max_length			)]]
		del dft_a
		del dft_b

		# Corner Case
		if len(inverce_c[0]			) <= 1:
			return inverce_c[0]
		# Inverse DFT
		__lowercase             =  2
		while next_ncol <= self.c_max_length:
			__lowercase             =  [[] for i in range(UpperCAmelCase__			)]
			__lowercase             =  self.root ** (next_ncol // 2)
			__lowercase             =  1
			# First half of next step
			for j in range(self.c_max_length // next_ncol			):
				for i in range(next_ncol // 2			):
					# Even positions
					new_inverse_c[i].append(
					    (
					        inverce_c[i][j]
					        + inverce_c[i][j + self.c_max_length // next_ncol]
					    )
					    / 2			)
					# Odd positions
					new_inverse_c[i + next_ncol // 2].append(
					    (
					        inverce_c[i][j]
					        - inverce_c[i][j + self.c_max_length // next_ncol]
					    )
					    / (2 * current_root)			)
				current_root *= root
			# Update
			__lowercase             =  new_inverse_c
			next_ncol *= 2
		# Unpack
		__lowercase             =  [round(x[0].real       ,				8			) + round(x[0].imag       ,				8			) * 1j for x in inverce_c]

		# Remove leading 0's
		while inverce_c[-1] == 0:
			inverce_c.pop()
		return inverce_c







	def __str__(  self      :							Any			)		-> List[str]:
		"""simple docstring"""







		__lowercase             =  '''A = ''' + ''' + '''.join(
		    F'{coef}*x^{i}' for coef, i in enumerate(self.polyA[: self.len_A]			)			)
		__lowercase             =  '''B = ''' + ''' + '''.join(
		    F'{coef}*x^{i}' for coef, i in enumerate(self.polyB[: self.len_B]			)			)
		__lowercase             =  '''A*B = ''' + ''' + '''.join(
		    F'{coef}*x^{i}' for coef, i in enumerate(self.product			)			)

		return F'{a}\n{b}\n{c}'


# Unit tests
if __name__ == "__main__":
						import doctest

						doctest.testmod()









import gc
import unittest

from diffusers import FlaxDPMSolverMultistepScheduler, FlaxStableDiffusionPipeline
from diffusers.utils import is_flax_available, slow
from diffusers.utils.testing_utils import require_flax


if is_flax_available():
						import jax
						import jax.numpy as jnp
						from flax.jax_utils import replicate
						from flax.training.common_utils import shard


@slow
@require_flax
class        __UpperCamelCase    (     unittest.TestCase   ):







	def  _a   (  self      :							Union[str, Any]			)		-> Any:
		"""simple docstring"""







		super().tearDown()
		gc.collect()







	def  _a   (  self      :							List[str]			)		-> int:
		"""simple docstring"""







		__lowercase       ,						__lowercase             =  FlaxStableDiffusionPipeline.from_pretrained(
		    """stabilityai/stable-diffusion-2"""       ,				revision="""bf16"""       ,				dtype=jnp.bfloataa       ,				)

		__lowercase             =  """A painting of a squirrel eating a burger"""
		__lowercase             =  jax.device_count()
		__lowercase             =  num_samples * [prompt]
		__lowercase             =  sd_pipe.prepare_inputs(_lowerCAmelCase			)

		__lowercase             =  replicate(_lowerCAmelCase			)
		__lowercase             =  shard(_lowerCAmelCase			)

		__lowercase             =  jax.random.PRNGKey(0			)
		__lowercase             =  jax.random.split(_lowerCAmelCase       ,				jax.device_count()			)

		__lowercase             =  sd_pipe(_lowerCAmelCase       ,				_lowerCAmelCase       ,				_lowerCAmelCase       ,				num_inference_steps=25       ,				jit=_lowerCAmelCase			)[0]
		assert images.shape == (jax.device_count(), 1, 768, 768, 3)

		__lowercase             =  images.reshape((images.shape[0] * images.shape[1],) + images.shape[-3:]			)
		__lowercase             =  images[0, 253:256, 253:256, -1]

		__lowercase             =  jnp.asarray(jax.device_get(image_slice.flatten()			)			)
		__lowercase             =  jnp.array([0.4_238, 0.4_414, 0.4_395, 0.4_453, 0.4_629, 0.4_590, 0.4_531, 0.45_508, 0.4_512]			)
		print(F'output_slice: {output_slice}'			)
		assert jnp.abs(output_slice - expected_slice			).max() < 1e-2







	def  _a   (  self      :							str			)		-> List[Any]:
		"""simple docstring"""







		__lowercase             =  """stabilityai/stable-diffusion-2"""
		__lowercase       ,						__lowercase             =  FlaxDPMSolverMultistepScheduler.from_pretrained(_lowerCAmelCase       ,				subfolder="""scheduler"""			)
		__lowercase       ,						__lowercase             =  FlaxStableDiffusionPipeline.from_pretrained(
		    _lowerCAmelCase       ,				scheduler=_lowerCAmelCase       ,				revision="""bf16"""       ,				dtype=jnp.bfloataa       ,				)
		__lowercase             =  scheduler_params

		__lowercase             =  """A painting of a squirrel eating a burger"""
		__lowercase             =  jax.device_count()
		__lowercase             =  num_samples * [prompt]
		__lowercase             =  sd_pipe.prepare_inputs(_lowerCAmelCase			)

		__lowercase             =  replicate(_lowerCAmelCase			)
		__lowercase             =  shard(_lowerCAmelCase			)

		__lowercase             =  jax.random.PRNGKey(0			)
		__lowercase             =  jax.random.split(_lowerCAmelCase       ,				jax.device_count()			)

		__lowercase             =  sd_pipe(_lowerCAmelCase       ,				_lowerCAmelCase       ,				_lowerCAmelCase       ,				num_inference_steps=25       ,				jit=_lowerCAmelCase			)[0]
		assert images.shape == (jax.device_count(), 1, 768, 768, 3)

		__lowercase             =  images.reshape((images.shape[0] * images.shape[1],) + images.shape[-3:]			)
		__lowercase             =  images[0, 253:256, 253:256, -1]

		__lowercase             =  jnp.asarray(jax.device_get(image_slice.flatten()			)			)
		__lowercase             =  jnp.array([0.4_336, 0.42_969, 0.4_453, 0.4_199, 0.4_297, 0.4_531, 0.4_434, 0.4_434, 0.4_297]			)
		print(F'output_slice: {output_slice}'			)
		assert jnp.abs(output_slice - expected_slice			).max() < 1e-2

