'''simple docstring'''


from __future__ import annotations

import unittest

from transformers import RoFormerConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
					import tensorflow as tf

					from transformers import (
					    TFRoFormerForCausalLM,
					    TFRoFormerForMaskedLM,
					    TFRoFormerForMultipleChoice,
					    TFRoFormerForQuestionAnswering,
					    TFRoFormerForSequenceClassification,
					    TFRoFormerForTokenClassification,
					    TFRoFormerModel,
					)
					from transformers.models.roformer.modeling_tf_roformer import (
					    TFRoFormerSelfAttention,
					    TFRoFormerSinusoidalPositionalEmbedding,
					)






class 						A   :





							def __init__(      self				:							Any     ,		__a				:							int     ,		__a				:							List[str]=1_3     ,		__a				:							str=7     ,		__a				:							List[Any]=True     ,		__a				:							Optional[Any]=True     ,		__a				:							Optional[Any]=True     ,		__a				:							Optional[int]=True     ,		__a				:							Any=9_9     ,		__a				:							List[str]=3_2     ,		__a				:							Union[str, Any]=2     ,		__a				:							Any=4     ,		__a				:							Dict=3_7     ,		__a				:							Optional[Any]="gelu"     ,		__a				:							Union[str, Any]=0.1     ,		__a				:							Optional[int]=0.1     ,		__a				:							List[str]=5_1_2     ,		__a				:							List[Any]=1_6     ,		__a				:							str=2     ,		__a				:							Optional[int]=0.0_2     ,		__a				:							List[Any]=3     ,		__a				:							List[Any]=4     ,		__a				:							str=None     ,		)							->	List[Any]:
								__UpperCAmelCase							=			parent
								__UpperCAmelCase							=			1_3
								__UpperCAmelCase							=			7
								__UpperCAmelCase							=			True
								__UpperCAmelCase							=			True
								__UpperCAmelCase							=			True
								__UpperCAmelCase							=			True
								__UpperCAmelCase							=			9_9
								__UpperCAmelCase							=			3_2
								__UpperCAmelCase							=			2
								__UpperCAmelCase							=			4
								__UpperCAmelCase							=			3_7
								__UpperCAmelCase							=			'''gelu'''
								__UpperCAmelCase							=			0.1
								__UpperCAmelCase							=			0.1
								__UpperCAmelCase							=			5_1_2
								__UpperCAmelCase							=			1_6
								__UpperCAmelCase							=			2
								__UpperCAmelCase							=			0.0_2
								__UpperCAmelCase							=			3
								__UpperCAmelCase							=			4
								__UpperCAmelCase							=			None





							def       snake_case__						(      self				:							Optional[Any]	)							->	str:
								__UpperCAmelCase							=			ids_tensor([self.batch_size, self.seq_length]     ,		self.vocab_size	)

								__UpperCAmelCase							=			None
								if self.use_input_mask:
									__UpperCAmelCase							=			random_attention_mask([self.batch_size, self.seq_length]	)

								__UpperCAmelCase							=			None
								if self.use_token_type_ids:
									__UpperCAmelCase							=			ids_tensor([self.batch_size, self.seq_length]     ,		self.type_vocab_size	)

								__UpperCAmelCase							=			None
								__UpperCAmelCase							=			None
								__UpperCAmelCase							=			None
								if self.use_labels:
									__UpperCAmelCase							=			ids_tensor([self.batch_size]     ,		self.type_sequence_label_size	)
									__UpperCAmelCase							=			ids_tensor([self.batch_size, self.seq_length]     ,		self.num_labels	)
									__UpperCAmelCase							=			ids_tensor([self.batch_size]     ,		self.num_choices	)

								__UpperCAmelCase							=			RoFormerConfig(
								    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     ,		initializer_range=self.initializer_range     ,		return_dict=__UpperCamelCase     ,		)

								return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels





							def       snake_case__						(      self				:							Union[str, Any]     ,		__a				:							List[Any]     ,		__a				:							Any     ,		__a				:							List[Any]     ,		__a				:							Optional[int]     ,		__a				:							Optional[Any]     ,		__a				:							Optional[int]     ,		__a				:							Dict	)							->	List[str]:
								__UpperCAmelCase							=			TFRoFormerModel(config=__UpperCamelCase	)
								__UpperCAmelCase							=			{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}

								__UpperCAmelCase							=			[input_ids, input_mask]
								__UpperCAmelCase							=			model(__UpperCamelCase	)

								__UpperCAmelCase							=			model(__UpperCamelCase	)

								self.parent.assertEqual(result.last_hidden_state.shape     ,		(self.batch_size, self.seq_length, self.hidden_size)	)





							def       snake_case__						(      self				:							Tuple     ,		__a				:							List[Any]     ,		__a				:							int     ,		__a				:							Union[str, Any]     ,		__a				:							Any     ,		__a				:							Optional[int]     ,		__a				:							Any     ,		__a				:							Tuple	)							->	List[Any]:
								__UpperCAmelCase							=			True
								__UpperCAmelCase							=			TFRoFormerForCausalLM(config=__UpperCamelCase	)
								__UpperCAmelCase							=			{
								    '''input_ids''': input_ids,
								    '''attention_mask''': input_mask,
								    '''token_type_ids''': token_type_ids,
								}
								__UpperCAmelCase							=			model(__UpperCamelCase	)['''logits''']
								self.parent.assertListEqual(
								    list(prediction_scores.numpy().shape	)     ,		[self.batch_size, self.seq_length, self.vocab_size]	)





							def       snake_case__						(      self				:							Optional[Any]     ,		__a				:							Optional[Any]     ,		__a				:							Dict     ,		__a				:							Dict     ,		__a				:							int     ,		__a				:							Any     ,		__a				:							List[str]     ,		__a				:							Union[str, Any]	)							->	List[str]:
								__UpperCAmelCase							=			TFRoFormerForMaskedLM(config=__UpperCamelCase	)
								__UpperCAmelCase							=			{
								    '''input_ids''': input_ids,
								    '''attention_mask''': input_mask,
								    '''token_type_ids''': token_type_ids,
								}
								__UpperCAmelCase							=			model(__UpperCamelCase	)
								self.parent.assertEqual(result.logits.shape     ,		(self.batch_size, self.seq_length, self.vocab_size)	)





							def       snake_case__						(      self				:							List[Any]     ,		__a				:							Optional[Any]     ,		__a				:							Dict     ,		__a				:							str     ,		__a				:							str     ,		__a				:							Any     ,		__a				:							Tuple     ,		__a				:							Optional[int]	)							->	List[Any]:
								__UpperCAmelCase							=			self.num_labels
								__UpperCAmelCase							=			TFRoFormerForSequenceClassification(config=__UpperCamelCase	)
								__UpperCAmelCase							=			{
								    '''input_ids''': input_ids,
								    '''attention_mask''': input_mask,
								    '''token_type_ids''': token_type_ids,
								}

								__UpperCAmelCase							=			model(__UpperCamelCase	)
								self.parent.assertEqual(result.logits.shape     ,		(self.batch_size, self.num_labels)	)





							def       snake_case__						(      self				:							int     ,		__a				:							List[Any]     ,		__a				:							int     ,		__a				:							Union[str, Any]     ,		__a				:							Any     ,		__a				:							List[str]     ,		__a				:							Tuple     ,		__a				:							Union[str, Any]	)							->	int:
								__UpperCAmelCase							=			self.num_choices
								__UpperCAmelCase							=			TFRoFormerForMultipleChoice(config=__UpperCamelCase	)
								__UpperCAmelCase							=			tf.tile(tf.expand_dims(__UpperCamelCase     ,		1	)     ,		(1, self.num_choices, 1)	)
								__UpperCAmelCase							=			tf.tile(tf.expand_dims(__UpperCamelCase     ,		1	)     ,		(1, self.num_choices, 1)	)
								__UpperCAmelCase							=			tf.tile(tf.expand_dims(__UpperCamelCase     ,		1	)     ,		(1, self.num_choices, 1)	)
								__UpperCAmelCase							=			{
								    '''input_ids''': multiple_choice_inputs_ids,
								    '''attention_mask''': multiple_choice_input_mask,
								    '''token_type_ids''': multiple_choice_token_type_ids,
								}
								__UpperCAmelCase							=			model(__UpperCamelCase	)
								self.parent.assertEqual(result.logits.shape     ,		(self.batch_size, self.num_choices)	)





							def       snake_case__						(      self				:							str     ,		__a				:							Optional[int]     ,		__a				:							Any     ,		__a				:							Dict     ,		__a				:							List[Any]     ,		__a				:							Optional[int]     ,		__a				:							str     ,		__a				:							Tuple	)							->	str:
								__UpperCAmelCase							=			self.num_labels
								__UpperCAmelCase							=			TFRoFormerForTokenClassification(config=__UpperCamelCase	)
								__UpperCAmelCase							=			{
								    '''input_ids''': input_ids,
								    '''attention_mask''': input_mask,
								    '''token_type_ids''': token_type_ids,
								}
								__UpperCAmelCase							=			model(__UpperCamelCase	)
								self.parent.assertEqual(result.logits.shape     ,		(self.batch_size, self.seq_length, self.num_labels)	)





							def       snake_case__						(      self				:							Dict     ,		__a				:							Optional[Any]     ,		__a				:							Optional[int]     ,		__a				:							Any     ,		__a				:							Optional[Any]     ,		__a				:							int     ,		__a				:							Any     ,		__a				:							Optional[int]	)							->	Optional[Any]:
								__UpperCAmelCase							=			TFRoFormerForQuestionAnswering(config=__UpperCamelCase	)
								__UpperCAmelCase							=			{
								    '''input_ids''': input_ids,
								    '''attention_mask''': input_mask,
								    '''token_type_ids''': token_type_ids,
								}

								__UpperCAmelCase							=			model(__UpperCamelCase	)
								self.parent.assertEqual(result.start_logits.shape     ,		(self.batch_size, self.seq_length)	)
								self.parent.assertEqual(result.end_logits.shape     ,		(self.batch_size, self.seq_length)	)






							def       snake_case__						(      self				:							int	)							->	Optional[Any]:
								__UpperCAmelCase							=			self.prepare_config_and_inputs()
								(
								    (
								    __UpperCAmelCase
								)				,			(
								    __UpperCAmelCase
								)				,			(
								    __UpperCAmelCase
								)				,			(
								    __UpperCAmelCase
								)				,			(
								    __UpperCAmelCase
								)				,			(
								    __UpperCAmelCase
								)				,			(
								    __UpperCAmelCase
								)				,			
								)							=			config_and_inputs
								__UpperCAmelCase							=			{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
								return config, inputs_dict






@require_tf
class 						A   (   _UpperCAmelCase       ,	_UpperCAmelCase       ,	unittest.TestCase   ):
							a_        =      (
							    (
							        TFRoFormerModel,
							        TFRoFormerForCausalLM,
							        TFRoFormerForMaskedLM,
							        TFRoFormerForQuestionAnswering,
							        TFRoFormerForSequenceClassification,
							        TFRoFormerForTokenClassification,
							        TFRoFormerForMultipleChoice,
							    )
							    if is_tf_available()
							    else ()
							)
							a_        =      (
							    {
							        'feature-extraction': TFRoFormerModel,
							        'fill-mask': TFRoFormerForMaskedLM,
							        'question-answering': TFRoFormerForQuestionAnswering,
							        'text-classification': TFRoFormerForSequenceClassification,
							        'text-generation': TFRoFormerForCausalLM,
							        'token-classification': TFRoFormerForTokenClassification,
							        'zero-shot': TFRoFormerForSequenceClassification,
							    }
							    if is_tf_available()
							    else {}
							)

							a_        =      False
							a_        =      False





							def       snake_case__						(      self				:							List[str]     ,		__a				:							Any     ,		__a				:							Optional[int]     ,		__a				:							int     ,		__a				:							Any     ,		__a				:							Union[str, Any]	)							->	List[str]:






								if pipeline_test_casse_name == "TextGenerationPipelineTests":
									return True

								return False





							def       snake_case__						(      self				:							int	)							->	Dict:
								__UpperCAmelCase							=			TFRoFormerModelTester(self	)
								__UpperCAmelCase							=			ConfigTester(self     ,		config_class=__UpperCamelCase     ,		hidden_size=3_7	)





							def       snake_case__						(      self				:							str	)							->	Dict:
								self.config_tester.run_common_tests()





							def       snake_case__						(      self				:							str	)							->	Optional[int]:
								__UpperCAmelCase							=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*__UpperCamelCase	)





							def       snake_case__						(      self				:							List[Any]	)							->	Optional[int]:
								__UpperCAmelCase							=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_lm(*__UpperCamelCase	)





							def       snake_case__						(      self				:							Optional[int]	)							->	Any:
								__UpperCAmelCase							=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_lm_head(*__UpperCamelCase	)





							def       snake_case__						(      self				:							List[str]	)							->	Union[str, Any]:
								__UpperCAmelCase							=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_multiple_choice(*__UpperCamelCase	)





							def       snake_case__						(      self				:							str	)							->	Optional[Any]:
								__UpperCAmelCase							=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_question_answering(*__UpperCamelCase	)





							def       snake_case__						(      self				:							Union[str, Any]	)							->	List[Any]:
								__UpperCAmelCase							=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_sequence_classification(*__UpperCamelCase	)





							def       snake_case__						(      self				:							List[str]	)							->	int:
								__UpperCAmelCase							=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_token_classification(*__UpperCamelCase	)






							@slow
							def       snake_case__						(      self				:							Dict	)							->	Optional[int]:
								__UpperCAmelCase							=			TFRoFormerModel.from_pretrained('''junnyu/roformer_chinese_base'''	)
								self.assertIsNotNone(__UpperCamelCase	)






