"""simple docstring"""





from math import sqrt





def        a_  (   _lowerCAmelCase						:				int  ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ) and (
           number >= 0
       ), "'number' must been an int and positive"

       lowercase__    :	List[str]     					=			True

       # 0 and 1 are none primes.
       if number <= 1:
              lowercase__    :	int     					=			False

       for divisor in range(2     ,				int(round(sqrt(_lowerCAmelCase  )  )  ) + 1  ):
              # if 'number' divisible by 'divisor' then sets 'status'
              # of false and break up the loop.
              if number % divisor == 0:
                     lowercase__    :	List[str]     					=			False
                     break

    # precondition
       assert isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ), "'status' must been from type bool"

       return status





def        a_  (   _lowerCAmelCase						:				Optional[Any]  ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ) and (n > 2), "'N' must been an int and > 2"

       # beginList: contains all natural numbers from 2 up to N
       lowercase__    :	int     					=			list(range(2     ,				n + 1  )  )

       lowercase__    :	Dict     					=			[]  # this list will be returns.

       # actual sieve of erathostenes
       for i in range(len(_lowerCAmelCase  )  ):
              for j in range(i + 1     ,				len(_lowerCAmelCase  )  ):
                     if (begin_list[i] != 0) and (begin_list[j] % begin_list[i] == 0):
                            lowercase__    :	Tuple     					=			0

    # filters actual prime numbers.
       lowercase__    :	List[Any]     					=			[x for x in begin_list if x != 0]

       # precondition
       assert isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ), "'ans' must been from type list"

       return ans





def        a_  (   _lowerCAmelCase						:				Any  ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ) and (n > 2), "'N' must been an int and > 2"

       lowercase__    :	List[Any]     					=			[]

       # iterates over all numbers between 2 up to N+1
       # if a number is prime then appends to list 'ans'
       for number in range(2     ,				n + 1  ):
              if is_prime(_lowerCAmelCase  ):
                     ans.append(_lowerCAmelCase  )

    # precondition
       assert isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ), "'ans' must been from type list"

       return ans





def        a_  (   _lowerCAmelCase						:				str  ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ) and number >= 0, "'number' must been an int and >= 0"

       lowercase__    :	Any     					=			[]  # this list will be returns of the function.

       # potential prime number factors.

       lowercase__    :	List[Any]     					=			2

       lowercase__    :	List[str]     					=			number

       if number == 0 or number == 1:
              ans.append(_lowerCAmelCase  )

       # if 'number' not prime then builds the prime factorization of 'number'
       elif not is_prime(_lowerCAmelCase  ):
              while quotient != 1:
                     if is_prime(_lowerCAmelCase  ) and (quotient % factor == 0):
                            ans.append(_lowerCAmelCase  )
                            quotient /= factor
                     else:
                            factor += 1

       else:
              ans.append(_lowerCAmelCase  )

       # precondition
       assert isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ), "'ans' must been from type list"

       return ans





def        a_  (   _lowerCAmelCase						:				Union[str, Any]  ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ) and (
           number >= 0
       ), "'number' bust been an int and >= 0"

       lowercase__    :	List[str]     					=			0

       # prime factorization of 'number'
       lowercase__    :	str     					=			prime_factorization(_lowerCAmelCase  )

       lowercase__    :	Dict     					=			max(_lowerCAmelCase  )

       # precondition
       assert isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ), "'ans' must been from type int"

       return ans





def        a_  (   _lowerCAmelCase						:				str  ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ) and (
           number >= 0
       ), "'number' bust been an int and >= 0"

       lowercase__    :	int     					=			0

       # prime factorization of 'number'
       lowercase__    :	Any     					=			prime_factorization(_lowerCAmelCase  )

       lowercase__    :	str     					=			min(_lowerCAmelCase  )

       # precondition
       assert isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ), "'ans' must been from type int"

       return ans





