






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




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Any							=	Vector([1, 2, 3])
          self.assertEqual(x.component(0)		,			1)
          self.assertEqual(x.component(2)		,			3)
          SCREAMING_SNAKE_CASE_   :						int							=	Vector()
      def _SCREAMING_SNAKE_CASE				(		self  :						int):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Tuple							=	Vector([0, 0, 0, 0, 0, 1])
          self.assertEqual(str(lowercase_)		,			'''(0,0,0,0,0,1)''')
      def _SCREAMING_SNAKE_CASE				(		self  :						Any):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	Vector([1, 2, 3, 4])
          self.assertEqual(len(lowercase_)		,			4)
      def _SCREAMING_SNAKE_CASE				(		self  :						List[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Dict							=	Vector([1, 2])
          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	Vector([1, 2, 3, 4, 5])
          SCREAMING_SNAKE_CASE_   :						str							=	Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
          SCREAMING_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 _SCREAMING_SNAKE_CASE				(		self  :						List[str]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						List[Any]							=	Vector([1, 2, 3])
          SCREAMING_SNAKE_CASE_   :						int							=	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 _SCREAMING_SNAKE_CASE				(		self  :						Tuple):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Any							=	Vector([1, 2, 3])
          SCREAMING_SNAKE_CASE_   :						str							=	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 _SCREAMING_SNAKE_CASE				(		self  :						str):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	Vector([1, 2, 3])
          SCREAMING_SNAKE_CASE_   :						Dict							=	Vector([2, -1, 4])  # for test of dot product
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	Vector([1, -2, -1])
          self.assertEqual(str(x * 3.0)		,			'''(3.0,6.0,9.0)''')
          self.assertEqual((a * b)		,			0)
      def _SCREAMING_SNAKE_CASE				(		self  :						Optional[Any]):




          '''simple docstring'''


          self.assertEqual(str(zero_vector(10)).count('''0''')		,			10)
      def _SCREAMING_SNAKE_CASE				(		self  :						str):




          '''simple docstring'''


          self.assertEqual(str(unit_basis_vector(3		,			1))		,			'''(0,1,0)''')
      def _SCREAMING_SNAKE_CASE				(		self  :						int):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						List[str]							=	Vector([1, 2, 3])
          SCREAMING_SNAKE_CASE_   :						List[str]							=	Vector([1, 0, 1])
          self.assertEqual(str(axpy(2		,			lowercase_		,			lowercase_))		,			'''(3,4,7)''')
      def _SCREAMING_SNAKE_CASE				(		self  :						Union[str, Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Dict							=	Vector([1, 0, 0, 0, 0, 0])
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	x.copy()
          self.assertEqual(str(lowercase_)		,			str(lowercase_))
      def _SCREAMING_SNAKE_CASE				(		self  :						Union[str, Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Tuple							=	Vector([1, 0, 0])
          x.change_component(0		,			0)
          x.change_component(1		,			1)
          self.assertEqual(str(lowercase_)		,			'''(0,1,0)''')
      def _SCREAMING_SNAKE_CASE				(		self  :						int):




          '''simple docstring'''


          SCREAMING_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(lowercase_))
      def _SCREAMING_SNAKE_CASE				(		self  :						Optional[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						List[Any]							=	Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]		,			3		,			3)
          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	[[-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(lowercase_		,			lowercase_))
      def _SCREAMING_SNAKE_CASE				(		self  :						int):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Dict							=	Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]		,			3		,			3)
          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	[[-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(lowercase_		,			lowercase_))
      def _SCREAMING_SNAKE_CASE				(		self  :						Union[str, Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]		,			3		,			3)
          self.assertEqual(-5		,			a.determinant())
      def _SCREAMING_SNAKE_CASE				(		self  :						Union[str, Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]		,			3		,			3)
          SCREAMING_SNAKE_CASE_   :						Dict							=	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 _SCREAMING_SNAKE_CASE				(		self  :						List[str]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						str							=	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(lowercase_))
      def _SCREAMING_SNAKE_CASE				(		self  :						List[str]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						int							=	Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]		,			3		,			3)
          self.assertEqual(7		,			a.component(2		,			1)		,			0.01)
      def _SCREAMING_SNAKE_CASE				(		self  :						Dict):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						str							=	Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]		,			3		,			3)
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	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 _SCREAMING_SNAKE_CASE				(		self  :						List[Any]):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						List[str]							=	Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]		,			3		,			3)
          SCREAMING_SNAKE_CASE_   :						Tuple							=	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 _SCREAMING_SNAKE_CASE				(		self  :						Optional[int]):




          '''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 __future__ import annotations



def       _A    (__a					,       __a					,       __a							)				-> int | float:
    """simple docstring"""






    if len(__a							) == 0:
        raise ValueError('''find_max() arg is an empty sequence'''							)
    if (
        left >= len(__a							)
        or left < -len(__a							)
        or right >= len(__a							)
        or right < -len(__a							)
    ):
        raise IndexError('''list index out of range'''							)
    if left == right:
        return nums[left]
    SCREAMING_SNAKE_CASE_   :						str							=	(left + right) >> 1  # the middle
    SCREAMING_SNAKE_CASE_   :						int							=	find_max(__a					,       __a					,       __a							)  # find max in range[left, mid]
    SCREAMING_SNAKE_CASE_   :						str							=	find_max(__a					,       mid + 1					,       __a							)  # find max in range[mid + 1, right]

    return left_max if left_max >= right_max else right_max


if __name__ == "__main__":
  import doctest

  doctest.testmod(verbose=True)


