code: 
  
  
  
  
  
  
  import warnings
  from collections.abc import Callable
  from typing import Any
  
  import numpy
  from matplotlib import pyplot
  
  lowerCamelCase			:							Any       =0.25 + 0.0j
  lowerCamelCase			:							Tuple       =-0.4 + 0.6j
  lowerCamelCase			:							Tuple       =-0.1 + 0.651j
  lowerCamelCase			:							Union[str, Any]       =-2.0
  lowerCamelCase			:							int       =56
  lowerCamelCase			:							Optional[Any]       =2.0
  lowerCamelCase			:							Tuple       =666
  
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase      ,					__lowerCAmelCase    )				->			numpy.ndarray:
       return numpy.exp(__lowerCAmelCase    ) + c_parameter
  
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase      ,					__lowerCAmelCase    )				->			numpy.ndarray:
       return z_values * z_values + c_parameter
  
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase      ,					__lowerCAmelCase    )				->			numpy.ndarray:
       UpperCamelCase__    :     Dict        =						numpy.linspace(-window_size      ,					__lowerCAmelCase      ,					__lowerCAmelCase    )
       UpperCamelCase__    :     Union[str, Any]        =						x.reshape((nb_pixels, 1)    )
       UpperCamelCase__    :     Optional[int]        =						numpy.linspace(-window_size      ,					__lowerCAmelCase      ,					__lowerCAmelCase    )
       UpperCamelCase__    :     Union[str, Any]        =						y.reshape((1, nb_pixels)    )
       return x + 1.0J * y
  
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase = None      ,					)				->			numpy.ndarray:
       UpperCamelCase__    :     Any        =						z_a.astype("complex64"    )
       for _ in range(__lowerCAmelCase    ):
            UpperCamelCase__    :     Dict        =						eval_function(__lowerCAmelCase      ,					__lowerCAmelCase    )
            if infinity is not None:
                 numpy.nan_to_num(__lowerCAmelCase      ,					copy=__lowerCAmelCase      ,					nan=__lowerCAmelCase    )
                 UpperCamelCase__    :     List[Any]        =						infinity
       return z_n
  
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase      ,					__lowerCAmelCase      ,					)				->			None:
       UpperCamelCase__    :     Union[str, Any]        =						(abs(__lowerCAmelCase    )).transpose()
       UpperCamelCase__    :     Optional[int]        =						abs_z_final[::-1, :]
       pyplot.matshow(abs_z_final < escape_radius    )
       pyplot.title(f'Julia set of ${function_label}$, $c={function_params}$'    )
       pyplot.show()
  
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      )				->			None:
       warnings.filterwarnings(
           "ignore"      ,					category=__lowerCAmelCase      ,					message="overflow encountered in multiply"    )
       warnings.filterwarnings(
           "ignore"      ,					category=__lowerCAmelCase      ,					message="invalid value encountered in multiply"      ,					)
       warnings.filterwarnings(
           "ignore"      ,					category=__lowerCAmelCase      ,					message="overflow encountered in absolute"    )
       warnings.filterwarnings(
           "ignore"      ,					category=__lowerCAmelCase      ,					message="overflow encountered in exp"    )
  
  
  if __name__ == "__main__":
   lowerCamelCase			:							Optional[Any]       =prepare_grid(window_size, nb_pixels)
  
   ignore_overflow_warnings()  # See file header for explanations
  
   lowerCamelCase			:							List[Any]       =24
   lowerCamelCase			:							Union[str, Any]       =2 * abs(c_cauliflower) + 1
   lowerCamelCase			:							Optional[int]       =iterate_function(
       eval_quadratic_polynomial,
       c_cauliflower,
       nb_iterations,
       z_a,
       infinity=1.1 * escape_radius,
   )
   show_results('''z^2+c''', c_cauliflower, escape_radius, z_final)
  
   lowerCamelCase			:							Union[str, Any]       =64
   lowerCamelCase			:							Optional[Any]       =2 * abs(c_polynomial_a) + 1
   lowerCamelCase			:							Optional[Any]       =iterate_function(
       eval_quadratic_polynomial,
       c_polynomial_a,
       nb_iterations,
       z_a,
       infinity=1.1 * escape_radius,
   )
   show_results('''z^2+c''', c_polynomial_a, escape_radius, z_final)
  
   lowerCamelCase			:							Optional[int]       =161
   lowerCamelCase			:							Union[str, Any]       =2 * abs(c_polynomial_a) + 1
   lowerCamelCase			:							Optional[int]       =iterate_function(
       eval_quadratic_polynomial,
       c_polynomial_a,
       nb_iterations,
       z_a,
       infinity=1.1 * escape_radius,
   )
   show_results('''z^2+c''', c_polynomial_a, escape_radius, z_final)
  
   lowerCamelCase			:							Dict       =12
   lowerCamelCase			:							Union[str, Any]       =1_0000.0
   lowerCamelCase			:							int       =iterate_function(
       eval_exponential,
       c_exponential,
       nb_iterations,
       z_a + 2,
       infinity=1.0E10,
   )
   show_results('''e^z+c''', c_exponential, escape_radius, z_final)
