






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    __A			(	self: str )     ->					List[str]:
												_A										=			Vector([1, 2, 3] )
												self.assertEqual(x.component(0 )		,  1 )
												self.assertEqual(x.component(2 )		,  3 )
												_A										=			Vector()

							def    __A			(	self: Dict )     ->					Optional[Any]:
												_A										=			Vector([0, 0, 0, 0, 0, 1] )
												self.assertEqual(str(lowercase_ )		,  '''(0,0,0,0,0,1)''' )

							def    __A			(	self: Optional[Any] )     ->					str:
												_A										=			Vector([1, 2, 3, 4] )
												self.assertEqual(len(lowercase_ )		,  4 )

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

							def    __A			(	self: List[str] )     ->					Tuple:
												self.assertEqual(str(zero_vector(10 ) ).count('''0''' )		,  10 )

							def    __A			(	self: int )     ->					Union[str, Any]:
												self.assertEqual(str(unit_basis_vector(3		,  1 ) )		,  '''(0,1,0)''' )

							def    __A			(	self: Any )     ->					List[str]:
												_A										=			Vector([1, 2, 3] )
												_A										=			Vector([1, 0, 1] )
												self.assertEqual(str(axpy(2		,  lowercase_		,  lowercase_ ) )		,  '''(3,4,7)''' )

							def    __A			(	self: str )     ->					str:
												_A										=			Vector([1, 0, 0, 0, 0, 0] )
												_A										=			x.copy()
												self.assertEqual(str(lowercase_ )		,  str(lowercase_ ) )

							def    __A			(	self: Optional[int] )     ->					List[Any]:
												_A										=			Vector([1, 0, 0] )
												x.change_component(0		,  0 )
												x.change_component(1		,  1 )
												self.assertEqual(str(lowercase_ )		,  '''(0,1,0)''' )

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

							def    __A			(	self: Optional[int] )     ->					int:
												_A										=			Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]		,  3		,  3 )
												_A										=			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    __A			(	self: Optional[int] )     ->					int:
												_A										=			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    __A			(	self: Dict )     ->					Dict:
												_A										=			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]		,  3		,  3 )
												self.assertEqual(7		,  a.component(2		,  1 )		,  0.01 )

							def    __A			(	self: Dict )     ->					List[Any]:
												_A										=			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]		,  3		,  3 )
												_A										=			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    __A			(	self: List[str] )     ->					int:
												_A										=			Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]		,  3		,  3 )
												_A										=			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    __A			(	self: str )     ->					Optional[int]:
												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"""





def     __SCREAMING_SNAKE_CASE    ( A_					):
	lowerCAmelCase__      :		Any    							=      int(A_					)
	if decimal in (0, 1):  # Exit cases for the recursion
		return str(A_					)
	lowerCAmelCase__							,lowerCAmelCase__      :		Any    							=      divmod(A_		,	2					)
	return binary_recursive(A_					) + str(A_					)

def     __SCREAMING_SNAKE_CASE    ( A_					):
	lowerCAmelCase__      :		Union[str, Any]    							=      str(A_					).strip()
	if not number:
		raise ValueError('''No input value was provided'''					)
	lowerCAmelCase__      :		Any    							=      '''-''' if number.startswith('''-'''					) else ''''''
	lowerCAmelCase__      :		Dict    							=      number.lstrip('''-'''					)
	if not number.isnumeric():
		raise ValueError('''Input value is not an integer'''					)
	return f'{negative}0b{binary_recursive(int(A_					)					)}'


if __name__ == "__main__":
							from doctest import testmod

							testmod()




