






import os
import pickle
import unittest

from transformers import AutoTokenizer
from transformers.models.bert.tokenization_bert import BertTokenizer
from transformers.models.bert_japanese.tokenization_bert_japanese import (
    VOCAB_FILES_NAMES,
    BertJapaneseTokenizer,
    CharacterTokenizer,
    JumanppTokenizer,
    MecabTokenizer,
    SudachiTokenizer,
    WordpieceTokenizer,
)
from transformers.testing_utils import custom_tokenizers, require_jumanpp, require_sudachi

from ...test_tokenization_common import TokenizerTesterMixin




@custom_tokenizers
class 					UpperCamelCase_ (     snake_case_			,   unittest.TestCase							):



	'''simple docstring'''




	lowerCAmelCase						=					BertJapaneseTokenizer
	lowerCAmelCase						=					False
	lowerCAmelCase						=					True




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

								snake_case_           =				[
								    '[UNK]',
								    '[CLS]',
								    '[SEP]',
								    'こんにちは',
								    'こん',
								    'にちは',
								    'ばんは',
								    '##こん',
								    '##にちは',
								    '##ばんは',
								    '世界',
								    '##世界',
								    '、',
								    '##、',
								    '。',
								    '##。',
								]

								snake_case_           =				os.path.join(self.tmpdirname			,     VOCAB_FILES_NAMES['vocab_file']   )
								with open(self.vocab_file			,     'w'			,     encoding='utf-8'   ) as vocab_writer:
															vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]   )   )




	def 				_UpperCamelCase     (			self			,     a   )			->       str:
								snake_case_           =				'こんにちは、世界。 \nこんばんは、世界。'
								snake_case_           =				'こんにちは 、 世界 。 こんばんは 、 世界 。'
								return input_text, output_text




	def 				_UpperCamelCase     (			self			,     a   )			->       List[Any]:
								snake_case_     ,						snake_case_           =				self.get_input_output_texts(a   )
								snake_case_           =				tokenizer.encode(a			,     add_special_tokens=a   )
								snake_case_           =				tokenizer.decode(a			,     clean_up_tokenization_spaces=a   )
								return text, ids




	def 				_UpperCamelCase     (			self   )			->       Any:
								pass  # TODO add if relevant




	def 				_UpperCamelCase     (			self   )			->       Optional[int]:
								pass  # TODO add if relevant




	def 				_UpperCamelCase     (			self   )			->       Dict:
								pass  # TODO add if relevant




	def 				_UpperCamelCase     (			self   )			->       Any:
								snake_case_           =				self.tokenizer_class(self.vocab_file   )

								snake_case_           =				tokenizer.tokenize('こんにちは、世界。\nこんばんは、世界。'   )
								self.assertListEqual(a			,     ['こんにちは', '、', '世界', '。', 'こん', '##ばんは', '、', '世界', '。']   )
								self.assertListEqual(tokenizer.convert_tokens_to_ids(a   )			,     [3, 12, 10, 14, 4, 9, 12, 10, 14]   )




	def 				_UpperCamelCase     (			self   )			->       List[Any]:
								snake_case_           =				self.tokenizer_class(self.vocab_file			,     word_tokenizer_type='mecab'   )
								self.assertIsNotNone(a   )

								snake_case_           =				'こんにちは、世界。\nこんばんは、世界。'
								snake_case_           =				tokenizer.tokenize(a   )
								self.assertListEqual(a			,     ['こんにちは', '、', '世界', '。', 'こん', '##ばんは', '、', '世界', '。']   )
								self.assertListEqual(tokenizer.convert_tokens_to_ids(a   )			,     [3, 12, 10, 14, 4, 9, 12, 10, 14]   )

								snake_case_           =				os.path.join(self.tmpdirname			,     'tokenizer.bin'   )
								with open(a			,     'wb'   ) as handle:
															pickle.dump(a			,     a   )

								with open(a			,     'rb'   ) as handle:
															snake_case_           =				pickle.load(a   )

								snake_case_           =				tokenizer_new.tokenize(a   )

								self.assertListEqual(a			,     a   )




	def 				_UpperCamelCase     (			self   )			->       List[str]:
								snake_case_           =				MecabTokenizer(mecab_dic='ipadic'   )

								self.assertListEqual(
								    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '   )			,     ['アップルストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れ', 'た', '。']			,     )




	def 				_UpperCamelCase     (			self   )			->       Tuple:
								try:
															snake_case_           =				MecabTokenizer(mecab_dic='unidic_lite'   )
								except ModuleNotFoundError:
															return

								self.assertListEqual(
								    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '   )			,     ['アップル', 'ストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れ', 'た', '。']			,     )




	def 				_UpperCamelCase     (			self   )			->       Optional[Any]:
								try:
															snake_case_           =				MecabTokenizer(mecab_dic='unidic'   )
								except ModuleNotFoundError:
															return

								self.assertListEqual(
								    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '   )			,     ['アップル', 'ストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れ', 'た', '。']			,     )




	def 				_UpperCamelCase     (			self   )			->       Tuple:
								snake_case_           =				MecabTokenizer(do_lower_case=a			,     mecab_dic='ipadic'   )

								self.assertListEqual(
								    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '   )			,     ['アップルストア', 'で', 'iphone', '8', 'が', '発売', 'さ', 'れ', 'た', '。']			,     )




	def 				_UpperCamelCase     (			self   )			->       str:
								try:
															snake_case_           =				MecabTokenizer(
															    do_lower_case=a			,     normalize_text=a			,     mecab_option='-d /usr/local/lib/mecab/dic/jumandic'   )
								except RuntimeError:
															# if dict doesn't exist in the system, previous code raises this error.
															return

								self.assertListEqual(
								    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '   )			,     ['ｱｯﾌﾟﾙストア', 'で', 'iPhone', '８', 'が', '発売', 'さ', 'れた', '\u3000', '。']			,     )




	def 				_UpperCamelCase     (			self   )			->       Any:
								snake_case_           =				MecabTokenizer(normalize_text=a			,     mecab_dic='ipadic'   )

								self.assertListEqual(
								    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '   )			,     ['ｱｯﾌﾟﾙストア', 'で', 'iPhone', '８', 'が', '発売', 'さ', 'れ', 'た', '　', '。']			,     )




	@require_sudachi
	def 				_UpperCamelCase     (			self   )			->       Tuple:
								snake_case_           =				self.tokenizer_class(self.vocab_file			,     word_tokenizer_type='sudachi'   )
								self.assertIsNotNone(a   )

								snake_case_           =				'こんにちは、世界。\nこんばんは、世界。'
								snake_case_           =				tokenizer.tokenize(a   )
								self.assertListEqual(a			,     ['こんにちは', '、', '世界', '。', 'こん', '##ばんは', '、', '世界', '。']   )
								self.assertListEqual(tokenizer.convert_tokens_to_ids(a   )			,     [3, 12, 10, 14, 4, 9, 12, 10, 14]   )

								snake_case_           =				os.path.join(self.tmpdirname			,     'tokenizer.bin'   )
								with open(a			,     'wb'   ) as handle:
															pickle.dump(a			,     a   )

								with open(a			,     'rb'   ) as handle:
															snake_case_           =				pickle.load(a   )

								snake_case_           =				tokenizer_new.tokenize(a   )

								self.assertListEqual(a			,     a   )




	@require_sudachi
	def 				_UpperCamelCase     (			self   )			->       Any:
								snake_case_           =				SudachiTokenizer(sudachi_dict_type='core'   )

								self.assertListEqual(
								    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '   )			,     [' ', '\t', 'アップル', 'ストア', 'で', 'iPhone', '8', ' ', 'が', ' ', ' ', '\n ', '発売', 'さ', 'れ', 'た', ' ', '。', ' ', ' ']			,     )




	@require_sudachi
	def 				_UpperCamelCase     (			self   )			->       Tuple:
								snake_case_           =				SudachiTokenizer(sudachi_dict_type='core'			,     sudachi_split_mode='A'   )

								self.assertListEqual(tokenizer.tokenize('外国人参政権'   )			,     ['外国', '人', '参政', '権']   )




	@require_sudachi
	def 				_UpperCamelCase     (			self   )			->       List[str]:
								snake_case_           =				SudachiTokenizer(sudachi_dict_type='core'			,     sudachi_split_mode='B'   )

								self.assertListEqual(tokenizer.tokenize('外国人参政権'   )			,     ['外国人', '参政権']   )




	@require_sudachi
	def 				_UpperCamelCase     (			self   )			->       Optional[Any]:
								snake_case_           =				SudachiTokenizer(sudachi_dict_type='core'			,     sudachi_split_mode='C'   )

								self.assertListEqual(tokenizer.tokenize('外国人参政権'   )			,     ['外国人参政権']   )




	@require_sudachi
	def 				_UpperCamelCase     (			self   )			->       Tuple:
								snake_case_           =				SudachiTokenizer(do_lower_case=a			,     sudachi_dict_type='core'   )

								self.assertListEqual(
								    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '   )			,     [' ', '\t', 'アップル', 'ストア', 'で', 'iphone', '8', ' ', 'が', ' ', ' ', '\n ', '発売', 'さ', 'れ', 'た', ' ', '。', ' ', ' ']			,     )




	@require_sudachi
	def 				_UpperCamelCase     (			self   )			->       Optional[Any]:
								snake_case_           =				SudachiTokenizer(normalize_text=a			,     sudachi_dict_type='core'   )

								self.assertListEqual(
								    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '   )			,     [' ', '\t', 'ｱｯﾌﾟﾙ', 'ストア', 'で', 'iPhone', '８', ' ', 'が', ' ', ' ', '\n ', '発売', 'さ', 'れ', 'た', '\u3000', '。', ' ', ' ']			,     )




	@require_sudachi
	def 				_UpperCamelCase     (			self   )			->       Optional[Any]:
								snake_case_           =				SudachiTokenizer(trim_whitespace=a			,     sudachi_dict_type='core'   )

								self.assertListEqual(
								    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '   )			,     ['アップル', 'ストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れ', 'た', '。']			,     )




	@require_jumanpp
	def 				_UpperCamelCase     (			self   )			->       Union[str, Any]:
								snake_case_           =				self.tokenizer_class(self.vocab_file			,     word_tokenizer_type='jumanpp'   )
								self.assertIsNotNone(a   )

								snake_case_           =				'こんにちは、世界。\nこんばんは、世界。'
								snake_case_           =				tokenizer.tokenize(a   )
								self.assertListEqual(a			,     ['こんにちは', '、', '世界', '。', 'こん', '##ばんは', '、', '世界', '。']   )
								self.assertListEqual(tokenizer.convert_tokens_to_ids(a   )			,     [3, 12, 10, 14, 4, 9, 12, 10, 14]   )

								snake_case_           =				os.path.join(self.tmpdirname			,     'tokenizer.bin'   )
								with open(a			,     'wb'   ) as handle:
															pickle.dump(a			,     a   )

								with open(a			,     'rb'   ) as handle:
															snake_case_           =				pickle.load(a   )

								snake_case_           =				tokenizer_new.tokenize(a   )

								self.assertListEqual(a			,     a   )




	@require_jumanpp
	def 				_UpperCamelCase     (			self   )			->       int:
								snake_case_           =				JumanppTokenizer()

								self.assertListEqual(
								    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '   )			,     ['アップル', 'ストア', 'で', 'iPhone', '8', '\u3000', 'が', '\u3000', '\u3000', '\u3000', '発売', 'さ', 'れた', '\u3000', '。']			,     )




	@require_jumanpp
	def 				_UpperCamelCase     (			self   )			->       List[str]:
								snake_case_           =				JumanppTokenizer(do_lower_case=a   )

								self.assertListEqual(
								    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '   )			,     ['アップル', 'ストア', 'で', 'iphone', '8', '\u3000', 'が', '\u3000', '\u3000', '\u3000', '発売', 'さ', 'れた', '\u3000', '。']			,     )




	@require_jumanpp
	def 				_UpperCamelCase     (			self   )			->       List[Any]:
								snake_case_           =				JumanppTokenizer(normalize_text=a   )

								self.assertListEqual(
								    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '   )			,     ['ｱ', 'ｯ', 'ﾌ', 'ﾟ', 'ﾙ', 'ストア', 'で', 'iPhone', '８', '\u3000', 'が', '\u3000', '\u3000', '\u3000', '発売', 'さ', 'れた', '\u3000', '。']			,     )




	@require_jumanpp
	def 				_UpperCamelCase     (			self   )			->       Union[str, Any]:
								snake_case_           =				JumanppTokenizer(trim_whitespace=a   )

								self.assertListEqual(
								    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '   )			,     ['アップル', 'ストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れた', '。']			,     )




	@require_jumanpp
	def 				_UpperCamelCase     (			self   )			->       Any:
								snake_case_           =				JumanppTokenizer()

								self.assertListEqual(
								    tokenizer.tokenize('ありがとうございますm(_ _)ｍ見つけるのが大変です。'   )			,     ['ありがとう', 'ございます', 'm(_ _)m', '見つける', 'の', 'が', '大変です', '。']			,     )




	def 				_UpperCamelCase     (			self   )			->       int:
								snake_case_           =				['[UNK]', '[CLS]', '[SEP]', 'こんにちは', 'こん', 'にちは', 'ばんは', '##こん', '##にちは', '##ばんは']

								snake_case_           =				{}
								for i, token in enumerate(a   ):
															snake_case_           =				i
								snake_case_           =				WordpieceTokenizer(vocab=a			,     unk_token='[UNK]'   )

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

								self.assertListEqual(tokenizer.tokenize('こんにちは'   )			,     ['こんにちは']   )

								self.assertListEqual(tokenizer.tokenize('こんばんは'   )			,     ['こん', '##ばんは']   )

								self.assertListEqual(tokenizer.tokenize('こんばんは こんばんにちは こんにちは'   )			,     ['こん', '##ばんは', '[UNK]', 'こんにちは']   )




	def 				_UpperCamelCase     (			self   )			->       List[Any]:
								snake_case_           =				BertJapaneseTokenizer.from_pretrained('nlp-waseda/roberta-base-japanese-with-auto-jumanpp'   )
								snake_case_           =				tokenizer.subword_tokenizer

								snake_case_           =				subword_tokenizer.tokenize('国境 の 長い トンネル を 抜ける と 雪国 であった 。'   )
								self.assertListEqual(a			,     ['▁国境', '▁の', '▁長い', '▁トンネル', '▁を', '▁抜ける', '▁と', '▁雪', '国', '▁であった', '▁。']   )

								snake_case_           =				subword_tokenizer.tokenize('こんばんは こんばん にち は こんにちは'   )
								self.assertListEqual(a			,     ['▁こん', 'ばん', 'は', '▁こん', 'ばん', '▁に', 'ち', '▁は', '▁こんにちは']   )






	def 				_UpperCamelCase     (			self   )			->       str:
								snake_case_           =				self.tokenizer_class.from_pretrained('cl-tohoku/bert-base-japanese'   )

								snake_case_           =				tokenizer.encode('ありがとう。'			,     add_special_tokens=a   )
								snake_case_           =				tokenizer.encode('どういたしまして。'			,     add_special_tokens=a   )

								snake_case_           =				tokenizer.build_inputs_with_special_tokens(a   )
								snake_case_           =				tokenizer.build_inputs_with_special_tokens(a			,     a   )

								# 2 is for "[CLS]", 3 is for "[SEP]"
								assert encoded_sentence == [2] + text + [3]
								assert encoded_pair == [2] + text + [3] + text_a + [3]






@custom_tokenizers
class 					UpperCamelCase_ (     snake_case_			,   unittest.TestCase							):



	'''simple docstring'''




	lowerCAmelCase						=					BertJapaneseTokenizer
	lowerCAmelCase						=					False




	def 				_UpperCamelCase     (			self   )			->       int:
								super().setUp()

								snake_case_           =				['[UNK]', '[CLS]', '[SEP]', 'こ', 'ん', 'に', 'ち', 'は', 'ば', '世', '界', '、', '。']

								snake_case_           =				os.path.join(self.tmpdirname			,     VOCAB_FILES_NAMES['vocab_file']   )
								with open(self.vocab_file			,     'w'			,     encoding='utf-8'   ) as vocab_writer:
															vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]   )   )




	def 				_UpperCamelCase     (			self			,     **a   )			->       Dict:
								return BertJapaneseTokenizer.from_pretrained(self.tmpdirname			,     subword_tokenizer_type='character'			,     **a   )




	def 				_UpperCamelCase     (			self			,     a   )			->       List[str]:
								snake_case_           =				'こんにちは、世界。 \nこんばんは、世界。'
								snake_case_           =				'こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。'
								return input_text, output_text




	def 				_UpperCamelCase     (			self   )			->       List[str]:
								pass  # TODO add if relevant




	def 				_UpperCamelCase     (			self   )			->       Any:
								pass  # TODO add if relevant




	def 				_UpperCamelCase     (			self   )			->       Tuple:
								pass  # TODO add if relevant




	def 				_UpperCamelCase     (			self   )			->       Tuple:
								snake_case_           =				self.tokenizer_class(self.vocab_file			,     subword_tokenizer_type='character'   )

								snake_case_           =				tokenizer.tokenize('こんにちは、世界。 \nこんばんは、世界。'   )
								self.assertListEqual(
								    a			,     ['こ', 'ん', 'に', 'ち', 'は', '、', '世', '界', '。', 'こ', 'ん', 'ば', 'ん', 'は', '、', '世', '界', '。']   )
								self.assertListEqual(
								    tokenizer.convert_tokens_to_ids(a   )			,     [3, 4, 5, 6, 7, 11, 9, 10, 12, 3, 4, 8, 4, 7, 11, 9, 10, 12]   )




	def 				_UpperCamelCase     (			self   )			->       Optional[Any]:
								snake_case_           =				['[UNK]', '[CLS]', '[SEP]', 'こ', 'ん', 'に', 'ち', 'は', 'ば', '世', '界', '、', '。']

								snake_case_           =				{}
								for i, token in enumerate(a   ):
															snake_case_           =				i
								snake_case_           =				CharacterTokenizer(vocab=a			,     unk_token='[UNK]'   )

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

								self.assertListEqual(tokenizer.tokenize('こんにちは'   )			,     ['こ', 'ん', 'に', 'ち', 'は']   )

								self.assertListEqual(tokenizer.tokenize('こんにちほ'   )			,     ['こ', 'ん', 'に', 'ち', '[UNK]']   )






	def 				_UpperCamelCase     (			self   )			->       List[Any]:
								snake_case_           =				self.tokenizer_class.from_pretrained('cl-tohoku/bert-base-japanese-char'   )

								snake_case_           =				tokenizer.encode('ありがとう。'			,     add_special_tokens=a   )
								snake_case_           =				tokenizer.encode('どういたしまして。'			,     add_special_tokens=a   )

								snake_case_           =				tokenizer.build_inputs_with_special_tokens(a   )
								snake_case_           =				tokenizer.build_inputs_with_special_tokens(a			,     a   )

								# 2 is for "[CLS]", 3 is for "[SEP]"
								assert encoded_sentence == [2] + text + [3]
								assert encoded_pair == [2] + text + [3] + text_a + [3]






@custom_tokenizers
class 					UpperCamelCase_ (     unittest.TestCase							):



	'''simple docstring'''




	def 				_UpperCamelCase     (			self   )			->       str:
								snake_case_           =				'cl-tohoku/bert-base-japanese'
								snake_case_           =				AutoTokenizer.from_pretrained(a   )
								self.assertIsInstance(a			,     a   )






class 					UpperCamelCase_ (     unittest.TestCase							):



	'''simple docstring'''




	def 				_UpperCamelCase     (			self   )			->       List[str]:
								snake_case_           =				'cl-tohoku/bert-base-japanese'
								with self.assertLogs('transformers'			,     level='WARNING'   ) as cm:
															BertTokenizer.from_pretrained(a   )
															self.assertTrue(
															    cm.records[0].message.startswith(
															        'The tokenizer class you load from this checkpoint is not the same type as the class this function'
															        ' is called from.'   )   )
								snake_case_           =				'bert-base-cased'
								with self.assertLogs('transformers'			,     level='WARNING'   ) as cm:
															BertJapaneseTokenizer.from_pretrained(a   )
															self.assertTrue(
															    cm.records[0].message.startswith(
															        'The tokenizer class you load from this checkpoint is not the same type as the class this function'
															        ' is called from.'   )   )













import unittest

import numpy as np





def 		__UpperCAmelCase     (	a_				,	a_				,	a_				,	a_ = None				,	):
							snake_case_           =				np.shape(a_)
							snake_case_           =				np.shape(a_)
							snake_case_           =				np.shape(a_)

							if shape_a[0] != shape_b[0]:
														snake_case_           =				(
														    'Expected the same number of rows for A and B. '
														    f'''Instead found A of size {shape_a} and B of size {shape_b}'''
														)
														raise ValueError(a_)

							if shape_b[1] != shape_c[1]:
														snake_case_           =				(
														    'Expected the same number of columns for B and C. '
														    f'''Instead found B of size {shape_b} and C of size {shape_c}'''
														)
														raise ValueError(a_)

							snake_case_           =				pseudo_inv
							if a_inv is None:
														try:
																					snake_case_           =				np.linalg.inv(a_)
														except np.linalg.LinAlgError:
																					raise ValueError(
																					    'Input matrix A is not invertible. Cannot compute Schur complement.')

							return mat_c - mat_b.T @ a_inv @ mat_b




class 					UpperCamelCase_ (     unittest.TestCase							):



	'''simple docstring'''




	def 				_UpperCamelCase     (			self   )			->       None:
								snake_case_           =				np.array([[1, 2, 1], [2, 1, 2], [3, 2, 4]]   )
								snake_case_           =				np.array([[0, 3], [3, 0], [2, 3]]   )
								snake_case_           =				np.array([[2, 1], [6, 3]]   )

								snake_case_           =				schur_complement(a			,     a			,     a   )

								snake_case_           =				np.block([[a, b], [b.T, c]]   )

								snake_case_           =				np.linalg.det(a   )
								snake_case_           =				np.linalg.det(a   )
								snake_case_           =				np.linalg.det(a   )

								self.assertAlmostEqual(a			,     det_a * det_s   )




	def 				_UpperCamelCase     (			self   )			->       None:
								snake_case_           =				np.array([[1, 2, 1], [2, 1, 2], [3, 2, 4]]   )
								snake_case_           =				np.array([[0, 3], [3, 0], [2, 3]]   )
								snake_case_           =				np.array([[2, 1], [6, 3]]   )

								with self.assertRaises(a   ):
															schur_complement(a			,     a			,     a   )






	def 				_UpperCamelCase     (			self   )			->       None:
								snake_case_           =				np.array([[1, 2, 1], [2, 1, 2], [3, 2, 4]]   )
								snake_case_           =				np.array([[0, 3], [3, 0], [2, 3]]   )
								snake_case_           =				np.array([[2, 1, 3], [6, 3, 5]]   )

								with self.assertRaises(a   ):
															schur_complement(a			,     a			,     a   )


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	unittest.main()





