
"""simple docstring"""




from math import isclose, sqrt



def 							_lowerCamelCase			(			__a,				__a,				__a     ):
		SCREAMING_SNAKE_CASE_    			=			point_y / 4 / point_x
		SCREAMING_SNAKE_CASE_    			=			2 * normal_gradient / (1 + normal_gradient * normal_gradient)
		SCREAMING_SNAKE_CASE_    			=			(1 - normal_gradient * normal_gradient) / (
		    1 + normal_gradient * normal_gradient
		)
		SCREAMING_SNAKE_CASE_    			=			(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
		SCREAMING_SNAKE_CASE_    			=			outgoing_gradient**2 + 4
		SCREAMING_SNAKE_CASE_    			=			2 * outgoing_gradient * (point_y - outgoing_gradient * point_x)
		SCREAMING_SNAKE_CASE_    			=			(point_y - outgoing_gradient * point_x) ** 2 - 100

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

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

		return next_x, next_y, outgoing_gradient



def 							_lowerCamelCase			(			__a = 1.4,				__a = -9.6     ):
		SCREAMING_SNAKE_CASE_    			=			0
		SCREAMING_SNAKE_CASE_    			=			first_x_coord
		SCREAMING_SNAKE_CASE_    			=			first_y_coord
		SCREAMING_SNAKE_CASE_    			=			(1_0.1 - point_y) / (0.0 - point_x)

		while not (-0.0_1 <= point_x <= 0.0_1 and point_y > 0):
				SCREAMING_SNAKE_CASE_			,SCREAMING_SNAKE_CASE_			,SCREAMING_SNAKE_CASE_    			=			next_point(__a,				__a,				__a     )
				num_reflections += 1

		return num_reflections


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

"""simple docstring"""




import doctest
from collections import deque

import numpy as np





class 			snake_case  :

							def __init__(self     ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_    			=			[2, 1, 2, -1]
									SCREAMING_SNAKE_CASE_    			=			[1, 2, 3, 4]







							def _lowercase       (self     ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_    			=			len(self.first_signal     )
									SCREAMING_SNAKE_CASE_    			=			len(self.second_signal     )

									SCREAMING_SNAKE_CASE_    			=			max(SCREAMING_SNAKE_CASE_							,							SCREAMING_SNAKE_CASE_     )

									# create a zero matrix of max_length x max_length
									SCREAMING_SNAKE_CASE_    			=			[[0] * max_length for i in range(SCREAMING_SNAKE_CASE_     )]

									# fills the smaller signal with zeros to make both signals of same length
									if length_first_signal < length_second_signal:
											self.first_signal += [0] * (max_length - length_first_signal)
									elif length_first_signal > length_second_signal:
											self.second_signal += [0] * (max_length - length_second_signal)
									for i in range(SCREAMING_SNAKE_CASE_     ):
											SCREAMING_SNAKE_CASE_    			=			deque(self.second_signal     )
											rotated_signal.rotate(SCREAMING_SNAKE_CASE_     )
											for j, item in enumerate(SCREAMING_SNAKE_CASE_     ):
													matrix[i][j] += item

        # multiply the matrix with the first signal
									SCREAMING_SNAKE_CASE_    			=			np.matmul(np.transpose(SCREAMING_SNAKE_CASE_     )							,							np.transpose(self.first_signal     )     )

									# rounding-off to two decimal places
									return [round(SCREAMING_SNAKE_CASE_							,							2     ) for i in final_signal]


if __name__ == "__main__":
						doctest.testmod()