



"""simple docstring"""




import numpy as np
from PIL import Image






def      __lowercase       (			a__							,       a__							,       a__       )    ->			np.ndarray:
							__SCREAMING_SNAKE_CASE									= np.array(a__       )
							if arr.shape[0] != arr.shape[1]:
														raise ValueError('The input array is not a square matrix'       )
							__SCREAMING_SNAKE_CASE									= 0
							__SCREAMING_SNAKE_CASE									= 0
							__SCREAMING_SNAKE_CASE									= 0
							__SCREAMING_SNAKE_CASE									= 0

							# compute the shape of the output matrix
							__SCREAMING_SNAKE_CASE									= (arr.shape[0] - size) // stride + 1
							# initialize the output matrix with zeros of shape maxpool_shape
							__SCREAMING_SNAKE_CASE									= np.zeros((maxpool_shape, maxpool_shape)       )

							while i < arr.shape[0]:
														if i + size > arr.shape[0]:
																					# if the end of the matrix is reached, break
																					break
														while j < arr.shape[1]:
																					# if the end of the matrix is reached, break
																					if j + size > arr.shape[1]:
																												break
																					# compute the maximum of the pooling matrix
																					__SCREAMING_SNAKE_CASE									= np.max(arr[i : i + size, j : j + size]       )
																					# shift the pooling matrix by stride of column pixels
																					j += stride
																					mat_j += 1

														# shift the pooling matrix by stride of row pixels
														i += stride
														mat_i += 1

														# reset the column index to 0
														__SCREAMING_SNAKE_CASE									= 0
														__SCREAMING_SNAKE_CASE									= 0

							return updated_arr






def      __lowercase       (			a__							,       a__							,       a__       )    ->			np.ndarray:
							__SCREAMING_SNAKE_CASE									= np.array(a__       )
							if arr.shape[0] != arr.shape[1]:
														raise ValueError('The input array is not a square matrix'       )
							__SCREAMING_SNAKE_CASE									= 0
							__SCREAMING_SNAKE_CASE									= 0
							__SCREAMING_SNAKE_CASE									= 0
							__SCREAMING_SNAKE_CASE									= 0

							# compute the shape of the output matrix
							__SCREAMING_SNAKE_CASE									= (arr.shape[0] - size) // stride + 1
							# initialize the output matrix with zeros of shape avgpool_shape
							__SCREAMING_SNAKE_CASE									= np.zeros((avgpool_shape, avgpool_shape)       )

							while i < arr.shape[0]:
														# if the end of the matrix is reached, break
														if i + size > arr.shape[0]:
																					break
														while j < arr.shape[1]:
																					# if the end of the matrix is reached, break
																					if j + size > arr.shape[1]:
																												break
																					# compute the average of the pooling matrix
																					__SCREAMING_SNAKE_CASE									= int(np.average(arr[i : i + size, j : j + size]       )       )
																					# shift the pooling matrix by stride of column pixels
																					j += stride
																					mat_j += 1

														# shift the pooling matrix by stride of row pixels
														i += stride
														mat_i += 1
														# reset the column index to 0
														__SCREAMING_SNAKE_CASE									= 0
														__SCREAMING_SNAKE_CASE									= 0

							return updated_arr


# Main Function
if __name__ == "__main__":
			from doctest import testmod

			testmod(name='''avgpooling''', verbose=True)

			# Loading the image
			lowerCAmelCase__		:					int							=Image.open('''path_to_image''')

			# Converting the image to numpy array and maxpooling, displaying the result
			# Ensure that the image is a square matrix

			Image.fromarray(maxpooling(np.array(image), size=3, stride=2)).show()

			# Converting the image to numpy array and averagepooling, displaying the result
			# Ensure that the image is a square matrix

			Image.fromarray(avgpooling(np.array(image), size=3, stride=2)).show()











from collections import deque

from .hash_table import HashTable

class        UpperCAmelCase_  (       UpperCamelCase_	):

						'''simple docstring'''




						def __init__(   self				,							*_A				,							**_A		):







													'''simple docstring'''

													super().__init__(*_A				,							**_A		)






						def 	_A     (   self				,							_A				,							_A		):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE									= deque([]		) if self.values[key] is None else self.values[key]
													self.values[key].appendleft(_A		)
													__SCREAMING_SNAKE_CASE									= self.values[key]






						def 	_A     (   self		):







													'''simple docstring'''

													return (
													    sum(self.charge_factor - len(_A		) for slot in self.values		)
													    / self.size_table
													    * self.charge_factor
													)






						def 	_A     (   self				,							_A				,							_A=None		):







													'''simple docstring'''

													if not (
													    len(self.values[key]		) == self.charge_factor and self.values.count(_A		) == 0
													):
																				return key
													return super()._collision_resolution(_A				,							_A		)






