import unittest

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



class      _A (     unittest.TestCase				):






  def 		_a       (self						)		->   Any:





       '''simple docstring'''





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






  def 		_a       (self						)		->   List[str]:





       '''simple docstring'''





       UpperCamelCase__					    =   Vector([0, 0, 0, 0, 0, 1]						)
       self.assertEqual(str(lowercase_						) ,					'''(0,0,0,0,0,1)'''						)






  def 		_a       (self						)		->   Optional[Any]:





       '''simple docstring'''





       UpperCamelCase__					    =   Vector([1, 2, 3, 4]						)
       self.assertEqual(len(lowercase_						) ,					4						)






  def 		_a       (self						)		->   Tuple:





       '''simple docstring'''





       UpperCamelCase__					    =   Vector([1, 2]						)
       UpperCamelCase__					    =   Vector([1, 2, 3, 4, 5]						)
       UpperCamelCase__					    =   Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]						)
       UpperCamelCase__					    =   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 		_a       (self						)		->   Optional[int]:





       '''simple docstring'''





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





       '''simple docstring'''





       UpperCamelCase__					    =   Vector([1, 2, 3]						)
       UpperCamelCase__					    =   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						)		->   Tuple:





       '''simple docstring'''





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






  def 		_a       (self						)		->   Any:





       '''simple docstring'''





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






  def 		_a       (self						)		->   List[Any]:





       '''simple docstring'''





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






  def 		_a       (self						)		->   Optional[int]:





       '''simple docstring'''





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






  def 		_a       (self						)		->   Any:





       '''simple docstring'''





       UpperCamelCase__					    =   Vector([1, 0, 0, 0, 0, 0]						)
       UpperCamelCase__					    =   x.copy()
       self.assertEqual(str(lowercase_						) ,					str(lowercase_						)						)






  def 		_a       (self						)		->   Tuple:





       '''simple docstring'''





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






  def 		_a       (self						)		->   Optional[int]:





       '''simple docstring'''





       UpperCamelCase__					    =   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 		_a       (self						)		->   Tuple:





       '''simple docstring'''





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





       '''simple docstring'''





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





       '''simple docstring'''





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






  def 		_a       (self						)		->   Tuple:





       '''simple docstring'''





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





       '''simple docstring'''





       UpperCamelCase__					    =   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 		_a       (self						)		->   Tuple:





       '''simple docstring'''





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






  def 		_a       (self						)		->   str:





       '''simple docstring'''





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





       '''simple docstring'''





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





       '''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'''

def 						__magic_name__       (      __UpperCAmelCase, __UpperCAmelCase, __UpperCAmelCase, __UpperCAmelCase      )						->   Optional[Any]:

					'''simple docstring'''

					snake_case_		     =							[False] * len(__UpperCAmelCase      )
					snake_case_		     =							[]
					queue.append(__UpperCAmelCase      )
					snake_case_		     =							True

					while queue:
										snake_case_		     =							queue.pop(0      )
										for ind in range(len(graph[u]      )      ):
															if visited[ind] is False and graph[u][ind] > 0:
																				queue.append(__UpperCAmelCase      )
																				snake_case_		     =							True
																				snake_case_		     =							u

					return visited[t]


def 						__magic_name__       (      __UpperCAmelCase, __UpperCAmelCase, __UpperCAmelCase      )						->   Tuple:

					'''simple docstring'''

					snake_case_		     =							[-1] * (len(__UpperCAmelCase      ))
					snake_case_		     =							0
					while bfs(__UpperCAmelCase, __UpperCAmelCase, __UpperCAmelCase, __UpperCAmelCase      ):
										snake_case_		     =							float('''Inf'''      )
										snake_case_		     =							sink

										while s != source:
															# Find the minimum value in select path
															snake_case_		     =							min(__UpperCAmelCase, graph[parent[s]][s]      )
															snake_case_		     =							parent[s]

										max_flow += path_flow
										snake_case_		     =							sink

										while v != source:
															snake_case_		     =							parent[v]
															graph[u][v] -= path_flow
															graph[v][u] += path_flow
															snake_case_		     =							parent[v]
					return max_flow


a    :							List[Any]										=    [
    [0, 16, 13, 0, 0, 0],
    [0, 0, 10, 12, 0, 0],
    [0, 4, 0, 0, 14, 0],
    [0, 0, 9, 0, 0, 20],
    [0, 0, 0, 7, 0, 4],
    [0, 0, 0, 0, 0, 0],
]

a						,a    :							int										=    0, 5

print(ford_fulkerson(graph, source, sink))

