





'''simple docstring'''

import unittest

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





class lowerCamelCase						(unittest.TestCase					):







  def 				UpperCAmelCase_				(		self		)		->						None:






        """simple docstring"""





        _snake_case		:	Dict					     =     Vector([1, 2, 3]		)
        self.assertEqual(x.component(0		)     ,     1		)
        self.assertEqual(x.component(2		)     ,     3		)
        _snake_case		:	Union[str, Any]					     =     Vector()







  def 				UpperCAmelCase_				(		self		)		->						None:






        """simple docstring"""





        _snake_case		:	Optional[int]					     =     Vector([0, 0, 0, 0, 0, 1]		)
        self.assertEqual(str(lowercase__		)     ,     '''(0,0,0,0,0,1)'''		)







  def 				UpperCAmelCase_				(		self		)		->						None:






        """simple docstring"""





        _snake_case		:	List[str]					     =     Vector([1, 2, 3, 4]		)
        self.assertEqual(len(lowercase__		)     ,     4		)







  def 				UpperCAmelCase_				(		self		)		->						None:






        """simple docstring"""





        _snake_case		:	Dict					     =     Vector([1, 2]		)
        _snake_case		:	Union[str, Any]					     =     Vector([1, 2, 3, 4, 5]		)
        _snake_case		:	Dict					     =     Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]		)
        _snake_case		:	Union[str, Any]					     =     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 				UpperCAmelCase_				(		self		)		->						None:






        """simple docstring"""





        _snake_case		:	Dict					     =     Vector([1, 2, 3]		)
        _snake_case		:	int					     =     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 				UpperCAmelCase_				(		self		)		->						None:






        """simple docstring"""





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






        """simple docstring"""





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







  def 				UpperCAmelCase_				(		self		)		->						None:






        """simple docstring"""





        self.assertEqual(str(zero_vector(10		)		).count('''0'''		)     ,     10		)







  def 				UpperCAmelCase_				(		self		)		->						None:






        """simple docstring"""





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







  def 				UpperCAmelCase_				(		self		)		->						None:






        """simple docstring"""





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







  def 				UpperCAmelCase_				(		self		)		->						None:






        """simple docstring"""





        _snake_case		:	Optional[int]					     =     Vector([1, 0, 0, 0, 0, 0]		)
        _snake_case		:	List[Any]					     =     x.copy()
        self.assertEqual(str(lowercase__		)     ,     str(lowercase__		)		)







  def 				UpperCAmelCase_				(		self		)		->						None:






        """simple docstring"""





        _snake_case		:	List[str]					     =     Vector([1, 0, 0]		)
        x.change_component(0     ,     0		)
        x.change_component(1     ,     1		)
        self.assertEqual(str(lowercase__		)     ,     '''(0,1,0)'''		)







  def 				UpperCAmelCase_				(		self		)		->						None:






        """simple docstring"""





        _snake_case		:	int					     =     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(lowercase__		)		)







  def 				UpperCAmelCase_				(		self		)		->						None:






        """simple docstring"""





        _snake_case		:	Optional[Any]					     =     Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     ,     3     ,     3		)
        _snake_case		:	Dict					     =     [[-3, -14, -10], [-5, -10, -5], [-2, -1, 0]]
        for x in range(a.height()		):
              for y in range(a.width()		):
                    self.assertEqual(minors[x][y]     ,     a.minor(lowercase__     ,     lowercase__		)		)







  def 				UpperCAmelCase_				(		self		)		->						None:






        """simple docstring"""





        _snake_case		:	int					     =     Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     ,     3     ,     3		)
        _snake_case		:	List[Any]					     =     [[-3, 14, -10], [5, -10, 5], [-2, 1, 0]]
        for x in range(a.height()		):
              for y in range(a.width()		):
                    self.assertEqual(cofactors[x][y]     ,     a.cofactor(lowercase__     ,     lowercase__		)		)







  def 				UpperCAmelCase_				(		self		)		->						None:






        """simple docstring"""





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







  def 				UpperCAmelCase_				(		self		)		->						None:






        """simple docstring"""





        _snake_case		:	str					     =     Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]     ,     3     ,     3		)
        _snake_case		:	Union[str, Any]					     =     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 				UpperCAmelCase_				(		self		)		->						None:






        """simple docstring"""





        _snake_case		:	List[Any]					     =     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(lowercase__		)		)







  def 				UpperCAmelCase_				(		self		)		->						None:






        """simple docstring"""





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







  def 				UpperCAmelCase_				(		self		)		->						None:






        """simple docstring"""





        _snake_case		:	Optional[Any]					     =     Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     ,     3     ,     3		)
        _snake_case		:	Dict					     =     Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]     ,     3     ,     3		)
        self.assertEqual('''|2,4,10|\n|4,8,10|\n|12,14,18|\n'''     ,     str(a + b		)		)







  def 				UpperCAmelCase_				(		self		)		->						None:






        """simple docstring"""





        _snake_case		:	Tuple					     =     Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     ,     3     ,     3		)
        _snake_case		:	Optional[Any]					     =     Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]     ,     3     ,     3		)
        self.assertEqual('''|0,0,-4|\n|0,0,0|\n|0,0,-2|\n'''     ,     str(a - b		)		)







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









'''simple docstring'''

UpperCAmelCase					:		Union[str, Any]		=							tuple[float, float, float]
UpperCAmelCase					:		int		=							tuple[float, float, float]




def    _a    (							lowerCAmelCase_			,      lowerCAmelCase_	):





      """simple docstring"""



      _snake_case		:	str					     =     end_pointa[0] - end_pointa[0]
      _snake_case		:	Tuple					     =     end_pointa[1] - end_pointa[1]
      _snake_case		:	Any					     =     end_pointa[2] - end_pointa[2]
      return (x, y, z)




def    _a    (							lowerCAmelCase_			,      lowerCAmelCase_	):





      """simple docstring"""



      _snake_case		:	Dict					     =     ab[1] * ac[2] - ab[2] * ac[1]  # *i
      _snake_case		:	List[str]					     =     (ab[0] * ac[2] - ab[2] * ac[0]) * -1  # *j
      _snake_case		:	Optional[int]					     =     ab[0] * ac[1] - ab[1] * ac[0]  # *k
      return (x, y, z)




def    _a    (							lowerCAmelCase_			,      lowerCAmelCase_	):





      """simple docstring"""



      return tuple(round(lowerCAmelCase_			,      lowerCAmelCase_	) for x in vector	) == (0, 0, 0)




def    _a    (							lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_			,      lowerCAmelCase_ = 10	):





      """simple docstring"""



      _snake_case		:	str					     =     create_vector(lowerCAmelCase_			,      lowerCAmelCase_	)
      _snake_case		:	Tuple					     =     create_vector(lowerCAmelCase_			,      lowerCAmelCase_	)
      return is_zero_vector(get_ad_vectors_cross(lowerCAmelCase_			,      lowerCAmelCase_	)			,      lowerCAmelCase_	)


