


def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase     )    ->Union[str, Any]:







      """simple docstring"""

      if n == 0:
            return 1

      elif n % 2 == 1:
            return binary_exponentiation(_UpperCamelCase,    n - 1     ) * a

      else:
            lowercase			:   str					   =		binary_exponentiation(_UpperCamelCase,    n / 2     )
            return b * b


if __name__ == "__main__":
  try:
    __a   				=      int(input('''Enter Base : ''').strip())
    __a   				=      int(input('''Enter Power : ''').strip())
  except ValueError:
    print('''Invalid literal for integer''')

  __a   				=      binary_exponentiation(BASE, POWER)
  print(F'''{BASE}^({POWER}) : {RESULT}''')





import numpy as np




def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase     )    ->Dict:







      """simple docstring"""

      lowercase			:   Optional[Any]					   =		np.array(_UpperCamelCase     )
      lowercase			:   Dict					   =		np.array(_UpperCamelCase     )

      lowercase			:   List[Any]					   =		abs(predict - actual     )
      lowercase			:   int					   =		difference.mean()

      return score




def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase     )    ->List[Any]:







      """simple docstring"""

      lowercase			:   Tuple					   =		np.array(_UpperCamelCase     )
      lowercase			:   str					   =		np.array(_UpperCamelCase     )

      lowercase			:   List[str]					   =		predict - actual
      lowercase			:   Tuple					   =		np.square(_UpperCamelCase     )

      lowercase			:   Union[str, Any]					   =		square_diff.mean()
      return score




def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase     )    ->str:







      """simple docstring"""

      lowercase			:   Union[str, Any]					   =		np.array(_UpperCamelCase     )
      lowercase			:   Optional[Any]					   =		np.array(_UpperCamelCase     )

      lowercase			:   Tuple					   =		predict - actual
      lowercase			:   Dict					   =		np.square(_UpperCamelCase     )
      lowercase			:   Union[str, Any]					   =		square_diff.mean()
      lowercase			:   Union[str, Any]					   =		np.sqrt(_UpperCamelCase     )
      return score




def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase     )    ->List[Any]:







      """simple docstring"""

      lowercase			:   List[str]					   =		np.array(_UpperCamelCase     )
      lowercase			:   List[Any]					   =		np.array(_UpperCamelCase     )

      lowercase			:   Dict					   =		np.log(predict + 1     )
      lowercase			:   List[str]					   =		np.log(actual + 1     )

      lowercase			:   int					   =		log_predict - log_actual
      lowercase			:   Tuple					   =		np.square(_UpperCamelCase     )
      lowercase			:   List[Any]					   =		square_diff.mean()

      lowercase			:   int					   =		np.sqrt(_UpperCamelCase     )

      return score




def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase     )    ->List[str]:







      """simple docstring"""

      lowercase			:   List[Any]					   =		np.array(_UpperCamelCase     )
      lowercase			:   Optional[int]					   =		np.array(_UpperCamelCase     )

      lowercase			:   Optional[int]					   =		predict - actual
      lowercase			:   Optional[int]					   =		np.sum(_UpperCamelCase     ) / len(_UpperCamelCase     )
      lowercase			:   Dict					   =		np.sum(_UpperCamelCase     ) / len(_UpperCamelCase     )
      # print(numerator, denumerator)
      lowercase			:   int					   =		float(_UpperCamelCase     ) / denumerator * 100

      return score




def 			__lowercase	(						_UpperCamelCase,    _UpperCamelCase     )    ->List[Any]:







      """simple docstring"""

      return np.mean(np.array(_UpperCamelCase     ) == np.array(_UpperCamelCase     )     )

