

from __future__ import annotations



def    lowerCAmelCase__							(		SCREAMING_SNAKE_CASE_:							list[int] )     -> list[int]:




				'''simple docstring'''





				A__            =     [0] * len(SCREAMING_SNAKE_CASE_ )
				for i in range(1		,    len(SCREAMING_SNAKE_CASE_ ) ):
								A__            =     duration_times[i - 1] + waiting_times[i - 1]
				return waiting_times



def    lowerCAmelCase__							(		SCREAMING_SNAKE_CASE_:							list[int]		,    SCREAMING_SNAKE_CASE_:							list[int] )     -> list[int]:




				'''simple docstring'''





				return [
				    duration_time + waiting_times[i]
				    for i, duration_time in enumerate(SCREAMING_SNAKE_CASE_ )
				]



def    lowerCAmelCase__							(		SCREAMING_SNAKE_CASE_:							list[int] )     -> float:




				'''simple docstring'''





				return sum(SCREAMING_SNAKE_CASE_ ) / len(SCREAMING_SNAKE_CASE_ )



def    lowerCAmelCase__							(		SCREAMING_SNAKE_CASE_:							list[int] )     -> float:




				'''simple docstring'''





				return sum(SCREAMING_SNAKE_CASE_ ) / len(SCREAMING_SNAKE_CASE_ )


if __name__ == "__main__":
	# process id's
	lowerCAmelCase__						=	[1, 2, 3]

	# ensure that we actually have processes
	if len(processes) == 0:
		print("""Zero amount of processes""")
		raise SystemExit(0)

	# duration time of all processes
	lowerCAmelCase__						=	[1_9, 8, 9]

	# ensure we can match each id to a duration time
	if len(duration_times) != len(processes):
		print("""Unable to match all id's with their duration time""")
		raise SystemExit(0)

	# get the waiting times and the turnaround times
	lowerCAmelCase__						=	calculate_waiting_times(duration_times)
	lowerCAmelCase__						=	calculate_turnaround_times(duration_times, waiting_times)

	# get the average times
	lowerCAmelCase__						=	calculate_average_waiting_time(waiting_times)
	lowerCAmelCase__						=	calculate_average_turnaround_time(turnaround_times)

	# print all the results
	print("""Process ID\tDuration Time\tWaiting Time\tTurnaround Time""")
	for i, process in enumerate(processes):
		print(
		    f"""{process}\t\t{duration_times[i]}\t\t{waiting_times[i]}\t\t"""
		    f"""{turnaround_times[i]}"""
		)
	print(f"""Average waiting time = {average_waiting_time}""")
	print(f"""Average turn around time = {average_turnaround_time}""")




import unittest

from cer import CER


lowerCAmelCase__						=	CER()