@require_tf
class 						A   (   unittest.TestCase   ):





							@slow
							def       snake_case__						(      self				:							Dict	)							->	List[str]:
								__UpperCAmelCase							=			TFRoFormerForMaskedLM.from_pretrained('''junnyu/roformer_chinese_base'''	)
								__UpperCAmelCase							=			tf.constant([[0, 1, 2, 3, 4, 5]]	)
								__UpperCAmelCase							=			model(__UpperCamelCase	)[0]

								# TODO Replace vocab size
								__UpperCAmelCase							=			5_0_0_0_0

								__UpperCAmelCase							=			[1, 6, vocab_size]
								self.assertEqual(output.shape     ,		__UpperCamelCase	)

								print(output[:, :3, :3]	)

								# TODO Replace values below with what was printed above.
								__UpperCAmelCase							=			tf.constant(
								    [
								        [
								            [-0.1_2_0_5_3_3_4_1, -1.0_2_6_4_9_0_1, 0.2_9_2_2_1_9_4_6],
								            [-1.5_1_3_3_7_8_3, 0.1_9_7_4_3_3, 0.1_5_1_9_0_6_0_7],
								            [-5.0_1_3_5_4_0_3, -3.9_0_0_2_5_6, -0.8_4_0_3_8_7_6_4],
								        ]
								    ]	)
								tf.debugging.assert_near(output[:, :3, :3]     ,		__UpperCamelCase     ,		atol=1e-4	)






