


"""simple docstring"""




import math
import unittest

def        lowercase							(		lowerCAmelCase__ :     int			) ->      bool:
		assert isinstance(lowerCAmelCase__    ,					lowerCAmelCase__			) 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(lowerCAmelCase__			) + 1			)    ,					6			):
				if number % i == 0 or number % (i + 2) == 0:
						return False
		return True
class 					__lowerCAmelCase					(   unittest.TestCase       ):


		'''simple docstring'''



		def 			__UpperCAmelCase       (  self      ):
				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 			__UpperCAmelCase       (  self      ):
				with self.assertRaises(_a      ):
						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()










"""simple docstring"""




import unittest

import torch
from torch import nn

from diffusers.models.activations import get_activation
class 					__lowerCAmelCase					(   unittest.TestCase       ):


		'''simple docstring'''



		def 			__UpperCAmelCase       (  self      ):
				__a           =			get_activation('''swish'''      )

				self.assertIsInstance(_a							, nn.SiLU      )

				self.assertEqual(act(torch.tensor(-100							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertNotEqual(act(torch.tensor(-1							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertEqual(act(torch.tensor(0							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertEqual(act(torch.tensor(20							, dtype=torch.floataa      )      ).item()							, 20      )

		def 			__UpperCAmelCase       (  self      ):
				__a           =			get_activation('''silu'''      )

				self.assertIsInstance(_a							, nn.SiLU      )

				self.assertEqual(act(torch.tensor(-100							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertNotEqual(act(torch.tensor(-1							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertEqual(act(torch.tensor(0							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertEqual(act(torch.tensor(20							, dtype=torch.floataa      )      ).item()							, 20      )

		def 			__UpperCAmelCase       (  self      ):
				__a           =			get_activation('''mish'''      )

				self.assertIsInstance(_a							, nn.Mish      )

				self.assertEqual(act(torch.tensor(-200							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertNotEqual(act(torch.tensor(-1							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertEqual(act(torch.tensor(0							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertEqual(act(torch.tensor(20							, dtype=torch.floataa      )      ).item()							, 20      )





		def 			__UpperCAmelCase       (  self      ):
				__a           =			get_activation('''gelu'''      )

				self.assertIsInstance(_a							, nn.GELU      )

				self.assertEqual(act(torch.tensor(-100							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertNotEqual(act(torch.tensor(-1							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertEqual(act(torch.tensor(0							, dtype=torch.floataa      )      ).item()							, 0      )
				self.assertEqual(act(torch.tensor(20							, dtype=torch.floataa      )      ).item()							, 20      )






