

'''simple docstring'''



import unittest

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







class 						lowerCAmelCase__   (      unittest.TestCase					):



 """simple docstring"""



 def       UpperCAmelCase__		(		self					:       Dict			)  -> None:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      Vector([1, 2, 3]			)
      self.assertEqual(x.component(0			)					,							1			)
      self.assertEqual(x.component(2			)					,							3			)
      __SCREAMING_SNAKE_CASE     =      Vector()
 def       UpperCAmelCase__		(		self					:       Optional[Any]			)  -> None:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      Vector([0, 0, 0, 0, 0, 1]			)
      self.assertEqual(str(__SCREAMING_SNAKE_CASE			)					,							"""(0,0,0,0,0,1)"""			)
 def       UpperCAmelCase__		(		self					:       Union[str, Any]			)  -> None:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      Vector([1, 2, 3, 4]			)
      self.assertEqual(len(__SCREAMING_SNAKE_CASE			)					,							4			)
 def       UpperCAmelCase__		(		self					:       int			)  -> None:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      Vector([1, 2]			)
      __SCREAMING_SNAKE_CASE     =      Vector([1, 2, 3, 4, 5]			)
      __SCREAMING_SNAKE_CASE     =      Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]			)
      __SCREAMING_SNAKE_CASE     =      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       UpperCAmelCase__		(		self					:       Tuple			)  -> None:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      Vector([1, 2, 3]			)
      __SCREAMING_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       UpperCAmelCase__		(		self					:       Optional[Any]			)  -> None:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      Vector([1, 2, 3]			)
      __SCREAMING_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       UpperCAmelCase__		(		self					:       Union[str, Any]			)  -> None:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      Vector([1, 2, 3]			)
      __SCREAMING_SNAKE_CASE     =      Vector([2, -1, 4]			)  # for test of dot product
      __SCREAMING_SNAKE_CASE     =      Vector([1, -2, -1]			)
      self.assertEqual(str(x * 3.0			)					,							"""(3.0,6.0,9.0)"""			)
      self.assertEqual((a * b)					,							0			)
 def       UpperCAmelCase__		(		self					:       Optional[int]			)  -> None:


      """simple docstring"""




      self.assertEqual(str(zero_vector(10			)			).count("""0"""			)					,							10			)
 def       UpperCAmelCase__		(		self					:       Dict			)  -> None:


      """simple docstring"""




      self.assertEqual(str(unit_basis_vector(3					,							1			)			)					,							"""(0,1,0)"""			)
 def       UpperCAmelCase__		(		self					:       int			)  -> None:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      Vector([1, 2, 3]			)
      __SCREAMING_SNAKE_CASE     =      Vector([1, 0, 1]			)
      self.assertEqual(str(axpy(2					,							__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE			)			)					,							"""(3,4,7)"""			)
 def       UpperCAmelCase__		(		self					:       List[str]			)  -> None:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      Vector([1, 0, 0, 0, 0, 0]			)
      __SCREAMING_SNAKE_CASE     =      x.copy()
      self.assertEqual(str(__SCREAMING_SNAKE_CASE			)					,							str(__SCREAMING_SNAKE_CASE			)			)
 def       UpperCAmelCase__		(		self					:       Optional[int]			)  -> None:


      """simple docstring"""




      __SCREAMING_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       UpperCAmelCase__		(		self					:       int			)  -> None:


      """simple docstring"""




      __SCREAMING_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       UpperCAmelCase__		(		self					:       int			)  -> None:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]					,							3					,							3			)
      __SCREAMING_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       UpperCAmelCase__		(		self					:       Dict			)  -> None:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]					,							3					,							3			)
      __SCREAMING_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       UpperCAmelCase__		(		self					:       Dict			)  -> None:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]					,							3					,							3			)
      self.assertEqual(-5					,							a.determinant()			)
 def       UpperCAmelCase__		(		self					:       List[str]			)  -> None:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]					,							3					,							3			)
      __SCREAMING_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       UpperCAmelCase__		(		self					:       Dict			)  -> None:


      """simple docstring"""




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


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]					,							3					,							3			)
      self.assertEqual(7					,							a.component(2					,							1			)					,							0.01			)
 def       UpperCAmelCase__		(		self					:       Dict			)  -> None:


      """simple docstring"""




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


      """simple docstring"""




      __SCREAMING_SNAKE_CASE     =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]					,							3					,							3			)
      __SCREAMING_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       UpperCAmelCase__		(		self					:       Optional[Any]			)  -> 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'''



from itertools import count







def    a__       (  a__ = 50						):




     """simple docstring"""


     __SCREAMING_SNAKE_CASE     =      [1] * min_block_length

     for n in count(a__						):
          fill_count_functions.append(1						)

          for block_length in range(a__      ,    n + 1						):
               for block_start in range(n - block_length						):
                    fill_count_functions[n] += fill_count_functions[
                        n - block_start - block_length - 1
                    ]

               fill_count_functions[n] += 1

          if fill_count_functions[n] > 1_00_00_00:
               break

     return n


if __name__ == "__main__":
  print(f"""{solution() = }""")