style_context: 
  
  
  
  
  
  
  def 	SCREAMING_SNAKE_CASE							(      __lowerCAmelCase    )				->			str:
       if len(__lowerCAmelCase    ) == 0 or not all(len(__lowerCAmelCase    ) == 2 for pair in coordinates    ):
            raise ValueError("The program cannot work out a fitting polynomial."    )
  
       if len({tuple(__lowerCAmelCase    ) for pair in coordinates}    ) != len(__lowerCAmelCase    ):
            raise ValueError("The program cannot work out a fitting polynomial."    )
  
       UpperCamelCase__    :     List[str]        =						{x for x, _ in coordinates}
       if len(__lowerCAmelCase    ) == 1:
            return f'x={coordinates[0][0]}'
  
       if len(__lowerCAmelCase    ) != len(__lowerCAmelCase    ):
            raise ValueError("The program cannot work out a fitting polynomial."    )
  
       UpperCamelCase__    :     Any        =						len(__lowerCAmelCase    )
  
       UpperCamelCase__    :     str        =						0
       UpperCamelCase__    :     list[list[float]]        =						[]
       # put the x and x to the power values in a matrix
       while count_of_line < x:
            UpperCamelCase__    :     int        =						0
            UpperCamelCase__    :     List[Any]        =						coordinates[count_of_line][0]
            UpperCamelCase__    :     list[float]        =						[]
            while count_in_line < x:
                 count_line.append(a ** (x - (count_in_line + 1))    )
                 count_in_line += 1
            matrix.append(__lowerCAmelCase    )
            count_of_line += 1
  
       UpperCamelCase__    :     List[Any]        =						0
       # put the y values into a vector
       UpperCamelCase__    :     list[float]        =						[]
       while count_of_line < x:
            vector.append(coordinates[count_of_line][1]    )
            count_of_line += 1
  
       UpperCamelCase__    :     Tuple        =						0
  
       while count < x:
            UpperCamelCase__    :     Dict        =						0
            while zahlen < x:
                 if count == zahlen:
                      zahlen += 1
                 if zahlen == x:
                      break
                 UpperCamelCase__    :     Optional[Any]        =						matrix[zahlen][count] / matrix[count][count]
                 for counting_columns, item in enumerate(matrix[count]    ):
                      # manipulating all the values in the matrix
                      matrix[zahlen][counting_columns] -= item * bruch
                 # manipulating the values in the vector
                 vector[zahlen] -= vector[count] * bruch
                 zahlen += 1
            count += 1
  
       UpperCamelCase__    :     Tuple        =						0
       # make solutions
       UpperCamelCase__    :     list[str]        =						[]
       while count < x:
            solution.append(str(vector[count] / matrix[count][count]    )    )
            count += 1
  
       UpperCamelCase__    :     int        =						0
       UpperCamelCase__    :     List[str]        =						"f(x)="
  
       while count < x:
            UpperCamelCase__    :     list[str]        =						solution[count].split("E"    )
            if len(__lowerCAmelCase    ) > 1:
                 UpperCamelCase__    :     Union[str, Any]        =						f'{remove_e[0]}*10^{remove_e[1]}'
            solved += f'x^{x - (count + 1)}*{solution[count]}'
            if count + 1 != x:
                 solved += "+"
            count += 1
  
       return solved
  
  
  if __name__ == "__main__":
   print(points_to_polynomial([]))
   print(points_to_polynomial([[]]))
   print(points_to_polynomial([[1, 0], [2, 0], [3, 0]]))
   print(points_to_polynomial([[1, 1], [2, 1], [3, 1]]))
   print(points_to_polynomial([[1, 3], [2, 3], [3, 3]]))
   print(points_to_polynomial([[1, 1], [2, 2], [3, 3]]))
   print(points_to_polynomial([[1, 1], [2, 4], [3, 9]]))
   print(points_to_polynomial([[1, 3], [2, 6], [3, 11]]))
   print(points_to_polynomial([[1, -3], [2, -6], [3, -11]]))
   print(points_to_polynomial([[1, 5], [2, 2], [3, 9]]))