






"""simple docstring"""





import unittest

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



class       __A		(   unittest.TestCase			):

					def   lowerCamelCase__   (			self  :      Dict					)			->							None:
											__magic_name__:	Any							=       Vector([1, 2, 3]					)
											self.assertEqual(x.component(0					)     ,		1					)
											self.assertEqual(x.component(2					)     ,		3					)
											__magic_name__:	Optional[Any]							=       Vector()

					def   lowerCamelCase__   (			self  :      Optional[Any]					)			->							None:
											__magic_name__:	Dict							=       Vector([0, 0, 0, 0, 0, 1]					)
											self.assertEqual(str(__snake_case					)     ,		"""(0,0,0,0,0,1)"""					)

					def   lowerCamelCase__   (			self  :      Union[str, Any]					)			->							None:
											__magic_name__:	Optional[Any]							=       Vector([1, 2, 3, 4]					)
											self.assertEqual(len(__snake_case					)     ,		4					)

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

					def   lowerCamelCase__   (			self  :      Optional[int]					)			->							None:
											self.assertEqual(str(zero_vector(1_0					)					).count("""0"""					)     ,		1_0					)

					def   lowerCamelCase__   (			self  :      List[str]					)			->							None:
											self.assertEqual(str(unit_basis_vector(3     ,		1					)					)     ,		"""(0,1,0)"""					)

					def   lowerCamelCase__   (			self  :      Tuple					)			->							None:
											__magic_name__:	int							=       Vector([1, 2, 3]					)
											__magic_name__:	Union[str, Any]							=       Vector([1, 0, 1]					)
											self.assertEqual(str(axpy(2     ,		__snake_case     ,		__snake_case					)					)     ,		"""(3,4,7)"""					)

					def   lowerCamelCase__   (			self  :      Optional[int]					)			->							None:
											__magic_name__:	List[Any]							=       Vector([1, 0, 0, 0, 0, 0]					)
											__magic_name__:	Optional[Any]							=       x.copy()
											self.assertEqual(str(__snake_case					)     ,		str(__snake_case					)					)

					def   lowerCamelCase__   (			self  :      str					)			->							None:
											__magic_name__:	Any							=       Vector([1, 0, 0]					)
											x.change_component(0     ,		0					)
											x.change_component(1     ,		1					)
											self.assertEqual(str(__snake_case					)     ,		"""(0,1,0)"""					)

					def   lowerCamelCase__   (			self  :      Optional[Any]					)			->							None:
											__magic_name__:	str							=       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(__snake_case					)					)

					def   lowerCamelCase__   (			self  :      Union[str, Any]					)			->							None:
											__magic_name__:	List[str]							=       Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     ,		3     ,		3					)
											__magic_name__:	str							=       [[-3, -1_4, -1_0], [-5, -1_0, -5], [-2, -1, 0]]
											for x in range(a.height()					):
																	for y in range(a.width()					):
																							self.assertEqual(minors[x][y]     ,		a.minor(__snake_case     ,		__snake_case					)					)

					def   lowerCamelCase__   (			self  :      Optional[int]					)			->							None:
											__magic_name__:	str							=       Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     ,		3     ,		3					)
											__magic_name__:	int							=       [[-3, 1_4, -1_0], [5, -1_0, 5], [-2, 1, 0]]
											for x in range(a.height()					):
																	for y in range(a.width()					):
																							self.assertEqual(cofactors[x][y]     ,		a.cofactor(__snake_case     ,		__snake_case					)					)

					def   lowerCamelCase__   (			self  :      Dict					)			->							None:
											__magic_name__:	Optional[Any]							=       Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     ,		3     ,		3					)
											self.assertEqual(-5     ,		a.determinant()					)

					def   lowerCamelCase__   (			self  :      Tuple					)			->							None:
											__magic_name__:	List[str]							=       Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]     ,		3     ,		3					)
											__magic_name__:	List[Any]							=       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  :      Any					)			->							None:
											__magic_name__:	Optional[int]							=       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(__snake_case					)					)

					def   lowerCamelCase__   (			self  :      Optional[Any]					)			->							None:
											__magic_name__:	List[Any]							=       Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     ,		3     ,		3					)
											self.assertEqual(7     ,		a.component(2     ,		1					)     ,		0.01					)

					def   lowerCamelCase__   (			self  :      List[str]					)			->							None:
											__magic_name__:	int							=       Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     ,		3     ,		3					)
											__magic_name__:	List[str]							=       Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 1_0]]     ,		3     ,		3					)
											self.assertEqual("""|2,4,10|\n|4,8,10|\n|12,14,18|\n"""     ,		str(a + b					)					)

					def   lowerCamelCase__   (			self  :      Dict					)			->							None:
											__magic_name__:	Any							=       Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     ,		3     ,		3					)
											__magic_name__:	Optional[Any]							=       Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 1_0]]     ,		3     ,		3					)
											self.assertEqual("""|0,0,-4|\n|0,0,0|\n|0,0,-2|\n"""     ,		str(a - b					)					)






					def   lowerCamelCase__   (			self  :      List[Any]					)			->							None:
											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.")






