


import unittest

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





class   __a			(    unittest.TestCase      ):
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Any:




        '''simple docstring'''
        lowercase__:   List[Any]  			=   Vector([1, 2, 3] )
        self.assertEqual(x.component(0 )				, 1 )
        self.assertEqual(x.component(2 )				, 3 )
        lowercase__:   List[str]  			=   Vector()
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Optional[Any]:




        '''simple docstring'''
        lowercase__:   Union[str, Any]  			=   Vector([0, 0, 0, 0, 0, 1] )
        self.assertEqual(str(lowerCAmelCase__ )				, '(0,0,0,0,0,1)' )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Optional[Any]:




        '''simple docstring'''
        lowercase__:   Optional[Any]  			=   Vector([1, 2, 3, 4] )
        self.assertEqual(len(lowerCAmelCase__ )				, 4 )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				int:




        '''simple docstring'''
        lowercase__:   Optional[int]  			=   Vector([1, 2] )
        lowercase__:   Optional[int]  			=   Vector([1, 2, 3, 4, 5] )
        lowercase__:   Dict  			=   Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0] )
        lowercase__:   int  			=   Vector([1, -1, 1, -1, 2, -3, 4, -5] )
        self.assertAlmostEqual(x.euclidean_length()				, 2.2_3_6				, 3 )
        self.assertAlmostEqual(y.euclidean_length()				, 7.4_1_6				, 3 )
        self.assertEqual(z.euclidean_length()				, 0 )
        self.assertAlmostEqual(w.euclidean_length()				, 7.6_1_6				, 3 )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				int:




        '''simple docstring'''
        lowercase__:   List[Any]  			=   Vector([1, 2, 3] )
        lowercase__:   str  			=   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 )					->				str:




        '''simple docstring'''
        lowercase__:   Tuple  			=   Vector([1, 2, 3] )
        lowercase__:   List[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'''
        lowercase__:   Any  			=   Vector([1, 2, 3] )
        lowercase__:   Optional[Any]  			=   Vector([2, -1, 4] )  # for test of dot product
        lowercase__:   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 )					->				Union[str, Any]:




        '''simple docstring'''
        self.assertEqual(str(zero_vector(10 ) ).count('0' )				, 10 )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Dict:




        '''simple docstring'''
        self.assertEqual(str(unit_basis_vector(3				, 1 ) )				, '(0,1,0)' )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				List[Any]:




        '''simple docstring'''
        lowercase__:   Any  			=   Vector([1, 2, 3] )
        lowercase__:   List[Any]  			=   Vector([1, 0, 1] )
        self.assertEqual(str(axpy(2				, lowerCAmelCase__				, lowerCAmelCase__ ) )				, '(3,4,7)' )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				str:




        '''simple docstring'''
        lowercase__:   Any  			=   Vector([1, 0, 0, 0, 0, 0] )
        lowercase__:   Union[str, Any]  			=   x.copy()
        self.assertEqual(str(lowerCAmelCase__ )				, str(lowerCAmelCase__ ) )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Any:




        '''simple docstring'''
        lowercase__:   List[str]  			=   Vector([1, 0, 0] )
        x.change_component(0				, 0 )
        x.change_component(1				, 1 )
        self.assertEqual(str(lowerCAmelCase__ )				, '(0,1,0)' )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Optional[int]:




        '''simple docstring'''
        lowercase__:   Optional[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 		SCREAMING_SNAKE_CASE__   (   self )					->				List[Any]:




        '''simple docstring'''
        lowercase__:   int  			=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]				, 3				, 3 )
        lowercase__:   Optional[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(lowerCAmelCase__				, lowerCAmelCase__ ) )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Tuple:




        '''simple docstring'''
        lowercase__:   Union[str, Any]  			=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]				, 3				, 3 )
        lowercase__:   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 		SCREAMING_SNAKE_CASE__   (   self )					->				Optional[Any]:




        '''simple docstring'''
        lowercase__:   Optional[Any]  			=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]				, 3				, 3 )
        self.assertEqual(-5				, a.determinant() )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Any:




        '''simple docstring'''
        lowercase__:   Union[str, Any]  			=   Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]				, 3				, 3 )
        lowercase__:   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 )					->				str:




        '''simple docstring'''
        lowercase__:   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 		SCREAMING_SNAKE_CASE__   (   self )					->				Optional[int]:




        '''simple docstring'''
        lowercase__:   Any  			=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]				, 3				, 3 )
        self.assertEqual(7				, a.component(2				, 1 )				, 0.0_1 )
 def 		SCREAMING_SNAKE_CASE__   (   self )					->				Union[str, Any]:




        '''simple docstring'''
        lowercase__:   Any  			=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]				, 3				, 3 )
        lowercase__:   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 )					->				int:




        '''simple docstring'''
        lowercase__:   Any  			=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]				, 3				, 3 )
        lowercase__:   Optional[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 		SCREAMING_SNAKE_CASE__   (   self )					->				Optional[Any]:




        '''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()




_lowerCamelCase       :				int       =			[4, 1, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
_lowerCamelCase       :				str       =			[3, 7, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
_lowerCamelCase       :				List[str]       =			{
    0: '''Sunday''',
    1: '''Monday''',
    2: '''Tuesday''',
    3: '''Wednesday''',
    4: '''Thursday''',
    5: '''Friday''',
    6: '''Saturday''',
}






def        a_		(       __lowercase   :	int       ,					__lowercase   :	int       ,					__lowercase   :	int ) ->  str:
			assert len(str(__lowercase ) ) > 2, "year should be in YYYY format"
			assert 1 <= month <= 12, "month should be between 1 to 12"
			assert 1 <= day <= 31, "day should be between 1 to 31"

			# Doomsday algorithm:
			_snake_case		=			year // 100
			_snake_case		=			(5 * (century % 4) + 2) % 7
			_snake_case		=			year % 100
			_snake_case		=			centurian % 12
			_snake_case		=			(
			    (centurian // 12) + centurian_m + (centurian_m // 4) + century_anchor
			) % 7
			_snake_case		=			(
			    DOOMSDAY_NOT_LEAP[month - 1]
			    if (year % 4 != 0) or (centurian == 0 and (year % 400) == 0)
			    else DOOMSDAY_LEAP[month - 1]
			)
			_snake_case		=			(dooms_day + day - day_anchor) % 7
			return WEEK_DAY_NAMES[week_day]


if __name__ == "__main__":
			import doctest

			doctest.testmod()