






'''simple docstring'''

import numpy as np
from PIL import Image
def     __lowercase  (_lowercase,						_lowercase,						_lowercase     )   ->     np.ndarray:


     """simple docstring"""
     __lowerCamelCase						:       Dict				   =				np.array(_lowercase     )
     if arr.shape[0] != arr.shape[1]:
          raise ValueError("""The input array is not a square matrix"""     )
     __lowerCamelCase						:       Union[str, Any]				   =				0
     __lowerCamelCase						:       Any				   =				0
     __lowerCamelCase						:       Any				   =				0
     __lowerCamelCase						:       List[str]				   =				0

     # compute the shape of the output matrix
     __lowerCamelCase						:       List[str]				   =				(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						:       Tuple				   =				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						:       Optional[Any]				   =				0
          __lowerCamelCase						:       Dict				   =				0

     return updated_arr
def     __lowercase  (_lowercase,						_lowercase,						_lowercase     )   ->     np.ndarray:


     """simple docstring"""
     __lowerCamelCase						:       Any				   =				np.array(_lowercase     )
     if arr.shape[0] != arr.shape[1]:
          raise ValueError("""The input array is not a square matrix"""     )
     __lowerCamelCase						:       Any				   =				0
     __lowerCamelCase						:       List[Any]				   =				0
     __lowerCamelCase						:       Optional[int]				   =				0
     __lowerCamelCase						:       Optional[Any]				   =				0

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

     return updated_arr


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

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

   # Loading the image
   UpperCAmelCase__						:Any          =			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'''

UpperCAmelCase__						:List[Any]          =			256
# Modulus to hash a string
UpperCAmelCase__						:str          =			1_000_003
def     __lowercase  (_lowercase,						_lowercase     )   ->     bool:


     """simple docstring"""
     __lowerCamelCase						:       str				   =				len(_lowercase     )
     __lowerCamelCase						:       List[str]				   =				len(_lowercase     )
     if p_len > t_len:
          return False

     __lowerCamelCase						:       Optional[Any]				   =				0
     __lowerCamelCase						:       Tuple				   =				0
     __lowerCamelCase						:       Dict				   =				1

     # Calculating the hash of pattern and substring of text
     for i in range(_lowercase     ):
          __lowerCamelCase						:       Optional[int]				   =				(ord(pattern[i]     ) + p_hash * alphabet_size) % modulus
          __lowerCamelCase						:       Dict				   =				(ord(text[i]     ) + text_hash * alphabet_size) % modulus
          if i == p_len - 1:
               continue
          __lowerCamelCase						:       Dict				   =				(modulus_power * alphabet_size) % modulus

     for i in range(0,						t_len - p_len + 1     ):
          if text_hash == p_hash and text[i : i + p_len] == pattern:
               return True
          if i == t_len - p_len:
               continue
          # Calculate the https://en.wikipedia.org/wiki/Rolling_hash
          __lowerCamelCase						:       Dict				   =				(
              (text_hash - ord(text[i]     ) * modulus_power) * alphabet_size
              + ord(text[i + p_len]     )
          ) % modulus
     return False
def     __lowercase  ()   ->     None:


     """simple docstring"""
     __lowerCamelCase						:       List[Any]				   =				"""abc1abc12"""
     __lowerCamelCase						:       Optional[Any]				   =				"""alskfjaldsabc1abc1abc12k23adsfabcabc"""
     __lowerCamelCase						:       List[Any]				   =				"""alskfjaldsk23adsfabcabc"""
     assert rabin_karp(_lowercase,						_lowercase     ) and not rabin_karp(_lowercase,						_lowercase     )

     # Test 2)
     __lowerCamelCase						:       Optional[int]				   =				"""ABABX"""
     __lowerCamelCase						:       Dict				   =				"""ABABZABABYABABX"""
     assert rabin_karp(_lowercase,						_lowercase     )

     # Test 3)
     __lowerCamelCase						:       Any				   =				"""AAAB"""
     __lowerCamelCase						:       int				   =				"""ABAAAAAB"""
     assert rabin_karp(_lowercase,						_lowercase     )

     # Test 4)
     __lowerCamelCase						:       Any				   =				"""abcdabcy"""
     __lowerCamelCase						:       Dict				   =				"""abcxabcdabxabcdabcdabcy"""
     assert rabin_karp(_lowercase,						_lowercase     )

     # Test 5)
     __lowerCamelCase						:       str				   =				"""Lü"""
     __lowerCamelCase						:       str				   =				"""Lüsai"""
     assert rabin_karp(_lowercase,						_lowercase     )
     __lowerCamelCase						:       Tuple				   =				"""Lue"""
     assert not rabin_karp(_lowercase,						_lowercase     )
     print("""Success."""     )


if __name__ == "__main__":
   test_rabin_karp()



