
"""simple docstring"""





import unittest

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


class A_	(unittest.TestCase      ):




  '''simple docstring'''







  def        UpperCamelCase__					(		self  ):

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







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Any			     =    Vector([0, 0, 0, 0, 0, 1]  )
     self.assertEqual(str(lowercase_  )				,   "(0,0,0,0,0,1)"  )







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Optional[Any]			     =    Vector([1, 2, 3, 4]  )
     self.assertEqual(len(lowercase_  )				,   4  )







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Any			     =    Vector([1, 2]  )
     UpperCAmelCase_					:					Union[str, Any]			     =    Vector([1, 2, 3, 4, 5]  )
     UpperCAmelCase_					:					str			     =    Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]  )
     UpperCAmelCase_					:					Optional[Any]			     =    Vector([1, -1, 1, -1, 2, -3, 4, -5]  )
     self.assertAlmostEqual(x.euclidean_length()				,   2.2_36				,   3  )
     self.assertAlmostEqual(y.euclidean_length()				,   7.4_16				,   3  )
     self.assertEqual(z.euclidean_length()				,   0  )
     self.assertAlmostEqual(w.euclidean_length()				,   7.6_16				,   3  )







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Optional[Any]			     =    Vector([1, 2, 3]  )
     UpperCAmelCase_					:					Tuple			     =    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  ):

     """simple docstring"""
     UpperCAmelCase_					:					List[str]			     =    Vector([1, 2, 3]  )
     UpperCAmelCase_					:					List[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        UpperCamelCase__					(		self  ):

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







  def        UpperCamelCase__					(		self  ):

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







  def        UpperCamelCase__					(		self  ):

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







  def        UpperCamelCase__					(		self  ):

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







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Dict			     =    Vector([1, 0, 0, 0, 0, 0]  )
     UpperCAmelCase_					:					Optional[Any]			     =    x.copy()
     self.assertEqual(str(lowercase_  )				,   str(lowercase_  )  )







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Optional[int]			     =    Vector([1, 0, 0]  )
     x.change_component(0				,   0  )
     x.change_component(1				,   1  )
     self.assertEqual(str(lowercase_  )				,   "(0,1,0)"  )







  def        UpperCamelCase__					(		self  ):

     """simple docstring"""
     UpperCAmelCase_					:					Union[str, Any]			     =    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(lowercase_  )  )







  def        UpperCamelCase__					(		self  ):

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







  def        UpperCamelCase__					(		self  ):

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







  def        UpperCamelCase__					(		self  ):

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







  def        UpperCamelCase__					(		self  ):

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

     """simple docstring"""
     UpperCAmelCase_					:					str			     =    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(lowercase_  )  )







  def        UpperCamelCase__					(		self  ):

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







  def        UpperCamelCase__					(		self  ):

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

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

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









'''simple docstring'''




from sympy import diff, lambdify, symbols
from sympy.functions import *  # noqa: F403






def        _lowerCAmelCase			(  __snake_case  : str ,							__snake_case  : complex ,							__snake_case  : str = "x" ,							__snake_case  : float = 10**-10 ,							__snake_case  : int = 1 ,							)     ->     complex:
     __A						: int      =       symbols(__snake_case			)
     __A						: Tuple      =       lambdify(__snake_case ,							__snake_case			)
     __A						: Any      =       lambdify(__snake_case ,							diff(__snake_case ,							__snake_case			)			)

     __A						: str      =       starting_point

     while True:
          if diff_function(__snake_case			) != 0:
               __A						: Optional[Any]      =       prev_guess - multiplicity * func(__snake_case			) / diff_function(
                   __snake_case			)
          else:
               raise ZeroDivisionError('Could not find root'			) from None

          # Precision is checked by comparing the difference of consecutive guesses
          if abs(next_guess - prev_guess			) < precision:
               return next_guess

          __A						: Dict      =       next_guess


# Let's Execute
if __name__ == "__main__":
  # Find root of trigonometric function
  # Find value of pi
  print(f"""The root of sin(x) = 0 is {newton_raphson("sin(x)", 2)}""")

  # Find root of polynomial
  # Find fourth Root of 5
  print(f"""The root of x**4 - 5 = 0 is {newton_raphson("x**4 -5", 0.4 +5j)}""")

  # Find value of e
  print(
      '''The root of log(y) - 1 = 0 is ''',
      f"""{newton_raphson("log(y) - 1", 2, variable="y")}""",
  )

  # Exponential Roots
  print(
      '''The root of exp(x) - 1 = 0 is''',
      f"""{newton_raphson("exp(x) - 1", 10, precision=0.005)}""",
  )

  # Find root of cos(x)
  print(f"""The root of cos(x) = 0 is {newton_raphson("cos(x)", 0)}""")