






from math import isclose, sqrt





def 					snake_case	(  lowerCamelCase					,	lowerCamelCase					,	lowerCamelCase       ):




	'''simple docstring'''







	__lowercase   							=	point_y / 4 / point_x
	__lowercase   							=	2 * normal_gradient / (1 + normal_gradient * normal_gradient)
	__lowercase   							=	(1 - normal_gradient * normal_gradient) / (
	    1 + normal_gradient * normal_gradient
	)
	__lowercase   							=	(sa - ca * incoming_gradient) / (ca + sa * incoming_gradient)

	# to find the next point, solve the simultaeneous equations:
	# y^2 + 4x^2 = 100
	# y - b = m * (x - a)
	# ==> A x^2 + B x + C = 0
	__lowercase   							=	outgoing_gradient**2 + 4
	__lowercase   							=	2 * outgoing_gradient * (point_y - outgoing_gradient * point_x)
	__lowercase   							=	(point_y - outgoing_gradient * point_x) ** 2 - 100

	__lowercase   							=	(
	    -linear_term - sqrt(linear_term**2 - 4 * quadratic_term * constant_term       )
	) / (2 * quadratic_term)
	__lowercase   							=	(
	    -linear_term + sqrt(linear_term**2 - 4 * quadratic_term * constant_term       )
	) / (2 * quadratic_term)

	# two solutions, one of which is our input point
	__lowercase   							=	x_minus if isclose(lowerCamelCase					,	lowerCamelCase       ) else x_plus
	__lowercase   							=	point_y + outgoing_gradient * (next_x - point_x)

	return next_x, next_y, outgoing_gradient





def 					snake_case	(  lowerCamelCase = 1.4					,	lowerCamelCase = -9.6       ):




	'''simple docstring'''







	__lowercase   							=	0
	__lowercase   							=	first_x_coord
	__lowercase   							=	first_y_coord
	__lowercase   							=	(10.1 - point_y) / (0.0 - point_x)

	while not (-0.01 <= point_x <= 0.01 and point_y > 0):
		__lowercase							,    __lowercase							,    __lowercase   							=	next_point(lowerCamelCase					,	lowerCamelCase					,	lowerCamelCase       )
		num_reflections += 1

	return num_reflections


if __name__ == "__main__":
						print(F'''{solution() = }''')








import random
import unittest

import torch

from diffusers import IFInpaintingPipeline
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_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin


@skip_mps
class        __magic_name__	(				lowerCamelCase__     ,					lowerCamelCase__     ,					unittest.TestCase				):





     """simple docstring"""



     __UpperCamelCase            =  IFInpaintingPipeline
     __UpperCamelCase            =  TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {'''width''', '''height'''}
     __UpperCamelCase            =  TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
     __UpperCamelCase            =  PipelineTesterMixin.required_optional_params - {'''latents'''}



     def     SCREAMING_SNAKE_CASE		(				self							:Optional[Any]	):





        '''simple docstring'''




        return self._get_dummy_components()



     def     SCREAMING_SNAKE_CASE		(				self							:List[Any]      ,   snake_case							:str      ,   snake_case							:List[Any]=0	):





        '''simple docstring'''




        if str(snake_case	).startswith("mps"	):
           A_       :					Optional[Any]        =      torch.manual_seed(snake_case	)
        else:
           A_       :					Any        =      torch.Generator(device=snake_case	).manual_seed(snake_case	)

        A_       :					Optional[Any]        =      floats_tensor((1, 3, 32, 32)      ,   rng=random.Random(snake_case	)	).to(snake_case	)
        A_       :					Any        =      floats_tensor((1, 3, 32, 32)      ,   rng=random.Random(snake_case	)	).to(snake_case	)

        A_       :					List[Any]        =      {
            "prompt": "A painting of a squirrel eating a burger",
            "image": image,
            "mask_image": mask_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     SCREAMING_SNAKE_CASE		(				self							:Any	):





        '''simple docstring'''




        self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3	)



     def     SCREAMING_SNAKE_CASE		(				self							:Optional[int]	):





        '''simple docstring'''




        self._test_save_load_optional_components()



     @unittest.skipIf(torch_device != "cuda"      ,   reason="float16 requires CUDA"	)
     def     SCREAMING_SNAKE_CASE		(				self							:Union[str, Any]	):





        '''simple docstring'''




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



     def     SCREAMING_SNAKE_CASE		(				self							:Dict	):





        '''simple docstring'''




        self._test_attention_slicing_forward_pass(expected_max_diff=1e-2	)



     def     SCREAMING_SNAKE_CASE		(				self							:List[Any]	):





        '''simple docstring'''




        self._test_save_load_local()





     def     SCREAMING_SNAKE_CASE		(				self							:Dict	):





        '''simple docstring'''




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