






import unittest

from .lib import (
    Matrix,
    Vector,
    axpy,
    square_zero_matrix,
    unit_basis_vector,
    zero_vector,
)
class 		SCREAMING_SNAKE_CASE__	(  unittest.TestCase     ):

  '''simple docstring'''







  def  lowerCamelCase       (      self		:			Union[str, Any]							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Vector([1, 2, 3]							)
         self.assertEqual(x.component(0							)       ,				1							)
         self.assertEqual(x.component(2							)       ,				3							)
         _UpperCAmelCase							=    Vector()


  def  lowerCamelCase       (      self		:			Tuple							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Vector([0, 0, 0, 0, 0, 1]							)
         self.assertEqual(str(lowerCamelCase							)       ,				"""(0,0,0,0,0,1)"""							)


  def  lowerCamelCase       (      self		:			Optional[int]							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Vector([1, 2, 3, 4]							)
         self.assertEqual(len(lowerCamelCase							)       ,				4							)


  def  lowerCamelCase       (      self		:			Tuple							)						->	None:


         """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  lowerCamelCase       (      self		:			Dict							)						->	None:


         """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  lowerCamelCase       (      self		:			Dict							)						->	None:


         """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  lowerCamelCase       (      self		:			int							)						->	None:


         """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  lowerCamelCase       (      self		:			Optional[int]							)						->	None:


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


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


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


  def  lowerCamelCase       (      self		:			Any							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Vector([1, 2, 3]							)
         _UpperCAmelCase							=    Vector([1, 0, 1]							)
         self.assertEqual(str(axpy(2       ,				lowerCamelCase       ,				lowerCamelCase							)							)       ,				"""(3,4,7)"""							)


  def  lowerCamelCase       (      self		:			Union[str, Any]							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Vector([1, 0, 0, 0, 0, 0]							)
         _UpperCAmelCase							=    x.copy()
         self.assertEqual(str(lowerCamelCase							)       ,				str(lowerCamelCase							)							)


  def  lowerCamelCase       (      self		:			Tuple							)						->	None:


         """simple docstring"""
         _UpperCAmelCase							=    Vector([1, 0, 0]							)
         x.change_component(0       ,				0							)
         x.change_component(1       ,				1							)
         self.assertEqual(str(lowerCamelCase							)       ,				"""(0,1,0)"""							)


  def  lowerCamelCase       (      self		:			Union[str, Any]							)						->	None:


         """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(lowerCamelCase							)							)


  def  lowerCamelCase       (      self		:			str							)						->	None:


         """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(lowerCamelCase       ,				lowerCamelCase							)							)


  def  lowerCamelCase       (      self		:			str							)						->	None:


         """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(lowerCamelCase       ,				lowerCamelCase							)							)


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


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


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


         """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  lowerCamelCase       (      self		:			Any							)						->	None:


         """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(lowerCamelCase							)							)


  def  lowerCamelCase       (      self		:			int							)						->	None:


         """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  lowerCamelCase       (      self		:			Optional[Any]							)						->	None:


         """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  lowerCamelCase       (      self		:			Tuple							)						->	None:


         """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  lowerCamelCase       (      self		:			List[str]							)						->	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()






"""simple docstring"""




class 			__UpperCamelCase							:  # Public class to implement a graph






							def __init__(  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					None:
								a :						int      =							row
								a :						Tuple      =							col
								a :						Optional[int]      =							graph






							def        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					bool:
								return (
								    0 <= i < self.ROW
								    and 0 <= j < self.COL
								    and not visited[i][j]
								    and self.graph[i][j]
								)






							def        __a  (  self ,   lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )      ->					None:
								# Checking all 8 elements surrounding nth element
								a :						Optional[Any]      =							[-1, -1, -1, 0, 0, 1, 1, 1]  # Coordinate order
								a :						str      =							[-1, 0, 1, -1, 1, -1, 0, 1]
								a :						str      =							True  # Make those cells visited
								for k in range(8 ):
									if self.is_safe(i + row_nbr[k] ,   j + col_nbr[k] ,   lowerCAmelCase__ ):
										self.diffs(i + row_nbr[k] ,   j + col_nbr[k] ,   lowerCAmelCase__ )






							def        __a  (  self )      ->					int:  # And finally, count all islands.
								a :						Union[str, Any]      =							[[False for j in range(self.COL )] for i in range(self.ROW )]
								a :						Dict      =							0
								for i in range(self.ROW ):
									for j in range(self.COL ):
										if visited[i][j] is False and self.graph[i][j] == 1:
											self.diffs(lowerCAmelCase__ ,   lowerCAmelCase__ ,   lowerCAmelCase__ )
											count += 1
								return count


