


'''simple docstring'''

import math
import unittest





def __snake_case      (   UpperCAmelCase_		:		int	):
 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   snake_case					(					unittest.TestCase    ):





  """simple docstring"""




  def 						snake_case	(					self  ):







   """simple docstring"""
   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  ):







   """simple docstring"""
   with self.assertRaises(UpperCamelCase  ):
    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 math





def __snake_case      (   UpperCAmelCase_		:		float      ,       UpperCAmelCase_		:		float	):
 return math.pow(UpperCAmelCase_      ,       2	) - a





def __snake_case      (   UpperCAmelCase_		:		float	):
 return 2 * x





def __snake_case      (   UpperCAmelCase_		:		float	):
 lowerCamelCase_  				=						2.0

 while start <= a:
  lowerCamelCase_  				=						math.pow(UpperCAmelCase_      ,       2	)

 return start





def __snake_case      (   UpperCAmelCase_		:		float      ,       UpperCAmelCase_		:		int = 9999      ,       UpperCAmelCase_		:		float = 0.00_0000_0000_0001	):

 if a < 0:
  raise ValueError("math domain error"	)

 lowerCamelCase_  				=						get_initial_point(UpperCAmelCase_	)

 for _ in range(UpperCAmelCase_	):
  lowerCamelCase_  				=						value
  lowerCamelCase_  				=						value - fx(UpperCAmelCase_      ,       UpperCAmelCase_	) / fx_derivative(UpperCAmelCase_	)
  if abs(prev_value - value	) < tolerance:
   return value

 return value


if __name__ == "__main__":
     from doctest import testmod

     testmod()



