



import unittest

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



class 			__lowerCAmelCase  (						unittest.TestCase ):




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     Vector([1, 2, 3]					)
    self.assertEqual(x.component(0					)						,					1					)
    self.assertEqual(x.component(2					)						,					3					)
    __lowerCamelCase    				=     Vector()




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     Vector([0, 0, 0, 0, 0, 1]					)
    self.assertEqual(str(__UpperCAmelCase					)						,					'''(0,0,0,0,0,1)'''					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     Vector([1, 2, 3, 4]					)
    self.assertEqual(len(__UpperCAmelCase					)						,					4					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     Vector([1, 2]					)
    __lowerCamelCase    				=     Vector([1, 2, 3, 4, 5]					)
    __lowerCamelCase    				=     Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]					)
    __lowerCamelCase    				=     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					):



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



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



    '''simple docstring'''
    __lowerCamelCase    				=     Vector([1, 2, 3]					)
    __lowerCamelCase    				=     Vector([2, -1, 4]					)  # for test of dot product
    __lowerCamelCase    				=     Vector([1, -2, -1]					)
    self.assertEqual(str(x * 3.0					)						,					'''(3.0,6.0,9.0)'''					)
    self.assertEqual((a * b)						,					0					)




 def 							lowerCamelCase   (    self					):



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




 def 							lowerCamelCase   (    self					):



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




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     Vector([1, 2, 3]					)
    __lowerCamelCase    				=     Vector([1, 0, 1]					)
    self.assertEqual(str(axpy(2						,					__UpperCAmelCase						,					__UpperCAmelCase					)					)						,					'''(3,4,7)'''					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     Vector([1, 0, 0, 0, 0, 0]					)
    __lowerCamelCase    				=     x.copy()
    self.assertEqual(str(__UpperCAmelCase					)						,					str(__UpperCAmelCase					)					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     Vector([1, 0, 0]					)
    x.change_component(0						,					0					)
    x.change_component(1						,					1					)
    self.assertEqual(str(__UpperCAmelCase					)						,					'''(0,1,0)'''					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     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 							lowerCamelCase   (    self					):



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



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



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




 def 							lowerCamelCase   (    self					):



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



    '''simple docstring'''
    __lowerCamelCase    				=     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 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,					3						,					3					)
    self.assertEqual(7						,					a.component(2						,					1					)						,					0.01					)




 def 							lowerCamelCase   (    self					):



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



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



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











def 		a__      (		_UpperCamelCase      :			str				):
   if not all(x.isalpha() for x in string				):
      raise ValueError('''String must only contain alphabetic characters.'''				)

   __lowerCamelCase    				=     sorted(string.lower()				)
   return len(_UpperCamelCase				) == len(set(_UpperCamelCase				)				)


if __name__ == "__main__":
  a_								=       input("""Enter a string """).strip()

  a_								=       is_isogram(input_str)
  print(f"{input_str} is {'an' if isogram else 'not an'} isogram.")






