

import math
import unittest







def 			A_      (    _UpperCAmelCase    ):
						assert isinstance(_UpperCAmelCase				,	_UpperCAmelCase    ) 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(_UpperCAmelCase    ) + 1    )				,	6    ):
												if number % i == 0 or number % (i + 2) == 0:
																		return False
						return True



class   __lowercase				( unittest.TestCase	):




			"""simple docstring"""







			def        _SCREAMING_SNAKE_CASE			( self  :     Optional[Any]):
									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        _SCREAMING_SNAKE_CASE			( self  :     str):
									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()









def 			A_      (    _UpperCAmelCase				,	_UpperCAmelCase				,	_UpperCAmelCase				,	_UpperCAmelCase				,	_UpperCAmelCase				,	):
						SCREAMING_SNAKE_CASE_: Optional[int]  		=       [redshift, radiation_density, matter_density, dark_energy]
						if any(p < 0 for p in parameters    ):
												raise ValueError("All input parameters must be positive"    )

						if any(p > 1 for p in parameters[1:4]    ):
												raise ValueError("Relative densities cannot be greater than one"    )
						else:
												SCREAMING_SNAKE_CASE_: int  		=       1 - (matter_density + radiation_density + dark_energy)

												SCREAMING_SNAKE_CASE_: Dict  		=       (
												    radiation_density * (redshift + 1) ** 4
												    + matter_density * (redshift + 1) ** 3
												    + curvature * (redshift + 1) ** 2
												    + dark_energy
												)

												SCREAMING_SNAKE_CASE_: Any  		=       hubble_constant * e_a ** (1 / 2)
												return hubble


if __name__ == "__main__":
						import doctest

						# run doctest
						doctest.testmod()

						# demo LCDM approximation
						lowerCAmelCase							:  List[Any]   	=						0.3

						print(
						    hubble_parameter(
						        hubble_constant=68.3,
						        radiation_density=1E-4,
						        matter_density=matter_density,
						        dark_energy=1 - matter_density,
						        redshift=0,
						    )
						)






