




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       _A				(		unittest.TestCase     ):






		def 				UpperCAmelCase (    self			):
								_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(_SCREAMING_SNAKE_CASE			)						,		_SCREAMING_SNAKE_CASE			)






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			np.random.randn(3						,		4			)
								self.assertTrue(np.allclose(transpose(_SCREAMING_SNAKE_CASE			)						,		x.transpose()			)			)

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






		@require_torch
		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			np.random.randn(3						,		4			)
								_UpperCAmelCase      =			torch.tensor(_SCREAMING_SNAKE_CASE			)
								self.assertTrue(np.allclose(transpose(_SCREAMING_SNAKE_CASE			)						,		transpose(_SCREAMING_SNAKE_CASE			).numpy()			)			)

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






		@require_tf
		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			np.random.randn(3						,		4			)
								_UpperCAmelCase      =			tf.constant(_SCREAMING_SNAKE_CASE			)
								self.assertTrue(np.allclose(transpose(_SCREAMING_SNAKE_CASE			)						,		transpose(_SCREAMING_SNAKE_CASE			).numpy()			)			)

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






		@require_flax
		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			np.random.randn(3						,		4			)
								_UpperCAmelCase      =			jnp.array(_SCREAMING_SNAKE_CASE			)
								self.assertTrue(np.allclose(transpose(_SCREAMING_SNAKE_CASE			)						,		np.asarray(transpose(_SCREAMING_SNAKE_CASE			)			)			)			)

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






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			np.random.randn(3						,		4			)
								self.assertTrue(np.allclose(reshape(_SCREAMING_SNAKE_CASE						,		(4, 3)			)						,		np.reshape(_SCREAMING_SNAKE_CASE						,		(4, 3)			)			)			)

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






		@require_torch
		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			np.random.randn(3						,		4			)
								_UpperCAmelCase      =			torch.tensor(_SCREAMING_SNAKE_CASE			)
								self.assertTrue(np.allclose(reshape(_SCREAMING_SNAKE_CASE						,		(4, 3)			)						,		reshape(_SCREAMING_SNAKE_CASE						,		(4, 3)			).numpy()			)			)

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






		@require_tf
		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			np.random.randn(3						,		4			)
								_UpperCAmelCase      =			tf.constant(_SCREAMING_SNAKE_CASE			)
								self.assertTrue(np.allclose(reshape(_SCREAMING_SNAKE_CASE						,		(4, 3)			)						,		reshape(_SCREAMING_SNAKE_CASE						,		(4, 3)			).numpy()			)			)

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






		@require_flax
		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			np.random.randn(3						,		4			)
								_UpperCAmelCase      =			jnp.array(_SCREAMING_SNAKE_CASE			)
								self.assertTrue(np.allclose(reshape(_SCREAMING_SNAKE_CASE						,		(4, 3)			)						,		np.asarray(reshape(_SCREAMING_SNAKE_CASE						,		(4, 3)			)			)			)			)

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






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			np.random.randn(1						,		3						,		4			)
								self.assertTrue(np.allclose(squeeze(_SCREAMING_SNAKE_CASE			)						,		np.squeeze(_SCREAMING_SNAKE_CASE			)			)			)

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






		@require_torch
		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			np.random.randn(1						,		3						,		4			)
								_UpperCAmelCase      =			torch.tensor(_SCREAMING_SNAKE_CASE			)
								self.assertTrue(np.allclose(squeeze(_SCREAMING_SNAKE_CASE			)						,		squeeze(_SCREAMING_SNAKE_CASE			).numpy()			)			)

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






		@require_tf
		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			np.random.randn(1						,		3						,		4			)
								_UpperCAmelCase      =			tf.constant(_SCREAMING_SNAKE_CASE			)
								self.assertTrue(np.allclose(squeeze(_SCREAMING_SNAKE_CASE			)						,		squeeze(_SCREAMING_SNAKE_CASE			).numpy()			)			)

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






		@require_flax
		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			np.random.randn(1						,		3						,		4			)
								_UpperCAmelCase      =			jnp.array(_SCREAMING_SNAKE_CASE			)
								self.assertTrue(np.allclose(squeeze(_SCREAMING_SNAKE_CASE			)						,		np.asarray(squeeze(_SCREAMING_SNAKE_CASE			)			)			)			)

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






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			np.random.randn(3						,		4			)
								self.assertTrue(np.allclose(expand_dims(_SCREAMING_SNAKE_CASE						,		axis=1			)						,		np.expand_dims(_SCREAMING_SNAKE_CASE						,		axis=1			)			)			)






		@require_torch
		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			np.random.randn(3						,		4			)
								_UpperCAmelCase      =			torch.tensor(_SCREAMING_SNAKE_CASE			)
								self.assertTrue(np.allclose(expand_dims(_SCREAMING_SNAKE_CASE						,		axis=1			)						,		expand_dims(_SCREAMING_SNAKE_CASE						,		axis=1			).numpy()			)			)






		@require_tf
		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			np.random.randn(3						,		4			)
								_UpperCAmelCase      =			tf.constant(_SCREAMING_SNAKE_CASE			)
								self.assertTrue(np.allclose(expand_dims(_SCREAMING_SNAKE_CASE						,		axis=1			)						,		expand_dims(_SCREAMING_SNAKE_CASE						,		axis=1			).numpy()			)			)






		@require_flax
		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			np.random.randn(3						,		4			)
								_UpperCAmelCase      =			jnp.array(_SCREAMING_SNAKE_CASE			)
								self.assertTrue(np.allclose(expand_dims(_SCREAMING_SNAKE_CASE						,		axis=1			)						,		np.asarray(expand_dims(_SCREAMING_SNAKE_CASE						,		axis=1			)			)			)			)





from __future__ import annotations




def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case       )						->				float:
						_UpperCAmelCase      =			sorted(numsa + numsa       )
						_UpperCAmelCase    ,					_UpperCAmelCase      =			divmod(len(snake_case       )			,     2       )
						if mod == 1:
												return all_numbers[div]
						else:
												return (all_numbers[div] + all_numbers[div - 1]) / 2


if __name__ == "__main__":
				import doctest

				doctest.testmod()
				a													=			[float(x) for x in input("Enter the elements of first array: ").split()]
				a													=			[float(x) for x in input("Enter the elements of second array: ").split()]
				print(F'The median of two arrays is: {median_of_two_arrays(array_a, array_a)}')