@require_tf
class 						A   (   unittest.TestCase   ):
							a_        =      1e-4





							def       snake_case__						(      self				:							Tuple	)							->	List[Any]:
								__UpperCAmelCase							=			tf.constant([[4, 1_0]]	)
								__UpperCAmelCase							=			TFRoFormerSinusoidalPositionalEmbedding(num_positions=6     ,		embedding_dim=6	)

								__UpperCAmelCase							=			emba(input_ids.shape	)
								__UpperCAmelCase							=			tf.constant(
								    [[0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0, 1.0_0_0_0, 1.0_0_0_0, 1.0_0_0_0], [0.8_4_1_5, 0.0_4_6_4, 0.0_0_2_2, 0.5_4_0_3, 0.9_9_8_9, 1.0_0_0_0]]	)

								tf.debugging.assert_near(__UpperCamelCase     ,		__UpperCamelCase     ,		atol=self.tolerance	)






							def       snake_case__						(      self				:							Tuple	)							->	int:
								__UpperCAmelCase							=			tf.constant(
								    [
								        [0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0, 0.0_0_0_0],
								        [0.8_4_1_5, 0.8_2_1_9, 0.8_0_2_0, 0.7_8_1_9, 0.7_6_1_7],
								        [0.9_0_9_3, 0.9_3_6_4, 0.9_5_8_1, 0.9_7_4_9, 0.9_8_7_0],
								    ]	)
								__UpperCAmelCase							=			TFRoFormerSinusoidalPositionalEmbedding(num_positions=5_1_2     ,		embedding_dim=5_1_2	)
								emba([2, 1_6, 5_1_2]	)
								__UpperCAmelCase							=			emba.weight[:3, :5]

								tf.debugging.assert_near(__UpperCamelCase     ,		__UpperCamelCase     ,		atol=self.tolerance	)






