





import unittest

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


class     A     (unittest.TestCase       ):
			'''simple docstring'''




			def   a_			(     self  :       Tuple  )      ->      None:







					"""simple docstring"""






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






			def   a_			(     self  :       int  )      ->      None:







					"""simple docstring"""






					A__     =  Vector([0, 0, 0, 0, 0, 1]  )
					self.assertEqual(str(__lowerCAmelCase  )				,      """(0,0,0,0,0,1)"""  )






			def   a_			(     self  :       List[str]  )      ->      None:







					"""simple docstring"""






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






			def   a_			(     self  :       Dict  )      ->      None:







					"""simple docstring"""






					A__     =  Vector([1, 2]  )
					A__     =  Vector([1, 2, 3, 4, 5]  )
					A__     =  Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]  )
					A__     =  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  :       int  )      ->      None:







					"""simple docstring"""






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







					"""simple docstring"""






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







					"""simple docstring"""






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






			def   a_			(     self  :       str  )      ->      None:







					"""simple docstring"""






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






			def   a_			(     self  :       Tuple  )      ->      None:







					"""simple docstring"""






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






			def   a_			(     self  :       List[Any]  )      ->      None:







					"""simple docstring"""






					A__     =  Vector([1, 2, 3]  )
					A__     =  Vector([1, 0, 1]  )
					self.assertEqual(str(axpy(2				,      __lowerCAmelCase				,      __lowerCAmelCase  )  )				,      """(3,4,7)"""  )






			def   a_			(     self  :       List[Any]  )      ->      None:







					"""simple docstring"""






					A__     =  Vector([1, 0, 0, 0, 0, 0]  )
					A__     =  x.copy()
					self.assertEqual(str(__lowerCAmelCase  )				,      str(__lowerCAmelCase  )  )






			def   a_			(     self  :       Optional[Any]  )      ->      None:







					"""simple docstring"""






					A__     =  Vector([1, 0, 0]  )
					x.change_component(0				,      0  )
					x.change_component(1				,      1  )
					self.assertEqual(str(__lowerCAmelCase  )				,      """(0,1,0)"""  )






			def   a_			(     self  :       Any  )      ->      None:







					"""simple docstring"""






					A__     =  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   a_			(     self  :       int  )      ->      None:







					"""simple docstring"""






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






			def   a_			(     self  :       Dict  )      ->      None:







					"""simple docstring"""






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






			def   a_			(     self  :       List[Any]  )      ->      None:







					"""simple docstring"""






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






			def   a_			(     self  :       str  )      ->      None:







					"""simple docstring"""






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







					"""simple docstring"""






					A__     =  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   a_			(     self  :       Optional[Any]  )      ->      None:







					"""simple docstring"""






					A__     =  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  :       Union[str, Any]  )      ->      None:







					"""simple docstring"""






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







					"""simple docstring"""






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










class     A     :
			'''simple docstring'''




			def __init__(     self  :       Optional[int]  )      ->      Dict:







					"""simple docstring"""






					A__     =  {}






			def   a_			(     self  :       Any  )      ->      None:







					"""simple docstring"""






					print(self.vertex  )
					for i in self.vertex:
							print(__lowerCAmelCase				,      """ -> """				,      """ -> """.join([str(__lowerCAmelCase  ) for j in self.vertex[i]]  )  )






			def   a_			(     self  :       Optional[int]				,      __lowerCAmelCase  :       int				,      __lowerCAmelCase  :       int  )      ->      None:







					"""simple docstring"""






					if from_vertex in self.vertex:
							self.vertex[from_vertex].append(__lowerCAmelCase  )
					else:
							# else make a new vertex
							A__     =  [to_vertex]






			def   a_			(     self  :       List[str]  )      ->      None:







					"""simple docstring"""






					A__     =  [False] * len(self.vertex  )

					# call the recursive helper function
					for i in range(len(self.vertex  )  ):
							if not visited[i]:
									self.dfs_recursive(__lowerCAmelCase				,      __lowerCAmelCase  )







			def   a_			(     self  :       List[str]				,      __lowerCAmelCase  :       int				,      __lowerCAmelCase  :       list  )      ->      None:







					"""simple docstring"""






					A__     =  True

					print(__lowerCAmelCase				,      end=""" """  )

					# Recur for all the vertices that are adjacent to this node
					for i in self.vertex:
							if not visited[i]:
									self.dfs_recursive(__lowerCAmelCase				,      __lowerCAmelCase  )


if __name__ == "__main__":
					A       :   Tuple					= Graph()
					g.add_edge(0, 1)
					g.add_edge(0, 2)
					g.add_edge(1, 2)
					g.add_edge(2, 0)
					g.add_edge(2, 3)
					g.add_edge(3, 3)

					g.print_graph()
					print('''DFS:''')
					g.dfs()

					# OUTPUT:
					# 0  ->  1 -> 2
					# 1  ->  2
					# 2  ->  0 -> 3
					# 3  ->  3
					# DFS:
					#  0 1 2 3



