


'''simple docstring'''




import unittest

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




class 			_lowercase (	unittest.TestCase							):
   def a  (						self       :      Optional[Any]      ) ->							None:
        __snake_case           =						Vector([1, 2, 3]      )
        self.assertEqual(x.component(0      )       ,   1      )
        self.assertEqual(x.component(2      )       ,   3      )
        __snake_case           =						Vector()
   def a  (						self       :      List[str]      ) ->							None:
        __snake_case           =						Vector([0, 0, 0, 0, 0, 1]      )
        self.assertEqual(str(SCREAMING_SNAKE_CASE_      )       ,   '(0,0,0,0,0,1)'      )
   def a  (						self       :      Optional[Any]      ) ->							None:
        __snake_case           =						Vector([1, 2, 3, 4]      )
        self.assertEqual(len(SCREAMING_SNAKE_CASE_      )       ,   4      )
   def a  (						self       :      Union[str, Any]      ) ->							None:
        __snake_case           =						Vector([1, 2]      )
        __snake_case           =						Vector([1, 2, 3, 4, 5]      )
        __snake_case           =						Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]      )
        __snake_case           =						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:
        __snake_case           =						Vector([1, 2, 3]      )
        __snake_case           =						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:
        __snake_case           =						Vector([1, 2, 3]      )
        __snake_case           =						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       :      Union[str, Any]      ) ->							None:
        __snake_case           =						Vector([1, 2, 3]      )
        __snake_case           =						Vector([2, -1, 4]      )  # for test of dot product
        __snake_case           =						Vector([1, -2, -1]      )
        self.assertEqual(str(x * 3.0      )       ,   '(3.0,6.0,9.0)'      )
        self.assertEqual((a * b)       ,   0      )
   def a  (						self       :      int      ) ->							None:
        self.assertEqual(str(zero_vector(10      )      ).count('0'      )       ,   10      )
   def a  (						self       :      Any      ) ->							None:
        self.assertEqual(str(unit_basis_vector(3       ,   1      )      )       ,   '(0,1,0)'      )
   def a  (						self       :      int      ) ->							None:
        __snake_case           =						Vector([1, 2, 3]      )
        __snake_case           =						Vector([1, 0, 1]      )
        self.assertEqual(str(axpy(2       ,   SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_      )      )       ,   '(3,4,7)'      )
   def a  (						self       :      Optional[Any]      ) ->							None:
        __snake_case           =						Vector([1, 0, 0, 0, 0, 0]      )
        __snake_case           =						x.copy()
        self.assertEqual(str(SCREAMING_SNAKE_CASE_      )       ,   str(SCREAMING_SNAKE_CASE_      )      )
   def a  (						self       :      Optional[Any]      ) ->							None:
        __snake_case           =						Vector([1, 0, 0]      )
        x.change_component(0       ,   0      )
        x.change_component(1       ,   1      )
        self.assertEqual(str(SCREAMING_SNAKE_CASE_      )       ,   '(0,1,0)'      )
   def a  (						self       :      Any      ) ->							None:
        __snake_case           =						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(SCREAMING_SNAKE_CASE_      )      )
   def a  (						self       :      Tuple      ) ->							None:
        __snake_case           =						Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,   3       ,   3      )
        __snake_case           =						[[-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(SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_      )      )
   def a  (						self       :      str      ) ->							None:
        __snake_case           =						Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,   3       ,   3      )
        __snake_case           =						[[-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(SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_      )      )
   def a  (						self       :      Optional[Any]      ) ->							None:
        __snake_case           =						Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,   3       ,   3      )
        self.assertEqual(-5       ,   a.determinant()      )
   def a  (						self       :      Any      ) ->							None:
        __snake_case           =						Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]       ,   3       ,   3      )
        __snake_case           =						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       :      Union[str, Any]      ) ->							None:
        __snake_case           =						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(SCREAMING_SNAKE_CASE_      )      )
   def a  (						self       :      Any      ) ->							None:
        __snake_case           =						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       :      Tuple      ) ->							None:
        __snake_case           =						Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,   3       ,   3      )
        __snake_case           =						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:
        __snake_case           =						Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]       ,   3       ,   3      )
        __snake_case           =						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       :      Any      ) ->							None:
        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       __UpperCamelCase					(      lowercase_       :  list[int]   ,       lowercase_       :  list[int]   ,       lowercase_       :  int   ):
       """simple docstring"""




       return not any(
           neighbour == 1 and colored_vertices[i] == color
           for i, neighbour in enumerate(lowercase_   )   )


def       __UpperCamelCase					(      lowercase_       :  list[list[int]]   ,       lowercase_       :  int   ,       lowercase_       :  list[int]   ,       lowercase_       :  int   ):
       """simple docstring"""




       if index == len(lowercase_   ):
              return True

       # Recursive Step
       for i in range(lowercase_   ):
              if valid_coloring(graph[index]   ,       lowercase_   ,       lowercase_   ):
                     # Color current vertex
                     a_						     =			i
                     # Validate coloring
                     if util_color(lowercase_   ,       lowercase_   ,       lowercase_   ,       index + 1   ):
                            return True
                     # Backtrack
                     a_						     =			-1
       return False


def       __UpperCamelCase					(      lowercase_       :  list[list[int]]   ,       lowercase_       :  int   ):
       """simple docstring"""




       a_						     =			[-1] * len(lowercase_   )

       if util_color(lowercase_   ,       lowercase_   ,       lowercase_   ,       0   ):
              return colored_vertices

       return []




