





import numpy as np
from PIL import Image






def 							_lowerCAmelCase (  _a   :					np.ndarray					,   _a   :					int					,   _a   :					int			)	->			np.ndarray:
     lowerCAmelCase_					:       Any    =		np.array(_a			)
     if arr.shape[0] != arr.shape[1]:
          raise ValueError("""The input array is not a square matrix"""			)
     lowerCAmelCase_					:       Any    =		0
     lowerCAmelCase_					:       Dict    =		0
     lowerCAmelCase_					:       List[str]    =		0
     lowerCAmelCase_					:       Tuple    =		0

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

     return updated_arr






def 							_lowerCAmelCase (  _a   :					np.ndarray					,   _a   :					int					,   _a   :					int			)	->			np.ndarray:
     lowerCAmelCase_					:       str    =		np.array(_a			)
     if arr.shape[0] != arr.shape[1]:
          raise ValueError("""The input array is not a square matrix"""			)
     lowerCAmelCase_					:       Optional[Any]    =		0
     lowerCAmelCase_					:       List[Any]    =		0
     lowerCAmelCase_					:       Optional[Any]    =		0
     lowerCAmelCase_					:       Dict    =		0

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

     return updated_arr


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

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

      # Loading the image
      UpperCAmelCase_					:   List[str] 							=						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()







def 							_lowerCAmelCase (  _a   :					int					,   _a   :					bool = False			)	->			bool:
     if n == 2:
          return True
     if not n % 2 or n < 2:
          return False
     if n > 5 and n % 10 not in (1, 3, 7, 9):  # can quickly check last digit
          return False
     if n > 3_31_70_44_06_46_79_88_73_85_96_19_81 and not allow_probable:
          raise ValueError(
              """Warning: upper bound of deterministic test is exceeded. """
              """Pass allow_probable=True to allow probabilistic test. """
              """A return value of True indicates a probable prime."""			)
     # array bounds provided by analysis
     lowerCAmelCase_					:       Optional[int]    =		[
         20_47,
         1_37_36_53,
         25_32_60_01,
         32_15_03_17_51,
         2_15_23_02_89_87_47,
         3_47_47_49_66_03_83,
         3_41_55_00_71_72_83_21,
         1,
         3_82_51_23_05_65_46_41_30_51,
         1,
         1,
         31_86_65_85_78_34_03_11_51_16_74_61,
         3_31_70_44_06_46_79_88_73_85_96_19_81,
     ]

     lowerCAmelCase_					:       Dict    =		[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41]
     for idx, _p in enumerate(_a					,   1			):
          if n < _p:
               # then we have our last prime to check
               lowerCAmelCase_					:       str    =		primes[:idx]
               break
     lowerCAmelCase_   ,  lowerCAmelCase_					:       Optional[Any]    =		n - 1, 0
     # break up n -1 into a power of 2 (s) and
     # remaining odd component
     # essentially, solve for d * 2 ** s == n - 1
     while d % 2 == 0:
          d //= 2
          s += 1
     for prime in plist:
          lowerCAmelCase_					:       Tuple    =		False
          for r in range(_a			):
               lowerCAmelCase_					:       Tuple    =		pow(_a					,   d * 2**r					,   _a			)
               # see article for analysis explanation for m
               if (r == 0 and m == 1) or ((m + 1) % n == 0):
                    lowerCAmelCase_					:       List[Any]    =		True
                    # this loop will not determine compositeness
                    break
          if pr:
               continue
          # if pr is False, then the above loop never evaluated to true,
          # and the n MUST be composite
          return False
     return True






def 							_lowerCAmelCase (  )	->			None:
     assert not miller_rabin(5_61			)
     assert miller_rabin(5_63			)
     # 2047

     assert not miller_rabin(83_82_01			)
     assert miller_rabin(83_82_07			)
     # 1_373_653

     assert not miller_rabin(17_31_60_01			)
     assert miller_rabin(17_31_60_17			)
     # 25_326_001

     assert not miller_rabin(30_78_38_66_41			)
     assert miller_rabin(30_78_38_66_53			)
     # 3_215_031_751

     assert not miller_rabin(1_71_30_45_57_48_01			)
     assert miller_rabin(1_71_30_45_57_48_19			)
     # 2_152_302_898_747

     assert not miller_rabin(2_77_97_99_72_83_07			)
     assert miller_rabin(2_77_97_99_72_83_27			)
     # 3_474_749_660_383

     assert not miller_rabin(1_13_85_00_23_90_94_41			)
     assert miller_rabin(1_13_85_00_23_90_95_27			)
     # 341_550_071_728_321

     assert not miller_rabin(1_27_50_41_01_88_48_80_43_51			)
     assert miller_rabin(1_27_50_41_01_88_48_80_43_91			)
     # 3_825_123_056_546_413_051

     assert not miller_rabin(7_96_66_46_44_58_50_77_87_79_18_67			)
     assert miller_rabin(7_96_66_46_44_58_50_77_87_79_19_51			)
     # 318_665_857_834_031_151_167_461

     assert not miller_rabin(55_28_40_67_74_46_64_78_97_66_03_33			)
     assert miller_rabin(55_28_40_67_74_46_64_78_97_66_03_59			)
     # 3_317_044_064_679_887_385_961_981
     # upper limit for probabilistic test


if __name__ == "__main__":
      test_miller_rabin()
