"""simple docstring"""







import json
import os
import unittest

from transformers.models.roc_bert.tokenization_roc_bert import (
    VOCAB_FILES_NAMES,
    RoCBertBasicTokenizer,
    RoCBertTokenizer,
    RoCBertWordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english



@require_tokenizers
class  _lowerCamelCase			(__lowerCamelCase						,							unittest.TestCase     ):
				_snake_case     =  RoCBertTokenizer
				_snake_case     =  None
				_snake_case     =  False
				_snake_case     =  True
				_snake_case     =  filter_non_english







				def 							__UpperCAmelCase					( self    :       Optional[Any]						):

					"""simple docstring"""






					super().setUp()

					_lowercase :    List[Any]							=							['[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', '你', '好', '是', '谁', 'a', 'b', 'c', 'd']
					_lowercase :    Optional[int]							=							{}
					_lowercase :    Tuple							=							{}
					for i, value in enumerate(lowerCamelCase_						):
						_lowercase :    Any							=							i
						_lowercase :    Dict							=							i
					_lowercase :    Optional[int]							=							os.path.join(self.tmpdirname			,					VOCAB_FILES_NAMES['vocab_file']						)
					_lowercase :    int							=							os.path.join(self.tmpdirname			,					VOCAB_FILES_NAMES['word_shape_file']						)
					_lowercase :    List[str]							=							os.path.join(self.tmpdirname			,					VOCAB_FILES_NAMES['word_pronunciation_file']						)
					with open(self.vocab_file			,					'w'			,					encoding='utf-8'						) as vocab_writer:
						vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]						)						)
					with open(self.word_shape_file			,					'w'			,					encoding='utf-8'						) as word_shape_writer:
						json.dump(lowerCamelCase_			,					lowerCamelCase_			,					ensure_ascii=lowerCamelCase_						)
					with open(self.word_pronunciation_file			,					'w'			,					encoding='utf-8'						) as word_pronunciation_writer:
						json.dump(lowerCamelCase_			,					lowerCamelCase_			,					ensure_ascii=lowerCamelCase_						)







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

					"""simple docstring"""






					_lowercase :    Any							=							self.tokenizer_class(self.vocab_file			,					self.word_shape_file			,					self.word_pronunciation_file						)

					_lowercase :    Any							=							tokenizer.tokenize('你好[SEP]你是谁'						)
					self.assertListEqual(lowerCamelCase_			,					['你', '好', '[SEP]', '你', '是', '谁']						)
					self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase_						)			,					[5, 6, 2, 5, 7, 8]						)
					self.assertListEqual(tokenizer.convert_tokens_to_shape_ids(lowerCamelCase_						)			,					[5, 6, 2, 5, 7, 8]						)
					self.assertListEqual(tokenizer.convert_tokens_to_pronunciation_ids(lowerCamelCase_						)			,					[5, 6, 2, 5, 7, 8]						)







				def 							__UpperCAmelCase					( self    :       Any						):

					"""simple docstring"""






					_lowercase :    Tuple							=							RoCBertBasicTokenizer()

					self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz'						)			,					['ah', '\u535A', '\u63A8', 'zz']						)







				def 							__UpperCAmelCase					( self    :       str						):

					"""simple docstring"""






					_lowercase :    Optional[int]							=							RoCBertBasicTokenizer(do_lower_case=lowerCamelCase_						)

					self.assertListEqual(
					    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '						)			,					['hello', '!', 'how', 'are', 'you', '?']						)
					self.assertListEqual(tokenizer.tokenize('H\u00E9llo'						)			,					['hello']						)







				def 							__UpperCAmelCase					( self    :       Tuple						):

					"""simple docstring"""






					_lowercase :    int							=							RoCBertBasicTokenizer(do_lower_case=lowerCamelCase_			,					strip_accents=lowerCamelCase_						)

					self.assertListEqual(
					    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '						)			,					['hällo', '!', 'how', 'are', 'you', '?']						)
					self.assertListEqual(tokenizer.tokenize('H\u00E9llo'						)			,					['h\u00E9llo']						)







				def 							__UpperCAmelCase					( self    :       Dict						):

					"""simple docstring"""






					_lowercase :    List[str]							=							RoCBertBasicTokenizer(do_lower_case=lowerCamelCase_			,					strip_accents=lowerCamelCase_						)

					self.assertListEqual(
					    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '						)			,					['hallo', '!', 'how', 'are', 'you', '?']						)
					self.assertListEqual(tokenizer.tokenize('H\u00E9llo'						)			,					['hello']						)







				def 							__UpperCAmelCase					( self    :       Dict						):

					"""simple docstring"""






					_lowercase :    Optional[Any]							=							RoCBertBasicTokenizer(do_lower_case=lowerCamelCase_						)

					self.assertListEqual(
					    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '						)			,					['hallo', '!', 'how', 'are', 'you', '?']						)
					self.assertListEqual(tokenizer.tokenize('H\u00E9llo'						)			,					['hello']						)







				def 							__UpperCAmelCase					( self    :       int						):

					"""simple docstring"""






					_lowercase :    List[Any]							=							RoCBertBasicTokenizer(do_lower_case=lowerCamelCase_						)

					self.assertListEqual(
					    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '						)			,					['HeLLo', '!', 'how', 'Are', 'yoU', '?']						)







				def 							__UpperCAmelCase					( self    :       List[str]						):

					"""simple docstring"""






					_lowercase :    int							=							RoCBertBasicTokenizer(do_lower_case=lowerCamelCase_			,					strip_accents=lowerCamelCase_						)

					self.assertListEqual(
					    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '						)			,					['HäLLo', '!', 'how', 'Are', 'yoU', '?']						)







				def 							__UpperCAmelCase					( self    :       Tuple						):

					"""simple docstring"""






					_lowercase :    Dict							=							RoCBertBasicTokenizer(do_lower_case=lowerCamelCase_			,					strip_accents=lowerCamelCase_						)

					self.assertListEqual(
					    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '						)			,					['HaLLo', '!', 'how', 'Are', 'yoU', '?']						)







				def 							__UpperCAmelCase					( self    :       int						):

					"""simple docstring"""






					_lowercase :    Union[str, Any]							=							RoCBertBasicTokenizer(do_lower_case=lowerCamelCase_			,					never_split=['[UNK]']						)

					self.assertListEqual(
					    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU? [UNK]'						)			,					['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]']						)







				def 							__UpperCAmelCase					( self    :       Tuple						):

					"""simple docstring"""






					_lowercase :    List[str]							=							['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing']

					_lowercase :    List[str]							=							{}
					for i, token in enumerate(lowerCamelCase_						):
						_lowercase :    str							=							i
					_lowercase :    Tuple							=							RoCBertWordpieceTokenizer(vocab=lowerCamelCase_			,					unk_token='[UNK]'						)

					self.assertListEqual(tokenizer.tokenize(''						)			,					[]						)

					self.assertListEqual(tokenizer.tokenize('unwanted running'						)			,					['un', '##want', '##ed', 'runn', '##ing']						)

					self.assertListEqual(tokenizer.tokenize('unwantedX running'						)			,					['[UNK]', 'runn', '##ing']						)







				def 							__UpperCAmelCase					( self    :       Optional[int]						):

					"""simple docstring"""






					self.assertTrue(_is_whitespace(' '						)						)
					self.assertTrue(_is_whitespace('\t'						)						)
					self.assertTrue(_is_whitespace('\r'						)						)
					self.assertTrue(_is_whitespace('\n'						)						)
					self.assertTrue(_is_whitespace('\u00A0'						)						)

					self.assertFalse(_is_whitespace('A'						)						)
					self.assertFalse(_is_whitespace('-'						)						)







				def 							__UpperCAmelCase					( self    :       List[str]						):

					"""simple docstring"""






					self.assertTrue(_is_control('\u0005'						)						)

					self.assertFalse(_is_control('A'						)						)
					self.assertFalse(_is_control(' '						)						)
					self.assertFalse(_is_control('\t'						)						)
					self.assertFalse(_is_control('\r'						)						)







				def 							__UpperCAmelCase					( self    :       Optional[int]						):

					"""simple docstring"""






					self.assertTrue(_is_punctuation('-'						)						)
					self.assertTrue(_is_punctuation('$'						)						)
					self.assertTrue(_is_punctuation('`'						)						)
					self.assertTrue(_is_punctuation('.'						)						)

					self.assertFalse(_is_punctuation('A'						)						)
					self.assertFalse(_is_punctuation(' '						)						)







				def 							__UpperCAmelCase					( self    :       Optional[int]						):

					"""simple docstring"""






					_lowercase :    Any							=							self.get_tokenizer()

					# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
					self.assertListEqual([tokenizer.tokenize(lowerCamelCase_						) for t in ['Test', '\xad', 'test']]			,					[['[UNK]'], [], ['[UNK]']]						)

					if self.test_rust_tokenizer:
						_lowercase :    str							=							self.get_rust_tokenizer()
						self.assertListEqual(
						    [rust_tokenizer.tokenize(lowerCamelCase_						) for t in ['Test', '\xad', 'test']]			,					[['[UNK]'], [], ['[UNK]']]						)







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

					"""simple docstring"""






					for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
						with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''						):
							_lowercase :    Union[str, Any]							=							self.rust_tokenizer_class.from_pretrained(lowerCamelCase_			,					**lowerCamelCase_						)

							_lowercase :    List[Any]							=							F'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
							_lowercase :    Union[str, Any]							=							tokenizer_r.encode_plus(
							    lowerCamelCase_			,					return_attention_mask=lowerCamelCase_			,					return_token_type_ids=lowerCamelCase_			,					return_offsets_mapping=lowerCamelCase_			,					add_special_tokens=lowerCamelCase_			,					)

							_lowercase :    Union[str, Any]							=							tokenizer_r.do_lower_case if hasattr(lowerCamelCase_			,					'do_lower_case'						) else False
							_lowercase :    Optional[Any]							=							(
							    [
							        ((0, 0), tokenizer_r.cls_token),
							        ((0, 1), 'A'),
							        ((1, 2), ','),
							        ((3, 5), 'na'),
							        ((5, 6), '##ï'),
							        ((6, 8), '##ve'),
							        ((9, 1_5), tokenizer_r.mask_token),
							        ((1_6, 2_1), 'Allen'),
							        ((2_1, 2_3), '##NL'),
							        ((2_3, 2_4), '##P'),
							        ((2_5, 3_3), 'sentence'),
							        ((3_3, 3_4), '.'),
							        ((0, 0), tokenizer_r.sep_token),
							    ]
							    if not do_lower_case
							    else [
							        ((0, 0), tokenizer_r.cls_token),
							        ((0, 1), 'a'),
							        ((1, 2), ','),
							        ((3, 8), 'naive'),
							        ((9, 1_5), tokenizer_r.mask_token),
							        ((1_6, 2_1), 'allen'),
							        ((2_1, 2_3), '##nl'),
							        ((2_3, 2_4), '##p'),
							        ((2_5, 3_3), 'sentence'),
							        ((3_3, 3_4), '.'),
							        ((0, 0), tokenizer_r.sep_token),
							    ]
							)

							self.assertEqual(
							    [e[1] for e in expected_results]			,					tokenizer_r.convert_ids_to_tokens(tokens['input_ids']						)						)
							self.assertEqual([e[0] for e in expected_results]			,					tokens['offset_mapping']						)







				def 							__UpperCAmelCase					( self    :       List[Any]						):

					"""simple docstring"""






					_lowercase :    Optional[Any]							=							['的', '人', '有']
					_lowercase :    Tuple							=							''.join(lowerCamelCase_						)
					for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
						with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''						):
							_lowercase :    Any							=							True
							_lowercase :    Tuple							=							self.tokenizer_class.from_pretrained(lowerCamelCase_			,					**lowerCamelCase_						)
							_lowercase :    Optional[int]							=							self.rust_tokenizer_class.from_pretrained(lowerCamelCase_			,					**lowerCamelCase_						)

							_lowercase :    int							=							tokenizer_p.encode(lowerCamelCase_			,					add_special_tokens=lowerCamelCase_						)
							_lowercase :    Optional[Any]							=							tokenizer_r.encode(lowerCamelCase_			,					add_special_tokens=lowerCamelCase_						)

							_lowercase :    List[Any]							=							tokenizer_r.convert_ids_to_tokens(lowerCamelCase_						)
							_lowercase :    Tuple							=							tokenizer_p.convert_ids_to_tokens(lowerCamelCase_						)

							# it is expected that each Chinese character is not preceded by "##"
							self.assertListEqual(lowerCamelCase_			,					lowerCamelCase_						)
							self.assertListEqual(lowerCamelCase_			,					lowerCamelCase_						)

							_lowercase :    Union[str, Any]							=							False
							_lowercase :    List[Any]							=							self.rust_tokenizer_class.from_pretrained(lowerCamelCase_			,					**lowerCamelCase_						)
							_lowercase :    Union[str, Any]							=							self.tokenizer_class.from_pretrained(lowerCamelCase_			,					**lowerCamelCase_						)

							_lowercase :    Union[str, Any]							=							tokenizer_r.encode(lowerCamelCase_			,					add_special_tokens=lowerCamelCase_						)
							_lowercase :    Union[str, Any]							=							tokenizer_p.encode(lowerCamelCase_			,					add_special_tokens=lowerCamelCase_						)

							_lowercase :    int							=							tokenizer_r.convert_ids_to_tokens(lowerCamelCase_						)
							_lowercase :    int							=							tokenizer_p.convert_ids_to_tokens(lowerCamelCase_						)

							# it is expected that only the first Chinese character is not preceded by "##".
							_lowercase :    Optional[int]							=							[
							    F'''##{token}''' if idx != 0 else token for idx, token in enumerate(lowerCamelCase_						)
							]
							self.assertListEqual(lowerCamelCase_			,					lowerCamelCase_						)
							self.assertListEqual(lowerCamelCase_			,					lowerCamelCase_						)







				@slow
				def 							__UpperCAmelCase					( self    :       List[Any]						):

					"""simple docstring"""






					_lowercase :    Dict							=							self.tokenizer_class(self.vocab_file			,					self.word_shape_file			,					self.word_pronunciation_file						)

					_lowercase :    Optional[int]							=							tokenizer.encode('你好'			,					add_special_tokens=lowerCamelCase_						)
					_lowercase :    Tuple							=							tokenizer.encode('你是谁'			,					add_special_tokens=lowerCamelCase_						)

					_lowercase :    Tuple							=							tokenizer.build_inputs_with_special_tokens(lowerCamelCase_						)
					_lowercase :    Union[str, Any]							=							tokenizer.build_inputs_with_special_tokens(lowerCamelCase_			,					lowerCamelCase_						)

					assert encoded_sentence == [1] + text + [2]
					assert encoded_pair == [1] + text + [2] + text_a + [2]







				def 							__UpperCAmelCase					( self    :       str						):

					"""simple docstring"""






					_lowercase :    Tuple							=							self.get_tokenizers(do_lower_case=lowerCamelCase_						)
					for tokenizer in tokenizers:
						with self.subTest(F'''{tokenizer.__class__.__name__}'''						):
							_lowercase :    Union[str, Any]							=							'你好，你是谁'
							_lowercase :    Optional[Any]							=							tokenizer.tokenize(lowerCamelCase_						)
							_lowercase :    Any							=							tokenizer.convert_tokens_to_ids(lowerCamelCase_						)
							_lowercase :    Tuple							=							tokenizer.convert_tokens_to_shape_ids(lowerCamelCase_						)
							_lowercase :    Union[str, Any]							=							tokenizer.convert_tokens_to_pronunciation_ids(lowerCamelCase_						)
							_lowercase :    Dict							=							tokenizer.prepare_for_model(
							    lowerCamelCase_			,					lowerCamelCase_			,					lowerCamelCase_			,					add_special_tokens=lowerCamelCase_						)

							_lowercase :    str							=							tokenizer.encode_plus(lowerCamelCase_			,					add_special_tokens=lowerCamelCase_						)

							self.assertEqual(lowerCamelCase_			,					lowerCamelCase_						)




"""simple docstring"""







from __future__ import annotations

import math
import random
from collections.abc import Collection
from typing import overload



class  _lowerCamelCase			:







				def __init__( self    :       str			,					lowerCamelCase_    :       Collection[float] | None = None						):

					"""simple docstring"""






					if components is None:
						_lowercase :    Any							=							[]
					_lowercase :    int							=							list(lowerCamelCase_						)







				def __len__( self    :       int						):

					"""simple docstring"""






					return len(self.__components						)







				def __str__( self    :       List[Any]						):

					"""simple docstring"""






					return "(" + ",".join(map(lowerCamelCase_			,					self.__components						)						) + ")"







				def __add__( self    :       Dict			,					lowerCamelCase_    :       Vector						):

					"""simple docstring"""






					_lowercase :    Union[str, Any]							=							len(self						)
					if size == len(lowerCamelCase_						):
						_lowercase :    int							=							[self.__components[i] + other.component(lowerCamelCase_						) for i in range(lowerCamelCase_						)]
						return Vector(lowerCamelCase_						)
					else:
						raise Exception('must have the same size'						)







				def __sub__( self    :       int			,					lowerCamelCase_    :       Vector						):

					"""simple docstring"""






					_lowercase :    Optional[int]							=							len(self						)
					if size == len(lowerCamelCase_						):
						_lowercase :    Optional[int]							=							[self.__components[i] - other.component(lowerCamelCase_						) for i in range(lowerCamelCase_						)]
						return Vector(lowerCamelCase_						)
					else:  # error case
						raise Exception('must have the same size'						)







				@overload
				def __mul__( self    :       Tuple			,					lowerCamelCase_    :       float						):

					"""simple docstring"""






					...







				@overload
				def __mul__( self    :       Tuple			,					lowerCamelCase_    :       Vector						):

					"""simple docstring"""






					...







				def __mul__( self    :       int			,					lowerCamelCase_    :       float | Vector						):

					"""simple docstring"""






					if isinstance(lowerCamelCase_			,					(float, int)						):
						_lowercase :    List[Any]							=							[c * other for c in self.__components]
						return Vector(lowerCamelCase_						)
					elif isinstance(lowerCamelCase_			,					lowerCamelCase_						) and len(self						) == len(lowerCamelCase_						):
						_lowercase :    Any							=							len(self						)
						_lowercase :    List[Any]							=							[self.__components[i] * other.component(lowerCamelCase_						) for i in range(lowerCamelCase_						)]
						return sum(lowerCamelCase_						)
					else:  # error case
						raise Exception('invalid operand!'						)







				def 							__UpperCAmelCase					( self    :       Dict						):

					"""simple docstring"""






					return Vector(self.__components						)







				def 							__UpperCAmelCase					( self    :       List[str]			,					lowerCamelCase_    :       int						):

					"""simple docstring"""






					if isinstance(lowerCamelCase_			,					lowerCamelCase_						) and -len(self.__components						) <= i < len(self.__components						):
						return self.__components[i]
					else:
						raise Exception('index out of range'						)







				def 							__UpperCAmelCase					( self    :       str			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       float						):

					"""simple docstring"""






					assert -len(self.__components						) <= pos < len(self.__components						)
					_lowercase :    Tuple							=							value







				def 							__UpperCAmelCase					( self    :       List[Any]						):

					"""simple docstring"""






					if len(self.__components						) == 0:
						raise Exception('Vector is empty'						)
					_lowercase :    Optional[int]							=							[c**2 for c in self.__components]
					return math.sqrt(sum(lowerCamelCase_						)						)







				def 							__UpperCAmelCase					( self    :       int			,					lowerCamelCase_    :       Vector			,					lowerCamelCase_    :       bool = False						):

					"""simple docstring"""






					_lowercase :    int							=							self * other
					_lowercase :    Any							=							self.euclidean_length() * other.euclidean_length()
					if deg:
						return math.degrees(math.acos(num / den						)						)
					else:
						return math.acos(num / den						)



def      __lowerCAmelCase(		__UpperCAmelCase			):






	"""simple docstring"""





	assert isinstance(__UpperCAmelCase     ,__UpperCAmelCase			)
	return Vector([0] * dimension			)


def      __lowerCAmelCase(		__UpperCAmelCase     ,__UpperCAmelCase			):






	"""simple docstring"""





	assert isinstance(__UpperCAmelCase     ,__UpperCAmelCase			) and (isinstance(__UpperCAmelCase     ,__UpperCAmelCase			))
	_lowercase :    str							=							[0] * dimension
	_lowercase :    List[Any]							=							1
	return Vector(__UpperCAmelCase			)


def      __lowerCAmelCase(		__UpperCAmelCase     ,__UpperCAmelCase     ,__UpperCAmelCase			):






	"""simple docstring"""





	assert (
	    isinstance(__UpperCAmelCase     ,__UpperCAmelCase			)
	    and isinstance(__UpperCAmelCase     ,__UpperCAmelCase			)
	    and (isinstance(__UpperCAmelCase     ,(int, float)			))
	)
	return x * scalar + y


def      __lowerCAmelCase(		__UpperCAmelCase     ,__UpperCAmelCase     ,__UpperCAmelCase			):






	"""simple docstring"""





	random.seed(__UpperCAmelCase			)
	_lowercase :    Tuple							=							[random.randint(__UpperCAmelCase     ,__UpperCAmelCase			) for _ in range(__UpperCAmelCase			)]
	return Vector(__UpperCAmelCase			)



class  _lowerCamelCase			:







				def __init__( self    :       Dict			,					lowerCamelCase_    :       list[list[float]]			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       int						):

					"""simple docstring"""






					_lowercase :    Tuple							=							matrix
					_lowercase :    str							=							w
					_lowercase :    Tuple							=							h







				def __str__( self    :       int						):

					"""simple docstring"""






					_lowercase :    Tuple							=							''
					for i in range(self.__height						):
						ans += "|"
						for j in range(self.__width						):
							if j < self.__width - 1:
								ans += str(self.__matrix[i][j]						) + ","
							else:
								ans += str(self.__matrix[i][j]						) + "|\n"
					return ans







				def __add__( self    :       Dict			,					lowerCamelCase_    :       Matrix						):

					"""simple docstring"""






					if self.__width == other.width() and self.__height == other.height():
						_lowercase :    Dict							=							[]
						for i in range(self.__height						):
							_lowercase :    Tuple							=							[
							    self.__matrix[i][j] + other.component(lowerCamelCase_			,					lowerCamelCase_						)
							    for j in range(self.__width						)
							]
							matrix.append(lowerCamelCase_						)
						return Matrix(lowerCamelCase_			,					self.__width			,					self.__height						)
					else:
						raise Exception('matrix must have the same dimension!'						)







				def __sub__( self    :       str			,					lowerCamelCase_    :       Matrix						):

					"""simple docstring"""






					if self.__width == other.width() and self.__height == other.height():
						_lowercase :    List[Any]							=							[]
						for i in range(self.__height						):
							_lowercase :    int							=							[
							    self.__matrix[i][j] - other.component(lowerCamelCase_			,					lowerCamelCase_						)
							    for j in range(self.__width						)
							]
							matrix.append(lowerCamelCase_						)
						return Matrix(lowerCamelCase_			,					self.__width			,					self.__height						)
					else:
						raise Exception('matrices must have the same dimension!'						)







				@overload
				def __mul__( self    :       Union[str, Any]			,					lowerCamelCase_    :       float						):

					"""simple docstring"""






					...







				@overload
				def __mul__( self    :       List[str]			,					lowerCamelCase_    :       Vector						):

					"""simple docstring"""






					...







				def __mul__( self    :       int			,					lowerCamelCase_    :       float | Vector						):

					"""simple docstring"""






					if isinstance(lowerCamelCase_			,					lowerCamelCase_						):  # matrix-vector
						if len(lowerCamelCase_						) == self.__width:
							_lowercase :    Optional[int]							=							zero_vector(self.__height						)
							for i in range(self.__height						):
								_lowercase :    Optional[Any]							=							[
								    self.__matrix[i][j] * other.component(lowerCamelCase_						)
								    for j in range(self.__width						)
								]
								ans.change_component(lowerCamelCase_			,					sum(lowerCamelCase_						)						)
							return ans
						else:
							raise Exception(
							    'vector must have the same size as the '
							    'number of columns of the matrix!'						)
					elif isinstance(lowerCamelCase_			,					(int, float)						):  # matrix-scalar
						_lowercase :    Optional[int]							=							[
						    [self.__matrix[i][j] * other for j in range(self.__width						)]
						    for i in range(self.__height						)
						]
						return Matrix(lowerCamelCase_			,					self.__width			,					self.__height						)
					return None







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

					"""simple docstring"""






					return self.__height







				def 							__UpperCAmelCase					( self    :       List[Any]						):

					"""simple docstring"""






					return self.__width







				def 							__UpperCAmelCase					( self    :       Optional[Any]			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       int						):

					"""simple docstring"""






					if 0 <= x < self.__height and 0 <= y < self.__width:
						return self.__matrix[x][y]
					else:
						raise Exception('change_component: indices out of bounds'						)







				def 							__UpperCAmelCase					( self    :       Optional[Any]			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       float						):

					"""simple docstring"""






					if 0 <= x < self.__height and 0 <= y < self.__width:
						_lowercase :    int							=							value
					else:
						raise Exception('change_component: indices out of bounds'						)







				def 							__UpperCAmelCase					( self    :       int			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       int						):

					"""simple docstring"""






					if self.__height != self.__width:
						raise Exception('Matrix is not square'						)
					_lowercase :    Union[str, Any]							=							self.__matrix[:x] + self.__matrix[x + 1 :]
					for i in range(len(lowerCamelCase_						)						):
						_lowercase :    int							=							minor[i][:y] + minor[i][y + 1 :]
					return Matrix(lowerCamelCase_			,					self.__width - 1			,					self.__height - 1						).determinant()







				def 							__UpperCAmelCase					( self    :       List[str]			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       int						):

					"""simple docstring"""






					if self.__height != self.__width:
						raise Exception('Matrix is not square'						)
					if 0 <= x < self.__height and 0 <= y < self.__width:
						return (-1) ** (x + y) * self.minor(lowerCamelCase_			,					lowerCamelCase_						)
					else:
						raise Exception('Indices out of bounds'						)







				def 							__UpperCAmelCase					( self    :       Dict						):

					"""simple docstring"""






					if self.__height != self.__width:
						raise Exception('Matrix is not square'						)
					if self.__height < 1:
						raise Exception('Matrix has no element'						)
					elif self.__height == 1:
						return self.__matrix[0][0]
					elif self.__height == 2:
						return (
						    self.__matrix[0][0] * self.__matrix[1][1]
						    - self.__matrix[0][1] * self.__matrix[1][0]
						)
					else:
						_lowercase :    Union[str, Any]							=							[
						    self.__matrix[0][y] * self.cofactor(0			,					lowerCamelCase_						) for y in range(self.__width						)
						]
						return sum(lowerCamelCase_						)



def      __lowerCAmelCase(		__UpperCAmelCase			):






	"""simple docstring"""





	_lowercase :    list[list[float]]							=							[[0] * n for _ in range(__UpperCAmelCase			)]
	return Matrix(__UpperCAmelCase     ,__UpperCAmelCase     ,__UpperCAmelCase			)







def      __lowerCAmelCase(		__UpperCAmelCase     ,__UpperCAmelCase     ,__UpperCAmelCase     ,__UpperCAmelCase			):






	"""simple docstring"""





	random.seed(__UpperCAmelCase			)
	_lowercase :    list[list[float]]							=							[
	    [random.randint(__UpperCAmelCase     ,__UpperCAmelCase			) for _ in range(__UpperCAmelCase			)] for _ in range(__UpperCAmelCase			)
	]
	return Matrix(__UpperCAmelCase     ,__UpperCAmelCase     ,__UpperCAmelCase			)



