code: 
  
  
  import unittest
  
  from cer import CER
  
  
  __a   				=      CER()
  
  
  
  
  
  
  
  class 				__SCREAMING_SNAKE_CASE   (			unittest.TestCase   ):
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   int					   =		['''White House''']
              lowercase			:   int					   =		['''white house''']
              # S = 2, D = 0, I = 0, N = 11, CER = 2 / 11
              lowercase			:   Optional[Any]					   =		cer.compute(predictions=SCREAMING_SNAKE_CASE__							,						references=SCREAMING_SNAKE_CASE__		)
              self.assertTrue(abs(char_error_rate - 0.1818181818		) < 1E-6		)
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   Optional[int]					   =		['''were wolf''']
              lowercase			:   int					   =		['''werewolf''']
              # S = 0, D = 0, I = 1, N = 9, CER = 1 / 9
              lowercase			:   Optional[int]					   =		cer.compute(predictions=SCREAMING_SNAKE_CASE__							,						references=SCREAMING_SNAKE_CASE__		)
              self.assertTrue(abs(char_error_rate - 0.1111111		) < 1E-6		)
  
              lowercase			:   Any					   =		['''werewolf''']
              lowercase			:   List[Any]					   =		['''weae     wolf''']
              # S = 1, D = 1, I = 0, N = 8, CER = 0.25
              lowercase			:   Tuple					   =		cer.compute(predictions=SCREAMING_SNAKE_CASE__							,						references=SCREAMING_SNAKE_CASE__		)
              self.assertTrue(abs(char_error_rate - 0.25		) < 1E-6		)
  
              # consecutive whitespaces case 1
              lowercase			:   List[Any]					   =		['''were wolf''']
              lowercase			:   Any					   =		['''were               wolf''']
              # S = 0, D = 0, I = 0, N = 9, CER = 0
              lowercase			:   Union[str, Any]					   =		cer.compute(predictions=SCREAMING_SNAKE_CASE__							,						references=SCREAMING_SNAKE_CASE__		)
              self.assertTrue(abs(char_error_rate - 0.0		) < 1E-6		)
  
              # consecutive whitespaces case 2
              lowercase			:   Tuple					   =		['''were   wolf''']
              lowercase			:   Tuple					   =		['''were               wolf''']
              # S = 0, D = 0, I = 0, N = 9, CER = 0
              lowercase			:   List[Any]					   =		cer.compute(predictions=SCREAMING_SNAKE_CASE__							,						references=SCREAMING_SNAKE_CASE__		)
              self.assertTrue(abs(char_error_rate - 0.0		) < 1E-6		)
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   Dict					   =		['''werewolf''']
              lowercase			:   List[Any]					   =		['''weaewolf''']
              # S = 1, D = 0, I = 0, N = 8, CER = 0.125
              lowercase			:   Optional[int]					   =		cer.compute(predictions=SCREAMING_SNAKE_CASE__							,						references=SCREAMING_SNAKE_CASE__		)
              self.assertTrue(abs(char_error_rate - 0.125		) < 1E-6		)
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   Union[str, Any]					   =		['''werewolf''']
              lowercase			:   List[Any]					   =		['''wereawolf''']
              # S = 0, D = 1, I = 0, N = 8, CER = 0.125
              lowercase			:   Optional[int]					   =		cer.compute(predictions=SCREAMING_SNAKE_CASE__							,						references=SCREAMING_SNAKE_CASE__		)
              self.assertTrue(abs(char_error_rate - 0.125		) < 1E-6		)
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   List[str]					   =		['''werewolf''']
              lowercase			:   Optional[Any]					   =		['''wereolf''']
              # S = 0, D = 0, I = 1, N = 8, CER = 0.125
              lowercase			:   str					   =		cer.compute(predictions=SCREAMING_SNAKE_CASE__							,						references=SCREAMING_SNAKE_CASE__		)
              self.assertTrue(abs(char_error_rate - 0.125		) < 1E-6		)
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   int					   =		['''werewolf''']
              lowercase			:   Optional[int]					   =		cer.compute(predictions=SCREAMING_SNAKE_CASE__							,						references=SCREAMING_SNAKE_CASE__		)
              self.assertEqual(SCREAMING_SNAKE_CASE__							,						0.0		)
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   str					   =		['''werewolf''', '''I am your father''']
              lowercase			:   List[str]					   =		cer.compute(predictions=SCREAMING_SNAKE_CASE__							,						references=SCREAMING_SNAKE_CASE__		)
              self.assertEqual(SCREAMING_SNAKE_CASE__							,						0.0		)
  
              lowercase			:   Optional[Any]					   =		['''werewolf''', '''I am your father''', '''doge''']
              lowercase			:   Tuple					   =		['''werxwolf''', '''I       am your father''', '''doge''']
              # S = 1, D = 0, I = 0, N = 28, CER = 1 / 28
              lowercase			:   List[str]					   =		cer.compute(predictions=SCREAMING_SNAKE_CASE__							,						references=SCREAMING_SNAKE_CASE__		)
              self.assertTrue(abs(char_error_rate - 0.03571428		) < 1E-6		)
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   Optional[Any]					   =		['''My hovercraft''', '''is full of eels''']
              lowercase			:   Tuple					   =		['''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
              lowercase			:   List[str]					   =		cer.compute(predictions=SCREAMING_SNAKE_CASE__							,						references=SCREAMING_SNAKE_CASE__							,						concatenate_texts=SCREAMING_SNAKE_CASE__		)
              self.assertTrue(abs(char_error_rate - 0.071428		) < 1E-6		)
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   int					   =		['''我能吞下玻璃而不伤身体''']
              lowercase			:   Union[str, Any]					   =		[''' 能吞虾玻璃而 不霜身体啦''']
              # S = 3, D = 2, I = 0, N = 11, CER = 5 / 11
              lowercase			:   Any					   =		cer.compute(predictions=SCREAMING_SNAKE_CASE__							,						references=SCREAMING_SNAKE_CASE__		)
              self.assertTrue(abs(char_error_rate - 0.4545454545		) < 1E-6		)
  
              lowercase			:   List[str]					   =		['''我能吞下玻璃''', '''而不伤身体''']
              lowercase			:   Optional[Any]					   =		['''我    能 吞 下 玻 璃''', '''而不伤身体''']
              # S = 0, D = 5, I = 0, N = 11, CER = 5 / 11
              lowercase			:   Optional[int]					   =		cer.compute(predictions=SCREAMING_SNAKE_CASE__							,						references=SCREAMING_SNAKE_CASE__		)
              self.assertTrue(abs(char_error_rate - 0.454545454545		) < 1E-6		)
  
              lowercase			:   Optional[int]					   =		['''我能吞下玻璃而不伤身体''']
              lowercase			:   List[Any]					   =		cer.compute(predictions=SCREAMING_SNAKE_CASE__							,						references=SCREAMING_SNAKE_CASE__		)
              self.assertFalse(SCREAMING_SNAKE_CASE__							,						0.0		)
  
  
  
  
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   Any					   =		['''''']
              lowercase			:   Optional[int]					   =		['''Hypothesis''']
              with self.assertRaises(SCREAMING_SNAKE_CASE__		):
                    cer.compute(predictions=SCREAMING_SNAKE_CASE__							,						references=SCREAMING_SNAKE_CASE__		)
  
  
  if __name__ == "__main__":
    unittest.main()
  
  
style_context: 
  
  
  import math
  
  
  
  
  def 			__lowercase	(						_UpperCamelCase     )    ->Union[str, Any]:
  
  
  
  
  
  
  
        """simple docstring"""
  
        lowercase			:   List[Any]					   =		0
        if n % 2 == 0:
              count += 1
              while n % 2 == 0:
                    lowercase			:   Any					   =		int(n / 2     )
      # the n input value must be odd so that
      # we can skip one element (ie i += 2)
  
        lowercase			:   Optional[int]					   =		3
  
        while i <= int(math.sqrt(_UpperCamelCase     )     ):
              if n % i == 0:
                    count += 1
                    while n % i == 0:
                          lowercase			:   Optional[Any]					   =		int(n / i     )
              lowercase			:   str					   =		i + 2
  
        # this condition checks the prime
        # number n is greater than 2
  
        if n > 2:
              count += 1
        return count
  
  
  if __name__ == "__main__":
    __a   				=      51_24_21_83
    print(F'''The number of distinct prime factors is/are {exact_prime_factor_count(n)}''')
    print(F'''The value of log(log(n)) is {math.log(math.log(n)):.4f}''')
  
  