





'''simple docstring'''

import numpy as np





def lowerCamelCase						(     __lowerCamelCase :    np.ndarray					,       __lowerCamelCase :    np.ndarray					,       __lowerCamelCase :    float = 1e-1_2					,       __lowerCamelCase :    int = 100					,       )						->tuple[float, np.ndarray]:
    assert np.shape(__lowerCamelCase    )[0] == np.shape(__lowerCamelCase    )[1]
    # Ensure proper dimensionality.
    assert np.shape(__lowerCamelCase    )[0] == np.shape(__lowerCamelCase    )[0]
    # Ensure inputs are either both complex or both real
    assert np.iscomplexobj(__lowerCamelCase    ) == np.iscomplexobj(__lowerCamelCase    )
    _SCREAMING_SNAKE_CASE									=			np.iscomplexobj(__lowerCamelCase    )
    if is_complex:
        # Ensure complex input_matrix is Hermitian
        assert np.array_equal(__lowerCamelCase					,       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.

    _SCREAMING_SNAKE_CASE									=			False
    _SCREAMING_SNAKE_CASE									=			0
    _SCREAMING_SNAKE_CASE									=			0
    _SCREAMING_SNAKE_CASE									=			1e1_2

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

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

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

        _SCREAMING_SNAKE_CASE									=			lambda_

    if is_complex:
        _SCREAMING_SNAKE_CASE									=			np.real(lambda_    )

    return lambda_, vector





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

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

        # Our implementation.
        _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE									=			power_iteration(__lowerCamelCase					,       __lowerCamelCase    )

        # Numpy implementation.

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


if __name__ == "__main__":
      import doctest

      doctest.testmod()
      test_power_iteration()










'''simple docstring'''

from __future__ import annotations

import math





def lowerCamelCase						(     __lowerCamelCase :    int    )						->list[int]:

    if num <= 0:
        _SCREAMING_SNAKE_CASE									=			F'{num}: Invalid input, please enter a positive integer.'
        raise ValueError(__lowerCamelCase    )

    _SCREAMING_SNAKE_CASE									=			[True] * (num + 1)
    _SCREAMING_SNAKE_CASE									=			[]
    _SCREAMING_SNAKE_CASE									=			2
    _SCREAMING_SNAKE_CASE									=			int(math.sqrt(__lowerCamelCase    )    )

    while start <= end:
        # If start is a prime
        if sieve[start] is True:
            prime.append(__lowerCamelCase    )

            # Set multiples of start be False
            for i in range(start * start					,       num + 1					,       __lowerCamelCase    ):
                if sieve[i] is True:
                    _SCREAMING_SNAKE_CASE									=			False

        start += 1

    for j in range(end + 1					,       num + 1    ):
        if sieve[j] is True:
            prime.append(__lowerCamelCase    )

    return prime


if __name__ == "__main__":
      print(prime_sieve(int(input("""Enter a positive integer: """).strip())))



