




import numpy as np







def 	_a      (						SCREAMING_SNAKE_CASE_							:				np.ndarray      ,      SCREAMING_SNAKE_CASE_							:				np.ndarray      ,      SCREAMING_SNAKE_CASE_							:				float = 1E-12      ,      SCREAMING_SNAKE_CASE_							:				int = 1_00      ,      ):
					assert np.shape(SCREAMING_SNAKE_CASE_     )[0] == np.shape(SCREAMING_SNAKE_CASE_     )[1]
					# Ensure proper dimensionality.
					assert np.shape(SCREAMING_SNAKE_CASE_     )[0] == np.shape(SCREAMING_SNAKE_CASE_     )[0]
					# Ensure inputs are either both complex or both real
					assert np.iscomplexobj(SCREAMING_SNAKE_CASE_     ) == np.iscomplexobj(SCREAMING_SNAKE_CASE_     )
					__lowerCAmelCase				   =       np.iscomplexobj(SCREAMING_SNAKE_CASE_     )
					if is_complex:
										# Ensure complex input_matrix is Hermitian
										assert np.array_equal(SCREAMING_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.

					__lowerCAmelCase				   =       False
					__lowerCAmelCase				   =       0
					__lowerCAmelCase				   =       0
					__lowerCAmelCase				   =       1E12

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

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

										if error <= error_tol or iterations >= max_iterations:
															__lowerCAmelCase				   =       True

										__lowerCAmelCase				   =       lambda_

					if is_complex:
										__lowerCAmelCase				   =       np.real(lambda_     )

					return lambda_, vector







def 	_a      (						):
					__lowerCAmelCase				   =       np.array([[41, 4, 20], [4, 26, 30], [20, 30, 50]]     )
					__lowerCAmelCase				   =       np.array([41, 4, 20]     )
					__lowerCAmelCase				   =       real_input_matrix.astype(np.complexaaa     )
					__lowerCAmelCase				   =       np.triu(1j * complex_input_matrix      ,      1     )
					complex_input_matrix += imag_matrix
					complex_input_matrix += -1 * imag_matrix.T
					__lowerCAmelCase				   =       np.array([41, 4, 20]     ).astype(np.complexaaa     )

					for problem_type in ["real", "complex"]:
										if problem_type == "real":
															__lowerCAmelCase				   =       real_input_matrix
															__lowerCAmelCase				   =       real_vector
										elif problem_type == "complex":
															__lowerCAmelCase				   =       complex_input_matrix
															__lowerCAmelCase				   =       complex_vector

										# Our implementation.
										__lowerCAmelCase   ,							__lowerCAmelCase				   =       power_iteration(SCREAMING_SNAKE_CASE_      ,      SCREAMING_SNAKE_CASE_     )

										# Numpy implementation.

										# Get eigenvalues and eigenvectors using built-in numpy
										# eigh (eigh used for symmetric or hermetian matrices).
										__lowerCAmelCase   ,							__lowerCAmelCase				   =       np.linalg.eigh(SCREAMING_SNAKE_CASE_     )
										# Last eigenvalue is the maximum one.
										__lowerCAmelCase				   =       eigen_values[-1]
										# Last column in this matrix is eigenvector corresponding to largest eigenvalue.
										__lowerCAmelCase				   =       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(SCREAMING_SNAKE_CASE_     ) - np.abs(SCREAMING_SNAKE_CASE_     )     ) <= 1E-6


if __name__ == "__main__":
					import doctest

					doctest.testmod()
					test_power_iteration()










def 	_a      (						SCREAMING_SNAKE_CASE_							:				int = 1_00_00_00     ):
					__lowerCAmelCase				   =       [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      ,      SCREAMING_SNAKE_CASE_     ):
																				phi[j] -= phi[j] // i

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


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




