






"""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      )		->       List[Any]:
       UpperCamelCase__         =    {
           'task_specific_params': {
               'summarization': {'length_penalty': 1.0, 'max_length': 128, 'min_length': 12, 'num_beams': 4},
               'summarization_cnn': {'length_penalty': 2.0, 'max_length': 142, 'min_length': 56, 'num_beams': 4},
               'summarization_xsum': {'length_penalty': 1.0, 'max_length': 62, 'min_length': 11, 'num_beams': 6},
           }
       }
       UpperCamelCase__         =    {
           'task_specific_params.summarization.length_penalty': 1.0,
           'task_specific_params.summarization.max_length': 128,
           'task_specific_params.summarization.min_length': 12,
           'task_specific_params.summarization.num_beams': 4,
           'task_specific_params.summarization_cnn.length_penalty': 2.0,
           'task_specific_params.summarization_cnn.max_length': 142,
           'task_specific_params.summarization_cnn.min_length': 56,
           'task_specific_params.summarization_cnn.num_beams': 4,
           'task_specific_params.summarization_xsum.length_penalty': 1.0,
           'task_specific_params.summarization_xsum.max_length': 62,
           'task_specific_params.summarization_xsum.min_length': 11,
           'task_specific_params.summarization_xsum.num_beams': 6,
       }

       self.assertEqual(flatten_dict(snake_case_      ) ,				snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Any:
       UpperCamelCase__         =    np.random.randn(3 ,				4      )
       self.assertTrue(np.allclose(transpose(snake_case_      ) ,				x.transpose()      )      )

       UpperCamelCase__         =    np.random.randn(3 ,				4 ,				5      )
       self.assertTrue(np.allclose(transpose(snake_case_ ,				axes=(1, 2, 0)      ) ,				x.transpose((1, 2, 0)      )      )      )

   @require_torch
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Any:
       UpperCamelCase__         =    np.random.randn(3 ,				4      )
       UpperCamelCase__         =    torch.tensor(snake_case_      )
       self.assertTrue(np.allclose(transpose(snake_case_      ) ,				transpose(snake_case_      ).numpy()      )      )

       UpperCamelCase__         =    np.random.randn(3 ,				4 ,				5      )
       UpperCamelCase__         =    torch.tensor(snake_case_      )
       self.assertTrue(np.allclose(transpose(snake_case_ ,				axes=(1, 2, 0)      ) ,				transpose(snake_case_ ,				axes=(1, 2, 0)      ).numpy()      )      )

   @require_tf
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Any:
       UpperCamelCase__         =    np.random.randn(3 ,				4      )
       UpperCamelCase__         =    tf.constant(snake_case_      )
       self.assertTrue(np.allclose(transpose(snake_case_      ) ,				transpose(snake_case_      ).numpy()      )      )

       UpperCamelCase__         =    np.random.randn(3 ,				4 ,				5      )
       UpperCamelCase__         =    tf.constant(snake_case_      )
       self.assertTrue(np.allclose(transpose(snake_case_ ,				axes=(1, 2, 0)      ) ,				transpose(snake_case_ ,				axes=(1, 2, 0)      ).numpy()      )      )

   @require_flax
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[Any]:
       UpperCamelCase__         =    np.random.randn(3 ,				4      )
       UpperCamelCase__         =    jnp.array(snake_case_      )
       self.assertTrue(np.allclose(transpose(snake_case_      ) ,				np.asarray(transpose(snake_case_      )      )      )      )

       UpperCamelCase__         =    np.random.randn(3 ,				4 ,				5      )
       UpperCamelCase__         =    jnp.array(snake_case_      )
       self.assertTrue(np.allclose(transpose(snake_case_ ,				axes=(1, 2, 0)      ) ,				np.asarray(transpose(snake_case_ ,				axes=(1, 2, 0)      )      )      )      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[Any]:
       UpperCamelCase__         =    np.random.randn(3 ,				4      )
       self.assertTrue(np.allclose(reshape(snake_case_ ,				(4, 3)      ) ,				np.reshape(snake_case_ ,				(4, 3)      )      )      )

       UpperCamelCase__         =    np.random.randn(3 ,				4 ,				5      )
       self.assertTrue(np.allclose(reshape(snake_case_ ,				(12, 5)      ) ,				np.reshape(snake_case_ ,				(12, 5)      )      )      )

   @require_torch
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Tuple:
       UpperCamelCase__         =    np.random.randn(3 ,				4      )
       UpperCamelCase__         =    torch.tensor(snake_case_      )
       self.assertTrue(np.allclose(reshape(snake_case_ ,				(4, 3)      ) ,				reshape(snake_case_ ,				(4, 3)      ).numpy()      )      )

       UpperCamelCase__         =    np.random.randn(3 ,				4 ,				5      )
       UpperCamelCase__         =    torch.tensor(snake_case_      )
       self.assertTrue(np.allclose(reshape(snake_case_ ,				(12, 5)      ) ,				reshape(snake_case_ ,				(12, 5)      ).numpy()      )      )

   @require_tf
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[Any]:
       UpperCamelCase__         =    np.random.randn(3 ,				4      )
       UpperCamelCase__         =    tf.constant(snake_case_      )
       self.assertTrue(np.allclose(reshape(snake_case_ ,				(4, 3)      ) ,				reshape(snake_case_ ,				(4, 3)      ).numpy()      )      )

       UpperCamelCase__         =    np.random.randn(3 ,				4 ,				5      )
       UpperCamelCase__         =    tf.constant(snake_case_      )
       self.assertTrue(np.allclose(reshape(snake_case_ ,				(12, 5)      ) ,				reshape(snake_case_ ,				(12, 5)      ).numpy()      )      )

   @require_flax
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[Any]:
       UpperCamelCase__         =    np.random.randn(3 ,				4      )
       UpperCamelCase__         =    jnp.array(snake_case_      )
       self.assertTrue(np.allclose(reshape(snake_case_ ,				(4, 3)      ) ,				np.asarray(reshape(snake_case_ ,				(4, 3)      )      )      )      )

       UpperCamelCase__         =    np.random.randn(3 ,				4 ,				5      )
       UpperCamelCase__         =    jnp.array(snake_case_      )
       self.assertTrue(np.allclose(reshape(snake_case_ ,				(12, 5)      ) ,				np.asarray(reshape(snake_case_ ,				(12, 5)      )      )      )      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Tuple:
       UpperCamelCase__         =    np.random.randn(1 ,				3 ,				4      )
       self.assertTrue(np.allclose(squeeze(snake_case_      ) ,				np.squeeze(snake_case_      )      )      )

       UpperCamelCase__         =    np.random.randn(1 ,				4 ,				1 ,				5      )
       self.assertTrue(np.allclose(squeeze(snake_case_ ,				axis=2      ) ,				np.squeeze(snake_case_ ,				axis=2      )      )      )

   @require_torch
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Any:
       UpperCamelCase__         =    np.random.randn(1 ,				3 ,				4      )
       UpperCamelCase__         =    torch.tensor(snake_case_      )
       self.assertTrue(np.allclose(squeeze(snake_case_      ) ,				squeeze(snake_case_      ).numpy()      )      )

       UpperCamelCase__         =    np.random.randn(1 ,				4 ,				1 ,				5      )
       UpperCamelCase__         =    torch.tensor(snake_case_      )
       self.assertTrue(np.allclose(squeeze(snake_case_ ,				axis=2      ) ,				squeeze(snake_case_ ,				axis=2      ).numpy()      )      )

   @require_tf
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       List[str]:
       UpperCamelCase__         =    np.random.randn(1 ,				3 ,				4      )
       UpperCamelCase__         =    tf.constant(snake_case_      )
       self.assertTrue(np.allclose(squeeze(snake_case_      ) ,				squeeze(snake_case_      ).numpy()      )      )

       UpperCamelCase__         =    np.random.randn(1 ,				4 ,				1 ,				5      )
       UpperCamelCase__         =    tf.constant(snake_case_      )
       self.assertTrue(np.allclose(squeeze(snake_case_ ,				axis=2      ) ,				squeeze(snake_case_ ,				axis=2      ).numpy()      )      )

   @require_flax
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       str:
       UpperCamelCase__         =    np.random.randn(1 ,				3 ,				4      )
       UpperCamelCase__         =    jnp.array(snake_case_      )
       self.assertTrue(np.allclose(squeeze(snake_case_      ) ,				np.asarray(squeeze(snake_case_      )      )      )      )

       UpperCamelCase__         =    np.random.randn(1 ,				4 ,				1 ,				5      )
       UpperCamelCase__         =    jnp.array(snake_case_      )
       self.assertTrue(np.allclose(squeeze(snake_case_ ,				axis=2      ) ,				np.asarray(squeeze(snake_case_ ,				axis=2      )      )      )      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       str:
       UpperCamelCase__         =    np.random.randn(3 ,				4      )
       self.assertTrue(np.allclose(expand_dims(snake_case_ ,				axis=1      ) ,				np.expand_dims(snake_case_ ,				axis=1      )      )      )

   @require_torch
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[Any]:
       UpperCamelCase__         =    np.random.randn(3 ,				4      )
       UpperCamelCase__         =    torch.tensor(snake_case_      )
       self.assertTrue(np.allclose(expand_dims(snake_case_ ,				axis=1      ) ,				expand_dims(snake_case_ ,				axis=1      ).numpy()      )      )

   @require_tf
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Dict:
       UpperCamelCase__         =    np.random.randn(3 ,				4      )
       UpperCamelCase__         =    tf.constant(snake_case_      )
       self.assertTrue(np.allclose(expand_dims(snake_case_ ,				axis=1      ) ,				expand_dims(snake_case_ ,				axis=1      ).numpy()      )      )







   @require_flax
   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[int]:
       UpperCamelCase__         =    np.random.randn(3 ,				4      )
       UpperCamelCase__         =    jnp.array(snake_case_      )
       self.assertTrue(np.allclose(expand_dims(snake_case_ ,				axis=1      ) ,				np.asarray(expand_dims(snake_case_ ,				axis=1      )      )      )      )












"""simple docstring"""





def   lowerCAmelCase_( SCREAMING_SNAKE_CASE					)					->	bool:
    """simple docstring"""

    UpperCamelCase__         =    (1 + 24 * n) ** 0.5
    return ((1 + root) / 6) % 1 == 0







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE = 50_00					)					->	int:
    """simple docstring"""

    UpperCamelCase__         =    [(i * (3 * i - 1)) // 2 for i in range(1 ,	SCREAMING_SNAKE_CASE					)]
    for i, pentagonal_i in enumerate(SCREAMING_SNAKE_CASE					):
        for j in range(SCREAMING_SNAKE_CASE ,	len(SCREAMING_SNAKE_CASE					)					):
            UpperCamelCase__         =    pentagonal_nums[j]
            UpperCamelCase__         =    pentagonal_i + pentagonal_j
            UpperCamelCase__         =    pentagonal_j - pentagonal_i
            if is_pentagonal(SCREAMING_SNAKE_CASE					) and is_pentagonal(SCREAMING_SNAKE_CASE					):
                return b

    return -1


if __name__ == "__main__":
  print(F"""{solution() = }""")




