





'''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   UpperCamelCase__   (  self     :					Union[str, Any]					):
								_a								= Vector([1, 2, 3]					)
								self.assertEqual(x.component(0					)					,				1					)
								self.assertEqual(x.component(2					)					,				3					)
								_a								= Vector()




				def   UpperCamelCase__   (  self     :					str					):
								_a								= Vector([0, 0, 0, 0, 0, 1]					)
								self.assertEqual(str(A_					)					,				"(0,0,0,0,0,1)"					)




				def   UpperCamelCase__   (  self     :					Optional[Any]					):
								_a								= Vector([1, 2, 3, 4]					)
								self.assertEqual(len(A_					)					,				4					)




				def   UpperCamelCase__   (  self     :					Union[str, Any]					):
								_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   UpperCamelCase__   (  self     :					List[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   UpperCamelCase__   (  self     :					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   UpperCamelCase__   (  self     :					int					):
								_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   UpperCamelCase__   (  self     :					Optional[Any]					):
								self.assertEqual(str(zero_vector(10					)					).count("0"					)					,				10					)




				def   UpperCamelCase__   (  self     :					Optional[int]					):
								self.assertEqual(str(unit_basis_vector(3					,				1					)					)					,				"(0,1,0)"					)




				def   UpperCamelCase__   (  self     :					List[Any]					):
								_a								= Vector([1, 2, 3]					)
								_a								= Vector([1, 0, 1]					)
								self.assertEqual(str(axpy(2					,				A_					,				A_					)					)					,				"(3,4,7)"					)




				def   UpperCamelCase__   (  self     :					Optional[Any]					):
								_a								= Vector([1, 0, 0, 0, 0, 0]					)
								_a								= x.copy()
								self.assertEqual(str(A_					)					,				str(A_					)					)




				def   UpperCamelCase__   (  self     :					Any					):
								_a								= Vector([1, 0, 0]					)
								x.change_component(0					,				0					)
								x.change_component(1					,				1					)
								self.assertEqual(str(A_					)					,				"(0,1,0)"					)




				def   UpperCamelCase__   (  self     :					Dict					):
								_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(A_					)					)




				def   UpperCamelCase__   (  self     :					Optional[int]					):
								_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(A_					,				A_					)					)




				def   UpperCamelCase__   (  self     :					Optional[Any]					):
								_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(A_					,				A_					)					)




				def   UpperCamelCase__   (  self     :					Optional[int]					):
								_a								= Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]					,				3					,				3					)
								self.assertEqual(-5					,				a.determinant()					)




				def   UpperCamelCase__   (  self     :					str					):
								_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   UpperCamelCase__   (  self     :					List[Any]					):
								_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(A_					)					)




				def   UpperCamelCase__   (  self     :					Union[str, Any]					):
								_a								= Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]					,				3					,				3					)
								self.assertEqual(7					,				a.component(2					,				1					)					,				0.01					)




				def   UpperCamelCase__   (  self     :					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   UpperCamelCase__   (  self     :					List[str]					):
								_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   UpperCamelCase__   (  self     :					List[Any]					):
								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 		_lowercase (     lowercase__						):
      if not all(x.isalpha() for x in string						):
            raise ValueError('''String must only contain alphabetic characters.'''						)

      __lowerCAmelCase					:						int					=					sorted(string.lower()						)
      return len(lowercase__						) == len(set(lowercase__						)						)


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

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


