






import os
import random
import sys

from . import cryptomath_module as cryptoMath  # noqa: N812
from . import rabin_miller as rabinMiller  # noqa: N812
def 		lowercase__  (				) ->			int:
      """simple docstring"""

      print('Making key files...')
      make_key_files('rsa'       ,							10_24)
      print('Key files generation successful.')
def 		lowercase__  (				_UpperCamelCase) ->			List[str]:
      """simple docstring"""

      print('Generating prime p...')
      UpperCamelCase					       =  rabinMiller.generate_large_prime(_UpperCamelCase)
      print('Generating prime q...')
      UpperCamelCase					       =  rabinMiller.generate_large_prime(_UpperCamelCase)
      UpperCamelCase					       =  p * q

      print('Generating e that is relatively prime to (p - 1) * (q - 1)...')
      while True:
            UpperCamelCase					       =  random.randrange(2 ** (key_size - 1)       ,							2 ** (key_size))
            if cryptoMath.gcd(_UpperCamelCase       ,							(p - 1) * (q - 1)) == 1:
                  break

      print('Calculating d that is mod inverse of e...')
      UpperCamelCase					       =  cryptoMath.find_mod_inverse(_UpperCamelCase       ,							(p - 1) * (q - 1))

      UpperCamelCase					       =  (n, e)
      UpperCamelCase					       =  (n, d)
      return (public_key, private_key)
def 		lowercase__  (				_UpperCamelCase       ,							_UpperCamelCase) ->			List[Any]:
      """simple docstring"""

      if os.path.exists(F'{name}_pubkey.txt') or os.path.exists(F'{name}_privkey.txt'):
            print('\nWARNING:')
            print(
                F'\"{name}_pubkey.txt\" or \"{name}_privkey.txt\" already exists. \n'
                'Use a different name or delete these files and re-run this program.')
            sys.exit()

      UpperCamelCase					       =  generate_key(_UpperCamelCase)
      print(F'\nWriting public key to file {name}_pubkey.txt...')
      with open(F'{name}_pubkey.txt'       ,							'w') as out_file:
            out_file.write(F'{key_size},{public_key[0]},{public_key[1]}')

      print(F'Writing private key to file {name}_privkey.txt...')
      with open(F'{name}_privkey.txt'       ,							'w') as out_file:
            out_file.write(F'{key_size},{private_key[0]},{private_key[1]}')


if __name__ == "__main__":
       main()






from collections.abc import Callable
from math import pi, sqrt
from random import uniform
from statistics import mean



def 			_A	(      SCREAMING_SNAKE_CASE      ):

	# A local function to see if a dot lands in the circle.
	def is_in_circle(SCREAMING_SNAKE_CASE	,SCREAMING_SNAKE_CASE      ) -> bool:
		UpperCAmelCase__:	Any									= sqrt((x**2) + (y**2)      )
		# Our circle has a radius of 1, so a distance
		# greater than 1 would land outside the circle.
		return distance_from_centre <= 1

	# The proportion of guesses that landed in the circle
	UpperCAmelCase__:	Optional[int]									= mean(
	    int(is_in_circle(uniform(-1.0	,1.0      )	,uniform(-1.0	,1.0      )      )      )
	    for _ in range(SCREAMING_SNAKE_CASE      )      )
	# The ratio of the area for circle to square is pi/4.
	UpperCAmelCase__:	Optional[int]									= proportion * 4
	print(f"The estimated value of pi is {pi_estimate}"      )
	print(f"The numpy value of pi is {pi}"      )
	print(f"The total error is {abs(pi - pi_estimate      )}"      )



def 			_A	(      SCREAMING_SNAKE_CASE	,SCREAMING_SNAKE_CASE	,SCREAMING_SNAKE_CASE = 0.0	,SCREAMING_SNAKE_CASE = 1.0	,):
	return mean(
	    function_to_integrate(uniform(SCREAMING_SNAKE_CASE	,SCREAMING_SNAKE_CASE      )      ) for _ in range(SCREAMING_SNAKE_CASE      )      ) * (max_value - min_value)



def 			_A	(      SCREAMING_SNAKE_CASE	,SCREAMING_SNAKE_CASE = 0.0	,SCREAMING_SNAKE_CASE = 1.0      ):

	def identity_function(SCREAMING_SNAKE_CASE      ) -> float:
		return x

	UpperCAmelCase__:	Tuple									= area_under_curve_estimator(
	    SCREAMING_SNAKE_CASE	,SCREAMING_SNAKE_CASE	,SCREAMING_SNAKE_CASE	,SCREAMING_SNAKE_CASE      )
	UpperCAmelCase__:	Optional[Any]									= (max_value * max_value - min_value * min_value) / 2

	print("******************"      )
	print(f"Estimating area under y=x where x varies from {min_value} to {max_value}"      )
	print(f"Estimated value is {estimated_value}"      )
	print(f"Expected value is {expected_value}"      )
	print(f"Total error is {abs(estimated_value - expected_value      )}"      )
	print("******************"      )



def 			_A	(      SCREAMING_SNAKE_CASE      ):

	def function_to_integrate(SCREAMING_SNAKE_CASE      ) -> float:
		return sqrt(4.0 - x * x      )

	UpperCAmelCase__:	Union[str, Any]									= area_under_curve_estimator(
	    SCREAMING_SNAKE_CASE	,SCREAMING_SNAKE_CASE	,0.0	,2.0      )

	print("******************"      )
	print("Estimating pi using area_under_curve_estimator"      )
	print(f"Estimated value is {estimated_value}"      )
	print(f"Expected value is {pi}"      )
	print(f"Total error is {abs(estimated_value - pi      )}"      )
	print("******************"      )


if __name__ == "__main__":
					import doctest

					doctest.testmod()