


from __future__ import annotations

from statistics import mean




def       a_ (       SCREAMING_SNAKE_CASE__   : list[int]						,     SCREAMING_SNAKE_CASE__   : list[int]						,     SCREAMING_SNAKE_CASE__   : int	):
       '''simple docstring'''





       _lowerCamelCase			:						Optional[int]            =[0] * no_of_processes
       _lowerCamelCase			:						str            =[0] * no_of_processes

       # Initialize remaining_time to waiting_time.

       for i in range(SCREAMING_SNAKE_CASE__	):
              _lowerCamelCase			:						str            =burst_time[i]
       _lowerCamelCase			:						list[int]            =[]

       _lowerCamelCase			:						Optional[Any]            =0
       _lowerCamelCase			:						int            =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			:						int            =[]
              _lowerCamelCase			:						Dict            =-1

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

              if len(SCREAMING_SNAKE_CASE__	) > 0:
                     _lowerCamelCase			:						Optional[Any]            =ready_process[0]
                     for i in ready_process:
                            if remaining_time[i] < remaining_time[target_process]:
                                   _lowerCamelCase			:						Optional[Any]            =i
                     total_time += burst_time[target_process]
                     completed += 1
                     _lowerCamelCase			:						Dict            =0
                     _lowerCamelCase			:						Tuple            =(
                         total_time - arrival_time[target_process] - burst_time[target_process]
                     )
              else:
                     total_time += 1

       return waiting_time




def       a_ (       SCREAMING_SNAKE_CASE__   : list[int]						,     SCREAMING_SNAKE_CASE__   : int						,     SCREAMING_SNAKE_CASE__   : list[int]	):
       '''simple docstring'''





       _lowerCamelCase			:						Any            =[0] * no_of_processes
       for i in range(SCREAMING_SNAKE_CASE__	):
              _lowerCamelCase			:						List[str]            =burst_time[i] + waiting_time[i]
       return turn_around_time


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

 lowerCamelCase		   =			4
 lowerCamelCase		   =			[2, 5, 3, 7]
 lowerCamelCase		   =			[0, 0, 0, 0]
 lowerCamelCase		   =			calculate_waitingtime(arrival_time, burst_time, no_of_processes)
 lowerCamelCase		   =			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}""")






import numpy as np




def       a_ (       SCREAMING_SNAKE_CASE__   : np.ndarray						,     SCREAMING_SNAKE_CASE__   : float	):
       '''simple docstring'''





       return np.where(vector > 0						,     SCREAMING_SNAKE_CASE__						,     (alpha * (np.exp(SCREAMING_SNAKE_CASE__	) - 1))	)


if __name__ == "__main__":
 import doctest

 doctest.testmod()


