




"""simple docstring"""







from __future__ import annotations

from math import pi
from typing import Protocol

import matplotlib.pyplot as plt
import numpy as np

class 				snake_case_			(					lowerCamelCase_			):







   """simple docstring"""




   def   UpperCAmelCase__			(		self       ,					lowerCamelCase_)				->   float:
       return 0.0





def      __snake_case (				_lowercase			,_lowercase    ):


    """simple docstring"""







    UpperCamelCase              =	min([-20, np.min(fft_results[1 : samplerate // 2 - 1]    )]    )
    UpperCamelCase              =	max([20, np.max(fft_results[1 : samplerate // 2 - 1]    )]    )
    return lowest, highest





def      __snake_case (				_lowercase			,_lowercase    ):


    """simple docstring"""







    UpperCamelCase              =	512
    UpperCamelCase              =	[1] + [0] * (size - 1)
    UpperCamelCase              =	[filter_type.process(_lowercase    ) for item in inputs]

    UpperCamelCase              =	[0] * (samplerate - size)  # zero-padding
    outputs += filler
    UpperCamelCase              =	np.abs(np.fft.fft(_lowercase    )    )
    UpperCamelCase              =	20 * np.logaa(_lowercase    )

    # Frequencies on log scale from 24 to nyquist frequency
    plt.xlim(24			,samplerate / 2 - 1    )
    plt.xlabel('''Frequency (Hz)'''    )
    plt.xscale('''log'''    )

    # Display within reasonable bounds
    UpperCamelCase              =	get_bounds(_lowercase			,_lowercase    )
    plt.ylim(max([-80, bounds[0]]    )			,min([80, bounds[1]]    )    )
    plt.ylabel('''Gain (dB)'''    )

    plt.plot(_lowercase    )
    plt.show()





def      __snake_case (				_lowercase			,_lowercase    ):


    """simple docstring"""







    UpperCamelCase              =	512
    UpperCamelCase              =	[1] + [0] * (size - 1)
    UpperCamelCase              =	[filter_type.process(_lowercase    ) for item in inputs]

    UpperCamelCase              =	[0] * (samplerate - size)  # zero-padding
    outputs += filler
    UpperCamelCase              =	np.angle(np.fft.fft(_lowercase    )    )

    # Frequencies on log scale from 24 to nyquist frequency
    plt.xlim(24			,samplerate / 2 - 1    )
    plt.xlabel('''Frequency (Hz)'''    )
    plt.xscale('''log'''    )

    plt.ylim(-2 * pi			,2 * pi    )
    plt.ylabel('''Phase shift (Radians)'''    )
    plt.plot(np.unwrap(_lowercase			,-2 * pi    )    )
    plt.show()







"""simple docstring"""


import math


def        UpperCAmelCase      (					a__     ,      a__ ):





						'''simple docstring'''






						if 0 not in (x, y):
												# We use the relation x^y = y*log10(x), where 10 is the base.
												return y * math.logaa(a__ )
						else:
												if x == 0:  # 0 raised to any number is 0
																		return 0
												elif y == 0:
																		return 1  # any number raised to 0 is 1
						raise AssertionError('This should never happen' )


if __name__ == "__main__":  # Main function
		# Read two numbers from input and typecast them to int using map function.
		# Here x is the base and y is the power.
		__SCREAMING_SNAKE_CASE   =   'Enter the base and the power separated by a comma: '
		__SCREAMING_SNAKE_CASE,						__SCREAMING_SNAKE_CASE   =   map(int, input(prompt).split(','))
		__SCREAMING_SNAKE_CASE,						__SCREAMING_SNAKE_CASE   =   map(int, input(prompt).split(','))

		# We find the log of each number, using the function res(), which takes two
		# arguments.
		__SCREAMING_SNAKE_CASE   =   res(xa, ya)
		__SCREAMING_SNAKE_CASE   =   res(xa, ya)

		# We check for the largest number
		if resa > resa:
				print('Largest number is', xa, '^', ya)
		elif resa > resa:
				print('Largest number is', xa, '^', ya)
		else:
				print('Both are equal')