






"""simple docstring"""
from __future__ import annotations

from scipy.special import comb  # type: ignore



class        UpperCamelCase__ :







    """simple docstring"""







    def __init__(		self :	Tuple				,    UpperCamelCase_ :	list[tuple[float, float]] ):





           '''simple docstring'''

           __magic_name__      				=    list_of_points
           # Degree determines the flexibility of the curve.
           # Degree = 1 will produce a straight line.
           __magic_name__      				=    len(UpperCamelCase_ ) - 1







    def 				a__			(		self :	List[Any]				,    UpperCamelCase_ :	float ):





           '''simple docstring'''

           assert 0 <= t <= 1, "Time t must be between 0 and 1."
           __magic_name__      				=    []
           for i in range(len(self.list_of_points ) ):
                  # basis function for each i
                  output_values.append(
                      comb(self.degree				,    UpperCamelCase_ ) * ((1 - t) ** (self.degree - i)) * (t**i) )
           # the basis must sum up to 1 for it to produce a valid Bezier curve.
           assert round(sum(UpperCamelCase_ )				,    5 ) == 1
           return output_values







    def 				a__			(		self :	Tuple				,    UpperCamelCase_ :	float ):





           '''simple docstring'''

           assert 0 <= t <= 1, "Time t must be between 0 and 1."

           __magic_name__      				=    self.basis_function(UpperCamelCase_ )
           __magic_name__      				=    0.0
           __magic_name__      				=    0.0
           for i in range(len(self.list_of_points ) ):
                  # For all points, sum up the product of i-th basis function and i-th point.
                  x += basis_function[i] * self.list_of_points[i][0]
                  y += basis_function[i] * self.list_of_points[i][1]
           return (x, y)







    def 				a__			(		self :	Union[str, Any]				,    UpperCamelCase_ :	float = 0.01 ):





           '''simple docstring'''

           from matplotlib import pyplot as plt  # type: ignore

           __magic_name__      				=    []  # x coordinates of points to plot
           __magic_name__      				=    []  # y coordinates of points to plot

           __magic_name__      				=    0.0
           while t <= 1:
                  __magic_name__      				=    self.bezier_curve_function(UpperCamelCase_ )
                  to_plot_x.append(value[0] )
                  to_plot_y.append(value[1] )
                  t += step_size

           __magic_name__      				=    [i[0] for i in self.list_of_points]
           __magic_name__      				=    [i[1] for i in self.list_of_points]

           plt.plot(
               UpperCamelCase_				,    UpperCamelCase_				,    color='blue'				,    label='Curve of Degree ' + str(self.degree )				,    )
           plt.scatter(UpperCamelCase_				,    UpperCamelCase_				,    color='red'				,    label='Control Points' )
           plt.legend()
           plt.show()


if __name__ == "__main__":
 import doctest

 doctest.testmod()

 BezierCurve([(1, 2), (3, 5)]).plot_curve()  # degree 1
 BezierCurve([(0, 0), (5, 5), (5, 0)]).plot_curve()  # degree 2
 BezierCurve([(0, 0), (5, 5), (5, 0), (2.5, -2.5)]).plot_curve()  # degree 3







"""simple docstring"""
from maths.prime_check import is_prime


def 							A						(				__snake_case: int  )    ->		int:

       """simple docstring"""





       if not isinstance(__snake_case ,     __snake_case  ):
              __magic_name__      				=    F"""Input value of [number={number}] must be an integer"""
              raise TypeError(__snake_case  )
       if is_prime(__snake_case  ) and is_prime(number + 2  ):
              return number + 2
       else:
              return -1


if __name__ == "__main__":
 import doctest

 doctest.testmod()