def        a_  (   _lowerCAmelCase						:				Optional[Any]  ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ), "'number' must been an int"
       assert isinstance(number % 2 == 0     ,				_lowerCAmelCase  ), "compare bust been from type bool"

       return number % 2 == 0





def        a_  (   _lowerCAmelCase						:				Any  ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ), "'number' must been an int"
       assert isinstance(number % 2 != 0     ,				_lowerCAmelCase  ), "compare bust been from type bool"

       return number % 2 != 0





def        a_  (   _lowerCAmelCase						:				Tuple  ):





       '''simple docstring'''

       assert (
           isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ) and (number > 2) and is_even(_lowerCAmelCase  )
       ), "'number' must been an int, even and > 2"

       lowercase__    :	Dict     					=			[]  # this list will returned

       # creates a list of prime numbers between 2 up to 'number'
       lowercase__    :	Optional[Any]     					=			get_prime_numbers(_lowerCAmelCase  )
       lowercase__    :	Optional[int]     					=			len(_lowerCAmelCase  )

       # run variable for while-loops.
       lowercase__    :	List[Any]     					=			0
       lowercase__    :	Any     					=			None

       # exit variable. for break up the loops
       lowercase__    :	List[Any]     					=			True

       while i < len_pn and loop:
              lowercase__    :	Dict     					=			i + 1

              while j < len_pn and loop:
                     if prime_numbers[i] + prime_numbers[j] == number:
                            lowercase__    :	Optional[Any]     					=			False
                            ans.append(prime_numbers[i]  )
                            ans.append(prime_numbers[j]  )

                     j += 1

              i += 1

       # precondition
       assert (
           isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  )
           and (len(_lowerCAmelCase  ) == 2)
           and (ans[0] + ans[1] == number)
           and is_prime(ans[0]  )
           and is_prime(ans[1]  )
       ), "'ans' must contains two primes. And sum of elements must been eq 'number'"

       return ans





def        a_  (   _lowerCAmelCase						:				Tuple     ,				_lowerCAmelCase						:				Dict  ):





       '''simple docstring'''

       assert (
           isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  )
           and isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  )
           and (numbera >= 0)
           and (numbera >= 0)
       ), "'number1' and 'number2' must been positive integer."

       lowercase__    :	List[Any]     					=			0

       while numbera != 0:
              lowercase__    :	Union[str, Any]     					=			numbera % numbera
              lowercase__    :	Any     					=			numbera
              lowercase__    :	Any     					=			rest

       # precondition
       assert isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ) and (
           numbera >= 0
       ), "'number' must been from type int and positive"

       return numbera





def        a_  (   _lowerCAmelCase						:				Union[str, Any]     ,				_lowerCAmelCase						:				str  ):





       '''simple docstring'''

       assert (
           isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  )
           and isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  )
           and (numbera >= 1)
           and (numbera >= 1)
       ), "'number1' and 'number2' must been positive integer."

       lowercase__    :	Tuple     					=			1  # actual answer that will be return.

       # for kgV (x,1)
       if numbera > 1 and numbera > 1:
              # builds the prime factorization of 'number1' and 'number2'
              lowercase__    :	int     					=			prime_factorization(_lowerCAmelCase  )
              lowercase__    :	Dict     					=			prime_factorization(_lowerCAmelCase  )

       elif numbera == 1 or numbera == 1:
              lowercase__    :	Any     					=			[]
              lowercase__    :	Tuple     					=			[]
              lowercase__    :	Tuple     					=			max(_lowerCAmelCase     ,				_lowerCAmelCase  )

       lowercase__    :	str     					=			0
       lowercase__    :	List[Any]     					=			0

       lowercase__    :	List[Any]     					=			[]  # captured numbers int both 'primeFac1' and 'primeFac2'

       # iterates through primeFac1
       for n in prime_fac_a:
              if n not in done:
                     if n in prime_fac_a:
                            lowercase__    :	Tuple     					=			prime_fac_a.count(_lowerCAmelCase  )
                            lowercase__    :	List[str]     					=			prime_fac_a.count(_lowerCAmelCase  )

                            for _ in range(max(_lowerCAmelCase     ,				_lowerCAmelCase  )  ):
                                   ans *= n

                     else:
                            lowercase__    :	Optional[Any]     					=			prime_fac_a.count(_lowerCAmelCase  )

                            for _ in range(_lowerCAmelCase  ):
                                   ans *= n

                     done.append(_lowerCAmelCase  )

    # iterates through primeFac2
       for n in prime_fac_a:
              if n not in done:
                     lowercase__    :	int     					=			prime_fac_a.count(_lowerCAmelCase  )

                     for _ in range(_lowerCAmelCase  ):
                            ans *= n

                     done.append(_lowerCAmelCase  )

    # precondition
       assert isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ) and (
           ans >= 0
       ), "'ans' must been from type int and positive"

       return ans





