import unittest

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

class       snake_case					(      unittest.TestCase						):




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




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				str			=		Vector([1, 2, 3]				)
       self.assertEqual(x.component(0				)     , 1				)
       self.assertEqual(x.component(2				)     , 3				)
       SCREAMING_SNAKE_CASE__				:				int			=		Vector()




  def 	__lowercase(      self     :	Any				)->       None:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				int			=		Vector([0, 0, 0, 0, 0, 1]				)
       self.assertEqual(str(a_				)     , '(0,0,0,0,0,1)'				)




  def 	__lowercase(      self     :	Tuple				)->       None:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				Optional[int]			=		Vector([1, 2, 3, 4]				)
       self.assertEqual(len(a_				)     , 4				)




  def 	__lowercase(      self     :	Dict				)->       None:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				Dict			=		Vector([1, 2]				)
       SCREAMING_SNAKE_CASE__				:				Union[str, Any]			=		Vector([1, 2, 3, 4, 5]				)
       SCREAMING_SNAKE_CASE__				:				int			=		Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]				)
       SCREAMING_SNAKE_CASE__				:				Optional[int]			=		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:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				List[str]			=		Vector([1, 2, 3]				)
       SCREAMING_SNAKE_CASE__				:				Union[str, Any]			=		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     :	Dict				)->       None:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				Any			=		Vector([1, 2, 3]				)
       SCREAMING_SNAKE_CASE__				:				Union[str, Any]			=		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     :	Union[str, Any]				)->       None:




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




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




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




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




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




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




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				Union[str, Any]			=		Vector([1, 2, 3]				)
       SCREAMING_SNAKE_CASE__				:				str			=		Vector([1, 0, 1]				)
       self.assertEqual(str(axpy(2     , a_     , a_				)				)     , '(3,4,7)'				)




  def 	__lowercase(      self     :	int				)->       None:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				Dict			=		Vector([1, 0, 0, 0, 0, 0]				)
       SCREAMING_SNAKE_CASE__				:				List[Any]			=		x.copy()
       self.assertEqual(str(a_				)     , str(a_				)				)




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




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				List[str]			=		Vector([1, 0, 0]				)
       x.change_component(0     , 0				)
       x.change_component(1     , 1				)
       self.assertEqual(str(a_				)     , '(0,1,0)'				)




  def 	__lowercase(      self     :	Tuple				)->       None:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				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(a_				)				)




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




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				str			=		Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     , 3     , 3				)
       SCREAMING_SNAKE_CASE__				:				Dict			=		[[-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 	__lowercase(      self     :	str				)->       None:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				int			=		Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     , 3     , 3				)
       SCREAMING_SNAKE_CASE__				:				Dict			=		[[-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 	__lowercase(      self     :	int				)->       None:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				Tuple			=		Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     , 3     , 3				)
       self.assertEqual(-5     , a.determinant()				)




  def 	__lowercase(      self     :	int				)->       None:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				int			=		Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]     , 3     , 3				)
       SCREAMING_SNAKE_CASE__				:				Tuple			=		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     :	int				)->       None:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				Any			=		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 	__lowercase(      self     :	Optional[Any]				)->       None:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				Any			=		Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     , 3     , 3				)
       self.assertEqual(7     , a.component(2     , 1				)     , 0.01				)




  def 	__lowercase(      self     :	Tuple				)->       None:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				Dict			=		Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     , 3     , 3				)
       SCREAMING_SNAKE_CASE__				:				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     :	Optional[Any]				)->       None:




       """simple docstring"""
       SCREAMING_SNAKE_CASE__				:				Optional[Any]			=		Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]     , 3     , 3				)
       SCREAMING_SNAKE_CASE__				:				Dict			=		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     :	List[str]				)->       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()




def     _a				(      lowercase__  :			int = 1_00_00_00 ):







     '''simple docstring'''


     SCREAMING_SNAKE_CASE__				:				str			=		[i - 1 for i in range(limit + 1 )]

     for i in range(2     ,  limit + 1 ):
          if phi[i] == i - 1:
               for j in range(2 * i     ,  limit + 1     ,  lowercase__ ):
                    phi[j] -= phi[j] // i

     return sum(phi[2 : limit + 1] )


if __name__ == "__main__":
      print(solution())



