


import unittest

from .lib import (
    Matrix,
    Vector,
    axpy,
    square_zero_matrix,
    unit_basis_vector,
    zero_vector,
)
class 						lowerCamelCase_							(					unittest.TestCase					):



					'''simple docstring'''







					def A   (					self    ) ->      None:







								'''simple docstring'''

								__lowercase			       = Vector([1, 2, 3]    )
								self.assertEqual(x.component(0    )			,							1    )
								self.assertEqual(x.component(2    )			,							3    )
								__lowercase			       = Vector()






					def A   (					self    ) ->      None:







								'''simple docstring'''

								__lowercase			       = Vector([0, 0, 0, 0, 0, 1]    )
								self.assertEqual(str(snake_case_    )			,							'''(0,0,0,0,0,1)'''    )






					def A   (					self    ) ->      None:







								'''simple docstring'''

								__lowercase			       = Vector([1, 2, 3, 4]    )
								self.assertEqual(len(snake_case_    )			,							4    )






					def A   (					self    ) ->      None:







								'''simple docstring'''

								__lowercase			       = Vector([1, 2]    )
								__lowercase			       = Vector([1, 2, 3, 4, 5]    )
								__lowercase			       = Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]    )
								__lowercase			       = Vector([1, -1, 1, -1, 2, -3, 4, -5]    )
								self.assertAlmostEqual(x.euclidean_length()			,							2.2_3_6			,							3    )
								self.assertAlmostEqual(y.euclidean_length()			,							7.4_1_6			,							3    )
								self.assertEqual(z.euclidean_length()			,							0    )
								self.assertAlmostEqual(w.euclidean_length()			,							7.6_1_6			,							3    )






					def A   (					self    ) ->      None:







								'''simple docstring'''

								__lowercase			       = Vector([1, 2, 3]    )
								__lowercase			       = 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 A   (					self    ) ->      None:







								'''simple docstring'''

								__lowercase			       = Vector([1, 2, 3]    )
								__lowercase			       = 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 A   (					self    ) ->      None:







								'''simple docstring'''

								__lowercase			       = Vector([1, 2, 3]    )
								__lowercase			       = Vector([2, -1, 4]    )  # for test of dot product
								__lowercase			       = Vector([1, -2, -1]    )
								self.assertEqual(str(x * 3.0    )			,							'''(3.0,6.0,9.0)'''    )
								self.assertEqual((a * b)			,							0    )






					def A   (					self    ) ->      None:







								'''simple docstring'''

								self.assertEqual(str(zero_vector(1_0    )    ).count('''0'''    )			,							1_0    )






					def A   (					self    ) ->      None:







								'''simple docstring'''

								self.assertEqual(str(unit_basis_vector(3			,							1    )    )			,							'''(0,1,0)'''    )






					def A   (					self    ) ->      None:







								'''simple docstring'''

								__lowercase			       = Vector([1, 2, 3]    )
								__lowercase			       = Vector([1, 0, 1]    )
								self.assertEqual(str(axpy(2			,							snake_case_			,							snake_case_    )    )			,							'''(3,4,7)'''    )






					def A   (					self    ) ->      None:







								'''simple docstring'''

								__lowercase			       = Vector([1, 0, 0, 0, 0, 0]    )
								__lowercase			       = x.copy()
								self.assertEqual(str(snake_case_    )			,							str(snake_case_    )    )






					def A   (					self    ) ->      None:







								'''simple docstring'''

								__lowercase			       = Vector([1, 0, 0]    )
								x.change_component(0			,							0    )
								x.change_component(1			,							1    )
								self.assertEqual(str(snake_case_    )			,							'''(0,1,0)'''    )






					def A   (					self    ) ->      None:







								'''simple docstring'''

								__lowercase			       = 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(snake_case_    )    )






					def A   (					self    ) ->      None:







								'''simple docstring'''

								__lowercase			       = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,							3			,							3    )
								__lowercase			       = [[-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(snake_case_			,							snake_case_    )    )






					def A   (					self    ) ->      None:







								'''simple docstring'''

								__lowercase			       = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,							3			,							3    )
								__lowercase			       = [[-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(snake_case_			,							snake_case_    )    )






					def A   (					self    ) ->      None:







								'''simple docstring'''

								__lowercase			       = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,							3			,							3    )
								self.assertEqual(-5			,							a.determinant()    )






					def A   (					self    ) ->      None:







								'''simple docstring'''

								__lowercase			       = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]			,							3			,							3    )
								__lowercase			       = 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 A   (					self    ) ->      None:







								'''simple docstring'''

								__lowercase			       = 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(snake_case_    )    )






					def A   (					self    ) ->      None:







								'''simple docstring'''

								__lowercase			       = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,							3			,							3    )
								self.assertEqual(7			,							a.component(2			,							1    )			,							0.0_1    )






					def A   (					self    ) ->      None:







								'''simple docstring'''

								__lowercase			       = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,							3			,							3    )
								__lowercase			       = 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 A   (					self    ) ->      None:







								'''simple docstring'''

								__lowercase			       = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,							3			,							3    )
								__lowercase			       = 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 A   (					self    ) ->      None:







								'''simple docstring'''

								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()






from maths.prime_factors import prime_factors


def 		lowercase_	(  _UpperCamelCase	):


			'''simple docstring'''







			if not isinstance(_UpperCamelCase							,      _UpperCamelCase	):
						__lowercase			       = F'Input value of [number={number}] must be an integer'
						raise TypeError(_UpperCamelCase	)
			if number < 1:
						raise ValueError('''Input must be a positive integer'''	)
			return -1 if len(prime_factors(_UpperCamelCase	)	) % 2 else 1


if __name__ == "__main__":
	import doctest

	doctest.testmod()