def        a_  (   _lowerCAmelCase						:				List[Any]  ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ) and (n >= 0), "'number' must been a positive int"

       lowercase__    :	int     					=			0
       lowercase__    :	List[Any]     					=			2  # this variable holds the answer

       while index < n:
              index += 1

              ans += 1  # counts to the next number

              # if ans not prime then
              # runs to the next prime number.
              while not is_prime(_lowerCAmelCase  ):
                     ans += 1

    # precondition
       assert isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ) and is_prime(
           _lowerCAmelCase  ), "'ans' must been a prime number and from type int"

       return ans





def        a_  (   _lowerCAmelCase						:				Optional[Any]     ,				_lowerCAmelCase						:				Union[str, Any]  ):





       '''simple docstring'''

       assert (
           is_prime(_lowerCAmelCase  ) and is_prime(_lowerCAmelCase  ) and (p_number_a < p_number_a)
       ), "The arguments must been prime numbers and 'pNumber1' < 'pNumber2'"

       lowercase__    :	List[str]     					=			p_number_a + 1  # jump to the next number

       lowercase__    :	Union[str, Any]     					=			[]  # this list will be returns.

       # if number is not prime then
       # fetch the next prime number.
       while not is_prime(_lowerCAmelCase  ):
              number += 1

       while number < p_number_a:
              ans.append(_lowerCAmelCase  )

              number += 1

              # fetch the next prime number.
              while not is_prime(_lowerCAmelCase  ):
                     number += 1

    # precondition
       assert (
           isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  )
           and ans[0] != p_number_a
           and ans[len(_lowerCAmelCase  ) - 1] != p_number_a
       ), "'ans' must been a list without the arguments"

       # 'ans' contains not 'pNumber1' and 'pNumber2' !
       return ans





def        a_  (   _lowerCAmelCase						:				Optional[int]  ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ) and (n >= 1), "'n' must been int and >= 1"

       lowercase__    :	Any     					=			[]  # will be returned.

       for divisor in range(1     ,				n + 1  ):
              if n % divisor == 0:
                     ans.append(_lowerCAmelCase  )

    # precondition
       assert ans[0] == 1 and ans[len(_lowerCAmelCase  ) - 1] == n, "Error in function getDivisiors(...)"

       return ans





def        a_  (   _lowerCAmelCase						:				Tuple  ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ) and (
           number > 1
       ), "'number' must been an int and >= 1"

       lowercase__    :	int     					=			get_divisors(_lowerCAmelCase  )

       # precondition
       assert (
           isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  )
           and (divisors[0] == 1)
           and (divisors[len(_lowerCAmelCase  ) - 1] == number)
       ), "Error in help-function getDivisiors(...)"

       # summed all divisors up to 'number' (exclusive), hence [:-1]
       return sum(divisors[:-1]  ) == number





