





from ..utils import is_flax_available, is_torch_available


if is_torch_available():
						from .autoencoder_kl import AutoencoderKL
						from .controlnet import ControlNetModel
						from .dual_transformer_ad import DualTransformeraDModel
						from .modeling_utils import ModelMixin
						from .prior_transformer import PriorTransformer
						from .ta_film_transformer import TaFilmDecoder
						from .transformer_ad import TransformeraDModel
						from .unet_ad import UNetaDModel
						from .unet_ad import UNetaDModel
						from .unet_ad_condition import UNetaDConditionModel
						from .unet_ad_condition import UNetaDConditionModel
						from .vq_model import VQModel

if is_flax_available():
						from .controlnet_flax import FlaxControlNetModel
						from .unet_ad_condition_flax import FlaxUNetaDConditionModel
						from .vae_flax import FlaxAutoencoderKL








def    __UpperCamelCase      (    a) ->float:
					return 10 - x * x





def    __UpperCamelCase      (    a,     a) ->float:
					# Bolzano theory in order to find if there is a root between a and b
					if equation(a) * equation(a) >= 0:
										raise ValueError("Wrong space!")

					lowerCamelCase__       =       a
					while (b - a) >= 0.0_1:
										# Find middle point
										lowerCamelCase__       =       (a + b) / 2
										# Check if middle point is root
										if equation(a) == 0.0:
															break
										# Decide the side to repeat the steps
										if equation(a) * equation(a) < 0:
															lowerCamelCase__       =       c
										else:
															lowerCamelCase__       =       c
					return c


if __name__ == "__main__":
						import doctest

						doctest.testmod()

						print(bisection(-2, 5))
						print(bisection(0, 6))

