



"""simple docstring"""






import unittest

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






class 	__snake_case	(     unittest.TestCase):




  def 						SCREAMING_SNAKE_CASE    (			self					:						int		):






         """simple docstring"""






         _lowerCamelCase						:    List[Any]         =			Vector([1, 2, 3]		)
         self.assertEqual(x.component(0		)						, 1		)
         self.assertEqual(x.component(2		)						, 3		)
         _lowerCamelCase						:    Optional[int]         =			Vector()




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[str]		):






         """simple docstring"""






         _lowerCamelCase						:    Tuple         =			Vector([0, 0, 0, 0, 0, 1]		)
         self.assertEqual(str(__lowerCAmelCase		)						, '''(0,0,0,0,0,1)'''		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						int		):






         """simple docstring"""






         _lowerCamelCase						:    str         =			Vector([1, 2, 3, 4]		)
         self.assertEqual(len(__lowerCAmelCase		)						, 4		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						Tuple		):






         """simple docstring"""






         _lowerCamelCase						:    List[Any]         =			Vector([1, 2]		)
         _lowerCamelCase						:    str         =			Vector([1, 2, 3, 4, 5]		)
         _lowerCamelCase						:    int         =			Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]		)
         _lowerCamelCase						:    Optional[int]         =			Vector([1, -1, 1, -1, 2, -3, 4, -5]		)
         self.assertAlmostEqual(x.euclidean_length()						, 2.2_36						, 3		)
         self.assertAlmostEqual(y.euclidean_length()						, 7.4_16						, 3		)
         self.assertEqual(z.euclidean_length()						, 0		)
         self.assertAlmostEqual(w.euclidean_length()						, 7.6_16						, 3		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[Any]		):






         """simple docstring"""






         _lowerCamelCase						:    str         =			Vector([1, 2, 3]		)
         _lowerCamelCase						:    List[str]         =			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 						SCREAMING_SNAKE_CASE    (			self					:						int		):






         """simple docstring"""






         _lowerCamelCase						:    int         =			Vector([1, 2, 3]		)
         _lowerCamelCase						:    Tuple         =			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 						SCREAMING_SNAKE_CASE    (			self					:						Dict		):






         """simple docstring"""






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




  def 						SCREAMING_SNAKE_CASE    (			self					:						Any		):






         """simple docstring"""






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




  def 						SCREAMING_SNAKE_CASE    (			self					:						Optional[Any]		):






         """simple docstring"""






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




  def 						SCREAMING_SNAKE_CASE    (			self					:						Any		):






         """simple docstring"""






         _lowerCamelCase						:    List[Any]         =			Vector([1, 2, 3]		)
         _lowerCamelCase						:    Union[str, Any]         =			Vector([1, 0, 1]		)
         self.assertEqual(str(axpy(2						, __lowerCAmelCase						, __lowerCAmelCase		)		)						, '''(3,4,7)'''		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						int		):






         """simple docstring"""






         _lowerCamelCase						:    int         =			Vector([1, 0, 0, 0, 0, 0]		)
         _lowerCamelCase						:    Optional[int]         =			x.copy()
         self.assertEqual(str(__lowerCAmelCase		)						, str(__lowerCAmelCase		)		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[Any]		):






         """simple docstring"""






         _lowerCamelCase						:    str         =			Vector([1, 0, 0]		)
         x.change_component(0						, 0		)
         x.change_component(1						, 1		)
         self.assertEqual(str(__lowerCAmelCase		)						, '''(0,1,0)'''		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[str]		):






         """simple docstring"""






         _lowerCamelCase						:    str         =			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(__lowerCAmelCase		)		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						Optional[Any]		):






         """simple docstring"""






         _lowerCamelCase						:    Dict         =			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						, 3						, 3		)
         _lowerCamelCase						:    List[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(__lowerCAmelCase						, __lowerCAmelCase		)		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						Optional[int]		):






         """simple docstring"""






         _lowerCamelCase						:    Any         =			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						, 3						, 3		)
         _lowerCamelCase						:    Tuple         =			[[-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(__lowerCAmelCase						, __lowerCAmelCase		)		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						Optional[int]		):






         """simple docstring"""






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




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[Any]		):






         """simple docstring"""






         _lowerCamelCase						:    str         =			Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]						, 3						, 3		)
         _lowerCamelCase						:    List[str]         =			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 						SCREAMING_SNAKE_CASE    (			self					:						Tuple		):






         """simple docstring"""






         _lowerCamelCase						:    Dict         =			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(__lowerCAmelCase		)		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						Optional[int]		):






         """simple docstring"""






         _lowerCamelCase						:    Union[str, Any]         =			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						, 3						, 3		)
         self.assertEqual(7						, a.component(2						, 1		)						, 0.01		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						Tuple		):






         """simple docstring"""






         _lowerCamelCase						:    List[str]         =			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						, 3						, 3		)
         _lowerCamelCase						:    List[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 						SCREAMING_SNAKE_CASE    (			self					:						Optional[Any]		):






         """simple docstring"""






         _lowerCamelCase						:    Union[str, Any]         =			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						, 3						, 3		)
         _lowerCamelCase						:    Optional[int]         =			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 						SCREAMING_SNAKE_CASE    (			self					:						Optional[Any]		):






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







"""simple docstring"""






from maths.prime_factors import prime_factors






def 	snake_case_  (				A_ :		int						):


       '''simple docstring'''





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


if __name__ == "__main__":
   import doctest

   doctest.testmod()


