




import unittest

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


class 							UpperCamelCase_       (					unittest.TestCase	):

    '''simple docstring'''






    def 			SCREAMING_SNAKE_CASE				(     self :      int)		->None:





           '''simple docstring'''

           A__ 					=       Vector([1, 2, 3])
           self.assertEqual(x.component(0)   ,					1)
           self.assertEqual(x.component(2)   ,					3)
           A__ 					=       Vector()


    def 			SCREAMING_SNAKE_CASE				(     self :      int)		->None:





           '''simple docstring'''

           A__ 					=       Vector([0, 0, 0, 0, 0, 1])
           self.assertEqual(str(UpperCAmelCase__)   ,					'''(0,0,0,0,0,1)''')


    def 			SCREAMING_SNAKE_CASE				(     self :      Dict)		->None:





           '''simple docstring'''

           A__ 					=       Vector([1, 2, 3, 4])
           self.assertEqual(len(UpperCAmelCase__)   ,					4)


    def 			SCREAMING_SNAKE_CASE				(     self :      Union[str, Any])		->None:





           '''simple docstring'''

           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 			SCREAMING_SNAKE_CASE				(     self :      Optional[Any])		->None:





           '''simple docstring'''

           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 			SCREAMING_SNAKE_CASE				(     self :      Any)		->None:





           '''simple docstring'''

           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 			SCREAMING_SNAKE_CASE				(     self :      int)		->None:





           '''simple docstring'''

           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 			SCREAMING_SNAKE_CASE				(     self :      Dict)		->None:





           '''simple docstring'''

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


    def 			SCREAMING_SNAKE_CASE				(     self :      Any)		->None:





           '''simple docstring'''

           self.assertEqual(str(unit_basis_vector(3   ,					1))   ,					'''(0,1,0)''')


    def 			SCREAMING_SNAKE_CASE				(     self :      Optional[Any])		->None:





           '''simple docstring'''

           A__ 					=       Vector([1, 2, 3])
           A__ 					=       Vector([1, 0, 1])
           self.assertEqual(str(axpy(2   ,					UpperCAmelCase__   ,					UpperCAmelCase__))   ,					'''(3,4,7)''')


    def 			SCREAMING_SNAKE_CASE				(     self :      Any)		->None:





           '''simple docstring'''

           A__ 					=       Vector([1, 0, 0, 0, 0, 0])
           A__ 					=       x.copy()
           self.assertEqual(str(UpperCAmelCase__)   ,					str(UpperCAmelCase__))


    def 			SCREAMING_SNAKE_CASE				(     self :      str)		->None:





           '''simple docstring'''

           A__ 					=       Vector([1, 0, 0])
           x.change_component(0   ,					0)
           x.change_component(1   ,					1)
           self.assertEqual(str(UpperCAmelCase__)   ,					'''(0,1,0)''')


    def 			SCREAMING_SNAKE_CASE				(     self :      Tuple)		->None:





           '''simple docstring'''

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


    def 			SCREAMING_SNAKE_CASE				(     self :      Union[str, Any])		->None:





           '''simple docstring'''

           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(UpperCAmelCase__   ,					UpperCAmelCase__))


    def 			SCREAMING_SNAKE_CASE				(     self :      List[str])		->None:





           '''simple docstring'''

           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(UpperCAmelCase__   ,					UpperCAmelCase__))


    def 			SCREAMING_SNAKE_CASE				(     self :      Any)		->None:





           '''simple docstring'''

           A__ 					=       Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,					3   ,					3)
           self.assertEqual(-5   ,					a.determinant())


    def 			SCREAMING_SNAKE_CASE				(     self :      Optional[int])		->None:





           '''simple docstring'''

           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 			SCREAMING_SNAKE_CASE				(     self :      int)		->None:





           '''simple docstring'''

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


    def 			SCREAMING_SNAKE_CASE				(     self :      List[str])		->None:





           '''simple docstring'''

           A__ 					=       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 :      List[Any])		->None:





           '''simple docstring'''

           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 			SCREAMING_SNAKE_CASE				(     self :      Any)		->None:





           '''simple docstring'''

           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 			SCREAMING_SNAKE_CASE				(     self :      Any)		->None:





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






def lowerCamelCase__     (		__lowerCamelCase			:				str				):







   '''simple docstring'''




   _UpperCAmelCase  :  Dict				       =''
   for ch in key:
      if ch == " " or ch not in key_no_dups and ch.isalpha():
         key_no_dups += ch
   return key_no_dups





def lowerCamelCase__     (		__lowerCamelCase			:				str				):







   '''simple docstring'''




   _UpperCAmelCase  :  List[str]				       =[chr(i + 6_5				) for i in range(2_6				)]
   # Remove duplicate characters from key
   _UpperCAmelCase  :  Any				       =remove_duplicates(key.upper()				)
   _UpperCAmelCase  :  Optional[Any]				       =len(__lowerCamelCase				)
   # First fill cipher with key characters
   _UpperCAmelCase  :  List[Any]				       ={alphabet[i]: char for i, char in enumerate(__lowerCamelCase				)}
   # Then map remaining characters in alphabet to
   # the alphabet from the beginning
   for i in range(len(__lowerCamelCase				)			,       2_6				):
      _UpperCAmelCase  :  Union[str, Any]				       =alphabet[i - offset]
      # Ensure we are not mapping letters to letters previously mapped
      while char in key:
         offset -= 1
         _UpperCAmelCase  :  str				       =alphabet[i - offset]
      _UpperCAmelCase  :  Any				       =char
   return cipher_alphabet





def lowerCamelCase__     (		__lowerCamelCase			:				str			,       __lowerCamelCase			:				dict[str, str]				):







   '''simple docstring'''




   return "".join(cipher_map.get(__lowerCamelCase			,       __lowerCamelCase				) for ch in message.upper()				)





def lowerCamelCase__     (		__lowerCamelCase			:				str			,       __lowerCamelCase			:				dict[str, str]				):







   '''simple docstring'''




   _UpperCAmelCase  :  List[str]				       ={v: k for k, v in cipher_map.items()}
   return "".join(rev_cipher_map.get(__lowerCamelCase			,       __lowerCamelCase				) for ch in message.upper()				)





def lowerCamelCase__     (		):







   '''simple docstring'''




   _UpperCAmelCase  :  Union[str, Any]				       =input('Enter message to encode or decode: '				).strip()
   _UpperCAmelCase  :  int				       =input('Enter keyword: '				).strip()
   _UpperCAmelCase  :  int				       =input('Encipher or decipher? E/D:'				).strip()[0].lower()
   try:
      _UpperCAmelCase  :  Tuple				       ={'e': encipher, 'd': decipher}[option]
   except KeyError:
      raise KeyError('invalid input option'				)
   _UpperCAmelCase  :  List[str]				       =create_cipher_map(__lowerCamelCase				)
   print(func(__lowerCamelCase			,       __lowerCamelCase				)				)


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 main()

