






import unittest

from parameterized import parameterized

from transformers import OpenLlamaConfig, is_torch_available, set_seed
from transformers.testing_utils import require_torch, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch

     from transformers import OpenLlamaForCausalLM, OpenLlamaForSequenceClassification, OpenLlamaModel
class 						lowerCamelCase_				:







    def __init__(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase=1_3       ,					__lowerCAmelCase=7       ,					__lowerCAmelCase=True       ,					__lowerCAmelCase=True       ,					__lowerCAmelCase=False       ,					__lowerCAmelCase=True       ,					__lowerCAmelCase=9_9       ,					__lowerCAmelCase=3_2       ,					__lowerCAmelCase=5       ,					__lowerCAmelCase=4       ,					__lowerCAmelCase=3_7       ,					__lowerCAmelCase="gelu"       ,					__lowerCAmelCase=0.1       ,					__lowerCAmelCase=0.1       ,					__lowerCAmelCase=5_1_2       ,					__lowerCAmelCase=1_6       ,					__lowerCAmelCase=2       ,					__lowerCAmelCase=0.02       ,					__lowerCAmelCase=3       ,					__lowerCAmelCase=4       ,					__lowerCAmelCase=None       ,					):
        """simple docstring"""
        __magic_name__		:Union[str, Any]        =      parent
        __magic_name__		:Tuple        =      batch_size
        __magic_name__		:Union[str, Any]        =      seq_length
        __magic_name__		:int        =      is_training
        __magic_name__		:Tuple        =      use_input_mask
        __magic_name__		:Optional[int]        =      use_token_type_ids
        __magic_name__		:Union[str, Any]        =      use_labels
        __magic_name__		:Dict        =      vocab_size
        __magic_name__		:int        =      hidden_size
        __magic_name__		:Union[str, Any]        =      num_hidden_layers
        __magic_name__		:Any        =      num_attention_heads
        __magic_name__		:str        =      intermediate_size
        __magic_name__		:List[Any]        =      hidden_act
        __magic_name__		:Tuple        =      hidden_dropout_prob
        __magic_name__		:Any        =      attention_probs_dropout_prob
        __magic_name__		:Tuple        =      max_position_embeddings
        __magic_name__		:str        =      type_vocab_size
        __magic_name__		:Tuple        =      type_sequence_label_size
        __magic_name__		:Tuple        =      initializer_range
        __magic_name__		:Any        =      num_labels
        __magic_name__		:Tuple        =      num_choices
        __magic_name__		:int        =      scope







    def 			A	(						self     ):
        """simple docstring"""
        __magic_name__		:Optional[Any]        =      ids_tensor([self.batch_size, self.seq_length]       ,					self.vocab_size     )

        __magic_name__		:Optional[Any]        =      None
        if self.use_input_mask:
            __magic_name__		:Tuple        =      random_attention_mask([self.batch_size, self.seq_length]     )

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

        __magic_name__		:str        =      None
        __magic_name__		:Union[str, Any]        =      None
        __magic_name__		:Dict        =      None
        if self.use_labels:
            __magic_name__		:List[Any]        =      ids_tensor([self.batch_size]       ,					self.type_sequence_label_size     )
            __magic_name__		:Optional[Any]        =      ids_tensor([self.batch_size, self.seq_length]       ,					self.num_labels     )
            __magic_name__		:Optional[int]        =      ids_tensor([self.batch_size]       ,					self.num_choices     )

        __magic_name__		:List[Any]        =      self.get_config()

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







    def 			A	(						self     ):
        """simple docstring"""
        return OpenLlamaConfig(
            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=__lowerCAmelCase       ,					initializer_range=self.initializer_range       ,					use_stable_embedding=__lowerCAmelCase       ,					)







    def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase     ):
        """simple docstring"""
        __magic_name__		:Optional[int]        =      OpenLlamaModel(config=__lowerCAmelCase     )
        model.to(__lowerCAmelCase     )
        model.eval()
        __magic_name__		:Optional[Any]        =      model(__lowerCAmelCase       ,					attention_mask=__lowerCAmelCase     )
        __magic_name__		:Optional[int]        =      model(__lowerCAmelCase     )
        self.parent.assertEqual(result.last_hidden_state.shape       ,					(self.batch_size, self.seq_length, self.hidden_size)     )







    def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					):
        """simple docstring"""
        __magic_name__		:str        =      True
        __magic_name__		:Any        =      OpenLlamaModel(__lowerCAmelCase     )
        model.to(__lowerCAmelCase     )
        model.eval()
        __magic_name__		:Union[str, Any]        =      model(
            __lowerCAmelCase       ,					attention_mask=__lowerCAmelCase       ,					encoder_hidden_states=__lowerCAmelCase       ,					encoder_attention_mask=__lowerCAmelCase       ,					)
        __magic_name__		:Optional[Any]        =      model(
            __lowerCAmelCase       ,					attention_mask=__lowerCAmelCase       ,					encoder_hidden_states=__lowerCAmelCase       ,					)
        __magic_name__		:Optional[int]        =      model(__lowerCAmelCase       ,					attention_mask=__lowerCAmelCase     )
        self.parent.assertEqual(result.last_hidden_state.shape       ,					(self.batch_size, self.seq_length, self.hidden_size)     )







    def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					):
        """simple docstring"""
        __magic_name__		:int        =      OpenLlamaForCausalLM(config=__lowerCAmelCase     )
        model.to(__lowerCAmelCase     )
        model.eval()
        __magic_name__		:Optional[Any]        =      model(__lowerCAmelCase       ,					attention_mask=__lowerCAmelCase       ,					labels=__lowerCAmelCase     )
        self.parent.assertEqual(result.logits.shape       ,					(self.batch_size, self.seq_length, self.vocab_size)     )







    def 			A	(						self       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					__lowerCAmelCase       ,					):
        """simple docstring"""
        __magic_name__		:List[Any]        =      True
        __magic_name__		:List[str]        =      True
        __magic_name__		:str        =      OpenLlamaForCausalLM(config=__lowerCAmelCase     )
        model.to(__lowerCAmelCase     )
        model.eval()

        # first forward pass
        __magic_name__		:Tuple        =      model(
            __lowerCAmelCase       ,					attention_mask=__lowerCAmelCase       ,					encoder_hidden_states=__lowerCAmelCase       ,					encoder_attention_mask=__lowerCAmelCase       ,					use_cache=__lowerCAmelCase       ,					)
        __magic_name__		:Union[str, Any]        =      outputs.past_key_values

        # create hypothetical multiple next token and extent to next_input_ids
        __magic_name__		:Union[str, Any]        =      ids_tensor((self.batch_size, 3)       ,					config.vocab_size     )
        __magic_name__		:int        =      ids_tensor((self.batch_size, 3)       ,					vocab_size=2     )

        # append to next input_ids and
        __magic_name__		:List[Any]        =      torch.cat([input_ids, next_tokens]       ,					dim=-1     )
        __magic_name__		:Union[str, Any]        =      torch.cat([input_mask, next_mask]       ,					dim=-1     )

        __magic_name__		:Union[str, Any]        =      model(
            __lowerCAmelCase       ,					attention_mask=__lowerCAmelCase       ,					encoder_hidden_states=__lowerCAmelCase       ,					encoder_attention_mask=__lowerCAmelCase       ,					output_hidden_states=__lowerCAmelCase       ,					)['''hidden_states'''][0]
        __magic_name__		:Dict        =      model(
            __lowerCAmelCase       ,					attention_mask=__lowerCAmelCase       ,					encoder_hidden_states=__lowerCAmelCase       ,					encoder_attention_mask=__lowerCAmelCase       ,					past_key_values=__lowerCAmelCase       ,					output_hidden_states=__lowerCAmelCase       ,					)['''hidden_states'''][0]

        # select random slice
        __magic_name__		:str        =      ids_tensor((1,)       ,					output_from_past.shape[-1]     ).item()
        __magic_name__		:str        =      output_from_no_past[:, -3:, random_slice_idx].detach()
        __magic_name__		:Any        =      output_from_past[:, :, random_slice_idx].detach()

        self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]     )

        # test that outputs are equal for slice
        self.parent.assertTrue(torch.allclose(__lowerCAmelCase       ,					__lowerCAmelCase       ,					atol=1E-3     )     )







    def 			A	(						self     ):
        """simple docstring"""
        __magic_name__		:Optional[int]        =      self.prepare_config_and_inputs()
        (
            __magic_name__				
        )		:Optional[int]        =      config_and_inputs
        __magic_name__		:Optional[Any]        =      {'''input_ids''': input_ids, '''attention_mask''': input_mask}
        return config, inputs_dict







