





'''simple docstring'''




from multiprocessing import Lock, Pipe, Process

# lock used to ensure that two processes do not access a pipe at the same time
lowercase__    :      Optional[Any]						=    Lock()






def        _lowerCAmelCase			(  __snake_case  : List[str] ,							__snake_case  : List[str] ,							__snake_case  : Union[str, Any] ,							__snake_case  : Any ,							__snake_case  : int ,							__snake_case  : Tuple ,							__snake_case  : List[Any]			)     ->     List[Any]:
     global process_lock

     # we perform n swaps since after n swaps we know we are sorted
     # we *could* stop early if we are sorted already, but it takes as long to
     # find out we are sorted as it does to sort the list with this algorithm
     for i in range(0 ,							10			):
          if (i + position) % 2 == 0 and r_send is not None:
               # send your value to your right neighbor
               process_lock.acquire()
               r_send[1].send(__snake_case			)
               process_lock.release()

               # receive your right neighbor's value
               process_lock.acquire()
               __A						: str      =       rr_cv[0].recv()
               process_lock.release()

               # take the lower value since you are on the left
               __A						: Optional[int]      =       min(__snake_case ,							__snake_case			)
          elif (i + position) % 2 != 0 and l_send is not None:
               # send your value to your left neighbor
               process_lock.acquire()
               l_send[1].send(__snake_case			)
               process_lock.release()

               # receive your left neighbor's value
               process_lock.acquire()
               __A						: Optional[int]      =       lr_cv[0].recv()
               process_lock.release()

               # take the higher value since you are on the right
               __A						: Tuple      =       max(__snake_case ,							__snake_case			)
    # after all swaps are performed, send the values back to main
     result_pipe[1].send(__snake_case			)






def        _lowerCAmelCase			(  __snake_case  : int			)     ->     Optional[Any]:
     __A						: Optional[int]      =       []
     __A						: List[str]      =       []
     # initialize the list of pipes where the values will be retrieved
     for _ in arr:
          result_pipe.append(Pipe()			)
     # creates the processes
     # the first and last process only have one neighbor so they are made outside
     # of the loop
     __A						: Any      =       Pipe()
     __A						: Tuple      =       Pipe()
     process_array_.append(
         Process(
             target=__snake_case ,							args=(0, arr[0], None, temp_rs, None, temp_rr, result_pipe[0]) ,							)			)
     __A						: Any      =       temp_rs
     __A						: Dict      =       temp_rr

     for i in range(1 ,							len(__snake_case			) - 1			):
          __A						: str      =       Pipe()
          __A						: Union[str, Any]      =       Pipe()
          process_array_.append(
              Process(
                  target=__snake_case ,							args=(i, arr[i], temp_ls, temp_rs, temp_lr, temp_rr, result_pipe[i]) ,							)			)
          __A						: List[str]      =       temp_rs
          __A						: Tuple      =       temp_rr

     process_array_.append(
         Process(
             target=__snake_case ,							args=(
                 len(__snake_case			) - 1,
                 arr[len(__snake_case			) - 1],
                 temp_ls,
                 None,
                 temp_lr,
                 None,
                 result_pipe[len(__snake_case			) - 1],
             ) ,							)			)

     # start the processes
     for p in process_array_:
          p.start()

     # wait for the processes to end and write their values to the list
     for p in range(0 ,							len(__snake_case			)			):
          __A						: Optional[int]      =       result_pipe[p][0].recv()
          process_array_[p].join()
     return arr






def        _lowerCAmelCase			(  )     ->     Union[str, Any]:
     __A						: Optional[int]      =       list(range(10 ,							0 ,							-1			)			)
     print('Initial List'			)
     print(*__snake_case			)
     __A						: Optional[int]      =       odd_even_transposition(__snake_case			)
     print('Sorted List\n'			)
     print(*__snake_case			)


if __name__ == "__main__":
  main()






'''simple docstring'''




from sympy import diff, lambdify, symbols
from sympy.functions import *  # noqa: F403






def        _lowerCAmelCase			(  __snake_case  : str ,							__snake_case  : complex ,							__snake_case  : str = "x" ,							__snake_case  : float = 10**-10 ,							__snake_case  : int = 1 ,							)     ->     complex:
     __A						: int      =       symbols(__snake_case			)
     __A						: Tuple      =       lambdify(__snake_case ,							__snake_case			)
     __A						: Any      =       lambdify(__snake_case ,							diff(__snake_case ,							__snake_case			)			)

     __A						: str      =       starting_point

     while True:
          if diff_function(__snake_case			) != 0:
               __A						: Optional[Any]      =       prev_guess - multiplicity * func(__snake_case			) / diff_function(
                   __snake_case			)
          else:
               raise ZeroDivisionError('Could not find root'			) from None

          # Precision is checked by comparing the difference of consecutive guesses
          if abs(next_guess - prev_guess			) < precision:
               return next_guess

          __A						: Dict      =       next_guess


# Let's Execute
if __name__ == "__main__":
  # Find root of trigonometric function
  # Find value of pi
  print(f"""The root of sin(x) = 0 is {newton_raphson("sin(x)", 2)}""")

  # Find root of polynomial
  # Find fourth Root of 5
  print(f"""The root of x**4 - 5 = 0 is {newton_raphson("x**4 -5", 0.4 +5j)}""")

  # Find value of e
  print(
      '''The root of log(y) - 1 = 0 is ''',
      f"""{newton_raphson("log(y) - 1", 2, variable="y")}""",
  )

  # Exponential Roots
  print(
      '''The root of exp(x) - 1 = 0 is''',
      f"""{newton_raphson("exp(x) - 1", 10, precision=0.005)}""",
  )

  # Find root of cos(x)
  print(f"""The root of cos(x) = 0 is {newton_raphson("cos(x)", 0)}""")