@require_tf
class 						A   (   unittest.TestCase   ):
							a_        =      1e-4





							def       snake_case__						(      self				:							List[str]	)							->	Optional[Any]:
								__UpperCAmelCase							=			tf.reshape(tf.range(2 * 1_2 * 1_6 * 6_4     ,		dtype=tf.floataa	)     ,		shape=(2, 1_2, 1_6, 6_4)	) / 1_0_0

								__UpperCAmelCase							=			-tf.reshape(tf.range(2 * 1_2 * 1_6 * 6_4     ,		dtype=tf.floataa	)     ,		shape=(2, 1_2, 1_6, 6_4)	) / 1_0_0

								__UpperCAmelCase							=			TFRoFormerSinusoidalPositionalEmbedding(num_positions=3_2     ,		embedding_dim=6_4	)
								__UpperCAmelCase							=			embed_positions([2, 1_6, 7_6_8]	)[None, None, :, :]

								__UpperCAmelCase				,			__UpperCAmelCase							=			TFRoFormerSelfAttention.apply_rotary_position_embeddings(
								    __UpperCamelCase     ,		__UpperCamelCase     ,		__UpperCamelCase	)

								__UpperCAmelCase							=			tf.constant(
								    [
								        [0.0_0_0_0, 0.0_1_0_0, 0.0_2_0_0, 0.0_3_0_0, 0.0_4_0_0, 0.0_5_0_0, 0.0_6_0_0, 0.0_7_0_0],
								        [-0.2_0_1_2, 0.8_8_9_7, 0.0_2_6_3, 0.9_4_0_1, 0.2_0_7_4, 0.9_4_6_3, 0.3_4_8_1, 0.9_3_4_3],
								        [-1.7_0_5_7, 0.6_2_7_1, -1.2_1_4_5, 1.3_8_9_7, -0.6_3_0_3, 1.7_6_4_7, -0.1_1_7_3, 1.8_9_8_5],
								        [-2.1_7_3_1, -1.6_3_9_7, -2.7_3_5_8, 0.2_8_5_4, -2.1_8_4_0, 1.7_1_8_3, -1.3_0_1_8, 2.4_8_7_1],
								        [0.2_7_1_7, -3.6_1_7_3, -2.9_2_0_6, -2.1_9_8_8, -3.6_6_3_8, 0.3_8_5_8, -2.9_1_5_5, 2.2_9_8_0],
								        [3.9_8_5_9, -2.1_5_8_0, -0.7_9_8_4, -4.4_9_0_4, -4.1_1_8_1, -2.0_2_5_2, -4.4_7_8_2, 1.1_2_5_3],
								    ]	)
								__UpperCAmelCase							=			tf.constant(
								    [
								        [0.0_0_0_0, -0.0_1_0_0, -0.0_2_0_0, -0.0_3_0_0, -0.0_4_0_0, -0.0_5_0_0, -0.0_6_0_0, -0.0_7_0_0],
								        [0.2_0_1_2, -0.8_8_9_7, -0.0_2_6_3, -0.9_4_0_1, -0.2_0_7_4, -0.9_4_6_3, -0.3_4_8_1, -0.9_3_4_3],
								        [1.7_0_5_7, -0.6_2_7_1, 1.2_1_4_5, -1.3_8_9_7, 0.6_3_0_3, -1.7_6_4_7, 0.1_1_7_3, -1.8_9_8_5],
								        [2.1_7_3_1, 1.6_3_9_7, 2.7_3_5_8, -0.2_8_5_4, 2.1_8_4_0, -1.7_1_8_3, 1.3_0_1_8, -2.4_8_7_1],
								        [-0.2_7_1_7, 3.6_1_7_3, 2.9_2_0_6, 2.1_9_8_8, 3.6_6_3_8, -0.3_8_5_8, 2.9_1_5_5, -2.2_9_8_0],
								        [-3.9_8_5_9, 2.1_5_8_0, 0.7_9_8_4, 4.4_9_0_4, 4.1_1_8_1, 2.0_2_5_2, 4.4_7_8_2, -1.1_2_5_3],
								    ]	)

								tf.debugging.assert_near(query_layer[0, 0, :6, :8]     ,		__UpperCamelCase     ,		atol=self.tolerance	)
								tf.debugging.assert_near(key_layer[0, 0, :6, :8]     ,		__UpperCamelCase     ,		atol=self.tolerance	)


