






import numpy as np

def   __lowercase       (			snake_case,	snake_case,	snake_case = 1E-1_2,	snake_case = 1_0_0,	):







				"""simple docstring"""






				assert np.shape(snake_case			)[0] == np.shape(snake_case			)[1]
				# Ensure proper dimensionality.
				assert np.shape(snake_case			)[0] == np.shape(snake_case			)[0]
				# Ensure inputs are either both complex or both real
				assert np.iscomplexobj(snake_case			) == np.iscomplexobj(snake_case			)
				__magic_name__		:List[str]   =   np.iscomplexobj(snake_case			)
				if is_complex:
								# Ensure complex input_matrix is Hermitian
								assert np.array_equal(snake_case,	input_matrix.conj().T			)

				# Set convergence to False. Will define convergence when we exceed max_iterations
				# or when we have small changes from one iteration to next.

				__magic_name__		:Any   =   False
				__magic_name__		:List[Any]   =   0
				__magic_name__		:str   =   0
				__magic_name__		:Any   =   1E1_2

				while not convergence:
								# Multiple matrix by the vector.
								__magic_name__		:Optional[Any]   =   np.dot(snake_case,	snake_case			)
								# Normalize the resulting output vector.
								__magic_name__		:str   =   w / np.linalg.norm(snake_case			)
								# Find rayleigh quotient
								# (faster than usual b/c we know vector is normalized already)
								__magic_name__		:str   =   vector.conj().T if is_complex else vector.T
								__magic_name__		:str   =   np.dot(snake_case,	np.dot(snake_case,	snake_case			)			)

								# Check convergence.
								__magic_name__		:str   =   np.abs(lambda_ - lambda_previous			) / lambda_
								iterations += 1

								if error <= error_tol or iterations >= max_iterations:
												__magic_name__		:Any   =   True

								__magic_name__		:Optional[int]   =   lambda_

				if is_complex:
								__magic_name__		:str   =   np.real(lambda_			)

				return lambda_, vector

def   __lowercase       (			):







				"""simple docstring"""






				__magic_name__		:str   =   np.array([[4_1, 4, 2_0], [4, 2_6, 3_0], [2_0, 3_0, 5_0]]			)
				__magic_name__		:Optional[int]   =   np.array([4_1, 4, 2_0]			)
				__magic_name__		:str   =   real_input_matrix.astype(np.complexaaa			)
				__magic_name__		:int   =   np.triu(1j * complex_input_matrix,	1			)
				complex_input_matrix += imag_matrix
				complex_input_matrix += -1 * imag_matrix.T
				__magic_name__		:Optional[Any]   =   np.array([4_1, 4, 2_0]			).astype(np.complexaaa			)

				for problem_type in ["real", "complex"]:
								if problem_type == "real":
												__magic_name__		:Tuple   =   real_input_matrix
												__magic_name__		:List[str]   =   real_vector
								elif problem_type == "complex":
												__magic_name__		:Dict   =   complex_input_matrix
												__magic_name__		:Tuple   =   complex_vector

								# Our implementation.
								__magic_name__  ,					__magic_name__		:Optional[Any]   =   power_iteration(snake_case,	snake_case			)

								# Numpy implementation.

								# Get eigenvalues and eigenvectors using built-in numpy
								# eigh (eigh used for symmetric or hermetian matrices).
								__magic_name__  ,					__magic_name__		:Any   =   np.linalg.eigh(snake_case			)
								# Last eigenvalue is the maximum one.
								__magic_name__		:Dict   =   eigen_values[-1]
								# Last column in this matrix is eigenvector corresponding to largest eigenvalue.
								__magic_name__		:List[str]   =   eigen_vectors[:, -1]

								# Check our implementation and numpy gives close answers.
								assert np.abs(eigen_value - eigen_value_max			) <= 1E-6
								# Take absolute values element wise of each eigenvector.
								# as they are only unique to a minus sign.
								assert np.linalg.norm(np.abs(snake_case			) - np.abs(snake_case			)			) <= 1E-6


if __name__ == "__main__":
					import doctest

					doctest.testmod()
					test_power_iteration()














import sys

SCREAMING_SNAKE_CASE__   :      Optional[Any]				=		(
    """73167176531330624919225119674426574742355349194934"""
    """96983520312774506326239578318016984801869478851843"""
    """85861560789112949495459501737958331952853208805511"""
    """12540698747158523863050715693290963295227443043557"""
    """66896648950445244523161731856403098711121722383113"""
    """62229893423380308135336276614282806444486645238749"""
    """30358907296290491560440772390713810515859307960866"""
    """70172427121883998797908792274921901699720888093776"""
    """65727333001053367881220235421809751254540594752243"""
    """52584907711670556013604839586446706324415722155397"""
    """53697817977846174064955149290862569321978468622482"""
    """83972241375657056057490261407972968652414535100474"""
    """82166370484403199890008895243450658541227588666881"""
    """16427171479924442928230863465674813919123162824586"""
    """17866458359124566529476545682848912883142607690042"""
    """24219022671055626321111109370544217506941658960408"""
    """07198403850962455444362981230987879927244284909188"""
    """84580156166097919133875499200524063689912560717606"""
    """05886116467109405077541002256983155200055935729725"""
    """71636269561882670428252483600823257530420752963450"""
)

def   __lowercase       (			snake_case = N			):







				"""simple docstring"""






				__magic_name__		:Optional[int]   =   -sys.maxsize - 1
				for i in range(len(snake_case			) - 1_2			):
								__magic_name__		:List[Any]   =   1
								for j in range(1_3			):
												product *= int(n[i + j]			)
								if product > largest_product:
												__magic_name__		:str   =   product
				return largest_product


if __name__ == "__main__":
					print(f"{solution() = }")