@require_torch
class 						lowerCamelCase_				(      lowerCamelCase			,				lowerCamelCase			,				lowerCamelCase			,				unittest.TestCase ):
    a__					       =  (
        (OpenLlamaModel, OpenLlamaForCausalLM, OpenLlamaForSequenceClassification) if is_torch_available() else ()
    )
    a__					       =  (OpenLlamaForCausalLM,) if is_torch_available() else ()
    a__					       =  (
        {
            '''feature-extraction''': OpenLlamaModel,
            '''text-classification''': OpenLlamaForSequenceClassification,
            '''text-generation''': OpenLlamaForCausalLM,
            '''zero-shot''': OpenLlamaForSequenceClassification,
        }
        if is_torch_available()
        else {}
    )
    a__					       =  False
    a__					       =  False







    def 			A	(						self     ):
        """simple docstring"""
        __magic_name__		:Union[str, Any]        =      OpenLlamaModelTester(self     )
        __magic_name__		:List[str]        =      ConfigTester(self       ,					config_class=__lowerCAmelCase       ,					hidden_size=3_7     )







    def 			A	(						self     ):
        """simple docstring"""
        self.config_tester.run_common_tests()







    def 			A	(						self     ):
        """simple docstring"""
        __magic_name__		:Optional[Any]        =      self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*__lowerCAmelCase     )







    def 			A	(						self     ):
        """simple docstring"""
        __magic_name__		:str        =      self.model_tester.prepare_config_and_inputs()
        for type in ["absolute", "relative_key", "relative_key_query"]:
            __magic_name__		:List[str]        =      type
            self.model_tester.create_and_check_model(*__lowerCAmelCase     )







    def 			A	(						self     ):
        """simple docstring"""
        __magic_name__		:List[Any]        =      self.model_tester.prepare_config_and_inputs_for_common()
        __magic_name__		:int        =      3
        __magic_name__		:Dict        =      input_dict['''input_ids''']
        __magic_name__		:int        =      input_ids.ne(1     ).to(__lowerCAmelCase     )
        __magic_name__		:List[Any]        =      ids_tensor([self.model_tester.batch_size]       ,					self.model_tester.type_sequence_label_size     )
        __magic_name__		:Any        =      OpenLlamaForSequenceClassification(__lowerCAmelCase     )
        model.to(__lowerCAmelCase     )
        model.eval()
        __magic_name__		:Dict        =      model(__lowerCAmelCase       ,					attention_mask=__lowerCAmelCase       ,					labels=__lowerCAmelCase     )
        self.assertEqual(result.logits.shape       ,					(self.model_tester.batch_size, self.model_tester.num_labels)     )







    def 			A	(						self     ):
        """simple docstring"""
        __magic_name__		:List[Any]        =      self.model_tester.prepare_config_and_inputs_for_common()
        __magic_name__		:Dict        =      3
        __magic_name__		:int        =      '''single_label_classification'''
        __magic_name__		:Dict        =      input_dict['''input_ids''']
        __magic_name__		:int        =      input_ids.ne(1     ).to(__lowerCAmelCase     )
        __magic_name__		:Optional[int]        =      ids_tensor([self.model_tester.batch_size]       ,					self.model_tester.type_sequence_label_size     )
        __magic_name__		:Union[str, Any]        =      OpenLlamaForSequenceClassification(__lowerCAmelCase     )
        model.to(__lowerCAmelCase     )
        model.eval()
        __magic_name__		:Optional[int]        =      model(__lowerCAmelCase       ,					attention_mask=__lowerCAmelCase       ,					labels=__lowerCAmelCase     )
        self.assertEqual(result.logits.shape       ,					(self.model_tester.batch_size, self.model_tester.num_labels)     )







    def 			A	(						self     ):
        """simple docstring"""
        __magic_name__		:Optional[Any]        =      self.model_tester.prepare_config_and_inputs_for_common()
        __magic_name__		:Any        =      3
        __magic_name__		:Any        =      '''multi_label_classification'''
        __magic_name__		:Optional[int]        =      input_dict['''input_ids''']
        __magic_name__		:Optional[int]        =      input_ids.ne(1     ).to(__lowerCAmelCase     )
        __magic_name__		:Dict        =      ids_tensor(
            [self.model_tester.batch_size, config.num_labels]       ,					self.model_tester.type_sequence_label_size     ).to(torch.float     )
        __magic_name__		:Dict        =      OpenLlamaForSequenceClassification(__lowerCAmelCase     )
        model.to(__lowerCAmelCase     )
        model.eval()
        __magic_name__		:Tuple        =      model(__lowerCAmelCase       ,					attention_mask=__lowerCAmelCase       ,					labels=__lowerCAmelCase     )
        self.assertEqual(result.logits.shape       ,					(self.model_tester.batch_size, self.model_tester.num_labels)     )







    @unittest.skip('''Open-Llama buffers include complex numbers, which breaks this test'''     )
    def 			A	(						self     ):
        """simple docstring"""
        pass







    @parameterized.expand([('''linear''',), ('''dynamic''',)]     )
    def 			A	(						self       ,					__lowerCAmelCase     ):
        """simple docstring"""
        __magic_name__		:List[str]        =      self.model_tester.prepare_config_and_inputs_for_common()
        __magic_name__		:Dict        =      ids_tensor([1, 1_0]       ,					config.vocab_size     )
        __magic_name__		:Optional[Any]        =      ids_tensor([1, int(config.max_position_embeddings * 1.5     )]       ,					config.vocab_size     )

        set_seed(4_2     )  # Fixed seed at init time so the two models get the same random weights
        __magic_name__		:List[str]        =      OpenLlamaModel(__lowerCAmelCase     )
        original_model.to(__lowerCAmelCase     )
        original_model.eval()
        __magic_name__		:str        =      original_model(__lowerCAmelCase     ).last_hidden_state
        __magic_name__		:int        =      original_model(__lowerCAmelCase     ).last_hidden_state

        set_seed(4_2     )  # Fixed seed at init time so the two models get the same random weights
        __magic_name__		:Dict        =      {'''type''': scaling_type, '''factor''': 10.0}
        __magic_name__		:str        =      OpenLlamaModel(__lowerCAmelCase     )
        scaled_model.to(__lowerCAmelCase     )
        scaled_model.eval()
        __magic_name__		:Union[str, Any]        =      scaled_model(__lowerCAmelCase     ).last_hidden_state
        __magic_name__		:Any        =      scaled_model(__lowerCAmelCase     ).last_hidden_state

        # Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original
        # maximum sequence length, so the outputs for the short input should match.
        if scaling_type == "dynamic":
            self.assertTrue(torch.allclose(__lowerCAmelCase       ,					__lowerCAmelCase       ,					atol=1E-5     )     )
        else:
            self.assertFalse(torch.allclose(__lowerCAmelCase       ,					__lowerCAmelCase       ,					atol=1E-5     )     )

        # The output should be different for long inputs
        self.assertFalse(torch.allclose(__lowerCAmelCase       ,					__lowerCAmelCase       ,					atol=1E-5     )     )














