


import gc
import unittest

from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline
from transformers.pipelines import PipelineException
from transformers.testing_utils import (
    is_pipeline_test,
    is_torch_available,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_gpu,
    slow,
)

from .test_pipelines_common import ANY
@is_pipeline_test
class 	lowerCamelCase_       (				unittest.TestCase				):



					'''simple docstring'''







					__UpperCAmelCase            =				MODEL_FOR_MASKED_LM_MAPPING
					__UpperCAmelCase            =				TF_MODEL_FOR_MASKED_LM_MAPPING






					def A      (				self						)   ->			Optional[Any]:







								'''simple docstring'''

								super().tearDown()
								# clean-up as much as possible GPU memory occupied by PyTorch
								gc.collect()
								if is_torch_available():
											import torch

											torch.cuda.empty_cache()






					@require_tf
					def A      (				self						)   ->			str:







								'''simple docstring'''

								__lowercase 					=   pipeline(task='''fill-mask''' ,       model='''sshleifer/tiny-distilroberta-base''' ,       top_k=2 ,       framework='''tf'''						)
								__lowercase 					=   unmasker('''My name is <mask>'''						)
								self.assertEqual(
								    nested_simplify(snake_case_ ,       decimals=6						) ,       [
								        {'''sequence''': '''My name is grouped''', '''score''': 2.1e-0_5, '''token''': 3_8_0_1_5, '''token_str''': ''' grouped'''},
								        {'''sequence''': '''My name is accuser''', '''score''': 2.1e-0_5, '''token''': 2_5_5_0_6, '''token_str''': ''' accuser'''},
								    ] ,       )

								__lowercase 					=   unmasker('''The largest city in France is <mask>'''						)
								self.assertEqual(
								    nested_simplify(snake_case_ ,       decimals=6						) ,       [
								        {
								            '''sequence''': '''The largest city in France is grouped''',
								            '''score''': 2.1e-0_5,
								            '''token''': 3_8_0_1_5,
								            '''token_str''': ''' grouped''',
								        },
								        {
								            '''sequence''': '''The largest city in France is accuser''',
								            '''score''': 2.1e-0_5,
								            '''token''': 2_5_5_0_6,
								            '''token_str''': ''' accuser''',
								        },
								    ] ,       )

								__lowercase 					=   unmasker('''My name is <mask>''' ,       targets=[''' Patrick''', ''' Clara''', ''' Teven'''] ,       top_k=3						)
								self.assertEqual(
								    nested_simplify(snake_case_ ,       decimals=6						) ,       [
								        {'''sequence''': '''My name is Clara''', '''score''': 2e-0_5, '''token''': 1_3_6_0_6, '''token_str''': ''' Clara'''},
								        {'''sequence''': '''My name is Patrick''', '''score''': 2e-0_5, '''token''': 3_4_9_9, '''token_str''': ''' Patrick'''},
								        {'''sequence''': '''My name is Te''', '''score''': 1.9e-0_5, '''token''': 2_9_4_1, '''token_str''': ''' Te'''},
								    ] ,       )






					@require_torch
					def A      (				self						)   ->			Any:







								'''simple docstring'''

								__lowercase 					=   pipeline(task='''fill-mask''' ,       model='''sshleifer/tiny-distilroberta-base''' ,       top_k=2 ,       framework='''pt'''						)

								__lowercase 					=   unmasker('''My name is <mask>'''						)
								self.assertEqual(
								    nested_simplify(snake_case_ ,       decimals=6						) ,       [
								        {'''sequence''': '''My name is Maul''', '''score''': 2.2e-0_5, '''token''': 3_5_6_7_6, '''token_str''': ''' Maul'''},
								        {'''sequence''': '''My name isELS''', '''score''': 2.2e-0_5, '''token''': 1_6_4_1_6, '''token_str''': '''ELS'''},
								    ] ,       )

								__lowercase 					=   unmasker('''The largest city in France is <mask>'''						)
								self.assertEqual(
								    nested_simplify(snake_case_ ,       decimals=6						) ,       [
								        {
								            '''sequence''': '''The largest city in France is Maul''',
								            '''score''': 2.2e-0_5,
								            '''token''': 3_5_6_7_6,
								            '''token_str''': ''' Maul''',
								        },
								        {'''sequence''': '''The largest city in France isELS''', '''score''': 2.2e-0_5, '''token''': 1_6_4_1_6, '''token_str''': '''ELS'''},
								    ] ,       )

								__lowercase 					=   unmasker('''My name is <mask>''' ,       targets=[''' Patrick''', ''' Clara''', ''' Teven'''] ,       top_k=3						)
								self.assertEqual(
								    nested_simplify(snake_case_ ,       decimals=6						) ,       [
								        {'''sequence''': '''My name is Patrick''', '''score''': 2.1e-0_5, '''token''': 3_4_9_9, '''token_str''': ''' Patrick'''},
								        {'''sequence''': '''My name is Te''', '''score''': 2e-0_5, '''token''': 2_9_4_1, '''token_str''': ''' Te'''},
								        {'''sequence''': '''My name is Clara''', '''score''': 2e-0_5, '''token''': 1_3_6_0_6, '''token_str''': ''' Clara'''},
								    ] ,       )

								__lowercase 					=   unmasker('''My name is <mask> <mask>''' ,       top_k=2						)

								self.assertEqual(
								    nested_simplify(snake_case_ ,       decimals=6						) ,       [
								        [
								            {
								                '''score''': 2.2e-0_5,
								                '''token''': 3_5_6_7_6,
								                '''token_str''': ''' Maul''',
								                '''sequence''': '''<s>My name is Maul<mask></s>''',
								            },
								            {'''score''': 2.2e-0_5, '''token''': 1_6_4_1_6, '''token_str''': '''ELS''', '''sequence''': '''<s>My name isELS<mask></s>'''},
								        ],
								        [
								            {
								                '''score''': 2.2e-0_5,
								                '''token''': 3_5_6_7_6,
								                '''token_str''': ''' Maul''',
								                '''sequence''': '''<s>My name is<mask> Maul</s>''',
								            },
								            {'''score''': 2.2e-0_5, '''token''': 1_6_4_1_6, '''token_str''': '''ELS''', '''sequence''': '''<s>My name is<mask>ELS</s>'''},
								        ],
								    ] ,       )






					@require_torch_gpu
					def A      (				self						)   ->			str:







								'''simple docstring'''

								__lowercase 					=   pipeline('''fill-mask''' ,       model='''hf-internal-testing/tiny-random-distilbert''' ,       device=0 ,       framework='''pt'''						)

								# convert model to fp16
								pipe.model.half()

								__lowercase 					=   pipe('''Paris is the [MASK] of France.'''						)
								# We actually don't care about the result, we just want to make sure
								# it works, meaning the float16 tensor got casted back to float32
								# for postprocessing.
								self.assertIsInstance(snake_case_ ,       snake_case_						)






					@slow
					@require_torch
					def A      (				self						)   ->			Tuple:







								'''simple docstring'''

								__lowercase 					=   pipeline(task='''fill-mask''' ,       model='''distilroberta-base''' ,       top_k=2 ,       framework='''pt'''						)
								self.run_large_test(snake_case_						)






					@slow
					@require_tf
					def A      (				self						)   ->			Dict:







								'''simple docstring'''

								__lowercase 					=   pipeline(task='''fill-mask''' ,       model='''distilroberta-base''' ,       top_k=2 ,       framework='''tf'''						)
								self.run_large_test(snake_case_						)






					def A      (				self ,       snake_case_						)   ->			Any:







								'''simple docstring'''

								__lowercase 					=   unmasker('''My name is <mask>'''						)
								self.assertEqual(
								    nested_simplify(snake_case_						) ,       [
								        {'''sequence''': '''My name is John''', '''score''': 0.0_0_8, '''token''': 6_1_0, '''token_str''': ''' John'''},
								        {'''sequence''': '''My name is Chris''', '''score''': 0.0_0_7, '''token''': 1_5_7_3, '''token_str''': ''' Chris'''},
								    ] ,       )
								__lowercase 					=   unmasker('''The largest city in France is <mask>'''						)
								self.assertEqual(
								    nested_simplify(snake_case_						) ,       [
								        {
								            '''sequence''': '''The largest city in France is Paris''',
								            '''score''': 0.2_5_1,
								            '''token''': 2_2_0_1,
								            '''token_str''': ''' Paris''',
								        },
								        {
								            '''sequence''': '''The largest city in France is Lyon''',
								            '''score''': 0.2_1_4,
								            '''token''': 1_2_7_9_0,
								            '''token_str''': ''' Lyon''',
								        },
								    ] ,       )

								__lowercase 					=   unmasker('''My name is <mask>''' ,       targets=[''' Patrick''', ''' Clara''', ''' Teven'''] ,       top_k=3						)
								self.assertEqual(
								    nested_simplify(snake_case_						) ,       [
								        {'''sequence''': '''My name is Patrick''', '''score''': 0.0_0_5, '''token''': 3_4_9_9, '''token_str''': ''' Patrick'''},
								        {'''sequence''': '''My name is Clara''', '''score''': 0.0_0_0, '''token''': 1_3_6_0_6, '''token_str''': ''' Clara'''},
								        {'''sequence''': '''My name is Te''', '''score''': 0.0_0_0, '''token''': 2_9_4_1, '''token_str''': ''' Te'''},
								    ] ,       )






					@require_torch
					def A      (				self						)   ->			Optional[Any]:







								'''simple docstring'''

								__lowercase 					=   pipeline(task='''fill-mask''' ,       model='''sshleifer/tiny-distilroberta-base''' ,       framework='''pt'''						)
								__lowercase 					=   None
								__lowercase 					=   None
								self.run_pipeline_test(snake_case_ ,       []						)






					@require_tf
					def A      (				self						)   ->			int:







								'''simple docstring'''

								__lowercase 					=   pipeline(task='''fill-mask''' ,       model='''sshleifer/tiny-distilroberta-base''' ,       framework='''tf'''						)
								__lowercase 					=   None
								__lowercase 					=   None
								self.run_pipeline_test(snake_case_ ,       []						)






					def A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_						)   ->			List[Any]:







								'''simple docstring'''

								if tokenizer is None or tokenizer.mask_token_id is None:
											self.skipTest('''The provided tokenizer has no mask token, (probably reformer or wav2vec2)'''						)

								__lowercase 					=   FillMaskPipeline(model=snake_case_ ,       tokenizer=snake_case_						)
								__lowercase 					=   [
								    F'This is another {tokenizer.mask_token} test',
								]
								return fill_masker, examples






					def A      (				self ,       snake_case_ ,       snake_case_						)   ->			Optional[Any]:







								'''simple docstring'''

								__lowercase 					=   fill_masker.tokenizer
								__lowercase 					=   fill_masker.model

								__lowercase 					=   fill_masker(
								    F'This is a {tokenizer.mask_token}' ,       )
								self.assertEqual(
								    snake_case_ ,       [
								        {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								        {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								        {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								        {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								        {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								    ] ,       )

								__lowercase 					=   fill_masker([F'This is a {tokenizer.mask_token}']						)
								self.assertEqual(
								    snake_case_ ,       [
								        {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								        {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								        {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								        {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								        {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								    ] ,       )

								__lowercase 					=   fill_masker([F'This is a {tokenizer.mask_token}', F'Another {tokenizer.mask_token} great test.']						)
								self.assertEqual(
								    snake_case_ ,       [
								        [
								            {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								            {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								            {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								            {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								            {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								        ],
								        [
								            {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								            {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								            {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								            {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								            {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								        ],
								    ] ,       )

								with self.assertRaises(snake_case_						):
											fill_masker([None]						)
								# No mask_token is not supported
								with self.assertRaises(snake_case_						):
											fill_masker('''This is'''						)

								self.run_test_top_k(snake_case_ ,       snake_case_						)
								self.run_test_targets(snake_case_ ,       snake_case_						)
								self.run_test_top_k_targets(snake_case_ ,       snake_case_						)
								self.fill_mask_with_duplicate_targets_and_top_k(snake_case_ ,       snake_case_						)
								self.fill_mask_with_multiple_masks(snake_case_ ,       snake_case_						)






					def A      (				self ,       snake_case_ ,       snake_case_						)   ->			Optional[Any]:







								'''simple docstring'''

								__lowercase 					=   tokenizer.get_vocab()
								__lowercase 					=   sorted(vocab.keys()						)[:2]
								# Pipeline argument
								__lowercase 					=   FillMaskPipeline(model=snake_case_ ,       tokenizer=snake_case_ ,       targets=snake_case_						)
								__lowercase 					=   fill_masker(F'This is a {tokenizer.mask_token}'						)
								self.assertEqual(
								    snake_case_ ,       [
								        {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								        {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								    ] ,       )
								__lowercase 					=   {vocab[el] for el in targets}
								self.assertEqual({el['''token'''] for el in outputs} ,       snake_case_						)
								__lowercase 					=   [tokenizer.decode([x]						) for x in target_ids]
								self.assertEqual({el['''token_str'''] for el in outputs} ,       set(snake_case_						)						)

								# Call argument
								__lowercase 					=   FillMaskPipeline(model=snake_case_ ,       tokenizer=snake_case_						)
								__lowercase 					=   fill_masker(F'This is a {tokenizer.mask_token}' ,       targets=snake_case_						)
								self.assertEqual(
								    snake_case_ ,       [
								        {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								        {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								    ] ,       )
								__lowercase 					=   {vocab[el] for el in targets}
								self.assertEqual({el['''token'''] for el in outputs} ,       snake_case_						)
								__lowercase 					=   [tokenizer.decode([x]						) for x in target_ids]
								self.assertEqual({el['''token_str'''] for el in outputs} ,       set(snake_case_						)						)

								# Score equivalence
								__lowercase 					=   fill_masker(F'This is a {tokenizer.mask_token}' ,       targets=snake_case_						)
								__lowercase 					=   [top_mask['''token_str'''] for top_mask in outputs]
								__lowercase 					=   [top_mask['''score'''] for top_mask in outputs]

								# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
								if set(snake_case_						) == set(snake_case_						):
											__lowercase 					=   fill_masker(F'This is a {tokenizer.mask_token}' ,       targets=snake_case_						)
											__lowercase 					=   [top_mask['''score'''] for top_mask in unmasked_targets]
											self.assertEqual(nested_simplify(snake_case_						) ,       nested_simplify(snake_case_						)						)

								# Raises with invalid
								with self.assertRaises(snake_case_						):
											__lowercase 					=   fill_masker(F'This is a {tokenizer.mask_token}' ,       targets=[]						)
								# For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised
								if "" not in tokenizer.get_vocab():
											with self.assertRaises(snake_case_						):
														__lowercase 					=   fill_masker(F'This is a {tokenizer.mask_token}' ,       targets=['''''']						)
											with self.assertRaises(snake_case_						):
														__lowercase 					=   fill_masker(F'This is a {tokenizer.mask_token}' ,       targets=''''''						)






					def A      (				self ,       snake_case_ ,       snake_case_						)   ->			Dict:







								'''simple docstring'''

								__lowercase 					=   FillMaskPipeline(model=snake_case_ ,       tokenizer=snake_case_ ,       top_k=2						)
								__lowercase 					=   fill_masker(F'This is a {tokenizer.mask_token}'						)
								self.assertEqual(
								    snake_case_ ,       [
								        {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								        {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								    ] ,       )

								__lowercase 					=   FillMaskPipeline(model=snake_case_ ,       tokenizer=snake_case_						)
								__lowercase 					=   fill_masker(F'This is a {tokenizer.mask_token}' ,       top_k=2						)
								self.assertEqual(
								    snake_case_ ,       [
								        {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								        {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								    ] ,       )
								self.assertEqual(nested_simplify(snake_case_						) ,       nested_simplify(snake_case_						)						)






					def A      (				self ,       snake_case_ ,       snake_case_						)   ->			List[str]:







								'''simple docstring'''

								__lowercase 					=   tokenizer.get_vocab()
								__lowercase 					=   FillMaskPipeline(model=snake_case_ ,       tokenizer=snake_case_						)

								# top_k=2, ntargets=3
								__lowercase 					=   sorted(vocab.keys()						)[:3]
								__lowercase 					=   fill_masker(F'This is a {tokenizer.mask_token}' ,       top_k=2 ,       targets=snake_case_						)

								# If we use the most probably targets, and filter differently, we should still
								# have the same results
								__lowercase 					=   [el['''token_str'''] for el in sorted(snake_case_ ,       key=lambda snake_case_						: x["score"] ,       reverse=snake_case_						)]
								# For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
								if set(snake_case_						).issubset(snake_case_						):
											__lowercase 					=   fill_masker(F'This is a {tokenizer.mask_token}' ,       top_k=3 ,       targets=snake_case_						)
											# They should yield exactly the same result
											self.assertEqual(nested_simplify(snake_case_						) ,       nested_simplify(snake_case_						)						)






					def A      (				self ,       snake_case_ ,       snake_case_						)   ->			int:







								'''simple docstring'''

								__lowercase 					=   FillMaskPipeline(model=snake_case_ ,       tokenizer=snake_case_						)
								__lowercase 					=   tokenizer.get_vocab()
								# String duplicates + id duplicates
								__lowercase 					=   sorted(vocab.keys()						)[:3]
								__lowercase 					=   [targets[0], targets[1], targets[0], targets[2], targets[1]]
								__lowercase 					=   fill_masker(F'My name is {tokenizer.mask_token}' ,       targets=snake_case_ ,       top_k=1_0						)

								# The target list contains duplicates, so we can't output more
								# than them
								self.assertEqual(len(snake_case_						) ,       3						)






					def A      (				self ,       snake_case_ ,       snake_case_						)   ->			List[str]:







								'''simple docstring'''

								__lowercase 					=   FillMaskPipeline(model=snake_case_ ,       tokenizer=snake_case_						)

								__lowercase 					=   fill_masker(
								    F'This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}' ,       top_k=2						)
								self.assertEqual(
								    snake_case_ ,       [
								        [
								            {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								            {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								        ],
								        [
								            {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								            {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								        ],
								        [
								            {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								            {'''sequence''': ANY(snake_case_						), '''score''': ANY(snake_case_						), '''token''': ANY(snake_case_						), '''token_str''': ANY(snake_case_						)},
								        ],
								    ] ,       )






def 		lowercase_  (     _UpperCamelCase  ):


			'''simple docstring'''







			__lowercase 					=   len(_UpperCamelCase  )
			__lowercase 					=   len(matrix[0]  )
			__lowercase 					=   min(_UpperCamelCase       ,			_UpperCamelCase  )

			for row in range(_UpperCamelCase  ):
						# Check if diagonal element is not zero
						if matrix[row][row] != 0:
									# Eliminate all the elements below the diagonal
									for col in range(row + 1       ,			_UpperCamelCase  ):
												__lowercase 					=   matrix[col][row] / matrix[row][row]
												for i in range(_UpperCamelCase       ,			_UpperCamelCase  ):
															matrix[col][i] -= multiplier * matrix[row][i]
						else:
									# Find a non-zero diagonal element to swap rows
									__lowercase 					=   True
									for i in range(row + 1       ,			_UpperCamelCase  ):
												if matrix[i][row] != 0:
															__lowercase					, __lowercase 					=   matrix[i], matrix[row]
															__lowercase 					=   False
															break
									if reduce:
												rank -= 1
												for i in range(_UpperCamelCase  ):
															__lowercase 					=   matrix[i][rank]

            # Reduce the row pointer by one to stay on the same row
									row -= 1

			return rank


if __name__ == "__main__":
	import doctest

	doctest.testmod()


