





import math
import unittest


def       SCREAMING_SNAKE_CASE__  (       _lowercase     : int			)   ->							bool:




		'''simple docstring'''
		assert isinstance(_lowercase   ,    _lowercase			) and (
		    number >= 0
		), "'number' must been an int and positive"

		if 1 < number < 4:
				# 2 and 3 are primes
				return True
		elif number < 2 or number % 2 == 0 or number % 3 == 0:
				# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
				return False

		# All primes number are in format of 6k +/- 1
		for i in range(5   ,    int(math.sqrt(_lowercase			) + 1			)   ,    6			):
				if number % i == 0 or number % (i + 2) == 0:
						return False
		return True


class       __lowerCAmelCase					(       unittest.TestCase      ):


	'''simple docstring'''





	def    snake_case__(						self:						List[str]			):
			self.assertTrue(is_prime(2			)			)
			self.assertTrue(is_prime(3			)			)
			self.assertTrue(is_prime(5			)			)
			self.assertTrue(is_prime(7			)			)
			self.assertTrue(is_prime(11			)			)
			self.assertTrue(is_prime(13			)			)
			self.assertTrue(is_prime(17			)			)
			self.assertTrue(is_prime(19			)			)
			self.assertTrue(is_prime(23			)			)
			self.assertTrue(is_prime(29			)			)





	def    snake_case__(						self:						Optional[int]			):
			with self.assertRaises(lowerCamelCase_			):
					is_prime(-19			)
			self.assertFalse(
			    is_prime(0			),					'Zero doesn\'t have any positive factors, primes must have exactly two.',					)
			self.assertFalse(
			    is_prime(1			),					'One only has 1 positive factor, primes must have exactly two.',					)
			self.assertFalse(is_prime(2 * 2			)			)
			self.assertFalse(is_prime(2 * 3			)			)
			self.assertFalse(is_prime(3 * 3			)			)
			self.assertFalse(is_prime(3 * 5			)			)
			self.assertFalse(is_prime(3 * 5 * 7			)			)


if __name__ == "__main__":
			unittest.main()









import numpy as np
from cva import destroyAllWindows, imread, imshow, waitKey


class       __lowerCAmelCase					:


	'''simple docstring'''





	def __init__(						self:						List[str],					lowerCamelCase_:						Optional[Any],					lowerCamelCase_:						int,					lowerCamelCase_:						int			):
			if dst_width < 0 or dst_height < 0:
					raise ValueError('Destination width/height should be > 0'			)

			lowercase__					:      str      =		img
			lowercase__					:      Tuple      =		img.shape[1]
			lowercase__					:      str      =		img.shape[0]
			lowercase__					:      Tuple      =		dst_width
			lowercase__					:      Any      =		dst_height

			lowercase__					:      Tuple      =		self.src_w / self.dst_w
			lowercase__					:      Union[str, Any]      =		self.src_h / self.dst_h

			lowercase__					:      List[Any]      =		(
			    np.ones((self.dst_h, self.dst_w, 3),					np.uinta			) * 255
			)

	def    snake_case__(						self:						Dict			):
			for i in range(self.dst_h			):
					for j in range(self.dst_w			):
							lowercase__					:      Tuple      =		self.img[self.get_y(lowerCamelCase_			)][self.get_x(lowerCamelCase_			)]

	def    snake_case__(						self:						List[str],					lowerCamelCase_:						int			):
			return int(self.ratio_x * x			)





	def    snake_case__(						self:						int,					lowerCamelCase_:						int			):
			return int(self.ratio_y * y			)


if __name__ == "__main__":
			__UpperCamelCase,	__UpperCamelCase:	List[Any] = 8_0_0, 6_0_0
			__UpperCamelCase:	Optional[Any] = imread("""image_data/lena.jpg""", 1)
			__UpperCamelCase:	Union[str, Any] = NearestNeighbour(im, dst_w, dst_h)
			n.process()

			imshow(
			    F'Image resized from: {im.shape[1]}x{im.shape[0]} to {dst_w}x{dst_h}', n.output
			)
			waitKey(0)
			destroyAllWindows()