import unittest

from .lib import (
    Matrix,
    Vector,
    axpy,
    square_zero_matrix,
    unit_basis_vector,
    zero_vector,
)
class 						lowerCamelCase_				(      unittest.TestCase ):







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Union[str, Any]        =      Vector([1, 2, 3]     )
								self.assertEqual(x.component(0     )       ,					1     )
								self.assertEqual(x.component(2     )       ,					3     )
								__magic_name__		:Tuple        =      Vector()







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Any        =      Vector([0, 0, 0, 0, 0, 1]     )
								self.assertEqual(str(__lowerCAmelCase     )       ,					'''(0,0,0,0,0,1)'''     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Optional[int]        =      Vector([1, 2, 3, 4]     )
								self.assertEqual(len(__lowerCAmelCase     )       ,					4     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Optional[Any]        =      Vector([1, 2]     )
								__magic_name__		:int        =      Vector([1, 2, 3, 4, 5]     )
								__magic_name__		:Any        =      Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]     )
								__magic_name__		:Optional[Any]        =      Vector([1, -1, 1, -1, 2, -3, 4, -5]     )
								self.assertAlmostEqual(x.euclidean_length()       ,					2.236       ,					3     )
								self.assertAlmostEqual(y.euclidean_length()       ,					7.416       ,					3     )
								self.assertEqual(z.euclidean_length()       ,					0     )
								self.assertAlmostEqual(w.euclidean_length()       ,					7.616       ,					3     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Union[str, Any]        =      Vector([1, 2, 3]     )
								__magic_name__		:List[str]        =      Vector([1, 1, 1]     )
								self.assertEqual((x + y).component(0     )       ,					2     )
								self.assertEqual((x + y).component(1     )       ,					3     )
								self.assertEqual((x + y).component(2     )       ,					4     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:List[str]        =      Vector([1, 2, 3]     )
								__magic_name__		:Union[str, Any]        =      Vector([1, 1, 1]     )
								self.assertEqual((x - y).component(0     )       ,					0     )
								self.assertEqual((x - y).component(1     )       ,					1     )
								self.assertEqual((x - y).component(2     )       ,					2     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:int        =      Vector([1, 2, 3]     )
								__magic_name__		:Optional[int]        =      Vector([2, -1, 4]     )  # for test of dot product
								__magic_name__		:List[Any]        =      Vector([1, -2, -1]     )
								self.assertEqual(str(x * 3.0     )       ,					'''(3.0,6.0,9.0)'''     )
								self.assertEqual((a * b)       ,					0     )







				def 			A	(						self     ):
								"""simple docstring"""
								self.assertEqual(str(zero_vector(1_0     )     ).count('''0'''     )       ,					1_0     )







				def 			A	(						self     ):
								"""simple docstring"""
								self.assertEqual(str(unit_basis_vector(3       ,					1     )     )       ,					'''(0,1,0)'''     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Dict        =      Vector([1, 2, 3]     )
								__magic_name__		:List[Any]        =      Vector([1, 0, 1]     )
								self.assertEqual(str(axpy(2       ,					__lowerCAmelCase       ,					__lowerCAmelCase     )     )       ,					'''(3,4,7)'''     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:List[str]        =      Vector([1, 0, 0, 0, 0, 0]     )
								__magic_name__		:Optional[int]        =      x.copy()
								self.assertEqual(str(__lowerCAmelCase     )       ,					str(__lowerCAmelCase     )     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:List[str]        =      Vector([1, 0, 0]     )
								x.change_component(0       ,					0     )
								x.change_component(1       ,					1     )
								self.assertEqual(str(__lowerCAmelCase     )       ,					'''(0,1,0)'''     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Any        =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,					3       ,					3     )
								self.assertEqual('''|1,2,3|\n|2,4,5|\n|6,7,8|\n'''       ,					str(__lowerCAmelCase     )     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Union[str, Any]        =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,					3       ,					3     )
								__magic_name__		:List[str]        =      [[-3, -1_4, -1_0], [-5, -1_0, -5], [-2, -1, 0]]
								for x in range(a.height()     ):
												for y in range(a.width()     ):
																self.assertEqual(minors[x][y]       ,					a.minor(__lowerCAmelCase       ,					__lowerCAmelCase     )     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:int        =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,					3       ,					3     )
								__magic_name__		:Any        =      [[-3, 1_4, -1_0], [5, -1_0, 5], [-2, 1, 0]]
								for x in range(a.height()     ):
												for y in range(a.width()     ):
																self.assertEqual(cofactors[x][y]       ,					a.cofactor(__lowerCAmelCase       ,					__lowerCAmelCase     )     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Tuple        =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,					3       ,					3     )
								self.assertEqual(-5       ,					a.determinant()     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:str        =      Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]       ,					3       ,					3     )
								__magic_name__		:Any        =      Vector([1, 2, 3]     )
								self.assertEqual('''(14,32,50)'''       ,					str(a * x     )     )
								self.assertEqual('''|2,4,6|\n|8,10,12|\n|14,16,18|\n'''       ,					str(a * 2     )     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:List[Any]        =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,					3       ,					3     )
								a.change_component(0       ,					2       ,					5     )
								self.assertEqual('''|1,2,5|\n|2,4,5|\n|6,7,8|\n'''       ,					str(__lowerCAmelCase     )     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:List[Any]        =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,					3       ,					3     )
								self.assertEqual(7       ,					a.component(2       ,					1     )       ,					0.01     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:List[str]        =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,					3       ,					3     )
								__magic_name__		:Optional[Any]        =      Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 1_0]]       ,					3       ,					3     )
								self.assertEqual('''|2,4,10|\n|4,8,10|\n|12,14,18|\n'''       ,					str(a + b     )     )







				def 			A	(						self     ):
								"""simple docstring"""
								__magic_name__		:Dict        =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,					3       ,					3     )
								__magic_name__		:Union[str, Any]        =      Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 1_0]]       ,					3       ,					3     )
								self.assertEqual('''|0,0,-4|\n|0,0,0|\n|0,0,-2|\n'''       ,					str(a - b     )     )







				def 			A	(						self     ):
								"""simple docstring"""
								self.assertEqual(
								    '''|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n'''       ,					str(square_zero_matrix(5     )     )       ,					)


if __name__ == "__main__":
					unittest.main()






