"""simple docstring"""






import unittest

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


class     UpperCAmelCase						(unittest.TestCase  ):



    """simple docstring"""

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






    def _snake_case			(   self							):
       lowercase__:   Tuple					=      Vector([0, 0, 0, 0, 0, 1]							)
       self.assertEqual(str(UpperCAmelCase__							)    ,			'''(0,0,0,0,0,1)'''							)






    def _snake_case			(   self							):
       lowercase__:   Dict					=      Vector([1, 2, 3, 4]							)
       self.assertEqual(len(UpperCAmelCase__							)    ,			4							)






    def _snake_case			(   self							):
       lowercase__:   Any					=      Vector([1, 2]							)
       lowercase__:   List[str]					=      Vector([1, 2, 3, 4, 5]							)
       lowercase__:   Any					=      Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]							)
       lowercase__:   str					=      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 _snake_case			(   self							):
       lowercase__:   str					=      Vector([1, 2, 3]							)
       lowercase__:   Tuple					=      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 _snake_case			(   self							):
       lowercase__:   Union[str, Any]					=      Vector([1, 2, 3]							)
       lowercase__:   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 _snake_case			(   self							):
       lowercase__:   Any					=      Vector([1, 2, 3]							)
       lowercase__:   str					=      Vector([2, -1, 4]							)  # for test of dot product
       lowercase__:   List[str]					=      Vector([1, -2, -1]							)
       self.assertEqual(str(x * 3.0							)    ,			'''(3.0,6.0,9.0)'''							)
       self.assertEqual((a * b)    ,			0							)






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






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






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






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






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






    def _snake_case			(   self							):
       lowercase__:   Optional[Any]					=      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(UpperCAmelCase__							)							)






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






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






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






    def _snake_case			(   self							):
       lowercase__:   Union[str, Any]					=      Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]    ,			3    ,			3							)
       lowercase__:   List[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 _snake_case			(   self							):
       lowercase__:   Optional[int]					=      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(UpperCAmelCase__							)							)






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






    def _snake_case			(   self							):
       lowercase__:   Optional[Any]					=      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]    ,			3    ,			3							)
       lowercase__:   Union[str, Any]					=      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 _snake_case			(   self							):
       lowercase__:   Tuple					=      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]    ,			3    ,			3							)
       lowercase__:   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 _snake_case			(   self							):
       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 	a_					( lowerCamelCase	:     Optional[Any]				):
   return [
       {
           0: [1, 2],
           1: [0, 2],
           2: [0, 1, 3, 5],
           3: [2, 4],
           4: [3],
           5: [2, 6, 8],
           6: [5, 7],
           7: [6, 8],
           8: [5, 7],
       },
       {
           0: [6],
           1: [9],
           2: [4, 5],
           3: [4],
           4: [2, 3],
           5: [2],
           6: [0, 7],
           7: [6],
           8: [],
           9: [1],
       },
       {
           0: [4],
           1: [6],
           2: [],
           3: [5, 6, 7],
           4: [0, 6],
           5: [3, 8, 9],
           6: [1, 3, 4, 7],
           7: [3, 6, 8, 9],
           8: [5, 7],
           9: [5, 7],
       },
       {
           0: [1, 3],
           1: [0, 2, 4],
           2: [1, 3, 4],
           3: [0, 2, 4],
           4: [1, 2, 3],
       },
   ][index]





def 	a_					( lowerCamelCase	:     dict[int, list[int]]				):
   lowerCAmelCase     =			0
   lowerCAmelCase     =			len(lowerCamelCase				)  # No of vertices in graph
   lowerCAmelCase     =			[0] * n
   lowerCAmelCase     =			[False] * n

   def dfs(lowerCamelCase	:     Tuple	, lowerCamelCase	:     str	, lowerCamelCase	:     Dict	, lowerCamelCase	:     str				):
      lowerCAmelCase     =			True
      lowerCAmelCase     =			id_
      id_ += 1
      for to in graph[at]:
         if to == parent:
            pass
         elif not visited[to]:
            dfs(lowerCamelCase	, lowerCamelCase	, lowerCamelCase	, id_				)
            lowerCAmelCase     =			min(low[at]	, low[to]				)
            if id_ <= low[to]:
               bridges.append((at, to) if at < to else (to, at)				)
         else:
            # This edge is a back edge and cannot be a bridge
            lowerCAmelCase     =			min(low[at]	, low[to]				)

   lowerCAmelCase     =			[]
   for i in range(lowerCamelCase				):
      if not visited[i]:
         dfs(lowerCamelCase	, -1	, lowerCamelCase	, id_				)
   return bridges


if __name__ == "__main__":
       import doctest

       doctest.testmod()





