from statistics import mean

import numpy as np




def    lowerCAmelCase_ (     __A,  __A,  __A,  __A							)     ->				list:







      '''simple docstring'''


      UpperCAmelCase__								=  0
      # Number of processes finished
      UpperCAmelCase__								=  0
      # Displays the finished process.
      # If it is 0, the performance is completed if it is 1, before the performance.
      UpperCAmelCase__								=  [0] * no_of_process
      # List to include calculation results
      UpperCAmelCase__								=  [0] * no_of_process

      # Sort by arrival time.
      UpperCAmelCase__								=  [burst_time[i] for i in np.argsort(__A							)]
      UpperCAmelCase__								=  [process_name[i] for i in np.argsort(__A							)]
      arrival_time.sort()

      while no_of_process > finished_process_count:
            UpperCAmelCase__								=  0
            while finished_process[i] == 1:
                  i += 1
            if current_time < arrival_time[i]:
                  UpperCAmelCase__								=  arrival_time[i]

            UpperCAmelCase__								=  0
            # Index showing the location of the process being performed
            UpperCAmelCase__								=  0
            # Saves the current response ratio.
            UpperCAmelCase__								=  0
            for i in range(0,  __A							):
                  if finished_process[i] == 0 and arrival_time[i] <= current_time:
                        UpperCAmelCase__								=  (burst_time[i] + (current_time - arrival_time[i])) / burst_time[
                            i
                        ]
                  if response_ratio < temp:
                        UpperCAmelCase__								=  temp
                        UpperCAmelCase__								=  i

        # Calculate the turn around time
            UpperCAmelCase__								=  current_time + burst_time[loc] - arrival_time[loc]
            current_time += burst_time[loc]
            # Indicates that the process has been performed.
            UpperCAmelCase__								=  1
            # Increase finished_process_count by 1
            finished_process_count += 1

      return turn_around_time




def    lowerCAmelCase_ (     __A,  __A,  __A,  __A							)     ->				list:







      '''simple docstring'''


      UpperCAmelCase__								=  [0] * no_of_process
      for i in range(0,  __A							):
            UpperCAmelCase__								=  turn_around_time[i] - burst_time[i]
      return waiting_time


if __name__ == "__main__":
      UpperCamelCase__											=					5
      UpperCamelCase__											=					['A', 'B', 'C', 'D', 'E']
      UpperCamelCase__											=					[1, 2, 3, 4, 5]
      UpperCamelCase__											=					[1, 2, 3, 4, 5]

      UpperCamelCase__											=					calculate_turn_around_time(
          process_name, arrival_time, burst_time, no_of_process
      )
      UpperCamelCase__											=					calculate_waiting_time(
          process_name, turn_around_time, burst_time, no_of_process
      )

      print('Process name \tArrival time \tBurst time \tTurn around time \tWaiting time')
      for i in range(0, no_of_process):
            print(
                f'''{process_name[i]}\t\t{arrival_time[i]}\t\t{burst_time[i]}\t\t'''
                f'''{turn_around_time[i]}\t\t\t{waiting_time[i]}'''
            )

      print(f'''average waiting time : {mean(waiting_time):.5f}''')
      print(f'''average turn around time : {mean(turn_around_time):.5f}''')




from manim import *





