






import unittest

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


class 						_a       (  unittest.TestCase    ):






  """simple docstring"""





  def    _UpperCAmelCase     (     self )			-> List[str]:
     UpperCamelCase_									=     Vector([1, 2, 3] )
     self.assertEqual(x.component(0 )		,		1 )
     self.assertEqual(x.component(2 )		,		3 )
     UpperCamelCase_									=     Vector()




  def    _UpperCAmelCase     (     self )			-> str:
     UpperCamelCase_									=     Vector([0, 0, 0, 0, 0, 1] )
     self.assertEqual(str(_UpperCAmelCase )		,		'(0,0,0,0,0,1)' )




  def    _UpperCAmelCase     (     self )			-> List[Any]:
     UpperCamelCase_									=     Vector([1, 2, 3, 4] )
     self.assertEqual(len(_UpperCAmelCase )		,		4 )




  def    _UpperCAmelCase     (     self )			-> List[str]:
     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.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    _UpperCAmelCase     (     self )			-> Tuple:
     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    _UpperCAmelCase     (     self )			-> Any:
     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    _UpperCAmelCase     (     self )			-> Tuple:
     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    _UpperCAmelCase     (     self )			-> int:
     self.assertEqual(str(zero_vector(10 ) ).count('0' )		,		10 )




  def    _UpperCAmelCase     (     self )			-> Union[str, Any]:
     self.assertEqual(str(unit_basis_vector(3		,		1 ) )		,		'(0,1,0)' )




  def    _UpperCAmelCase     (     self )			-> str:
     UpperCamelCase_									=     Vector([1, 2, 3] )
     UpperCamelCase_									=     Vector([1, 0, 1] )
     self.assertEqual(str(axpy(2		,		_UpperCAmelCase		,		_UpperCAmelCase ) )		,		'(3,4,7)' )




  def    _UpperCAmelCase     (     self )			-> Union[str, Any]:
     UpperCamelCase_									=     Vector([1, 0, 0, 0, 0, 0] )
     UpperCamelCase_									=     x.copy()
     self.assertEqual(str(_UpperCAmelCase )		,		str(_UpperCAmelCase ) )




  def    _UpperCAmelCase     (     self )			-> List[str]:
     UpperCamelCase_									=     Vector([1, 0, 0] )
     x.change_component(0		,		0 )
     x.change_component(1		,		1 )
     self.assertEqual(str(_UpperCAmelCase )		,		'(0,1,0)' )




  def    _UpperCAmelCase     (     self )			-> str:
     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(_UpperCAmelCase ) )




  def    _UpperCAmelCase     (     self )			-> Any:
     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(_UpperCAmelCase		,		_UpperCAmelCase ) )




  def    _UpperCAmelCase     (     self )			-> Optional[Any]:
     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(_UpperCAmelCase		,		_UpperCAmelCase ) )




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




  def    _UpperCAmelCase     (     self )			-> Optional[Any]:
     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    _UpperCAmelCase     (     self )			-> str:
     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(_UpperCAmelCase ) )




  def    _UpperCAmelCase     (     self )			-> Optional[Any]:
     UpperCamelCase_									=     Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]		,		3		,		3 )
     self.assertEqual(7		,		a.component(2		,		1 )		,		0.0_1 )




  def    _UpperCAmelCase     (     self )			-> Optional[int]:
     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    _UpperCAmelCase     (     self )			-> Optional[int]:
     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    _UpperCAmelCase     (     self )			-> Any:
     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()













def     _snake_case    (__lowercase    ,      __lowercase    ,      __lowercase):
   return not any(
       neighbour == 1 and colored_vertices[i] == color
       for i, neighbour in enumerate(__lowercase))






def     _snake_case    (__lowercase    ,      __lowercase    ,      __lowercase    ,      __lowercase):

   # Base Case
   if index == len(__lowercase):
      return True

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






def     _snake_case    (__lowercase    ,      __lowercase):
   UpperCamelCase_									=     [-1] * len(__lowercase)

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

   return []





