


'''simple docstring'''






import unittest

from transformers import SPIECE_UNDERLINE, XLNetTokenizer, XLNetTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


__UpperCAmelCase       =							get_tests_dir('''fixtures/test_sentencepiece.model''')




@require_sentencepiece
@require_tokenizers
class 		a__    (							a__    ,    unittest.TestCase  ):





							'''simple docstring'''






							lowercase__      :       Optional[Any]     						=				XLNetTokenizer
							lowercase__      :       List[str]     						=				XLNetTokenizerFast
							lowercase__      :       Optional[Any]     						=				True
							lowercase__      :       int     						=				True







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							str:
														super().setUp()

														# We have a SentencePiece fixture for testing
														lowerCAmelCase__	       =     XLNetTokenizer(lowerCamelCase_ ,   keep_accents=lowerCamelCase_       )
														tokenizer.sanitize_special_tokens()
														tokenizer.save_pretrained(self.tmpdirname       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							int:
														lowerCAmelCase__	       =     '''<s>'''
														lowerCAmelCase__	       =     1

														self.assertEqual(self.get_tokenizer()._convert_token_to_id(lowerCamelCase_       ) ,   lowerCamelCase_       )
														self.assertEqual(self.get_tokenizer()._convert_id_to_token(lowerCamelCase_       ) ,   lowerCamelCase_       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							int:
														lowerCAmelCase__	       =     list(self.get_tokenizer().get_vocab().keys()       )

														self.assertEqual(vocab_keys[0] ,   '''<unk>'''       )
														self.assertEqual(vocab_keys[1] ,   '''<s>'''       )
														self.assertEqual(vocab_keys[-1] ,   '''<eod>'''       )
														self.assertEqual(len(lowerCamelCase_       ) ,   10_06       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							List[Any]:
														self.assertEqual(self.get_tokenizer().vocab_size ,   10_00       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							List[Any]:
														lowerCAmelCase__	       =     XLNetTokenizer(lowerCamelCase_ ,   keep_accents=lowerCamelCase_       )

														lowerCAmelCase__	       =     tokenizer.tokenize('''This is a test'''       )
														self.assertListEqual(lowerCamelCase_ ,   ['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']       )

														self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase_       ) ,   [2_85, 46, 10, 1_70, 3_82]       )

														lowerCAmelCase__	       =     tokenizer.tokenize('''I was born in 92000, and this is falsé.'''       )
														self.assertListEqual(
														    lowerCamelCase_ ,   [
														        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''',
														        '''é''',
														        '''.''',
														    ] ,   )
														lowerCAmelCase__	       =     tokenizer.convert_tokens_to_ids(lowerCamelCase_       )
														self.assertListEqual(lowerCamelCase_ ,   [8, 21, 84, 55, 24, 19, 7, 0, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 0, 4]       )

														lowerCAmelCase__	       =     tokenizer.convert_ids_to_tokens(lowerCamelCase_       )
														self.assertListEqual(
														    lowerCamelCase_ ,   [
														        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   __SCREAMING_SNAKE_CASE							(		self       )	->							List[str]:
														lowerCAmelCase__	       =     XLNetTokenizer(lowerCamelCase_ ,   do_lower_case=lowerCamelCase_       )
														lowerCAmelCase__	       =     tokenizer.tokenize('''I was born in 92000, and this is falsé.'''       )
														self.assertListEqual(
														    lowerCamelCase_ ,   [
														        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''',
														        '''se''',
														        '''.''',
														    ] ,   )
														self.assertListEqual(tokenizer.tokenize('''H\u00E9llo'''       ) ,   ['''▁he''', '''ll''', '''o''']       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Tuple:
														lowerCAmelCase__	       =     XLNetTokenizer(lowerCamelCase_ ,   do_lower_case=lowerCamelCase_       )
														lowerCAmelCase__	       =     tokenizer.tokenize('''I was born in 92000, and this is falsé.'''       )
														self.assertListEqual(
														    lowerCamelCase_ ,   [
														        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''',
														        '''se''',
														        '''.''',
														    ] ,   )







							@slow
							def   __SCREAMING_SNAKE_CASE							(		self       )	->							List[str]:
														lowerCAmelCase__	       =     XLNetTokenizer.from_pretrained('''xlnet-base-cased'''       )

														lowerCAmelCase__	       =     tokenizer.encode('''sequence builders''' ,   add_special_tokens=lowerCamelCase_       )
														lowerCAmelCase__	       =     tokenizer.encode('''multi-sequence build''' ,   add_special_tokens=lowerCamelCase_       )

														lowerCAmelCase__	       =     tokenizer.build_inputs_with_special_tokens(lowerCamelCase_       )
														lowerCAmelCase__	       =     tokenizer.build_inputs_with_special_tokens(lowerCamelCase_ ,   lowerCamelCase_       )

														assert encoded_sentence == text + [4, 3]
														assert encoded_pair == text + [4] + text_a + [4, 3]







							@slow
							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Optional[Any]:
														# fmt: off
														lowerCAmelCase__	       =     {'''input_ids''': [[17, 2_14_42, 2_70, 17, 10, 1_46_45, 3_18, 34, 17, 45_46, 31_45, 7_87, 13, 77_52, 2_20_18, 23, 21, 17, 45_46, 31_45, 7_87, 13, 33_52, 1_44_31, 13, 55_00, 11, 11_76, 5_80, 13, 1_68_19, 47_97, 23, 17, 10, 1_71_35, 6_58, 19, 4_57, 79_32, 13, 1_84, 19, 31_54, 1_71_35, 64_68, 19, 14_04, 1_22_69, 19, 42_29, 53_56, 1_62_64, 46, 19, 17, 2_05_45, 1_03_95, 9, 9, 9, 11, 28, 64_21, 95_31, 2_07_29, 17, 10, 3_53, 1_70_22, 11, 21, 64_21, 95_31, 1_69_49, 17, 10, 1_15_09, 7_53, 11, 33, 95, 24_21, 73_85, 9_56, 1_44_31, 26_26, 25, 8_42, 73_85, 48_36, 21, 14_29, 22_72, 98_55, 31_20, 1_61, 2_47_38, 19, 1_32_03, 6_58, 2_18, 7_87, 21, 4_30, 1_84_82, 8_47, 26_37, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3_22, 2_21_78, 27, 10_64, 22, 9_56, 13, 1_11_01, 14_29, 58_54, 2_43_13, 1_89_53, 40, 4_22, 2_43_66, 68, 17_58, 37, 1_04_83, 1_42_57, 31, 2_07, 2_63, 21, 2_03, 37_73, 25, 71, 97_35, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 32, 20_49, 34_42, 17, 1_38_94, 33_80, 23, 95, 18, 1_76_34, 22_88, 9, 4, 3]], '''token_type_ids''': [[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, 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, 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, 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, 0, 0, 0, 0, 0, 0, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 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, 0, 0, 0, 0, 0, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2]], '''attention_mask''': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [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, 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, 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, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [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, 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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}  # noqa: E501
														# fmt: on

														self.tokenizer_integration_test_util(
														    expected_encoding=lowerCamelCase_ ,   model_name='''xlnet-base-cased''' ,   revision='''c841166438c31ec7ca9a106dee7bb312b73ae511''' ,   )



'''simple docstring'''






from __future__ import annotations

import numpy as np
from numpy import floataa
from numpy.typing import NDArray


def  _snake_case       (					A			,   A			,   A			,   A			,   )						->   list[float]:
							lowerCAmelCase__       , lowerCAmelCase__	       =     coefficient_matrix.shape
							lowerCAmelCase__       , lowerCAmelCase__	       =     constant_matrix.shape

							if rowsa != colsa:
														lowerCAmelCase__	       =     F"""Coefficient matrix dimensions must be nxn but received {rowsa}x{colsa}"""
														raise ValueError(A	)

							if colsa != 1:
														lowerCAmelCase__	       =     F"""Constant matrix must be nx1 but received {rowsa}x{colsa}"""
														raise ValueError(A	)

							if rowsa != rowsa:
														lowerCAmelCase__	       =     (
														    '''Coefficient and constant matrices dimensions must be nxn and nx1 but '''
														    F"""received {rowsa}x{colsa} and {rowsa}x{colsa}"""
														)
														raise ValueError(A	)

							if len(A	) != rowsa:
														lowerCAmelCase__	       =     (
														    '''Number of initial values must be equal to number of rows in coefficient '''
														    F"""matrix but received {len(A	)} and {rowsa}"""
														)
														raise ValueError(A	)

							if iterations <= 0:
														raise ValueError('''Iterations must be at least 1'''	)

							lowerCAmelCase__	       =     np.concatenate(
							    (coefficient_matrix, constant_matrix)			,   axis=1	)

							lowerCAmelCase__       , lowerCAmelCase__	       =     table.shape

							strictly_diagonally_dominant(A	)

							# Iterates the whole matrix for given number of times
							for _ in range(A	):
														lowerCAmelCase__	       =     []
														for row in range(A	):
																					lowerCAmelCase__	       =     0
																					for col in range(A	):
																												if col == row:
																																			lowerCAmelCase__	       =     table[row][col]
																												elif col == cols - 1:
																																			lowerCAmelCase__	       =     table[row][col]
																												else:
																																			temp += (-1) * table[row][col] * init_val[col]
																					lowerCAmelCase__	       =     (temp + val) / denom
																					new_val.append(A	)
														lowerCAmelCase__	       =     new_val

							return [float(A	) for i in new_val]


def  _snake_case       (					A	)						->   bool:
							lowerCAmelCase__       , lowerCAmelCase__	       =     table.shape

							lowerCAmelCase__	       =     True

							for i in range(0			,   A	):
														lowerCAmelCase__	       =     0
														for j in range(0			,   cols - 1	):
																					if i == j:
																												continue
																					else:
																												total += table[i][j]

														if table[i][i] <= total:
																					raise ValueError('''Coefficient matrix is not strictly diagonally dominant'''	)

							return is_diagonally_dominant


# Test Cases
if __name__ == "__main__":
		import doctest

		doctest.testmod()