class      A							(				UpperCAmelCase_     ):


   def 			lowercase_      (self     :						Union[str, Any]		)						->				List[str]:
         """simple docstring"""



         UpperCAmelCase__								=  Rectangle(height=0.5       ,  width=0.5		)
         UpperCAmelCase__								=  Rectangle(height=0.46       ,  width=0.46		).set_stroke(width=0		)

         UpperCAmelCase__								=  Rectangle(height=0.25       ,  width=0.25		)

         UpperCAmelCase__								=  [mem.copy() for i in range(6		)]
         UpperCAmelCase__								=  [mem.copy() for i in range(6		)]
         UpperCAmelCase__								=  VGroup(*__UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0		)
         UpperCAmelCase__								=  VGroup(*__UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0		)
         UpperCAmelCase__								=  VGroup(__UpperCAmelCase       ,  __UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0		)
         UpperCAmelCase__								=  Text("CPU"       ,  font_size=2_4		)
         UpperCAmelCase__								=  Group(__UpperCAmelCase       ,  __UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0.5       ,  aligned_edge=__UpperCAmelCase		)
         cpu.move_to([-2.5, -0.5, 0]		)
         self.add(__UpperCAmelCase		)

         UpperCAmelCase__								=  [mem.copy() for i in range(4		)]
         UpperCAmelCase__								=  VGroup(*__UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0		)
         UpperCAmelCase__								=  Text("GPU"       ,  font_size=2_4		)
         UpperCAmelCase__								=  Group(__UpperCAmelCase       ,  __UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0.5       ,  aligned_edge=__UpperCAmelCase		)
         gpu.move_to([-1, -1, 0]		)
         self.add(__UpperCAmelCase		)

         UpperCAmelCase__								=  [mem.copy() for i in range(6		)]
         UpperCAmelCase__								=  VGroup(*__UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0		)

         UpperCAmelCase__								=  Text("Model"       ,  font_size=2_4		)
         UpperCAmelCase__								=  Group(__UpperCAmelCase       ,  __UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0.5       ,  aligned_edge=__UpperCAmelCase		)
         model.move_to([3, -1.0, 0]		)
         self.add(__UpperCAmelCase		)

         UpperCAmelCase__								=  []
         UpperCAmelCase__								=  []

         for i, rect in enumerate(__UpperCAmelCase		):
               UpperCAmelCase__								=  fill.copy().set_fill(__UpperCAmelCase       ,  opacity=0.8		)
               target.move_to(__UpperCAmelCase		)
               model_arr.append(__UpperCAmelCase		)

               UpperCAmelCase__								=  Rectangle(height=0.46       ,  width=0.46		).set_stroke(width=0.0		).set_fill(__UpperCAmelCase       ,  opacity=0.8		)
               cpu_target.move_to(cpu_left_col_base[i]		)
               model_cpu_arr.append(__UpperCAmelCase		)

         self.add(*__UpperCAmelCase       ,  *__UpperCAmelCase		)

         UpperCAmelCase__								=  [meta_mem.copy() for i in range(6		)]
         UpperCAmelCase__								=  [meta_mem.copy() for i in range(6		)]
         UpperCAmelCase__								=  VGroup(*__UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0		)
         UpperCAmelCase__								=  VGroup(*__UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0		)
         UpperCAmelCase__								=  VGroup(__UpperCAmelCase       ,  __UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0		)
         UpperCAmelCase__								=  Text("Disk"       ,  font_size=2_4		)
         UpperCAmelCase__								=  Group(__UpperCAmelCase       ,  __UpperCAmelCase		).arrange(__UpperCAmelCase       ,  buff=0.5       ,  aligned_edge=__UpperCAmelCase		)
         disk.move_to([-4, -1.25, 0]		)
         self.add(__UpperCAmelCase       ,  __UpperCAmelCase		)

         UpperCAmelCase__								=  Square(side_length=2.2		)
         key.move_to([-5, 2, 0]		)

         UpperCAmelCase__								=  MarkupText(
             f"""<b>Key:</b>\n\n<span fgcolor='{YELLOW}'>●</span> Empty Model"""       ,  font_size=1_8       ,  )

         key_text.move_to([-5, 2.4, 0]		)

         self.add(__UpperCAmelCase       ,  __UpperCAmelCase		)

         UpperCAmelCase__								=  MarkupText(
             f"""<span fgcolor='{BLUE}'>●</span> Checkpoint"""       ,  font_size=1_8       ,  )

         blue_text.next_to(__UpperCAmelCase       ,  DOWN * 2.4       ,  aligned_edge=key_text.get_left()		)
         self.add(__UpperCAmelCase		)

         UpperCAmelCase__								=  MarkupText(
             f"""Now watch as an input is passed through the model\nand how the memory is utilized and handled."""       ,  font_size=2_4       ,  )
         step_a.move_to([2, 2, 0]		)

         self.play(Write(__UpperCAmelCase		)		)

         UpperCAmelCase__								=  Square(0.3		)
         input.set_fill(__UpperCAmelCase       ,  opacity=1.0		)
         input.set_stroke(width=0.0		)
         input.next_to(model_base[0]       ,  __UpperCAmelCase       ,  buff=0.5		)

         self.play(Write(__UpperCAmelCase		)		)

         input.generate_target()
         input.target.next_to(model_arr[0]       ,  direction=__UpperCAmelCase       ,  buff=0.02		)
         self.play(MoveToTarget(__UpperCAmelCase		)		)

         self.play(FadeOut(__UpperCAmelCase		)		)

         UpperCAmelCase__								=  Arrow(start=__UpperCAmelCase       ,  end=__UpperCAmelCase       ,  color=__UpperCAmelCase       ,  buff=0.5		)
         a.next_to(model_arr[0].get_left()       ,  __UpperCAmelCase       ,  buff=0.2		)

         model_cpu_arr[0].generate_target()
         model_cpu_arr[0].target.move_to(gpu_rect[0]		)

         UpperCAmelCase__								=  MarkupText(
             f"""As the input reaches a layer, the hook triggers\nand weights are moved from the CPU\nto the GPU and back."""       ,  font_size=2_4       ,  )
         step_a.move_to([2, 2, 0]		)

         self.play(Write(__UpperCAmelCase       ,  run_time=3		)		)

         UpperCAmelCase__								=  {"run_time": 1, "fade_in": True, "fade_out": True, "buff": 0.02}

         self.play(
             Write(__UpperCAmelCase		)       ,  Circumscribe(model_arr[0]       ,  color=__UpperCAmelCase       ,  **__UpperCAmelCase		)       ,  Circumscribe(model_cpu_arr[0]       ,  color=__UpperCAmelCase       ,  **__UpperCAmelCase		)       ,  Circumscribe(gpu_rect[0]       ,  color=__UpperCAmelCase       ,  **__UpperCAmelCase		)       ,  )
         self.play(MoveToTarget(model_cpu_arr[0]		)		)

         UpperCAmelCase__								=  a.copy()
         for i in range(6		):
               a_c.next_to(model_arr[i].get_right() + 0.02       ,  __UpperCAmelCase       ,  buff=0.2		)

               input.generate_target()
               input.target.move_to(model_arr[i].get_right() + 0.02		)

               UpperCAmelCase__								=  AnimationGroup(
                   FadeOut(__UpperCAmelCase       ,  run_time=0.5		)       ,  MoveToTarget(__UpperCAmelCase       ,  run_time=0.5		)       ,  FadeIn(__UpperCAmelCase       ,  run_time=0.5		)       ,  lag_ratio=0.2		)

               self.play(__UpperCAmelCase		)

               model_cpu_arr[i].generate_target()
               model_cpu_arr[i].target.move_to(cpu_left_col_base[i]		)

               if i < 5:
                     model_cpu_arr[i + 1].generate_target()
                     model_cpu_arr[i + 1].target.move_to(gpu_rect[0]		)
                     if i >= 1:
                           UpperCAmelCase__								=  0.7

                     self.play(
                         Circumscribe(model_arr[i]       ,  **__UpperCAmelCase		)       ,  Circumscribe(cpu_left_col_base[i]       ,  **__UpperCAmelCase		)       ,  Circumscribe(cpu_left_col_base[i + 1]       ,  color=__UpperCAmelCase       ,  **__UpperCAmelCase		)       ,  Circumscribe(gpu_rect[0]       ,  color=__UpperCAmelCase       ,  **__UpperCAmelCase		)       ,  Circumscribe(model_arr[i + 1]       ,  color=__UpperCAmelCase       ,  **__UpperCAmelCase		)       ,  )
                     if i < 1:
                           self.play(
                               MoveToTarget(model_cpu_arr[i]		)       ,  MoveToTarget(model_cpu_arr[i + 1]		)       ,  )
                     else:
                           self.play(
                               MoveToTarget(model_cpu_arr[i]       ,  run_time=0.7		)       ,  MoveToTarget(model_cpu_arr[i + 1]       ,  run_time=0.7		)       ,  )
               else:
                     model_cpu_arr[i].generate_target()
                     model_cpu_arr[i].target.move_to(cpu_left_col_base[-1]		)
                     input.generate_target()
                     input.target.next_to(model_arr[-1].get_right()       ,  RIGHT + 0.02       ,  buff=0.2		)

                     self.play(
                         Circumscribe(model_arr[-1]       ,  color=__UpperCAmelCase       ,  **__UpperCAmelCase		)       ,  Circumscribe(cpu_left_col_base[-1]       ,  color=__UpperCAmelCase       ,  **__UpperCAmelCase		)       ,  Circumscribe(gpu_rect[0]       ,  color=__UpperCAmelCase       ,  **__UpperCAmelCase		)       ,  )

                     self.play(MoveToTarget(model_cpu_arr[i]		)		)

               UpperCAmelCase__								=  a_c
               UpperCAmelCase__								=  a_c.copy()

         input.generate_target()
         input.target.next_to(model_base[-1]       ,  RIGHT + 0.02       ,  buff=0.5		)
         self.play(
             FadeOut(__UpperCAmelCase		)       ,  FadeOut(__UpperCAmelCase       ,  run_time=0.5		)       ,  )

         UpperCAmelCase__								=  MarkupText(f"""Inference on a model too large for GPU memory\nis successfully completed."""       ,  font_size=2_4		)
         step_a.move_to([2, 2, 0]		)

         self.play(Write(__UpperCAmelCase       ,  run_time=3		)       ,  MoveToTarget(__UpperCAmelCase		)		)

         self.wait()



