


'''simple docstring'''






import unittest

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






class        __snake_case	(       unittest.TestCase):







				"""simple docstring"""



				def __lowercase       (       self   :  Optional[int]		)       ->  None:
						lowerCAmelCase_      :				Tuple      =       Vector([1, 2, 3]		)
						self.assertEqual(x.component(0		)   ,						1		)
						self.assertEqual(x.component(2		)   ,						3		)
						lowerCAmelCase_      :				Tuple      =       Vector()

				def __lowercase       (       self   :  Any		)       ->  None:
						lowerCAmelCase_      :				Dict      =       Vector([0, 0, 0, 0, 0, 1]		)
						self.assertEqual(str(lowerCamelCase		)   ,						"""(0,0,0,0,0,1)"""		)

				def __lowercase       (       self   :  List[Any]		)       ->  None:
						lowerCAmelCase_      :				Union[str, Any]      =       Vector([1, 2, 3, 4]		)
						self.assertEqual(len(lowerCamelCase		)   ,						4		)

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

				def __lowercase       (       self   :  Union[str, Any]		)       ->  None:
						self.assertEqual(str(zero_vector(10		)		).count("""0"""		)   ,						10		)

				def __lowercase       (       self   :  Dict		)       ->  None:
						self.assertEqual(str(unit_basis_vector(3   ,						1		)		)   ,						"""(0,1,0)"""		)

				def __lowercase       (       self   :  Optional[int]		)       ->  None:
						lowerCAmelCase_      :				int      =       Vector([1, 2, 3]		)
						lowerCAmelCase_      :				List[str]      =       Vector([1, 0, 1]		)
						self.assertEqual(str(axpy(2   ,						lowerCamelCase   ,						lowerCamelCase		)		)   ,						"""(3,4,7)"""		)

				def __lowercase       (       self   :  str		)       ->  None:
						lowerCAmelCase_      :				List[Any]      =       Vector([1, 0, 0, 0, 0, 0]		)
						lowerCAmelCase_      :				int      =       x.copy()
						self.assertEqual(str(lowerCamelCase		)   ,						str(lowerCamelCase		)		)

				def __lowercase       (       self   :  Optional[int]		)       ->  None:
						lowerCAmelCase_      :				Dict      =       Vector([1, 0, 0]		)
						x.change_component(0   ,						0		)
						x.change_component(1   ,						1		)
						self.assertEqual(str(lowerCamelCase		)   ,						"""(0,1,0)"""		)

				def __lowercase       (       self   :  List[Any]		)       ->  None:
						lowerCAmelCase_      :				Dict      =       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 __lowercase       (       self   :  Dict		)       ->  None:
						lowerCAmelCase_      :				List[str]      =       Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,						3   ,						3		)
						lowerCAmelCase_      :				Tuple      =       [[-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 __lowercase       (       self   :  List[Any]		)       ->  None:
						lowerCAmelCase_      :				Optional[Any]      =       Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,						3   ,						3		)
						lowerCAmelCase_      :				List[Any]      =       [[-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 __lowercase       (       self   :  Any		)       ->  None:
						lowerCAmelCase_      :				List[str]      =       Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,						3   ,						3		)
						self.assertEqual(-5   ,						a.determinant()		)

				def __lowercase       (       self   :  Union[str, Any]		)       ->  None:
						lowerCAmelCase_      :				Optional[int]      =       Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]   ,						3   ,						3		)
						lowerCAmelCase_      :				List[str]      =       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 __lowercase       (       self   :  Dict		)       ->  None:
						lowerCAmelCase_      :				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(lowerCamelCase		)		)

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

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







'''simple docstring'''






from __future__ import annotations







def     UpperCamelCase_      (   A__ :       int | float | str							,   A__ :       int | float | str ):
  '''simple docstring'''





  if nth_term == "":
    return [""]
  lowerCAmelCase_      :				str      =       int(A__ )
  lowerCAmelCase_      :				Tuple      =       int(A__ )
  lowerCAmelCase_      :				list[str]      =       []
  for temp in range(int(A__ ) ):
    series.append(f'1 / {pow(temp + 1							,   int(A__ ) )}' if series else """1""" )
  return series


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  __A :  str    							=				int(input("Enter the last number (nth term) of the P-Series"))
  __A :  Tuple    							=				int(input("Enter the power for  P-Series"))
  print("Formula of P-Series => 1+1/2^p+1/3^p ..... 1/n^p")
  print(p_series(nth_term, power))



