





import numpy as np
def 			__UpperCamelCase				(			lowercase__	:       int		,    lowercase__	:       Optional[int]		)	->      Any:
    '''simple docstring'''





    lowerCAmelCase_					:	int						=   np.array(lowercase__		)
    lowerCAmelCase_					:	Dict						=   np.array(lowercase__		)

    lowerCAmelCase_					:	Optional[int]						=   abs(predict - actual		)
    lowerCAmelCase_					:	Optional[Any]						=   difference.mean()

    return score
def 			__UpperCamelCase				(			lowercase__	:       Any		,    lowercase__	:       List[str]		)	->      Optional[Any]:
    '''simple docstring'''





    lowerCAmelCase_					:	List[Any]						=   np.array(lowercase__		)
    lowerCAmelCase_					:	Dict						=   np.array(lowercase__		)

    lowerCAmelCase_					:	Optional[int]						=   predict - actual
    lowerCAmelCase_					:	List[str]						=   np.square(lowercase__		)

    lowerCAmelCase_					:	List[str]						=   square_diff.mean()
    return score
def 			__UpperCamelCase				(			lowercase__	:       Optional[int]		,    lowercase__	:       Optional[Any]		)	->      Optional[Any]:
    '''simple docstring'''





    lowerCAmelCase_					:	Any						=   np.array(lowercase__		)
    lowerCAmelCase_					:	int						=   np.array(lowercase__		)

    lowerCAmelCase_					:	str						=   predict - actual
    lowerCAmelCase_					:	Optional[int]						=   np.square(lowercase__		)
    lowerCAmelCase_					:	Dict						=   square_diff.mean()
    lowerCAmelCase_					:	Any						=   np.sqrt(lowercase__		)
    return score
def 			__UpperCamelCase				(			lowercase__	:       Union[str, Any]		,    lowercase__	:       str		)	->      Tuple:
    '''simple docstring'''





    lowerCAmelCase_					:	Optional[int]						=   np.array(lowercase__		)
    lowerCAmelCase_					:	Any						=   np.array(lowercase__		)

    lowerCAmelCase_					:	Union[str, Any]						=   np.log(predict + 1		)
    lowerCAmelCase_					:	Optional[Any]						=   np.log(actual + 1		)

    lowerCAmelCase_					:	List[str]						=   log_predict - log_actual
    lowerCAmelCase_					:	List[str]						=   np.square(lowercase__		)
    lowerCAmelCase_					:	Any						=   square_diff.mean()

    lowerCAmelCase_					:	str						=   np.sqrt(lowercase__		)

    return score
def 			__UpperCamelCase				(			lowercase__	:       Dict		,    lowercase__	:       List[Any]		)	->      Optional[Any]:
    '''simple docstring'''





    lowerCAmelCase_					:	Optional[Any]						=   np.array(lowercase__		)
    lowerCAmelCase_					:	Union[str, Any]						=   np.array(lowercase__		)

    lowerCAmelCase_					:	Union[str, Any]						=   predict - actual
    lowerCAmelCase_					:	Any						=   np.sum(lowercase__		) / len(lowercase__		)
    lowerCAmelCase_					:	Any						=   np.sum(lowercase__		) / len(lowercase__		)
    # print(numerator, denumerator)
    lowerCAmelCase_					:	Tuple						=   float(lowercase__		) / denumerator * 100

    return score

def 			__UpperCamelCase				(			lowercase__	:       Optional[Any]		,    lowercase__	:       List[Any]		)	->      Tuple:
    '''simple docstring'''





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











import math
def 			__UpperCamelCase				(			lowercase__	:       int		)	->      list:
    '''simple docstring'''





    if n <= 0:
        raise ValueError("""Only positive integers have prime factors"""		)
    lowerCAmelCase_					:	str						=   []
    while n % 2 == 0:
        pf.append(2		)
        lowerCAmelCase_					:	str						=   int(n / 2		)
    for i in range(3		,    int(math.sqrt(lowercase__		)		) + 1		,    2		):
        while n % i == 0:
            pf.append(lowercase__		)
            lowerCAmelCase_					:	List[Any]						=   int(n / i		)
    if n > 2:
        pf.append(lowercase__		)
    return pf
def 			__UpperCamelCase				(			lowercase__	:       int		)	->      int:
    '''simple docstring'''





    if n <= 0:
        raise ValueError("""Only positive numbers are accepted"""		)
    lowerCAmelCase_					:	Union[str, Any]						=   1
    lowerCAmelCase_					:	str						=   1
    while n % 2 == 0:
        temp += 1
        lowerCAmelCase_					:	Optional[Any]						=   int(n / 2		)
    div *= temp
    for i in range(3		,    int(math.sqrt(lowercase__		)		) + 1		,    2		):
        lowerCAmelCase_					:	Tuple						=   1
        while n % i == 0:
            temp += 1
            lowerCAmelCase_					:	Any						=   int(n / i		)
        div *= temp
    if n > 1:
        div *= 2
    return div
def 			__UpperCamelCase				(			lowercase__	:       int		)	->      int:
    '''simple docstring'''





    if n <= 0:
        raise ValueError("""Only positive numbers are accepted"""		)
    lowerCAmelCase_					:	Tuple						=   1
    lowerCAmelCase_					:	str						=   1
    while n % 2 == 0:
        temp += 1
        lowerCAmelCase_					:	Optional[int]						=   int(n / 2		)
    if temp > 1:
        s *= (2**temp - 1) / (2 - 1)
    for i in range(3		,    int(math.sqrt(lowercase__		)		) + 1		,    2		):
        lowerCAmelCase_					:	int						=   1
        while n % i == 0:
            temp += 1
            lowerCAmelCase_					:	Any						=   int(n / i		)
        if temp > 1:
            s *= (i**temp - 1) / (i - 1)
    return int(lowercase__		)
def 			__UpperCamelCase				(			lowercase__	:       int		)	->      int:
    '''simple docstring'''





    lowerCAmelCase_					:	str						=   n
    for x in set(prime_factors(lowercase__		)		):
        s *= (x - 1) / x
    return int(lowercase__		)


if __name__ == "__main__":
  import doctest

  doctest.testmod()