class    a__  (   unittest.TestCase     ):
			"""simple docstring"""







			def        UpperCamelCase						(      self    )					->  Tuple:
							'''simple docstring'''






							A__            =     ["White House"]
							A__            =     ["white house"]
							# S = 2, D = 0, I = 0, N = 11, CER = 2 / 11
							A__            =     cer.compute(predictions=lowercase , references=lowercase    )
							self.assertTrue(abs(char_error_rate - 0.18_1818_1818    ) < 1e-6    )


			def        UpperCamelCase						(      self    )					->  Any:
							'''simple docstring'''






							A__            =     ["were wolf"]
							A__            =     ["werewolf"]
							# S = 0, D = 0, I = 1, N = 9, CER = 1 / 9
							A__            =     cer.compute(predictions=lowercase , references=lowercase    )
							self.assertTrue(abs(char_error_rate - 0.111_1111    ) < 1e-6    )

							A__            =     ["werewolf"]
							A__            =     ["weae     wolf"]
							# S = 1, D = 1, I = 0, N = 8, CER = 0.25
							A__            =     cer.compute(predictions=lowercase , references=lowercase    )
							self.assertTrue(abs(char_error_rate - 0.25    ) < 1e-6    )

							# consecutive whitespaces case 1
							A__            =     ["were wolf"]
							A__            =     ["were               wolf"]
							# S = 0, D = 0, I = 0, N = 9, CER = 0
							A__            =     cer.compute(predictions=lowercase , references=lowercase    )
							self.assertTrue(abs(char_error_rate - 0.0    ) < 1e-6    )

							# consecutive whitespaces case 2
							A__            =     ["were   wolf"]
							A__            =     ["were               wolf"]
							# S = 0, D = 0, I = 0, N = 9, CER = 0
							A__            =     cer.compute(predictions=lowercase , references=lowercase    )
							self.assertTrue(abs(char_error_rate - 0.0    ) < 1e-6    )


			def        UpperCamelCase						(      self    )					->  str:
							'''simple docstring'''






							A__            =     ["werewolf"]
							A__            =     ["weaewolf"]
							# S = 1, D = 0, I = 0, N = 8, CER = 0.125
							A__            =     cer.compute(predictions=lowercase , references=lowercase    )
							self.assertTrue(abs(char_error_rate - 0.125    ) < 1e-6    )


			def        UpperCamelCase						(      self    )					->  Tuple:
							'''simple docstring'''






							A__            =     ["werewolf"]
							A__            =     ["wereawolf"]
							# S = 0, D = 1, I = 0, N = 8, CER = 0.125
							A__            =     cer.compute(predictions=lowercase , references=lowercase    )
							self.assertTrue(abs(char_error_rate - 0.125    ) < 1e-6    )


			def        UpperCamelCase						(      self    )					->  str:
							'''simple docstring'''






							A__            =     ["werewolf"]
							A__            =     ["wereolf"]
							# S = 0, D = 0, I = 1, N = 8, CER = 0.125
							A__            =     cer.compute(predictions=lowercase , references=lowercase    )
							self.assertTrue(abs(char_error_rate - 0.125    ) < 1e-6    )


			def        UpperCamelCase						(      self    )					->  str:
							'''simple docstring'''






							A__            =     ["werewolf"]
							A__            =     cer.compute(predictions=lowercase , references=lowercase    )
							self.assertEqual(lowercase , 0.0    )


			def        UpperCamelCase						(      self    )					->  Any:
							'''simple docstring'''






							A__            =     ["werewolf", "I am your father"]
							A__            =     cer.compute(predictions=lowercase , references=lowercase    )
							self.assertEqual(lowercase , 0.0    )

							A__            =     ["werewolf", "I am your father", "doge"]
							A__            =     ["werxwolf", "I       am your father", "doge"]
							# S = 1, D = 0, I = 0, N = 28, CER = 1 / 28
							A__            =     cer.compute(predictions=lowercase , references=lowercase    )
							self.assertTrue(abs(char_error_rate - 0.0357_1428    ) < 1e-6    )


			def        UpperCamelCase						(      self    )					->  str:
							'''simple docstring'''






							A__            =     ["My hovercraft", "is full of eels"]
							A__            =     ["My hovercraft is full", " of eels"]
							# S = 0, D = 0, I = 2, N = 28, CER = 2 / 28
							# whitespace at the front of " of eels" will be strip during preporcessing
							# so need to insert 2 whitespaces
							A__            =     cer.compute(predictions=lowercase , references=lowercase , concatenate_texts=lowercase    )
							self.assertTrue(abs(char_error_rate - 0.07_1428    ) < 1e-6    )


			def        UpperCamelCase						(      self    )					->  List[str]:
							'''simple docstring'''






							A__            =     ["我能吞下玻璃而不伤身体"]
							A__            =     [" 能吞虾玻璃而 不霜身体啦"]
							# S = 3, D = 2, I = 0, N = 11, CER = 5 / 11
							A__            =     cer.compute(predictions=lowercase , references=lowercase    )
							self.assertTrue(abs(char_error_rate - 0.45_4545_4545    ) < 1e-6    )

							A__            =     ["我能吞下玻璃", "而不伤身体"]
							A__            =     ["我    能 吞 下 玻 璃", "而不伤身体"]
							# S = 0, D = 5, I = 0, N = 11, CER = 5 / 11
							A__            =     cer.compute(predictions=lowercase , references=lowercase    )
							self.assertTrue(abs(char_error_rate - 0.4545_4545_4545    ) < 1e-6    )

							A__            =     ["我能吞下玻璃而不伤身体"]
							A__            =     cer.compute(predictions=lowercase , references=lowercase    )
							self.assertFalse(lowercase , 0.0    )


			def        UpperCamelCase						(      self    )					->  Optional[Any]:
							'''simple docstring'''






							A__            =     [""]
							A__            =     ["Hypothesis"]
							with self.assertRaises(lowercase    ):
											cer.compute(predictions=lowercase , references=lowercase    )


if __name__ == "__main__":
	unittest.main()

