



"""simple docstring"""
import unittest

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




class 			snake_case_						(						unittest.TestCase				):






							def snake_case_  (   self      ):
									a_     :      Union[str, Any] 						=     Vector([1, 2, 3]      )
									self.assertEqual(x.component(0      )			,     1      )
									self.assertEqual(x.component(2      )			,     3      )
									a_     :      Tuple 						=     Vector()






							def snake_case_  (   self      ):
									a_     :      int 						=     Vector([0, 0, 0, 0, 0, 1]      )
									self.assertEqual(str(a_      )			,     "(0,0,0,0,0,1)"      )






							def snake_case_  (   self      ):
									a_     :      int 						=     Vector([1, 2, 3, 4]      )
									self.assertEqual(len(a_      )			,     4      )






							def snake_case_  (   self      ):
									a_     :      Optional[Any] 						=     Vector([1, 2]      )
									a_     :      int 						=     Vector([1, 2, 3, 4, 5]      )
									a_     :      List[str] 						=     Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]      )
									a_     :      Tuple 						=     Vector([1, -1, 1, -1, 2, -3, 4, -5]      )
									self.assertAlmostEqual(x.euclidean_length()			,     2.236			,     3      )
									self.assertAlmostEqual(y.euclidean_length()			,     7.416			,     3      )
									self.assertEqual(z.euclidean_length()			,     0      )
									self.assertAlmostEqual(w.euclidean_length()			,     7.616			,     3      )






							def snake_case_  (   self      ):
									a_     :      Any 						=     Vector([1, 2, 3]      )
									a_     :      Any 						=     Vector([1, 1, 1]      )
									self.assertEqual((x + y).component(0      )			,     2      )
									self.assertEqual((x + y).component(1      )			,     3      )
									self.assertEqual((x + y).component(2      )			,     4      )






							def snake_case_  (   self      ):
									a_     :      Optional[Any] 						=     Vector([1, 2, 3]      )
									a_     :      str 						=     Vector([1, 1, 1]      )
									self.assertEqual((x - y).component(0      )			,     0      )
									self.assertEqual((x - y).component(1      )			,     1      )
									self.assertEqual((x - y).component(2      )			,     2      )






							def snake_case_  (   self      ):
									a_     :      List[Any] 						=     Vector([1, 2, 3]      )
									a_     :      int 						=     Vector([2, -1, 4]      )  # for test of dot product
									a_     :      str 						=     Vector([1, -2, -1]      )
									self.assertEqual(str(x * 3.0      )			,     "(3.0,6.0,9.0)"      )
									self.assertEqual((a * b)			,     0      )






							def snake_case_  (   self      ):
									self.assertEqual(str(zero_vector(1_0      )      ).count("0"      )			,     1_0      )






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






							def snake_case_  (   self      ):
									a_     :      Any 						=     Vector([1, 2, 3]      )
									a_     :      Union[str, Any] 						=     Vector([1, 0, 1]      )
									self.assertEqual(str(axpy(2			,     a_			,     a_      )      )			,     "(3,4,7)"      )






							def snake_case_  (   self      ):
									a_     :      str 						=     Vector([1, 0, 0, 0, 0, 0]      )
									a_     :      Union[str, Any] 						=     x.copy()
									self.assertEqual(str(a_      )			,     str(a_      )      )






							def snake_case_  (   self      ):
									a_     :      Optional[int] 						=     Vector([1, 0, 0]      )
									x.change_component(0			,     0      )
									x.change_component(1			,     1      )
									self.assertEqual(str(a_      )			,     "(0,1,0)"      )






							def snake_case_  (   self      ):
									a_     :      Union[str, Any] 						=     Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,     3			,     3      )
									self.assertEqual("|1,2,3|\n|2,4,5|\n|6,7,8|\n"			,     str(a_      )      )






							def snake_case_  (   self      ):
									a_     :      Any 						=     Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,     3			,     3      )
									a_     :      Any 						=     [[-3, -1_4, -1_0], [-5, -1_0, -5], [-2, -1, 0]]
									for x in range(a.height()      ):
											for y in range(a.width()      ):
													self.assertEqual(minors[x][y]			,     a.minor(a_			,     a_      )      )






							def snake_case_  (   self      ):
									a_     :      Optional[int] 						=     Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,     3			,     3      )
									a_     :      str 						=     [[-3, 1_4, -1_0], [5, -1_0, 5], [-2, 1, 0]]
									for x in range(a.height()      ):
											for y in range(a.width()      ):
													self.assertEqual(cofactors[x][y]			,     a.cofactor(a_			,     a_      )      )






							def snake_case_  (   self      ):
									a_     :      Union[str, Any] 						=     Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,     3			,     3      )
									self.assertEqual(-5			,     a.determinant()      )






							def snake_case_  (   self      ):
									a_     :      List[str] 						=     Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]			,     3			,     3      )
									a_     :      Optional[int] 						=     Vector([1, 2, 3]      )
									self.assertEqual("(14,32,50)"			,     str(a * x      )      )
									self.assertEqual("|2,4,6|\n|8,10,12|\n|14,16,18|\n"			,     str(a * 2      )      )






							def snake_case_  (   self      ):
									a_     :      str 						=     Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,     3			,     3      )
									a.change_component(0			,     2			,     5      )
									self.assertEqual("|1,2,5|\n|2,4,5|\n|6,7,8|\n"			,     str(a_      )      )






							def snake_case_  (   self      ):
									a_     :      Any 						=     Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,     3			,     3      )
									self.assertEqual(7			,     a.component(2			,     1      )			,     0.01      )






							def snake_case_  (   self      ):
									a_     :      List[str] 						=     Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,     3			,     3      )
									a_     :      Union[str, Any] 						=     Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 1_0]]			,     3			,     3      )
									self.assertEqual("|2,4,10|\n|4,8,10|\n|12,14,18|\n"			,     str(a + b      )      )






							def snake_case_  (   self      ):
									a_     :      str 						=     Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,     3			,     3      )
									a_     :      Tuple 						=     Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 1_0]]			,     3			,     3      )
									self.assertEqual("|0,0,-4|\n|0,0,0|\n|0,0,-2|\n"			,     str(a - b      )      )






							def snake_case_  (   self      ):
									self.assertEqual(
									    "|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n"			,     str(square_zero_matrix(5      )      )			,     )


