def 							UpperCAmelCase__(					__UpperCAmelCase			:     str     ,				__UpperCAmelCase			:     Union[str, Any]       ):
   # "extended trapezoidal rule"
   # int(f) = dx/2 * (f1 + 2f2 + ... + fn)
   __snake_case   :			str										=						(boundary[1] - boundary[0]) / steps
   __snake_case   :			Dict										=						boundary[0]
   __snake_case   :			str										=						boundary[1]
   __snake_case   :			List[Any]										=						make_points(_lowerCAmelCase     ,				_lowerCAmelCase     ,				_lowerCAmelCase       )
   __snake_case   :			Tuple										=						0.0
   y += (h / 2.0) * f(_lowerCAmelCase       )
   for i in x_i:
      # print(i)
      y += h * f(_lowerCAmelCase       )
   y += (h / 2.0) * f(_lowerCAmelCase       )
   return y






def 							UpperCAmelCase__(					__UpperCAmelCase			:     List[Any]     ,				__UpperCAmelCase			:     Tuple     ,				__UpperCAmelCase			:     Any       ):
   __snake_case   :			str										=						a + h
   while x < (b - h):
      yield x
      __snake_case   :			str										=						x + h






def 							UpperCAmelCase__(					__UpperCAmelCase			:     List[str]       ):  # enter your function here
   __snake_case   :			List[str]										=						(x - 0) * (x - 0)
   return y






def 							UpperCAmelCase__(					):
   __snake_case   :			Optional[Any]										=						0.0  # Lower bound of integration
   __snake_case   :			List[Any]										=						1.0  # Upper bound of integration
   __snake_case   :			int										=						10.0  # define number of steps or resolution
   __snake_case   :			Union[str, Any]										=						[a, b]  # define boundary of integration
   __snake_case   :			Any										=						method_a(_lowerCAmelCase     ,				_lowerCAmelCase       )
   print(F"""y = {y}"""       )


if __name__ == "__main__":
 main()





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

from statistics import mean

def  lowercase     (_lowerCAmelCase ,    _lowerCAmelCase ,    _lowerCAmelCase						):
						__lowerCAmelCase     =  [0] * no_of_processes
						__lowerCAmelCase     =  [0] * no_of_processes

						# Initialize remaining_time to waiting_time.

						for i in range(_lowerCAmelCase						):
												__lowerCAmelCase     =  burst_time[i]
						__lowerCAmelCase     =  []

						__lowerCAmelCase     =  0
						__lowerCAmelCase     =  0

						# When processes are not completed,
						# A process whose arrival time has passed \
						# and has remaining execution time is put into the ready_process.
						# The shortest process in the ready_process, target_process is executed.

						while completed != no_of_processes:
												__lowerCAmelCase     =  []
												__lowerCAmelCase     =  -1

												for i in range(_lowerCAmelCase						):
																		if (arrival_time[i] <= total_time) and (remaining_time[i] > 0):
																								ready_process.append(_lowerCAmelCase						)

												if len(_lowerCAmelCase						) > 0:
																		__lowerCAmelCase     =  ready_process[0]
																		for i in ready_process:
																								if remaining_time[i] < remaining_time[target_process]:
																														__lowerCAmelCase     =  i
																		total_time += burst_time[target_process]
																		completed += 1
																		__lowerCAmelCase     =  0
																		__lowerCAmelCase     =  (
																		    total_time - arrival_time[target_process] - burst_time[target_process]
																		)
												else:
																		total_time += 1

						return waiting_time

def  lowercase     (_lowerCAmelCase ,    _lowerCAmelCase ,    _lowerCAmelCase						):
						__lowerCAmelCase     =  [0] * no_of_processes
						for i in range(_lowerCAmelCase						):
												__lowerCAmelCase     =  burst_time[i] + waiting_time[i]
						return turn_around_time


if __name__ == "__main__":
			print('''[TEST CASE 01]''')

			SCREAMING_SNAKE_CASE_					     =	4
			SCREAMING_SNAKE_CASE_					     =	[2, 5, 3, 7]
			SCREAMING_SNAKE_CASE_					     =	[0, 0, 0, 0]
			SCREAMING_SNAKE_CASE_					     =	calculate_waitingtime(arrival_time, burst_time, no_of_processes)
			SCREAMING_SNAKE_CASE_					     =	calculate_turnaroundtime(
			    burst_time, no_of_processes, waiting_time
			)

			# Printing the Result
			print('''PID\tBurst Time\tArrival Time\tWaiting Time\tTurnaround Time''')
			for i, process_id in enumerate(list(range(1, 5))):
						print(
						    F"{process_id}\t{burst_time[i]}\t\t\t{arrival_time[i]}\t\t\t\t"
						    F"{waiting_time[i]}\t\t\t\t{turn_around_time[i]}"
						)
			print(F"\nAverage waiting time = {mean(waiting_time):.5f}")
			print(F"Average turnaround time = {mean(turn_around_time):.5f}")
