

"""simple docstring"""





import random




def   _A  (  UpperCamelCase_					:	int)     ->						bool:
   '''simple docstring'''


   __lowercase								=						num - 1
   __lowercase								=						0

   while s % 2 == 0:
      __lowercase								=						s // 2
      t += 1

   for _ in range(5):
      __lowercase								=						random.randrange(2,      num - 1)
      __lowercase								=						pow(UpperCamelCase_,      UpperCamelCase_,      UpperCamelCase_)
      if v != 1:
         __lowercase								=						0
         while v != (num - 1):
            if i == t - 1:
               return False
            else:
               __lowercase								=						i + 1
               __lowercase								=						(v**2) % num
   return True




def   _A  (  UpperCamelCase_					:	int)     ->						bool:
   '''simple docstring'''


   if num < 2:
      return False

   __lowercase								=						[
       2,
       3,
       5,
       7,
       11,
       13,
       17,
       19,
       23,
       29,
       31,
       37,
       41,
       43,
       47,
       53,
       59,
       61,
       67,
       71,
       73,
       79,
       83,
       89,
       97,
       101,
       103,
       107,
       109,
       113,
       127,
       131,
       137,
       139,
       149,
       151,
       157,
       163,
       167,
       173,
       179,
       181,
       191,
       193,
       197,
       199,
       211,
       223,
       227,
       229,
       233,
       239,
       241,
       251,
       257,
       263,
       269,
       271,
       277,
       281,
       283,
       293,
       307,
       311,
       313,
       317,
       331,
       337,
       347,
       349,
       353,
       359,
       367,
       373,
       379,
       383,
       389,
       397,
       401,
       409,
       419,
       421,
       431,
       433,
       439,
       443,
       449,
       457,
       461,
       463,
       467,
       479,
       487,
       491,
       499,
       503,
       509,
       521,
       523,
       541,
       547,
       557,
       563,
       569,
       571,
       577,
       587,
       593,
       599,
       601,
       607,
       613,
       617,
       619,
       631,
       641,
       643,
       647,
       653,
       659,
       661,
       673,
       677,
       683,
       691,
       701,
       709,
       719,
       727,
       733,
       739,
       743,
       751,
       757,
       761,
       769,
       773,
       787,
       797,
       809,
       811,
       821,
       823,
       827,
       829,
       839,
       853,
       857,
       859,
       863,
       877,
       881,
       883,
       887,
       907,
       911,
       919,
       929,
       937,
       941,
       947,
       953,
       967,
       971,
       977,
       983,
       991,
       997,
   ]

   if num in low_primes:
      return True

   for prime in low_primes:
      if (num % prime) == 0:
         return False

   return rabin_miller(UpperCamelCase_)




def   _A  (  UpperCamelCase_					:	int = 1024)     ->						int:
   '''simple docstring'''


   while True:
      __lowercase								=						random.randrange(2 ** (keysize - 1),      2 ** (keysize))
      if is_prime_low_num(UpperCamelCase_):
         return num


if __name__ == "__main__":
   _a							=							generate_large_prime()
   print(('Prime number:', num))
   print(('is_prime_low_num:', is_prime_low_num(num)))







"""simple docstring"""





import json
import os
import tempfile

import datasets
from utils import generate_example_dataset, get_duration


_a							=							5_00_00
_a							=							50_00

_a				,						_a							=							os.path.split(__file__)
_a							=							os.path.join(RESULTS_BASEPATH, 'results', RESULTS_FILENAME.replace('.py', '.json'))




@get_duration
def   _A  (  UpperCamelCase_					:	datasets.Dataset,      UpperCamelCase_					:	List[str])     ->						List[str]:
   '''simple docstring'''


   for i in range(UpperCamelCase_):
      __lowercase								=						dataset[i]




@get_duration
def   _A  (  UpperCamelCase_					:	datasets.Dataset,      UpperCamelCase_					:	List[Any],      UpperCamelCase_					:	int)     ->						Dict:
   '''simple docstring'''


   for i in range(0,      len(UpperCamelCase_),      UpperCamelCase_):
      __lowercase								=						dataset[i : i + batch_size]




@get_duration
def   _A  (  UpperCamelCase_					:	datasets.Dataset,      UpperCamelCase_					:	Any,      UpperCamelCase_					:	Optional[int])     ->						List[str]:
   '''simple docstring'''


   with dataset.formatted_as(type=UpperCamelCase_):
      for i in range(UpperCamelCase_):
         __lowercase								=						dataset[i]




@get_duration
def   _A  (  UpperCamelCase_					:	datasets.Dataset,      UpperCamelCase_					:	str,      UpperCamelCase_					:	Union[str, Any],      UpperCamelCase_					:	Union[str, Any])     ->						Dict:
   '''simple docstring'''


   with dataset.formatted_as(type=UpperCamelCase_):
      for i in range(0,      UpperCamelCase_,      UpperCamelCase_):
         __lowercase								=						dataset[i : i + batch_size]




def   _A  (  )     ->						List[str]:
   '''simple docstring'''


   __lowercase								=						{"num examples": SPEED_TEST_N_EXAMPLES}
   __lowercase								=						[
       (read, {"length": SMALL_TEST}),
       (read, {"length": SPEED_TEST_N_EXAMPLES}),
       (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 10}),
       (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 100}),
       (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 1000}),
       (read_formatted, {"type": "numpy", "length": SMALL_TEST}),
       (read_formatted, {"type": "pandas", "length": SMALL_TEST}),
       (read_formatted, {"type": "torch", "length": SMALL_TEST}),
       (read_formatted, {"type": "tensorflow", "length": SMALL_TEST}),
       (read_formatted_batch, {"type": "numpy", "length": SMALL_TEST, "batch_size": 10}),
       (read_formatted_batch, {"type": "numpy", "length": SMALL_TEST, "batch_size": 1000}),
   ]

   __lowercase								=						[
       (read, {"length": SMALL_TEST}),
       (read, {"length": SPEED_TEST_N_EXAMPLES}),
       (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 10}),
       (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 100}),
       (read_batch, {"length": SPEED_TEST_N_EXAMPLES, "batch_size": 1000}),
       (read_formatted, {"type": "numpy", "length": SMALL_TEST}),
       (read_formatted_batch, {"type": "numpy", "length": SMALL_TEST, "batch_size": 10}),
       (read_formatted_batch, {"type": "numpy", "length": SMALL_TEST, "batch_size": 1000}),
   ]
   with tempfile.TemporaryDirectory() as tmp_dir:
      print("generating dataset")
      __lowercase								=						datasets.Features(
          {"list": datasets.Sequence(datasets.Value("float32")), "numbers": datasets.Value("float32")})
      __lowercase								=						generate_example_dataset(
          os.path.join(UpperCamelCase_,      "dataset.arrow"),      UpperCamelCase_,      num_examples=UpperCamelCase_,      seq_shapes={"list": (100,)},      )
      print("first set of iterations")
      for func, kwargs in functions:
         print(func.__name__,      str(UpperCamelCase_))
         __lowercase								=						func(UpperCamelCase_,      **UpperCamelCase_)

      print("shuffling dataset")
      __lowercase								=						dataset.shuffle()
      print("Second set of iterations (after shuffling")
      for func, kwargs in functions_shuffled:
         print("shuffled ",      func.__name__,      str(UpperCamelCase_))
         __lowercase								=						func(
             UpperCamelCase_,      **UpperCamelCase_)

   with open(UpperCamelCase_,      "wb") as f:
      f.write(json.dumps(UpperCamelCase_).encode("utf-8"))


if __name__ == "__main__":  # useful to run the profiler
   benchmark_iterating()