if __name__ == "__main__":
					unittest.main()




"""simple docstring"""
def        lowerCAmelCase_						(							SCREAMING_SNAKE_CASE__, SCREAMING_SNAKE_CASE__ = False	)			->      bool:
		if n == 2:
				return True
		if not n % 2 or n < 2:
				return False
		if n > 5 and n % 10 not in (1, 3, 7, 9):  # can quickly check last digit
				return False
		if n > 3_317_044_064_679_887_385_961_981 and not allow_probable:
				raise ValueError(
				    "Warning: upper bound of deterministic test is exceeded. "
				    "Pass allow_probable=True to allow probabilistic test. "
				    "A return value of True indicates a probable prime."	)
		# array bounds provided by analysis
		a_     :      Optional[Any] 						=     [
		    2_047,
		    1_373_653,
		    25_326_001,
		    3_215_031_751,
		    2_152_302_898_747,
		    3_474_749_660_383,
		    341_550_071_728_321,
		    1,
		    3_825_123_056_546_413_051,
		    1,
		    1,
		    318_665_857_834_031_151_167_461,
		    3_317_044_064_679_887_385_961_981,
		]

		a_     :      Optional[int] 						=     [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41]
		for idx, _p in enumerate(SCREAMING_SNAKE_CASE__, 1	):
				if n < _p:
						# then we have our last prime to check
						a_     :      List[Any] 						=     primes[:idx]
						break
		a_						,				a_     :      Tuple 						=     n - 1, 0
		# break up n -1 into a power of 2 (s) and
		# remaining odd component
		# essentially, solve for d * 2 ** s == n - 1
		while d % 2 == 0:
				d //= 2
				s += 1
		for prime in plist:
				a_     :      str 						=     False
				for r in range(SCREAMING_SNAKE_CASE__	):
						a_     :      List[str] 						=     pow(SCREAMING_SNAKE_CASE__, d * 2**r, SCREAMING_SNAKE_CASE__	)
						# see article for analysis explanation for m
						if (r == 0 and m == 1) or ((m + 1) % n == 0):
								a_     :      List[Any] 						=     True
								# this loop will not determine compositeness
								break
				if pr:
						continue
				# if pr is False, then the above loop never evaluated to true,
				# and the n MUST be composite
				return False
		return True



def        lowerCAmelCase_						(							)			->      None:
		assert not miller_rabin(561	)
		assert miller_rabin(563	)
		# 2047

		assert not miller_rabin(838_201	)
		assert miller_rabin(838_207	)
		# 1_373_653

		assert not miller_rabin(17_316_001	)
		assert miller_rabin(17_316_017	)
		# 25_326_001

		assert not miller_rabin(3_078_386_641	)
		assert miller_rabin(3_078_386_653	)
		# 3_215_031_751

		assert not miller_rabin(1_713_045_574_801	)
		assert miller_rabin(1_713_045_574_819	)
		# 2_152_302_898_747

		assert not miller_rabin(2_779_799_728_307	)
		assert miller_rabin(2_779_799_728_327	)
		# 3_474_749_660_383

		assert not miller_rabin(113_850_023_909_441	)
		assert miller_rabin(113_850_023_909_527	)
		# 341_550_071_728_321

		assert not miller_rabin(1_275_041_018_848_804_351	)
		assert miller_rabin(1_275_041_018_848_804_391	)
		# 3_825_123_056_546_413_051

		assert not miller_rabin(79_666_464_458_507_787_791_867	)
		assert miller_rabin(79_666_464_458_507_787_791_951	)
		# 318_665_857_834_031_151_167_461

		assert not miller_rabin(552_840_677_446_647_897_660_333	)
		assert miller_rabin(552_840_677_446_647_897_660_359	)
		# 3_317_044_064_679_887_385_961_981
		# upper limit for probabilistic test


if __name__ == "__main__":
					test_miller_rabin()