





"""simple docstring"""


import random

def      UpperCamelCase							(SCREAMING_SNAKE_CASE     ):
						UpperCamelCase				:		Tuple				   =			num - 1
						UpperCamelCase				:		Tuple				   =			0

						while s % 2 == 0:
												UpperCamelCase				:		Any				   =			s // 2
												t += 1

						for _ in range(5     ):
												UpperCamelCase				:		str				   =			random.randrange(2							,     num - 1     )
												UpperCamelCase				:		List[Any]				   =			pow(SCREAMING_SNAKE_CASE							,     SCREAMING_SNAKE_CASE							,     SCREAMING_SNAKE_CASE     )
												if v != 1:
																		UpperCamelCase				:		Dict				   =			0
																		while v != (num - 1):
																								if i == t - 1:
																														return False
																								else:
																														UpperCamelCase				:		Any				   =			i + 1
																														UpperCamelCase				:		List[str]				   =			(v**2) % num
						return True

def      UpperCamelCase							(SCREAMING_SNAKE_CASE     ):
						if num < 2:
												return False

						UpperCamelCase				:		Dict				   =			[
						    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(SCREAMING_SNAKE_CASE     )

def      UpperCamelCase							(SCREAMING_SNAKE_CASE = 1024     ):
						while True:
												UpperCamelCase				:		Dict				   =			random.randrange(2 ** (keysize - 1)							,     2 ** (keysize)     )
												if is_prime_low_num(SCREAMING_SNAKE_CASE     ):
																		return num


if __name__ == "__main__":
		__magic_name__       :					str						=			generate_large_prime()
		print(("""Prime number:""", num))
		print(("""is_prime_low_num:""", is_prime_low_num(num)))







"""simple docstring"""

import unittest

import numpy as np

from transformers.testing_utils import require_flax, require_tf, require_torch
from transformers.utils import (
    expand_dims,
    flatten_dict,
    is_flax_available,
    is_tf_available,
    is_torch_available,
    reshape,
    squeeze,
    transpose,
)


if is_flax_available():
       import jax.numpy as jnp

if is_tf_available():
       import tensorflow as tf

if is_torch_available():
       import torch





class  lowerCamelCase__    (		unittest.TestCase     ):
      def SCREAMING_SNAKE_CASE_						(		self						:						Any				):






       '''simple docstring'''


       __lowercase						=						{
           """task_specific_params""": {
               """summarization""": {"""length_penalty""": 1.0, """max_length""": 1_2_8, """min_length""": 1_2, """num_beams""": 4},
               """summarization_cnn""": {"""length_penalty""": 2.0, """max_length""": 1_4_2, """min_length""": 5_6, """num_beams""": 4},
               """summarization_xsum""": {"""length_penalty""": 1.0, """max_length""": 6_2, """min_length""": 1_1, """num_beams""": 6},
           }
       }
       __lowercase						=						{
           """task_specific_params.summarization.length_penalty""": 1.0,
           """task_specific_params.summarization.max_length""": 1_2_8,
           """task_specific_params.summarization.min_length""": 1_2,
           """task_specific_params.summarization.num_beams""": 4,
           """task_specific_params.summarization_cnn.length_penalty""": 2.0,
           """task_specific_params.summarization_cnn.max_length""": 1_4_2,
           """task_specific_params.summarization_cnn.min_length""": 5_6,
           """task_specific_params.summarization_cnn.num_beams""": 4,
           """task_specific_params.summarization_xsum.length_penalty""": 1.0,
           """task_specific_params.summarization_xsum.max_length""": 6_2,
           """task_specific_params.summarization_xsum.min_length""": 1_1,
           """task_specific_params.summarization_xsum.num_beams""": 6,
       }

       self.assertEqual(flatten_dict(A_				)   ,							A_				)
      def SCREAMING_SNAKE_CASE_						(		self						:						Union[str, Any]				):






       '''simple docstring'''


       __lowercase						=						np.random.randn(3   ,							4				)
       self.assertTrue(np.allclose(transpose(A_				)   ,							x.transpose()				)				)

       __lowercase						=						np.random.randn(3   ,							4   ,							5				)
       self.assertTrue(np.allclose(transpose(A_   ,							axes=(1, 2, 0)				)   ,							x.transpose((1, 2, 0)				)				)				)
      @require_torch
      def SCREAMING_SNAKE_CASE_						(		self						:						Tuple				):






       '''simple docstring'''


       __lowercase						=						np.random.randn(3   ,							4				)
       __lowercase						=						torch.tensor(A_				)
       self.assertTrue(np.allclose(transpose(A_				)   ,							transpose(A_				).numpy()				)				)

       __lowercase						=						np.random.randn(3   ,							4   ,							5				)
       __lowercase						=						torch.tensor(A_				)
       self.assertTrue(np.allclose(transpose(A_   ,							axes=(1, 2, 0)				)   ,							transpose(A_   ,							axes=(1, 2, 0)				).numpy()				)				)
      @require_tf
      def SCREAMING_SNAKE_CASE_						(		self						:						int				):






       '''simple docstring'''


       __lowercase						=						np.random.randn(3   ,							4				)
       __lowercase						=						tf.constant(A_				)
       self.assertTrue(np.allclose(transpose(A_				)   ,							transpose(A_				).numpy()				)				)

       __lowercase						=						np.random.randn(3   ,							4   ,							5				)
       __lowercase						=						tf.constant(A_				)
       self.assertTrue(np.allclose(transpose(A_   ,							axes=(1, 2, 0)				)   ,							transpose(A_   ,							axes=(1, 2, 0)				).numpy()				)				)
      @require_flax
      def SCREAMING_SNAKE_CASE_						(		self						:						Optional[int]				):






       '''simple docstring'''


       __lowercase						=						np.random.randn(3   ,							4				)
       __lowercase						=						jnp.array(A_				)
       self.assertTrue(np.allclose(transpose(A_				)   ,							np.asarray(transpose(A_				)				)				)				)

       __lowercase						=						np.random.randn(3   ,							4   ,							5				)
       __lowercase						=						jnp.array(A_				)
       self.assertTrue(np.allclose(transpose(A_   ,							axes=(1, 2, 0)				)   ,							np.asarray(transpose(A_   ,							axes=(1, 2, 0)				)				)				)				)
      def SCREAMING_SNAKE_CASE_						(		self						:						Tuple				):






       '''simple docstring'''


       __lowercase						=						np.random.randn(3   ,							4				)
       self.assertTrue(np.allclose(reshape(A_   ,							(4, 3)				)   ,							np.reshape(A_   ,							(4, 3)				)				)				)

       __lowercase						=						np.random.randn(3   ,							4   ,							5				)
       self.assertTrue(np.allclose(reshape(A_   ,							(1_2, 5)				)   ,							np.reshape(A_   ,							(1_2, 5)				)				)				)
      @require_torch
      def SCREAMING_SNAKE_CASE_						(		self						:						Dict				):






       '''simple docstring'''


       __lowercase						=						np.random.randn(3   ,							4				)
       __lowercase						=						torch.tensor(A_				)
       self.assertTrue(np.allclose(reshape(A_   ,							(4, 3)				)   ,							reshape(A_   ,							(4, 3)				).numpy()				)				)

       __lowercase						=						np.random.randn(3   ,							4   ,							5				)
       __lowercase						=						torch.tensor(A_				)
       self.assertTrue(np.allclose(reshape(A_   ,							(1_2, 5)				)   ,							reshape(A_   ,							(1_2, 5)				).numpy()				)				)
      @require_tf
      def SCREAMING_SNAKE_CASE_						(		self						:						Optional[int]				):






       '''simple docstring'''


       __lowercase						=						np.random.randn(3   ,							4				)
       __lowercase						=						tf.constant(A_				)
       self.assertTrue(np.allclose(reshape(A_   ,							(4, 3)				)   ,							reshape(A_   ,							(4, 3)				).numpy()				)				)

       __lowercase						=						np.random.randn(3   ,							4   ,							5				)
       __lowercase						=						tf.constant(A_				)
       self.assertTrue(np.allclose(reshape(A_   ,							(1_2, 5)				)   ,							reshape(A_   ,							(1_2, 5)				).numpy()				)				)
      @require_flax
      def SCREAMING_SNAKE_CASE_						(		self						:						str				):






       '''simple docstring'''


       __lowercase						=						np.random.randn(3   ,							4				)
       __lowercase						=						jnp.array(A_				)
       self.assertTrue(np.allclose(reshape(A_   ,							(4, 3)				)   ,							np.asarray(reshape(A_   ,							(4, 3)				)				)				)				)

       __lowercase						=						np.random.randn(3   ,							4   ,							5				)
       __lowercase						=						jnp.array(A_				)
       self.assertTrue(np.allclose(reshape(A_   ,							(1_2, 5)				)   ,							np.asarray(reshape(A_   ,							(1_2, 5)				)				)				)				)
      def SCREAMING_SNAKE_CASE_						(		self						:						Dict				):






       '''simple docstring'''


       __lowercase						=						np.random.randn(1   ,							3   ,							4				)
       self.assertTrue(np.allclose(squeeze(A_				)   ,							np.squeeze(A_				)				)				)

       __lowercase						=						np.random.randn(1   ,							4   ,							1   ,							5				)
       self.assertTrue(np.allclose(squeeze(A_   ,							axis=2				)   ,							np.squeeze(A_   ,							axis=2				)				)				)
      @require_torch
      def SCREAMING_SNAKE_CASE_						(		self						:						List[Any]				):






       '''simple docstring'''


       __lowercase						=						np.random.randn(1   ,							3   ,							4				)
       __lowercase						=						torch.tensor(A_				)
       self.assertTrue(np.allclose(squeeze(A_				)   ,							squeeze(A_				).numpy()				)				)

       __lowercase						=						np.random.randn(1   ,							4   ,							1   ,							5				)
       __lowercase						=						torch.tensor(A_				)
       self.assertTrue(np.allclose(squeeze(A_   ,							axis=2				)   ,							squeeze(A_   ,							axis=2				).numpy()				)				)
      @require_tf
      def SCREAMING_SNAKE_CASE_						(		self						:						Tuple				):






       '''simple docstring'''


       __lowercase						=						np.random.randn(1   ,							3   ,							4				)
       __lowercase						=						tf.constant(A_				)
       self.assertTrue(np.allclose(squeeze(A_				)   ,							squeeze(A_				).numpy()				)				)

       __lowercase						=						np.random.randn(1   ,							4   ,							1   ,							5				)
       __lowercase						=						tf.constant(A_				)
       self.assertTrue(np.allclose(squeeze(A_   ,							axis=2				)   ,							squeeze(A_   ,							axis=2				).numpy()				)				)
      @require_flax
      def SCREAMING_SNAKE_CASE_						(		self						:						List[Any]				):






       '''simple docstring'''


       __lowercase						=						np.random.randn(1   ,							3   ,							4				)
       __lowercase						=						jnp.array(A_				)
       self.assertTrue(np.allclose(squeeze(A_				)   ,							np.asarray(squeeze(A_				)				)				)				)

       __lowercase						=						np.random.randn(1   ,							4   ,							1   ,							5				)
       __lowercase						=						jnp.array(A_				)
       self.assertTrue(np.allclose(squeeze(A_   ,							axis=2				)   ,							np.asarray(squeeze(A_   ,							axis=2				)				)				)				)
      def SCREAMING_SNAKE_CASE_						(		self						:						Tuple				):






       '''simple docstring'''


       __lowercase						=						np.random.randn(3   ,							4				)
       self.assertTrue(np.allclose(expand_dims(A_   ,							axis=1				)   ,							np.expand_dims(A_   ,							axis=1				)				)				)
      @require_torch
      def SCREAMING_SNAKE_CASE_						(		self						:						Optional[int]				):






       '''simple docstring'''


       __lowercase						=						np.random.randn(3   ,							4				)
       __lowercase						=						torch.tensor(A_				)
       self.assertTrue(np.allclose(expand_dims(A_   ,							axis=1				)   ,							expand_dims(A_   ,							axis=1				).numpy()				)				)
      @require_tf
      def SCREAMING_SNAKE_CASE_						(		self						:						Optional[Any]				):






       '''simple docstring'''


       __lowercase						=						np.random.randn(3   ,							4				)
       __lowercase						=						tf.constant(A_				)
       self.assertTrue(np.allclose(expand_dims(A_   ,							axis=1				)   ,							expand_dims(A_   ,							axis=1				).numpy()				)				)






      @require_flax
      def SCREAMING_SNAKE_CASE_						(		self						:						List[str]				):






       '''simple docstring'''


       __lowercase						=						np.random.randn(3   ,							4				)
       __lowercase						=						jnp.array(A_				)
       self.assertTrue(np.allclose(expand_dims(A_   ,							axis=1				)   ,							np.asarray(expand_dims(A_   ,							axis=1				)				)				)				)
