






"""simple docstring"""
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				):
		A_		:    str						     = Vector([1, 2, 3]				)
		self.assertEqual(x.component(0				)  ,  1				)
		self.assertEqual(x.component(2				)  ,  3				)
		A_		:    List[Any]						     = Vector()





	def  lowerCamelCase(self				):
		A_		:    Any						     = Vector([0, 0, 0, 0, 0, 1]				)
		self.assertEqual(str(lowerCAmelCase_				)  ,  """(0,0,0,0,0,1)"""				)





	def  lowerCamelCase(self				):
		A_		:    Any						     = Vector([1, 2, 3, 4]				)
		self.assertEqual(len(lowerCAmelCase_				)  ,  4				)





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





	def  lowerCamelCase(self				):
		self.assertEqual(str(zero_vector(10				)				).count("""0"""				)  ,  10				)





	def  lowerCamelCase(self				):
		self.assertEqual(str(unit_basis_vector(3  ,  1				)				)  ,  """(0,1,0)"""				)





	def  lowerCamelCase(self				):
		A_		:    List[str]						     = Vector([1, 2, 3]				)
		A_		:    Tuple						     = Vector([1, 0, 1]				)
		self.assertEqual(str(axpy(2  ,  lowerCAmelCase_  ,  lowerCAmelCase_				)				)  ,  """(3,4,7)"""				)





	def  lowerCamelCase(self				):
		A_		:    List[Any]						     = Vector([1, 0, 0, 0, 0, 0]				)
		A_		:    str						     = x.copy()
		self.assertEqual(str(lowerCAmelCase_				)  ,  str(lowerCAmelCase_				)				)





	def  lowerCamelCase(self				):
		A_		:    Tuple						     = Vector([1, 0, 0]				)
		x.change_component(0  ,  0				)
		x.change_component(1  ,  1				)
		self.assertEqual(str(lowerCAmelCase_				)  ,  """(0,1,0)"""				)





	def  lowerCamelCase(self				):
		A_		:    Union[str, Any]						     = 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				):
		A_		:    List[Any]						     = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]  ,  3  ,  3				)
		A_		:    Optional[int]						     = [[-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				):
		A_		:    Tuple						     = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]  ,  3  ,  3				)
		A_		:    Optional[int]						     = [[-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				):
		A_		:    Any						     = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]  ,  3  ,  3				)
		self.assertEqual(-5  ,  a.determinant()				)





	def  lowerCamelCase(self				):
		A_		:    Tuple						     = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]  ,  3  ,  3				)
		A_		:    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  lowerCamelCase(self				):
		A_		:    Optional[Any]						     = 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				):
		A_		:    List[str]						     = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]  ,  3  ,  3				)
		self.assertEqual(7  ,  a.component(2  ,  1				)  ,  0.01				)





	def  lowerCamelCase(self				):
		A_		:    Optional[int]						     = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]  ,  3  ,  3				)
		A_		:    List[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  lowerCamelCase(self				):
		A_		:    Optional[int]						     = Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]  ,  3  ,  3				)
		A_		:    List[Any]						     = 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				):
		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       __UpperCamelCase						(		snake_case__ , snake_case__       ):
	if len(snake_case__       ) == 0:
		return False
	A_		:    Union[str, Any]						     = len(snake_case__       ) // 2
	if a_list[midpoint] == item:
		return True
	if item < a_list[midpoint]:
		return binary_search(a_list[:midpoint] , snake_case__       )
	else:
		return binary_search(a_list[midpoint + 1 :] , snake_case__       )


if __name__ == "__main__":
							_lowerCAmelCase       =				input("Enter numbers separated by comma:\n").strip()
							_lowerCAmelCase       =				[int(item.strip()) for item in user_input.split(",")]
							_lowerCAmelCase       =				int(input("Enter the number to be found in the list:\n").strip())
							_lowerCAmelCase       =				"" if binary_search(sequence, target) else "not "
							print(F'{target} was {not_str}found in {sequence}')

