





import flax.linen as nn
import jax
import jax.numpy as jnp







class   __lowerCAmelCase			(					nn.Module  ):
   _UpperCamelCase :						int
   _UpperCamelCase :						jnp.dtype     		=				jnp.floataa





   def 	_snake_case ( self      )				->  Any:
      """simple docstring"""





      a__	:						Dict      		=  nn.Conv(
          self.out_channels					,			kernel_size=(3, 3)					,			strides=(1, 1)					,			padding=((1, 1), (1, 1))					,			dtype=self.dtype					,			)





   def __call__( self					,			snake_case      )				->  str:
      """simple docstring"""





      a__	:						Union[str, Any]      		=  hidden_states.shape
      a__	:						Optional[Any]      		=  jax.image.resize(
          snake_case					,			shape=(batch, height * 2, width * 2, channels)					,			method="nearest"					,			)
      a__	:						Union[str, Any]      		=  self.conv(snake_case      )
      return hidden_states







class   __lowerCAmelCase			(					nn.Module  ):
   _UpperCamelCase :						int
   _UpperCamelCase :						jnp.dtype     		=				jnp.floataa





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





      a__	:						Optional[int]      		=  nn.Conv(
          self.out_channels					,			kernel_size=(3, 3)					,			strides=(2, 2)					,			padding=((1, 1), (1, 1))					,			dtype=self.dtype					,			)





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





      a__	:						str      		=  self.conv(snake_case      )
      return hidden_states







class   __lowerCAmelCase			(					nn.Module  ):
   _UpperCamelCase :						int
   _UpperCamelCase :						int     		=				None
   _UpperCamelCase :						float     		=				0.0
   _UpperCamelCase :						bool     		=				None
   _UpperCamelCase :						jnp.dtype     		=				jnp.floataa





   def 	_snake_case ( self      )				->  Dict:
      """simple docstring"""





      a__	:						Tuple      		=  self.in_channels if self.out_channels is None else self.out_channels

      a__	:						Optional[int]      		=  nn.GroupNorm(num_groups=32					,			epsilon=1E-5      )
      a__	:						Tuple      		=  nn.Conv(
          snake_case					,			kernel_size=(3, 3)					,			strides=(1, 1)					,			padding=((1, 1), (1, 1))					,			dtype=self.dtype					,			)

      a__	:						Optional[Any]      		=  nn.Dense(snake_case					,			dtype=self.dtype      )

      a__	:						Dict      		=  nn.GroupNorm(num_groups=32					,			epsilon=1E-5      )
      a__	:						int      		=  nn.Dropout(self.dropout_prob      )
      a__	:						Optional[int]      		=  nn.Conv(
          snake_case					,			kernel_size=(3, 3)					,			strides=(1, 1)					,			padding=((1, 1), (1, 1))					,			dtype=self.dtype					,			)

      a__	:						Dict      		=  self.in_channels != out_channels if self.use_nin_shortcut is None else self.use_nin_shortcut

      a__	:						Any      		=  None
      if use_nin_shortcut:
         a__	:						Any      		=  nn.Conv(
             snake_case					,			kernel_size=(1, 1)					,			strides=(1, 1)					,			padding="VALID"					,			dtype=self.dtype					,			)





   def __call__( self					,			snake_case					,			snake_case					,			snake_case=True      )				->  str:
      """simple docstring"""





      a__	:						Tuple      		=  hidden_states
      a__	:						List[Any]      		=  self.norma(snake_case      )
      a__	:						List[Any]      		=  nn.swish(snake_case      )
      a__	:						List[Any]      		=  self.conva(snake_case      )

      a__	:						Tuple      		=  self.time_emb_proj(nn.swish(snake_case      )      )
      a__	:						Optional[int]      		=  jnp.expand_dims(jnp.expand_dims(snake_case					,			1      )					,			1      )
      a__	:						int      		=  hidden_states + temb

      a__	:						Dict      		=  self.norma(snake_case      )
      a__	:						Tuple      		=  nn.swish(snake_case      )
      a__	:						Dict      		=  self.dropout(snake_case					,			snake_case      )
      a__	:						str      		=  self.conva(snake_case      )

      if self.conv_shortcut is not None:
         a__	:						Any      		=  self.conv_shortcut(snake_case      )

      return hidden_states + residual








from collections.abc import Callable
from math import pi, sqrt
from random import uniform
from statistics import mean






def       _A  (      lowerCamelCase   ):

   # A local function to see if a dot lands in the circle.
   def is_in_circle(lowerCamelCase							, lowerCamelCase   ) -> bool:
      a__	:						Any      		=  sqrt((x**2) + (y**2)   )
      # Our circle has a radius of 1, so a distance
      # greater than 1 would land outside the circle.
      return distance_from_centre <= 1

   # The proportion of guesses that landed in the circle
   a__	:						Union[str, Any]      		=  mean(
       int(is_in_circle(uniform(-1.0							, 1.0   )							, uniform(-1.0							, 1.0   )   )   )
       for _ in range(lowerCamelCase   )   )
   # The ratio of the area for circle to square is pi/4.
   a__	:						Any      		=  proportion * 4
   print(F"""The estimated value of pi is {pi_estimate}"""   )
   print(F"""The numpy value of pi is {pi}"""   )
   print(F"""The total error is {abs(pi - pi_estimate   )}"""   )






def       _A  (      lowerCamelCase							, lowerCamelCase							, lowerCamelCase = 0.0							, lowerCamelCase = 1.0							, ):
   return mean(
       function_to_integrate(uniform(lowerCamelCase							, lowerCamelCase   )   ) for _ in range(lowerCamelCase   )   ) * (max_value - min_value)






def       _A  (      lowerCamelCase							, lowerCamelCase = 0.0							, lowerCamelCase = 1.0   ):

   def identity_function(lowerCamelCase   ) -> float:
      return x

   a__	:						int      		=  area_under_curve_estimator(
       lowerCamelCase							, lowerCamelCase							, lowerCamelCase							, lowerCamelCase   )
   a__	:						int      		=  (max_value * max_value - min_value * min_value) / 2

   print("******************"   )
   print(F"""Estimating area under y=x where x varies from {min_value} to {max_value}"""   )
   print(F"""Estimated value is {estimated_value}"""   )
   print(F"""Expected value is {expected_value}"""   )
   print(F"""Total error is {abs(estimated_value - expected_value   )}"""   )
   print("******************"   )






def       _A  (      lowerCamelCase   ):

   def function_to_integrate(lowerCamelCase   ) -> float:
      return sqrt(4.0 - x * x   )

   a__	:						int      		=  area_under_curve_estimator(
       lowerCamelCase							, lowerCamelCase							, 0.0							, 2.0   )

   print("******************"   )
   print("Estimating pi using area_under_curve_estimator"   )
   print(F"""Estimated value is {estimated_value}"""   )
   print(F"""Expected value is {pi}"""   )
   print(F"""Total error is {abs(estimated_value - pi   )}"""   )
   print("******************"   )


if __name__ == "__main__":
  import doctest

  doctest.testmod()

