




import unittest

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




class 		__lowercase						(unittest.TestCase				):




      """simple docstring"""





      def       UpperCAmelCase ( self      )						->							None:
         snake_case :							Any           =			Vector([1, 2, 3]      )
         self.assertEqual(x.component(0      )							, 1      )
         self.assertEqual(x.component(2      )							, 3      )
         snake_case :							str           =			Vector()

      def       UpperCAmelCase ( self      )						->							None:
         snake_case :							List[str]           =			Vector([0, 0, 0, 0, 0, 1]      )
         self.assertEqual(str(snake_case_      )							, """(0,0,0,0,0,1)"""      )

      def       UpperCAmelCase ( self      )						->							None:
         snake_case :							Dict           =			Vector([1, 2, 3, 4]      )
         self.assertEqual(len(snake_case_      )							, 4      )

      def       UpperCAmelCase ( self      )						->							None:
         snake_case :							Any           =			Vector([1, 2]      )
         snake_case :							Any           =			Vector([1, 2, 3, 4, 5]      )
         snake_case :							Optional[int]           =			Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]      )
         snake_case :							List[str]           =			Vector([1, -1, 1, -1, 2, -3, 4, -5]      )
         self.assertAlmostEqual(x.euclidean_length()							, 2.2_36							, 3      )
         self.assertAlmostEqual(y.euclidean_length()							, 7.4_16							, 3      )
         self.assertEqual(z.euclidean_length()							, 0      )
         self.assertAlmostEqual(w.euclidean_length()							, 7.6_16							, 3      )

      def       UpperCAmelCase ( self      )						->							None:
         snake_case :							str           =			Vector([1, 2, 3]      )
         snake_case :							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       UpperCAmelCase ( self      )						->							None:
         snake_case :							Any           =			Vector([1, 2, 3]      )
         snake_case :							int           =			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      )						->							None:
         snake_case :							List[str]           =			Vector([1, 2, 3]      )
         snake_case :							int           =			Vector([2, -1, 4]      )  # for test of dot product
         snake_case :							int           =			Vector([1, -2, -1]      )
         self.assertEqual(str(x * 3.0      )							, """(3.0,6.0,9.0)"""      )
         self.assertEqual((a * b)							, 0      )

      def       UpperCAmelCase ( self      )						->							None:
         self.assertEqual(str(zero_vector(1_0      )      ).count("""0"""      )							, 1_0      )

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

      def       UpperCAmelCase ( self      )						->							None:
         snake_case :							Any           =			Vector([1, 2, 3]      )
         snake_case :							Dict           =			Vector([1, 0, 1]      )
         self.assertEqual(str(axpy(2							, snake_case_							, snake_case_      )      )							, """(3,4,7)"""      )

      def       UpperCAmelCase ( self      )						->							None:
         snake_case :							Any           =			Vector([1, 0, 0, 0, 0, 0]      )
         snake_case :							str           =			x.copy()
         self.assertEqual(str(snake_case_      )							, str(snake_case_      )      )

      def       UpperCAmelCase ( self      )						->							None:
         snake_case :							Dict           =			Vector([1, 0, 0]      )
         x.change_component(0							, 0      )
         x.change_component(1							, 1      )
         self.assertEqual(str(snake_case_      )							, """(0,1,0)"""      )

      def       UpperCAmelCase ( self      )						->							None:
         snake_case :							str           =			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(snake_case_      )      )

      def       UpperCAmelCase ( self      )						->							None:
         snake_case :							Optional[Any]           =			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]							, 3							, 3      )
         snake_case :							Optional[int]           =			[[-3, -1_4, -1_0], [-5, -1_0, -5], [-2, -1, 0]]
         for x in range(a.height()      ):
            for y in range(a.width()      ):
               self.assertEqual(minors[x][y]							, a.minor(snake_case_							, snake_case_      )      )

      def       UpperCAmelCase ( self      )						->							None:
         snake_case :							List[Any]           =			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]							, 3							, 3      )
         snake_case :							int           =			[[-3, 1_4, -1_0], [5, -1_0, 5], [-2, 1, 0]]
         for x in range(a.height()      ):
            for y in range(a.width()      ):
               self.assertEqual(cofactors[x][y]							, a.cofactor(snake_case_							, snake_case_      )      )

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

      def       UpperCAmelCase ( self      )						->							None:
         snake_case :							Optional[int]           =			Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]							, 3							, 3      )
         snake_case :							List[str]           =			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      )						->							None:
         snake_case :							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(snake_case_      )      )

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

      def       UpperCAmelCase ( self      )						->							None:
         snake_case :							Optional[int]           =			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]							, 3							, 3      )
         snake_case :							Union[str, Any]           =			Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 1_0]]							, 3							, 3      )
         self.assertEqual("""|2,4,10|\n|4,8,10|\n|12,14,18|\n"""							, str(a + b      )      )

      def       UpperCAmelCase ( self      )						->							None:
         snake_case :							Any           =			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]							, 3							, 3      )
         snake_case :							int           =			Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 1_0]]							, 3							, 3      )
         self.assertEqual("""|0,0,-4|\n|0,0,0|\n|0,0,-2|\n"""							, str(a - b      )      )

      def       UpperCAmelCase ( self      )						->							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()









a			:			Any												=					[sum(int(c, 10) ** 2 for c in i.__str__()) for i in range(100000)]


def 		lowercase_	(  _UpperCamelCase	):


			'''simple docstring'''







			__lowercase			       = 0
			while number:
						# Increased Speed Slightly by checking every 5 digits together.
						sum_of_digits_squared += DIGITS_SQUARED[number % 10_00_00]
						number //= 10_00_00

			return sum_of_digits_squared


# There are 2 Chains made,
# One ends with 89 with the chain member 58 being the one which when declared first,
# there will be the least number of iterations for all the members to be checked.

# The other one ends with 1 and has only one element 1.

# So 58 and 1 are chosen to be declared at the starting.

# Changed dictionary to an array to quicken the solution
a			:			list[bool | None]												=					[None] * 10000000
a			:			int												=					True
a			:			Any												=					False


def 		lowercase_	(  _UpperCamelCase	):


			'''simple docstring'''







			if CHAINS[number - 1] is not None:
						return CHAINS[number - 1]  # type: ignore

			__lowercase			       = chain(next_number(_UpperCamelCase	)	)
			__lowercase			       = number_chain

			while number < 10_00_00_00:
						__lowercase			       = number_chain
						number *= 10

			return number_chain


def 		lowercase_	(  _UpperCamelCase = 10_00_00_00	):


			'''simple docstring'''







			for i in range(1							,      _UpperCamelCase	):
						if CHAINS[i] is None:
									chain(i + 1	)

			return CHAINS[:number].count(_UpperCamelCase	)


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	print(f'''{solution() = }''')