'''simple docstring'''


from math import sqrt

import numpy as np
from sympy import symbols

# Coefficient
# Speed of light (m/s)
__lowerCAmelCase	:       str						       =	299_792_458

# Symbols
__lowerCAmelCase       ,	__lowerCAmelCase       ,	__lowerCAmelCase       ,	__lowerCAmelCase	:       Any						       =	symbols("ct x y z")





def       lowerCAmelCase					(		UpperCamelCase__				:   float       ):


	"""simple docstring"""
	if velocity > c:
		raise ValueError('''Speed must not exceed light speed 299,792,458 [m/s]!'''       )
	elif velocity < 1:
		# Usually the speed should be much higher than 1 (c order of magnitude)
		raise ValueError('''Speed must be greater than or equal to 1!'''       )

	return velocity / c





def       lowerCAmelCase					(		UpperCamelCase__				:   float       ):


	"""simple docstring"""
	return 1 / sqrt(1 - beta(UpperCamelCase__       ) ** 2       )





def       lowerCAmelCase					(		UpperCamelCase__				:   float       ):


	"""simple docstring"""
	return np.array(
	    [
	        [gamma(UpperCamelCase__       ), -gamma(UpperCamelCase__       ) * beta(UpperCamelCase__       ), 0, 0],
	        [-gamma(UpperCamelCase__       ) * beta(UpperCamelCase__       ), gamma(UpperCamelCase__       ), 0, 0],
	        [0, 0, 1, 0],
	        [0, 0, 0, 1],
	    ]       )





def       lowerCAmelCase					(		UpperCamelCase__				:   float    ,					UpperCamelCase__				:   np.ndarray | None = None       ):


	"""simple docstring"""
	# Ensure event is not empty
	if event is None:
		__UpperCAmelCase							=			np.array([ct, x, y, z]       )  # Symbolic four vector
	else:
		event[0] *= c  # x0 is ct (speed of light * time)

	return transformation_matrix(UpperCamelCase__       ) @ event


if __name__ == "__main__":
					import doctest

					doctest.testmod()

					# Example of symbolic vector:
					__lowerCAmelCase	:       Dict						       =	transform(29_979_245)
					print("Example of four vector: ")
					print(F"""ct' = {four_vector[0]}""")
					print(F"""x' = {four_vector[1]}""")
					print(F"""y' = {four_vector[2]}""")
					print(F"""z' = {four_vector[3]}""")

					# Substitute symbols with numerical values
					__lowerCAmelCase	:       Union[str, Any]						       =	{ct: c, x: 1, y: 1, z: 1}
					__lowerCAmelCase	:       Optional[int]						       =	[four_vector[i].subs(sub_dict) for i in range(4)]

					print(F"""\n{numerical_vector}""")