def        a_  (   _lowerCAmelCase						:				Optional[int]     ,				_lowerCAmelCase						:				Any  ):





       '''simple docstring'''

       assert (
           isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  )
           and isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  )
           and (denominator != 0)
       ), "The arguments must been from type int and 'denominator' != 0"

       # build the greatest common divisor of numerator and denominator.
       lowercase__    :	Dict     					=			gcd(abs(_lowerCAmelCase  )     ,				abs(_lowerCAmelCase  )  )

       # precondition
       assert (
           isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  )
           and (numerator % gcd_of_fraction == 0)
           and (denominator % gcd_of_fraction == 0)
       ), "Error in function gcd(...,...)"

       return (numerator // gcd_of_fraction, denominator // gcd_of_fraction)





def        a_  (   _lowerCAmelCase						:				Dict  ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ) and (n >= 0), "'n' must been a int and >= 0"

       lowercase__    :	Optional[Any]     					=			1  # this will be return.

       for factor in range(1     ,				n + 1  ):
              ans *= factor

       return ans






def        a_  (   _lowerCAmelCase						:				int  ):





       '''simple docstring'''

       assert isinstance(_lowerCAmelCase     ,				_lowerCAmelCase  ) and (n >= 0), "'n' must been an int and >= 0"

       lowercase__    :	Union[str, Any]     					=			0
       lowercase__    :	Optional[Any]     					=			1
       lowercase__    :	Union[str, Any]     					=			1  # this will be return

       for _ in range(n - 1  ):
              lowercase__    :	Optional[int]     					=			ans
              ans += fiba
              lowercase__    :	List[Any]     					=			tmp

       return ans


"""simple docstring"""





import unittest

import numpy as np

from transformers import AlbertConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
       import jax.numpy as jnp

       from transformers.models.albert.modeling_flax_albert import (
           FlaxAlbertForMaskedLM,
           FlaxAlbertForMultipleChoice,
           FlaxAlbertForPreTraining,
           FlaxAlbertForQuestionAnswering,
           FlaxAlbertForSequenceClassification,
           FlaxAlbertForTokenClassification,
           FlaxAlbertModel,
       )


class   UpperCAmelCase_			(					unittest.TestCase):


      def __init__(     self	,    a	,    a=1_3	,    a=7	,    a=True	,    a=True	,    a=True	,    a=True	,    a=9_9	,    a=3_2	,    a=5	,    a=4	,    a=3_7	,    a="gelu"	,    a=0.1	,    a=0.1	,    a=5_1_2	,    a=1_6	,    a=2	,    a=0.02	,    a=4	,    ) ->      Dict:
             lowercase__    :	Optional[Any]     					=			parent
             lowercase__    :	Dict     					=			batch_size
             lowercase__    :	List[Any]     					=			seq_length
             lowercase__    :	int     					=			is_training
             lowercase__    :	str     					=			use_attention_mask
             lowercase__    :	Dict     					=			use_token_type_ids
             lowercase__    :	Optional[int]     					=			use_labels
             lowercase__    :	Tuple     					=			vocab_size
             lowercase__    :	List[str]     					=			hidden_size
             lowercase__    :	Union[str, Any]     					=			num_hidden_layers
             lowercase__    :	int     					=			num_attention_heads
             lowercase__    :	Dict     					=			intermediate_size
             lowercase__    :	List[str]     					=			hidden_act
             lowercase__    :	Dict     					=			hidden_dropout_prob
             lowercase__    :	Tuple     					=			attention_probs_dropout_prob
             lowercase__    :	List[str]     					=			max_position_embeddings
             lowercase__    :	int     					=			type_vocab_size
             lowercase__    :	List[str]     					=			type_sequence_label_size
             lowercase__    :	Union[str, Any]     					=			initializer_range
             lowercase__    :	Optional[int]     					=			num_choices


      def 	_UpperCAmelCase (     self							) ->      Tuple:
             lowercase__    :	List[Any]     					=			ids_tensor([self.batch_size, self.seq_length]	,    self.vocab_size							)

             lowercase__    :	str     					=			None
             if self.use_attention_mask:
                    lowercase__    :	Optional[Any]     					=			random_attention_mask([self.batch_size, self.seq_length]							)

             lowercase__    :	List[str]     					=			None
             if self.use_token_type_ids:
                    lowercase__    :	Optional[int]     					=			ids_tensor([self.batch_size, self.seq_length]	,    self.type_vocab_size							)

             lowercase__    :	Any     					=			AlbertConfig(
                 vocab_size=self.vocab_size	,    hidden_size=self.hidden_size	,    num_hidden_layers=self.num_hidden_layers	,    num_attention_heads=self.num_attention_heads	,    intermediate_size=self.intermediate_size	,    hidden_act=self.hidden_act	,    hidden_dropout_prob=self.hidden_dropout_prob	,    attention_probs_dropout_prob=self.attention_probs_dropout_prob	,    max_position_embeddings=self.max_position_embeddings	,    type_vocab_size=self.type_vocab_size	,    is_decoder=a	,    initializer_range=self.initializer_range	,    )

             return config, input_ids, token_type_ids, attention_mask


      def 	_UpperCAmelCase (     self							) ->      Any:
             lowercase__    :	Optional[int]     					=			self.prepare_config_and_inputs()
             lowercase__					,   lowercase__					,   lowercase__					,   lowercase__    :	Tuple     					=			config_and_inputs
             lowercase__    :	Union[str, Any]     					=			{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': attention_mask}
             return config, inputs_dict





@require_flax
class   UpperCAmelCase_			(					_a				,							unittest.TestCase):
      lowerCamelCase__	:					Tuple										=						(
          (
              FlaxAlbertModel,
              FlaxAlbertForPreTraining,
              FlaxAlbertForMaskedLM,
              FlaxAlbertForMultipleChoice,
              FlaxAlbertForQuestionAnswering,
              FlaxAlbertForSequenceClassification,
              FlaxAlbertForTokenClassification,
              FlaxAlbertForQuestionAnswering,
          )
          if is_flax_available()
          else ()
      )


      def 	_UpperCAmelCase (     self							) ->      List[Any]:
             lowercase__    :	Union[str, Any]     					=			FlaxAlbertModelTester(self							)


      @slow
      def 	_UpperCAmelCase (     self							) ->      str:
             for model_class_name in self.all_model_classes:
                    lowercase__    :	str     					=			model_class_name.from_pretrained('albert-base-v2'							)
                    lowercase__    :	Tuple     					=			model(np.ones((1, 1)							)							)
                    self.assertIsNotNone(a							)





@require_flax
class   UpperCAmelCase_			(					unittest.TestCase):


      @slow
      def 	_UpperCAmelCase (     self							) ->      Tuple:
             lowercase__    :	str     					=			FlaxAlbertModel.from_pretrained('albert-base-v2'							)
             lowercase__    :	Optional[int]     					=			np.array([[0, 3_4_5, 2_3_2, 3_2_8, 7_4_0, 1_4_0, 1_6_9_5, 6_9, 6_0_7_8, 1_5_8_8, 2]]							)
             lowercase__    :	Optional[Any]     					=			np.array([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]							)
             lowercase__    :	Any     					=			model(a	,    attention_mask=a							)[0]
             lowercase__    :	Tuple     					=			(1, 1_1, 7_6_8)
             self.assertEqual(output.shape	,    a							)
             lowercase__    :	Optional[Any]     					=			np.array(
                 [[[-0.6_513, 1.5_035, -0.2_766], [-0.6_515, 1.5_046, -0.2_780], [-0.6_512, 1.5_049, -0.2_784]]]							)

             self.assertTrue(jnp.allclose(output[:, 1:4, 1:4]	,    a	,    atol=1e-4							)							)

