





import numpy as np
from PIL import Image





def      lowerCAmelCase_ (       __a	,    __a	,    __a		)     ->		np.ndarray:







  """simple docstring"""





  lowerCamelCase__:      str			  =np.array(__a		)
  if arr.shape[0] != arr.shape[1]:
    raise ValueError("The input array is not a square matrix"		)
  lowerCamelCase__:      Optional[int]			  =0
  lowerCamelCase__:      Union[str, Any]			  =0
  lowerCamelCase__:      Union[str, Any]			  =0
  lowerCamelCase__:      List[Any]			  =0

  # compute the shape of the output matrix
  lowerCamelCase__:      Optional[Any]			  =(arr.shape[0] - size) // stride + 1
  # initialize the output matrix with zeros of shape maxpool_shape
  lowerCamelCase__:      Optional[int]			  =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
      lowerCamelCase__:      int			  =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
    lowerCamelCase__:      Tuple			  =0
    lowerCamelCase__:      List[Any]			  =0

  return updated_arr





def      lowerCAmelCase_ (       __a	,    __a	,    __a		)     ->		np.ndarray:







  """simple docstring"""





  lowerCamelCase__:      str			  =np.array(__a		)
  if arr.shape[0] != arr.shape[1]:
    raise ValueError("The input array is not a square matrix"		)
  lowerCamelCase__:      List[str]			  =0
  lowerCamelCase__:      List[Any]			  =0
  lowerCamelCase__:      List[str]			  =0
  lowerCamelCase__:      str			  =0

  # compute the shape of the output matrix
  lowerCamelCase__:      str			  =(arr.shape[0] - size) // stride + 1
  # initialize the output matrix with zeros of shape avgpool_shape
  lowerCamelCase__:      Optional[int]			  =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
      lowerCamelCase__:      int			  =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
    lowerCamelCase__:      Dict			  =0
    lowerCamelCase__:      List[str]			  =0

  return updated_arr


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

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

     # Loading the image
     __A									=				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()









'''simple docstring'''







class _lowercase	:




							def __init__(							self:				Tuple			,							UpperCamelCase__:				list[int]     ):
														lowerCamelCase__					:	Union[str, Any]         =       len(UpperCamelCase__     )
														lowerCamelCase__					:	Union[str, Any]         =       [0] * len_array

														if len_array > 0:
																					lowerCamelCase__					:	Union[str, Any]         =       array[0]

														for i in range(1			,							UpperCamelCase__     ):
																					lowerCamelCase__					:	Tuple         =       self.prefix_sum[i - 1] + array[i]




							def 		lowerCamelCase_				(							self:				Tuple			,							UpperCamelCase__:				int			,							UpperCamelCase__:				int     ):
														if start == 0:
																					return self.prefix_sum[end]

														return self.prefix_sum[end] - self.prefix_sum[start - 1]




							def 		lowerCamelCase_				(							self:				Optional[int]			,							UpperCamelCase__:				int     ):
														lowerCamelCase__					:	Dict         =       {0}
														for sum_item in self.prefix_sum:
																					if sum_item - target_sum in sums:
																												return True

																					sums.add(UpperCamelCase__     )

														return False


if __name__ == "__main__":
			import doctest

			doctest.testmod()

