import shutil
import tempfile
import unittest

from transformers import (
    SPIECE_UNDERLINE,
    AddedToken,
    BatchEncoding,
    NllbTokenizer,
    NllbTokenizerFast,
    is_torch_available,
)
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


__lowerCamelCase      :			Optional[Any]							       =		get_tests_dir('''fixtures/test_sentencepiece.model''')


if is_torch_available():
   from transformers.models.mam_aaa.modeling_mam_aaa import shift_tokens_right

__lowerCamelCase      :			List[str]							       =		25_6047
__lowerCamelCase      :			Any							       =		25_6145







@require_sentencepiece
@require_tokenizers
class __snake_case    (						lowerCamelCase_       ,		unittest.TestCase		):
   lowerCAmelCase_														=							NllbTokenizer
   lowerCAmelCase_														=							NllbTokenizerFast
   lowerCAmelCase_														=							True
   lowerCAmelCase_														=							True
   lowerCAmelCase_														=							{}




   def      __a						(   self      :    List[str]				):



     """simple docstring"""






     super().setUp()

     # We have a SentencePiece fixture for testing
     SCREAMING_SNAKE_CASE__      							=				NllbTokenizer(_lowercase	,     keep_accents=_lowercase				)
     tokenizer.save_pretrained(self.tmpdirname				)




   def      __a						(   self      :    Tuple				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				NllbTokenizer(_lowercase	,     keep_accents=_lowercase				)

     SCREAMING_SNAKE_CASE__      							=				tokenizer.tokenize("""This is a test"""				)
     self.assertListEqual(_lowercase	,     ["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]				)

     self.assertListEqual(
         tokenizer.convert_tokens_to_ids(_lowercase				)	,     [value + tokenizer.fairseq_offset for value in [2_85, 46, 10, 1_70, 3_82]]	,     )

     SCREAMING_SNAKE_CASE__      							=				tokenizer.tokenize("""I was born in 92000, and this is falsé."""				)
     self.assertListEqual(
         _lowercase	,     [
             SPIECE_UNDERLINE + """I""",
             SPIECE_UNDERLINE + """was""",
             SPIECE_UNDERLINE + """b""",
             """or""",
             """n""",
             SPIECE_UNDERLINE + """in""",
             SPIECE_UNDERLINE + """""",
             """9""",
             """2""",
             """0""",
             """0""",
             """0""",
             """,""",
             SPIECE_UNDERLINE + """and""",
             SPIECE_UNDERLINE + """this""",
             SPIECE_UNDERLINE + """is""",
             SPIECE_UNDERLINE + """f""",
             """al""",
             """s""",
             """é""",
             """.""",
         ]	,     )
     SCREAMING_SNAKE_CASE__      							=				tokenizer.convert_tokens_to_ids(_lowercase				)
     self.assertListEqual(
         _lowercase	,     [
             value + tokenizer.fairseq_offset
             for value in [8, 21, 84, 55, 24, 19, 7, 2, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 2, 4]
         ]	,     )

     SCREAMING_SNAKE_CASE__      							=				tokenizer.convert_ids_to_tokens(_lowercase				)
     self.assertListEqual(
         _lowercase	,     [
             SPIECE_UNDERLINE + """I""",
             SPIECE_UNDERLINE + """was""",
             SPIECE_UNDERLINE + """b""",
             """or""",
             """n""",
             SPIECE_UNDERLINE + """in""",
             SPIECE_UNDERLINE + """""",
             """<unk>""",
             """2""",
             """0""",
             """0""",
             """0""",
             """,""",
             SPIECE_UNDERLINE + """and""",
             SPIECE_UNDERLINE + """this""",
             SPIECE_UNDERLINE + """is""",
             SPIECE_UNDERLINE + """f""",
             """al""",
             """s""",
             """<unk>""",
             """.""",
         ]	,     )




   def      __a						(   self      :    Optional[Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				(self.rust_tokenizer_class, """hf-internal-testing/tiny-random-nllb""", {})
     for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
       with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""				):
         SCREAMING_SNAKE_CASE__      							=				self.rust_tokenizer_class.from_pretrained(_lowercase	,     **_lowercase				)
         SCREAMING_SNAKE_CASE__      							=				self.tokenizer_class.from_pretrained(_lowercase	,     **_lowercase				)

         SCREAMING_SNAKE_CASE__      							=				tempfile.mkdtemp()

         SCREAMING_SNAKE_CASE__      							=				tokenizer_r.save_pretrained(_lowercase				)
         SCREAMING_SNAKE_CASE__      							=				tokenizer_p.save_pretrained(_lowercase				)

         # Checks it save with the same files + the tokenizer.json file for the fast one
         self.assertTrue(any("""tokenizer.json""" in f for f in tokenizer_r_files				)				)
         SCREAMING_SNAKE_CASE__      							=				tuple(f for f in tokenizer_r_files if """tokenizer.json""" not in f				)
         self.assertSequenceEqual(_lowercase	,     _lowercase				)

         # Checks everything loads correctly in the same way
         SCREAMING_SNAKE_CASE__      							=				tokenizer_r.from_pretrained(_lowercase				)
         SCREAMING_SNAKE_CASE__      							=				tokenizer_p.from_pretrained(_lowercase				)

         # Check special tokens are set accordingly on Rust and Python
         for key in tokenizer_pp.special_tokens_map:
           self.assertTrue(hasattr(_lowercase	,     _lowercase				)				)

         shutil.rmtree(_lowercase				)

         # Save tokenizer rust, legacy_format=True
         SCREAMING_SNAKE_CASE__      							=				tempfile.mkdtemp()

         SCREAMING_SNAKE_CASE__      							=				tokenizer_r.save_pretrained(_lowercase	,     legacy_format=_lowercase				)
         SCREAMING_SNAKE_CASE__      							=				tokenizer_p.save_pretrained(_lowercase				)

         # Checks it save with the same files
         self.assertSequenceEqual(_lowercase	,     _lowercase				)

         # Checks everything loads correctly in the same way
         SCREAMING_SNAKE_CASE__      							=				tokenizer_r.from_pretrained(_lowercase				)
         SCREAMING_SNAKE_CASE__      							=				tokenizer_p.from_pretrained(_lowercase				)

         # Check special tokens are set accordingly on Rust and Python
         for key in tokenizer_pp.special_tokens_map:
           self.assertTrue(hasattr(_lowercase	,     _lowercase				)				)

         shutil.rmtree(_lowercase				)

         # Save tokenizer rust, legacy_format=False
         SCREAMING_SNAKE_CASE__      							=				tempfile.mkdtemp()

         SCREAMING_SNAKE_CASE__      							=				tokenizer_r.save_pretrained(_lowercase	,     legacy_format=_lowercase				)
         SCREAMING_SNAKE_CASE__      							=				tokenizer_p.save_pretrained(_lowercase				)

         # Checks it saved the tokenizer.json file
         self.assertTrue(any("""tokenizer.json""" in f for f in tokenizer_r_files				)				)

         # Checks everything loads correctly in the same way
         SCREAMING_SNAKE_CASE__      							=				tokenizer_r.from_pretrained(_lowercase				)
         SCREAMING_SNAKE_CASE__      							=				tokenizer_p.from_pretrained(_lowercase				)

         # Check special tokens are set accordingly on Rust and Python
         for key in tokenizer_pp.special_tokens_map:
           self.assertTrue(hasattr(_lowercase	,     _lowercase				)				)

         shutil.rmtree(_lowercase				)




   @require_torch
   def      __a						(   self      :    Tuple				):



     """simple docstring"""






     if not self.test_seqaseq:
       return

     SCREAMING_SNAKE_CASE__      							=				self.get_tokenizers()
     for tokenizer in tokenizers:
       with self.subTest(f"""{tokenizer.__class__.__name__}"""				):
         # Longer text that will definitely require truncation.
         SCREAMING_SNAKE_CASE__      							=				[
             """ UN Chief Says There Is No Military Solution in Syria""",
             """ Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for"""
             """ Syria is that 'there is no military solution' to the nearly five-year conflict and more weapons"""
             """ will only worsen the violence and misery for millions of people.""",
         ]
         SCREAMING_SNAKE_CASE__      							=				[
             """Şeful ONU declară că nu există o soluţie militară în Siria""",
             """Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al"""
             """ Rusiei pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi"""
             """ că noi arme nu vor face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.""",
         ]
         try:
           SCREAMING_SNAKE_CASE__      							=				tokenizer.prepare_seqaseq_batch(
               src_texts=_lowercase	,     tgt_texts=_lowercase	,     max_length=3	,     max_target_length=10	,     return_tensors="""pt"""	,     src_lang="""eng_Latn"""	,     tgt_lang="""ron_Latn"""	,     )
         except NotImplementedError:
           return
         self.assertEqual(batch.input_ids.shape[1]	,     3				)
         self.assertEqual(batch.labels.shape[1]	,     10				)
         # max_target_length will default to max_length if not specified
         SCREAMING_SNAKE_CASE__      							=				tokenizer.prepare_seqaseq_batch(
             _lowercase	,     tgt_texts=_lowercase	,     max_length=3	,     return_tensors="""pt"""				)
         self.assertEqual(batch.input_ids.shape[1]	,     3				)
         self.assertEqual(batch.labels.shape[1]	,     3				)

         SCREAMING_SNAKE_CASE__      							=				tokenizer.prepare_seqaseq_batch(
             src_texts=_lowercase	,     max_length=3	,     max_target_length=10	,     return_tensors="""pt"""				)
         self.assertEqual(batch_encoder_only.input_ids.shape[1]	,     3				)
         self.assertEqual(batch_encoder_only.attention_mask.shape[1]	,     3				)
         self.assertNotIn("""decoder_input_ids"""	,     _lowercase				)




   @unittest.skip("""Unfortunately way too slow to build a BPE with SentencePiece."""				)
   def      __a						(   self      :    List[str]				):



     """simple docstring"""






     pass




   def      __a						(   self      :    str				):



     """simple docstring"""






     for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
       with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""				):
         SCREAMING_SNAKE_CASE__      							=				[AddedToken("""<special>"""	,     lstrip=_lowercase				)]

         SCREAMING_SNAKE_CASE__      							=				self.rust_tokenizer_class.from_pretrained(
             _lowercase	,     additional_special_tokens=_lowercase	,     **_lowercase				)
         SCREAMING_SNAKE_CASE__      							=				tokenizer_r.encode("""Hey this is a <special> token"""				)

         SCREAMING_SNAKE_CASE__      							=				tokenizer_r.encode("""<special>"""	,     add_special_tokens=_lowercase				)[0]

         self.assertTrue(special_token_id in r_output				)

         if self.test_slow_tokenizer:
           SCREAMING_SNAKE_CASE__      							=				self.rust_tokenizer_class.from_pretrained(
               _lowercase	,     additional_special_tokens=_lowercase	,     **_lowercase	,     )
           SCREAMING_SNAKE_CASE__      							=				self.tokenizer_class.from_pretrained(
               _lowercase	,     additional_special_tokens=_lowercase	,     **_lowercase				)

           SCREAMING_SNAKE_CASE__      							=				tokenizer_p.encode("""Hey this is a <special> token"""				)

           SCREAMING_SNAKE_CASE__      							=				tokenizer_cr.encode("""Hey this is a <special> token"""				)

           self.assertEqual(_lowercase	,     _lowercase				)
           self.assertEqual(_lowercase	,     _lowercase				)
           self.assertTrue(special_token_id in p_output				)
           self.assertTrue(special_token_id in cr_output				)







@require_torch
@require_sentencepiece
@require_tokenizers
class __snake_case    (						unittest.TestCase		):
   lowerCAmelCase_														=							"facebook/nllb-200-distilled-600M"
   lowerCAmelCase_														=							[
       " UN Chief Says There Is No Military Solution in Syria",
       " Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.",
   ]
   lowerCAmelCase_														=							[
       "Şeful ONU declară că nu există o soluţie militară în Siria",
       "Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei"
       " pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor"
       " face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.",
   ]
   lowerCAmelCase_														=							[
       25_60_47,
       1_62_97,
       13_44_08,
       81_65,
       24_80_66,
       1_47_34,
       9_50,
       11_35,
       10_57_21,
       35_73,
       83,
       2_73_52,
       1_08,
       4_94_86,
       2,
   ]




   @classmethod
   def      __a						(   cls      :    str				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				NllbTokenizer.from_pretrained(
         cls.checkpoint_name	,     src_lang="""eng_Latn"""	,     tgt_lang="""ron_Latn"""				)
     SCREAMING_SNAKE_CASE__      							=				1
     return cls




   def      __a						(   self      :    List[str]				):



     """simple docstring"""






     self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ace_Arab"""]	,     25_60_01				)
     self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ace_Latn"""]	,     25_60_02				)
     self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""fra_Latn"""]	,     25_60_57				)




   def      __a						(   self      :    Optional[int]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				self.tokenizer.batch_encode_plus(self.src_text				).input_ids[0]
     self.assertListEqual(self.expected_src_tokens	,     _lowercase				)




   def      __a						(   self      :    Any				):



     """simple docstring"""






     self.assertIn(_lowercase	,     self.tokenizer.all_special_ids				)
     # fmt: off
     SCREAMING_SNAKE_CASE__      							=				[RO_CODE, 42_54, 9_80_68, 11_29_23, 3_90_72, 39_09, 7_13, 10_27_67, 26, 1_73_14, 3_56_42, 1_46_83, 3_31_18, 20_22, 6_69_87, 2, 25_60_47]
     # fmt: on

     SCREAMING_SNAKE_CASE__      							=				self.tokenizer.decode(_lowercase	,     skip_special_tokens=_lowercase				)
     SCREAMING_SNAKE_CASE__      							=				self.tokenizer.decode(generated_ids[1:]	,     skip_special_tokens=_lowercase				)
     self.assertEqual(_lowercase	,     _lowercase				)
     self.assertNotIn(self.tokenizer.eos_token	,     _lowercase				)




   def      __a						(   self      :    Any				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				["""this is gunna be a long sentence """ * 20]
     assert isinstance(src_text[0]	,     _lowercase				)
     SCREAMING_SNAKE_CASE__      							=				10
     SCREAMING_SNAKE_CASE__      							=				self.tokenizer(_lowercase	,     max_length=_lowercase	,     truncation=_lowercase				).input_ids[0]
     self.assertEqual(ids[-1]	,     2				)
     self.assertEqual(ids[0]	,     _lowercase				)
     self.assertEqual(len(_lowercase				)	,     _lowercase				)




   def      __a						(   self      :    str				):



     """simple docstring"""






     self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["""<mask>""", """ar_AR"""]				)	,     [25_62_03, 3]				)




   def      __a						(   self      :    Tuple				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				tempfile.mkdtemp()
     SCREAMING_SNAKE_CASE__      							=				self.tokenizer.fairseq_tokens_to_ids
     self.tokenizer.save_pretrained(_lowercase				)
     SCREAMING_SNAKE_CASE__      							=				NllbTokenizer.from_pretrained(_lowercase				)
     self.assertDictEqual(new_tok.fairseq_tokens_to_ids	,     _lowercase				)




   @require_torch
   def      __a						(   self      :    List[Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				self.tokenizer(
         self.src_text	,     text_target=self.tgt_text	,     padding=_lowercase	,     truncation=_lowercase	,     max_length=len(self.expected_src_tokens				)	,     return_tensors="""pt"""	,     )
     SCREAMING_SNAKE_CASE__      							=				shift_tokens_right(
         batch["""labels"""]	,     self.tokenizer.pad_token_id	,     self.tokenizer.lang_code_to_id["""ron_Latn"""]				)

     self.assertIsInstance(_lowercase	,     _lowercase				)

     self.assertEqual((2, 15)	,     batch.input_ids.shape				)
     self.assertEqual((2, 15)	,     batch.attention_mask.shape				)
     SCREAMING_SNAKE_CASE__      							=				batch.input_ids.tolist()[0]
     self.assertListEqual(self.expected_src_tokens	,     _lowercase				)
     self.assertEqual(_lowercase	,     batch.decoder_input_ids[0, 0]				)  # EOS
     # Test that special tokens are reset
     self.assertEqual(self.tokenizer.prefix_tokens	,     [EN_CODE]				)
     self.assertEqual(self.tokenizer.suffix_tokens	,     [self.tokenizer.eos_token_id]				)




   def      __a						(   self      :    Any				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				self.tokenizer(self.src_text	,     padding=_lowercase	,     truncation=_lowercase	,     max_length=3	,     return_tensors="""pt"""				)
     SCREAMING_SNAKE_CASE__      							=				self.tokenizer(
         text_target=self.tgt_text	,     padding=_lowercase	,     truncation=_lowercase	,     max_length=10	,     return_tensors="""pt"""				)
     SCREAMING_SNAKE_CASE__      							=				targets["""input_ids"""]
     SCREAMING_SNAKE_CASE__      							=				shift_tokens_right(
         _lowercase	,     self.tokenizer.pad_token_id	,     decoder_start_token_id=self.tokenizer.lang_code_to_id[self.tokenizer.tgt_lang]	,     )

     self.assertEqual(batch.input_ids.shape[1]	,     3				)
     self.assertEqual(batch.decoder_input_ids.shape[1]	,     10				)




   @require_torch
   def      __a						(   self      :    Optional[Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				self.tokenizer._build_translation_inputs(
         """A test"""	,     return_tensors="""pt"""	,     src_lang="""eng_Latn"""	,     tgt_lang="""fra_Latn"""				)

     self.assertEqual(
         nested_simplify(_lowercase				)	,     {
             # A, test, EOS, en_XX
             """input_ids""": [[25_60_47, 70, 73_56, 2]],
             """attention_mask""": [[1, 1, 1, 1]],
             # ar_AR
             """forced_bos_token_id""": 25_60_57,
         }	,     )




   @require_torch
   def      __a						(   self      :    Union[str, Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				True
     SCREAMING_SNAKE_CASE__      							=				self.tokenizer(
         """UN Chief says there is no military solution in Syria"""	,     src_lang="""eng_Latn"""	,     tgt_lang="""fra_Latn"""				)
     self.assertEqual(
         inputs.input_ids	,     [1_62_97, 13_44_08, 2_56_53, 63_70, 2_48, 2_54, 10_39_29, 9_49_95, 1_08, 4_94_86, 2, 25_60_47]				)

     SCREAMING_SNAKE_CASE__      							=				False
     SCREAMING_SNAKE_CASE__      							=				self.tokenizer(
         """UN Chief says there is no military solution in Syria"""	,     src_lang="""eng_Latn"""	,     tgt_lang="""fra_Latn"""				)
     self.assertEqual(
         inputs.input_ids	,     [25_60_47, 1_62_97, 13_44_08, 2_56_53, 63_70, 2_48, 2_54, 10_39_29, 9_49_95, 1_08, 4_94_86, 2]				)

import unittest

from .lib import (
    Matrix,
    Vector,
    axpy,
    square_zero_matrix,
    unit_basis_vector,
    zero_vector,
)







class __snake_case    (						unittest.TestCase		):




   def      __a						(   self      :    Dict				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Vector([1, 2, 3]				)
     self.assertEqual(x.component(0				)	,     1				)
     self.assertEqual(x.component(2				)	,     3				)
     SCREAMING_SNAKE_CASE__      							=				Vector()




   def      __a						(   self      :    int				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Vector([0, 0, 0, 0, 0, 1]				)
     self.assertEqual(str(_lowercase				)	,     """(0,0,0,0,0,1)"""				)




   def      __a						(   self      :    Tuple				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Vector([1, 2, 3, 4]				)
     self.assertEqual(len(_lowercase				)	,     4				)




   def      __a						(   self      :    Optional[Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Vector([1, 2]				)
     SCREAMING_SNAKE_CASE__      							=				Vector([1, 2, 3, 4, 5]				)
     SCREAMING_SNAKE_CASE__      							=				Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]				)
     SCREAMING_SNAKE_CASE__      							=				Vector([1, -1, 1, -1, 2, -3, 4, -5]				)
     self.assertAlmostEqual(x.euclidean_length()	,     2.2_36	,     3				)
     self.assertAlmostEqual(y.euclidean_length()	,     7.4_16	,     3				)
     self.assertEqual(z.euclidean_length()	,     0				)
     self.assertAlmostEqual(w.euclidean_length()	,     7.6_16	,     3				)




   def      __a						(   self      :    Optional[int]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Vector([1, 2, 3]				)
     SCREAMING_SNAKE_CASE__      							=				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      :    Any				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Vector([1, 2, 3]				)
     SCREAMING_SNAKE_CASE__      							=				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      :    str				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Vector([1, 2, 3]				)
     SCREAMING_SNAKE_CASE__      							=				Vector([2, -1, 4]				)  # for test of dot product
     SCREAMING_SNAKE_CASE__      							=				Vector([1, -2, -1]				)
     self.assertEqual(str(x * 3.0				)	,     """(3.0,6.0,9.0)"""				)
     self.assertEqual((a * b)	,     0				)




   def      __a						(   self      :    Union[str, Any]				):



     """simple docstring"""






     self.assertEqual(str(zero_vector(10				)				).count("""0"""				)	,     10				)




   def      __a						(   self      :    str				):



     """simple docstring"""






     self.assertEqual(str(unit_basis_vector(3	,     1				)				)	,     """(0,1,0)"""				)




   def      __a						(   self      :    Any				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Vector([1, 2, 3]				)
     SCREAMING_SNAKE_CASE__      							=				Vector([1, 0, 1]				)
     self.assertEqual(str(axpy(2	,     _lowercase	,     _lowercase				)				)	,     """(3,4,7)"""				)




   def      __a						(   self      :    str				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Vector([1, 0, 0, 0, 0, 0]				)
     SCREAMING_SNAKE_CASE__      							=				x.copy()
     self.assertEqual(str(_lowercase				)	,     str(_lowercase				)				)




   def      __a						(   self      :    str				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Vector([1, 0, 0]				)
     x.change_component(0	,     0				)
     x.change_component(1	,     1				)
     self.assertEqual(str(_lowercase				)	,     """(0,1,0)"""				)




   def      __a						(   self      :    Optional[Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				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(_lowercase				)				)




   def      __a						(   self      :    List[Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]	,     3	,     3				)
     SCREAMING_SNAKE_CASE__      							=				[[-3, -14, -10], [-5, -10, -5], [-2, -1, 0]]
     for x in range(a.height()				):
       for y in range(a.width()				):
         self.assertEqual(minors[x][y]	,     a.minor(_lowercase	,     _lowercase				)				)




   def      __a						(   self      :    Dict				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]	,     3	,     3				)
     SCREAMING_SNAKE_CASE__      							=				[[-3, 14, -10], [5, -10, 5], [-2, 1, 0]]
     for x in range(a.height()				):
       for y in range(a.width()				):
         self.assertEqual(cofactors[x][y]	,     a.cofactor(_lowercase	,     _lowercase				)				)




   def      __a						(   self      :    Union[str, Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]	,     3	,     3				)
     self.assertEqual(-5	,     a.determinant()				)




   def      __a						(   self      :    List[Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]	,     3	,     3				)
     SCREAMING_SNAKE_CASE__      							=				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      :    Optional[Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				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(_lowercase				)				)




   def      __a						(   self      :    Union[str, Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]	,     3	,     3				)
     self.assertEqual(7	,     a.component(2	,     1				)	,     0.01				)




   def      __a						(   self      :    List[Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]	,     3	,     3				)
     SCREAMING_SNAKE_CASE__      							=				Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]	,     3	,     3				)
     self.assertEqual("""|2,4,10|\n|4,8,10|\n|12,14,18|\n"""	,     str(a + b				)				)




   def      __a						(   self      :    Optional[Any]				):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__      							=				Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]	,     3	,     3				)
     SCREAMING_SNAKE_CASE__      							=				Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]	,     3	,     3				)
     self.assertEqual("""|0,0,-4|\n|0,0,0|\n|0,0,-2|\n"""	,     str(a - b				)				)




   def      __a						(   self      :    Any				):



     """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()
