openum 0.9.5__py3-none-any.whl

openum/BVP.py

@@ -0,0 +1,112 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from ODE import runge_kutta
+from NonLinEq import linear_interpolation
+from typing import Callable
+
+def Matrix(h: float, n: int) -> np.ndarray:
+    """
+    Constructs a tridiagonal matrix for the finite difference method.
+    
+    Args:
+        h (float): Step size.
+        n (int): Number of unknowns.
+    
+    Returns:
+        np.ndarray: Tridiagonal matrix of size (n, n).
+    """
+    diag_main = -(2 + 2 * h**2) * np.ones(n)
+    diag_upper = np.ones(n - 1)
+    diag_lower = np.ones(n - 1)
+    A = np.diag(diag_main) + np.diag(diag_upper, 1) + np.diag(diag_lower, -1)
+    return A
+
+def Vector(n: int, y0: float, yn: float) -> np.ndarray:
+    """
+    Constructs the right-hand side vector for the finite difference method.
+    
+    Args:
+        n (int): Number of unknowns.
+        y0 (float): Boundary condition at x0.
+        yn (float): Boundary condition at xn.
+    
+    Returns:
+        np.ndarray: Right-hand side vector.
+    """
+    b = np.zeros(n)
+    b[0] -= y0
+    b[-1] -= yn
+    return b
+
+def Matrix_method(x0: float, xn: float, n: int, y0: float, yn: float) -> np.ndarray:
+    """
+    Solves a boundary value problem using the finite difference method.
+    
+    Args:
+        x0 (float): Left boundary of the domain.
+        xn (float): Right boundary of the domain.
+        n (int): Number of interior grid points.
+        y0 (float): Boundary condition at x0.
+        yn (float): Boundary condition at xn.
+    
+    Returns:
+        np.ndarray: Solution values at the grid points.
+    """
+    h = (xn - x0) / (n + 1)
+    list_x = np.linspace(x0, xn, n + 2)
+    list_y = np.zeros(n + 2)
+    list_y[0] = y0
+    list_y[-1] = yn
+
+    A = Matrix(h, n)
+    b = Vector(n, y0, yn)
+    y = np.linalg.solve(A, b)
+
+    for i in range(1, n + 1):
+        list_y[i] = y[i - 1]
+
+    # Plot solution
+    plt.figure(figsize=(8, 6))
+    plt.plot(list_x, list_y, color='b', label='Numerical Solution')
+    plt.xlabel('x')
+    plt.ylabel('y')
+    plt.grid(True)
+    plt.legend()
+    plt.show()
+    
+    return y
+
+def solve_by_shooting(ode: Callable, x_1: float, x_2: float, n: int, v_0: list, u_1: float, u_2: float, max_iter: int) -> tuple[float, np.ndarray, np.ndarray]:
+    """
+    Solves a boundary value problem using the shooting method.
+    
+    Args:
+        ode (callable): Function defining the ODE system.
+        x_1 (float): Left boundary of the domain.
+        x_2 (float): Right boundary of the domain.
+        n (int): Number of interior grid points.
+        v_0 (list): Initial guesses for the derivative at x_1.
+        u_1 (float): Boundary condition at x_1.
+        u_2 (float): Boundary condition at x_2.
+        max_iter (int): Maximum number of iterations for root finding.
+    
+    Returns:
+        tuple: (Corrected initial derivative, solution grid points, solution values)
+    """
+    def difference(v):
+        y_0 = [u_1, v]
+        _, y_values = runge_kutta(x_1, x_2, y_0, n, ode, False)
+        return y_values[-1, 0] - u_2
+
+    # Debug: Check function values at initial guesses
+    print(f"difference({v_0[0]}) = {difference(v_0[0])}")
+    print(f"difference({v_0[1]}) = {difference(v_0[1])}")
+
+    v_corr = linear_interpolation(difference, v_0[0], v_0[1], max_iter)
+
+    if v_corr is None:
+        raise RuntimeError("Root finding failed.")
+
+    y_0 = [u_1, v_corr]
+    x, y = runge_kutta(x_1, x_2, y_0, n, ode, False)
+    return v_corr, x, y

openum/Errorcalc.py

@@ -0,0 +1,64 @@
+import numint, numdiff
+from typing import Callable
+
+class IntegrationandDiffMethodError:
+    def __init__(self, method, a: float, b: float, func:Callable):
+        """
+        Initialisiert die Integrationsmethode.
+
+        Args:
+            method (function): Die Integrationsmethode (z. B. Newton_cotes oder Trapezoidal)
+            a (float): Untere Grenze des Integrals
+            b (float): Obere Grenze des Integrals
+            func (function): Funktion, die integriert werden soll
+        """
+        self.method = method
+        self.n = 1000  # Standardanzahl der Unterintervalle
+        self.a = a
+        self.b = b
+        self.func = func
+        self.exact = None
+
+    def calculate_exact(self):
+        """
+        Führt die numerische Integration durch und speichert das Ergebnis.
+
+        Returns:
+            float: Das Ergebnis der numerischen Integration
+        """
+        self.exact = self.method(self.n, self.a, self.b, self.func)
+        return self.exact
+
+    def calculate_error(self, approx_value: float) -> float:
+        """
+        Berechnet den Fehler der numerischen Integration, falls der exakte Wert bekannt ist.
+
+        Args:
+            approx_value (float): Der approximierte Wert des Integrals
+
+        Returns:
+            float: Der Fehler der numerischen Integration
+        """
+        if self.exact is None:
+            self.calculate_exact()
+        return abs(approx_value - self.exact)
+
+
+def error(method, a: float, b: float, func:Callable, approx_result: float) -> float:
+    """
+    Berechnet den Fehler der numerischen Integration.
+
+    Args:
+        method: Methode, die für die Berechnung des approximierten Werts verwendet wird
+        a (float): Untere Grenze des Integrals
+        b (float): Obere Grenze des Integrals
+        func: Funktion, die integriert werden muss
+        approx_result (float): Der approximierte Wert des Integrals
+    
+    Returns:
+        error (float): Fehler der numerischen Integration
+    """
+    err_func = IntegrationandDiffMethodError(method, a, b, func)
+    exact_value = err_func.calculate_exact()  # Calculate exact value
+    error_value = err_func.calculate_error(approx_result)  # Calculate the error
+    return error_value

openum/Interpolation.py

@@ -0,0 +1,68 @@
+import numpy as np
+from typing import Callable, Optional
+
+def h(i, x):
+    return x[i + 1] - x[i]  # Schrittweite zwischen den Punkten
+
+def cubic_splines(n: int, x: np.ndarray, func: Callable) -> tuple[Optional[np.ndarray], Optional[np.ndarray], Optional[np.ndarray]]:
+    """
+    Constructs cubic splines for interpolation.
+
+    Args:
+        n (int): Number of intervals (len(x) - 1).
+        x (np.ndarray): Array of grid points.
+        func (Callable): Function to evaluate at grid points.
+
+    Returns:
+        tuple: A tuple containing (matrix, vec, solution), where 'matrix' is the 
+               coefficient matrix, 'vec' is the right-hand side vector, and 'solution' 
+               is the array of approximated spline second derivatives. Returns None 
+               for elements if the calculation fails.
+    """
+    values = func(x)
+    if n < 2:
+        print("Nicht genügend Punkte für Splines")
+        return None, None, None
+    
+    matrix = np.zeros((n - 1, n - 1), dtype=float)
+    vec = np.zeros(n - 1, dtype=float)
+
+    # Anfangsbedingungen
+    matrix[0, 0] = (h(0, x) + h(1, x)) * (h(0, x) + 2 * h(1, x)) / h(1, x)
+    if n > 2:
+        matrix[0, 1] = (h(1, x) ** 2 - h(0, x) ** 2) / h(1, x)
+    
+    vec[0] = (values[2] - values[1]) / h(1, x) - (values[1] - values[0]) / h(0, x)
+
+    # Für den Rest der Matrix
+    for i in range(1, n - 2):
+        matrix[i, i - 1] = h(i, x)
+        matrix[i, i] = 2 * (h(i, x) + h(i + 1, x))
+        matrix[i, i + 1] = h(i + 1, x)
+        vec[i] = (values[i + 2] - values[i + 1]) / h(i + 1, x) - (values[i + 1] - values[i]) / h(i, x)
+
+    # Endbedingungen
+    if n > 2:
+        matrix[n - 2, n - 3] = (h(n - 3, x) ** 2 - h(n - 2, x) ** 2) / h(n - 3, x)
+        matrix[n - 2, n - 2] = (h(n - 2, x) + h(n - 1, x)) * (h(n - 2, x) + 2 * h(n - 1, x)) / h(n - 1, x)
+    
+    vec[n - 2] = (values[n] - values[n - 1]) / h(n - 1, x) - (values[n - 1] - values[n - 2]) / h(n - 2, x)
+    vec *= 6
+
+    # Konditionierung der Matrix überprüfen
+    if np.linalg.cond(matrix) > 1e12:
+        print("Matrix ist schlecht konditioniert, Lösung könnte ungenau sein.")
+        return matrix, vec, None
+    
+    try:
+        # Lösung des linearen Systems
+        solution = np.linalg.solve(matrix, vec)
+        S_0 = ((h(0, x) + h(1, x)) * solution[0] - h(0, x) * solution[1]) / h(1, x)
+        S_n = ((h(n - 2, x) + h(n - 1, x)) * solution[n - 2] - h(n - 1, x) * solution[n - 3]) / h(n - 2, x)
+        
+        solution = np.append(solution, S_n)
+        solution = np.insert(solution, 0, S_0)
+        return matrix, vec, solution
+    except np.linalg.LinAlgError:
+        print("Keine Lösung vorhanden")
+        return matrix, vec, None

openum/MC.py

@@ -0,0 +1,61 @@
+import numpy as np
+from typing import Callable
+
+def Monte_Carlo(n: int, a: float, b: float, func: Callable) -> tuple[float, float]:
+    """
+    Calculating the integral of a function via Monte Carlo integration.
+
+    Args:
+        n (int): Number of random samples
+        a (float): Lower bound of the integral
+        b (float): Upper bound of the integral
+        func : Function that needs to be integrated
+    
+    Returns:
+        tuple: (result, error)
+            result (float): Approximated value of the integration
+            error (float): Estimated statistical error (Standard Error of the Mean)
+    """
+    n = int(n)
+    
+    x_random = np.random.uniform(a, b, n)
+    f_values = func(x_random)
+    
+    volume = b - a
+    result = volume * np.mean(f_values)
+    
+    # Statistischer Fehler: Volumen * (Standardabweichung / Wurzel(n))
+    # ddof=1 für die unvezerrte Stichprobenvarianz
+    error = volume * (np.std(f_values, ddof=1) / np.sqrt(n))
+    
+    return result, error
+
+
+def Monte_Carlo_nD(n: int, bounds: list, func: Callable) -> tuple[float, float]:
+    """
+    Calculating the integral of a multi-dimensional function via Monte Carlo integration.
+
+    Args:
+        n (int): Number of random samples
+        bounds (list of tuples): [(lower, upper), ...] for each dimension
+        func : Function to integrate
+    
+    Returns:
+        tuple: (result, error)
+    """
+    n = int(n)
+    dimensions = len(bounds)
+    volume = 1.0
+    random_points = np.zeros((n, dimensions))
+    
+    for d in range(dimensions):
+        a, b = bounds[d]
+        random_points[:, d] = np.random.uniform(a, b, n)
+        volume *= (b - a)
+        
+    f_values = np.array([func(point) for point in random_points])
+    
+    result = volume * np.mean(f_values)
+    error = volume * (np.std(f_values, ddof=1) / np.sqrt(n))
+    
+    return result, error

openum/NonLinEq.py

@@ -0,0 +1,258 @@
+import numpy as np
+from typing import Callable
+
+def newtons_method(f: Callable, df: Callable, x0: float, max_iter: int, epsilon: float=1e-6) -> float:
+    """
+    Find the root of a function using Newton's method.
+
+    Args:
+        f (function): Function for which the root is to be found.
+        df (function): Derivative of the function.
+        x0 (float): Initial guess.
+        max_iter (int): Maximum number of iterations.
+        epsilon (float): Convergence criterion.
+
+    Returns:
+        x (float): Approximation of the root, or None if no convergence.
+    """
+    x = x0
+    for _ in range(max_iter):
+        fx = f(x)
+        dfx = df(x)
+
+        if np.abs(fx) < epsilon:
+            return x
+
+        if dfx == 0:
+            print("Derivative is zero. Cannot proceed.")
+            return None
+
+        x -= fx / dfx
+
+    print("Did not converge.")
+    return None
+
+
+def linear_interpolation(f: Callable, x0: float, x1: float, max_iter: int, epsilon: float=1e-6) -> float:
+    """
+    Find the root of a function using linear interpolation.
+
+    Args:
+        f (function): Function for which the root is to be found.
+        x0 (float): Initial guess.
+        x1 (float): Second guess.
+        max_iter (int): Maximum number of iterations.
+        epsilon (float): Convergence criterion.
+
+    Returns:
+        x2 (float): Approximation of the root, or None if no convergence.
+    """
+    for _ in range(max_iter):
+        f0, f1 = f(x0), f(x1)
+
+        if f1 == f0:  # Prevent division by zero
+            print("Division by zero encountered.")
+            return None
+
+        x2 = x1 - f1 * (x1 - x0) / (f1 - f0)
+
+        if np.abs(x2 - x1) < epsilon:
+            print(f"Root found: {f(x2)}")
+            return x2
+
+        x0, x1 = x1, x2
+
+    print("Did not converge.")
+    return None
+
+
+def solve_fixed_point(f1: Callable, f2: Callable, x_init: float, y_init: float, max_iter: int, tol=1e-8) -> tuple[float,float]:
+    """
+    Solve a system of equations using fixed-point iteration.
+
+    Args:
+        f1 (function): Function for the first equation.
+        f2 (function): Function for the second equation.
+        x_init (float): Initial guess for x.
+        y_init (float): Initial guess for y.
+        max_iter (int): Maximum number of iterations.
+        tol (float): Convergence criterion.
+
+    Returns:
+        tuple: Approximations of the roots (x, y), or (None, None) if no convergence.
+    """
+    x, y = x_init, y_init
+
+    for i in range(max_iter):
+        x_new = f1(y)
+        y_new = f2(x)
+
+        if np.abs(x_new - x) < tol and np.abs(y_new - y) < tol:
+            print(f"Converged in {i + 1} iterations.")
+            return x_new, y_new
+
+        x, y = x_new, y_new
+
+    print("Did not converge.")
+    return None, None
+
+def newton_halley(f: Callable, df: Callable, d2f: Callable, x0: float, max_iter: int, epsilon: float=1e-6) -> float:
+    """
+    Find the root of a function using Newton-Halley method.
+
+    Args:
+        f (function): Function for which the root is to be found.
+        df (function): First derivative of the function.
+        d2f (function): Second derivative of the function.
+        x0 (float): Initial guess.
+        max_iter (int): Maximum number of iterations.
+        epsilon (float): Convergence criterion.
+
+    Returns:
+        x (float): Approximation of the root, or None if no convergence.
+    """
+    x = x0
+    for _ in range(max_iter):
+        fx = f(x)
+        dfx = df(x)
+        d2fx = d2f(x)
+
+        if np.abs(fx) < epsilon:
+            return x
+
+        if dfx == 0:
+            print("Derivative is zero. Cannot proceed.")
+            return None
+
+        x -= (2*fx*dfx)/(2*dfx**2-d2fx*fx)
+
+    print("Did not converge.")
+    return None
+
+
+def bisection_method(x1: float, x2: float, f: Callable, max_iter: int, eps: float=1e-6) -> float:
+    """
+    Solving nonlinear equations with bisection method.
+
+    Args:
+        x1 (float): Lower bound of the interval.
+        x2 (float): Upper bound of the interval.
+        f (function): Function for which the root is to be found.
+        max_iter (int): Maximum number of iterations.
+        eps (float): Convergence criterion.
+
+    Returns:
+        float: Approximation of the root, or None if no convergence.
+    """
+    x_new = (x1+x2)/2
+    for _ in range(max_iter):
+
+        if f(x_new)*f(x1) < 0:
+            x2 = x_new
+        
+        elif f(x_new)*f(x2) < 0:
+            x1 = x_new
+        
+        x_new = (x1+x2)/2
+
+        if np.abs(f(x_new)) < eps:
+            return x_new
+
+    print("Did not converge.")
+    return None
+
+import numpy as np
+
+def jacobi_method(A: np.ndarray, b: np.ndarray, init_val: list, max_iter: int, tol: float=1e-6) -> np.ndarray:
+    """
+    Solve a linear system using the iterative Jacobi method.
+    
+    In contrast to Gauss-Seidel, the Jacobi method uses only the values 
+    from the previous iteration step to calculate the new approximations.
+
+    Args:
+        A (numpy.ndarray): Coefficient matrix.
+        b (numpy.ndarray): Right-hand side vector.
+        init_val (list): Initial guess for the solution vector x.
+        max_iter (int): Maximum number of iterations.
+        tol (float): Convergence tolerance.
+
+    Returns:
+        numpy.ndarray: Solution vector if convergence is achieved.
+    """
+    rows, cols = A.shape
+    if rows != cols:
+        raise ValueError("Coefficient matrix A must be square.")
+        
+    x_old = np.array(init_val, dtype=float)
+    x_new = np.zeros_like(x_old)
+
+    for iteration in range(max_iter):
+        for i in range(rows):
+            if A[i, i] == 0:
+                raise ValueError("Diagonal element is zero, cannot proceed with Jacobi method.")
+            
+            # Sum over all j != i
+            s = 0.0
+            for j in range(cols):
+                if j != i:
+                    s += A[i, j] * x_old[j]
+            
+            x_new[i] = (b[i] - s) / A[i, i]
+
+        # Check for convergence (using infinity norm)
+        if np.linalg.norm(x_new - x_old, ord=np.inf) < tol:
+            return x_new
+
+        # Update x_old for the next iteration
+        x_old = x_new.copy()
+
+    raise RuntimeError("Jacobi method did not converge within the maximum number of iterations.")
+
+
+def Gauss_elimination_pivoted(matrix: np.ndarray, vector: np.ndarray) -> np.ndarray:
+    """
+    Function for Gaussian elimination using partial pivoting to reduce numerical errors.
+    
+    Swaps rows to ensure the largest absolute value in the current column 
+    becomes the pivot element, minimizing floating-point inaccuracies.
+
+    Args:
+        matrix (numpy.ndarray): Coefficient matrix.
+        vector (numpy.ndarray): Right-hand side vector.
+
+    Returns:
+        x (numpy.ndarray): Solution vector.
+    """
+    U_Matrix = np.copy(matrix).astype(float)
+    U_vector = np.copy(vector).astype(float)
+    rows, columns = U_Matrix.shape
+    x = np.zeros(rows)
+    
+    # Forward elimination with partial pivoting
+    for i in range(rows - 1):
+        # --- NEW: Partial Pivoting ---
+        # Find the row with the largest absolute value in the current column i
+        max_row_index = i + np.argmax(np.abs(U_Matrix[i:rows, i]))
+        
+        if max_row_index != i:
+            # Swap the current row i with the row containing the maximum value
+            U_Matrix[[i, max_row_index]] = U_Matrix[[max_row_index, i]]
+            U_vector[[i, max_row_index]] = U_vector[[max_row_index, i]]
+        # -----------------------------
+            
+        if np.isclose(U_Matrix[i, i], 0):
+            raise ValueError("Matrix is singular or nearly singular.")
+
+        for j in range(i + 1, rows):
+            factor = U_Matrix[j, i] / U_Matrix[i, i]
+            U_Matrix[j] -= factor * U_Matrix[i]
+            U_vector[j] -= factor * U_vector[i]
+
+    # Back substitution (same as before)
+    for i in range(rows - 1, -1, -1):
+        if np.isclose(U_Matrix[i, i], 0):
+            raise ValueError("Matrix is singular or nearly singular.")
+        x[i] = (U_vector[i] - np.dot(U_Matrix[i, i + 1:], x[i + 1:])) / U_Matrix[i, i]
+    
+    return x

openum/NumEigenv.py

@@ -0,0 +1,142 @@
+import numpy as np
+
+def matrix_vector(N: np.ndarray, Matrix: np.ndarray, Vector: np.ndarray) -> np.ndarray:
+    """
+    Multiply a matrix by a vector.
+
+    Args:
+        N (int): Size of the matrix and vector.
+        Matrix (ndarray): Input matrix.
+        Vector (ndarray): Input vector.
+
+    Returns:
+        ndarray: Resulting vector after multiplication.
+    """
+    Solution = np.zeros(N)
+    for i in range(N):
+        for j in range(N):
+            Solution[i] += Matrix[i][j] * Vector[j]
+    return Solution
+
+def Eigenvalue_calc(mat: np.ndarray, vec: np.ndarray, Iteration: int) -> tuple[float, np.ndarray]:
+    """
+    Compute an eigenvalue and eigenvector using power iteration.
+
+    Args:
+        mat (ndarray): Input matrix.
+        vec (ndarray): Initial vector.
+        Iteration (int): Number of iterations.
+
+    Returns:
+        tuple: Eigenvalue and eigenvector.
+    """
+    size = mat.shape[0]
+
+    for _ in range(Iteration):
+        vec = matrix_vector(size, mat, vec)
+        vec = vec / np.linalg.norm(vec)  # Normalize the vector to prevent overflow
+
+    eigenvalue = np.dot(matrix_vector(size, mat, vec), vec) / np.dot(vec, vec)
+    eigenvector = vec
+    return eigenvalue, eigenvector
+
+def Eigenvalues(mat: np.ndarray, vec: np.ndarray, Iteration: int)-> tuple[list[float], list[np.ndarray]]:
+    """
+    Compute eigenvalues and eigenvectors of a matrix and its inverse.
+
+    Args:
+        mat (ndarray): Input matrix.
+        vec (ndarray): Initial vector.
+        Iteration (int): Number of iterations.
+
+    Returns:
+        tuple: List of eigenvalues and eigenvectors.
+    """
+    eigenvalues = []
+    eigenvectors = []
+
+    try:
+        inv_mat = np.linalg.inv(mat)
+        for matrix in [mat, inv_mat]:
+            eigenvalue, eigenvector = Eigenvalue_calc(matrix, vec, Iteration)
+            eigenvalues.append(eigenvalue)
+            eigenvectors.append(eigenvector)
+    except np.linalg.LinAlgError:
+        eigenvalue, eigenvector = Eigenvalue_calc(mat, vec, Iteration)
+        eigenvalues.append(eigenvalue)
+        eigenvectors.append(eigenvector)
+
+    return eigenvalues, eigenvectors
+
+def Aitken(Eigenvalues: list[float])->float:
+    """
+    Apply Aitken's delta-squared process for accelerated convergence.
+
+    Args:
+        Eigenvalues (list): List of computed eigenvalues.
+
+    Returns:
+        float: Accelerated eigenvalue.
+    """
+    if len(Eigenvalues) < 3:
+        return Eigenvalues[-1]
+    else:
+        x_n, x_n1, x_n2 = Eigenvalues[-3], Eigenvalues[-2], Eigenvalues[-1]
+        return x_n - (x_n1 - x_n) ** 2 / (x_n2 - 2 * x_n1 + x_n)
+
+def eigenvalue_calc_aitken(mat: np.ndarray, vec: np.ndarray, Iteration: int)->tuple[float, np.ndarray]:
+    """
+    Compute an eigenvalue and eigenvector using Aitken's method.
+
+    Args:
+        mat (ndarray): Input matrix.
+        vec (ndarray): Initial vector.
+        Iteration (int): Number of iterations.
+
+    Returns:
+        tuple: Eigenvalue and eigenvector.
+    """
+    EVArray = []
+    size = mat.shape[0]
+
+    for i in range(Iteration):
+        vec = matrix_vector(size, mat, vec)
+        vec = vec / np.linalg.norm(vec)
+        eigenvalue = np.dot(matrix_vector(size, mat, vec), vec) / np.dot(vec, vec)
+        EVArray.append(eigenvalue)
+
+        Aitken_Eigenvalue = Aitken(EVArray)
+
+        if i >= 3 and abs(Aitken_Eigenvalue - EVArray[-1]) < 1e-8:
+            eigenvalue = Aitken_Eigenvalue
+            break
+
+    return eigenvalue, vec
+
+def Eigenvalues_Aitken(mat: np.ndarray, vec: np.ndarray, Iteration: int)-> tuple[list[float],list[np.ndarray]]:
+    """
+    Compute eigenvalues and eigenvectors using Aitken's method.
+
+    Args:
+        mat (ndarray): Input matrix.
+        vec (ndarray): Initial vector.
+        Iteration (int): Number of iterations.
+
+    Returns:
+        tuple: List of eigenvalues and eigenvectors.
+    """
+    eigenvalues = []
+    eigenvectors = []
+
+    try:
+        inv_mat = np.linalg.inv(mat)
+        for matrix in [mat, inv_mat]:
+            eigenvalue, eigenvector = eigenvalue_calc_aitken(matrix, vec, Iteration)
+            eigenvalues.append(eigenvalue)
+            eigenvectors.append(eigenvector)
+    except np.linalg.LinAlgError:
+        eigenvalue, eigenvector = eigenvalue_calc_aitken(mat, vec, Iteration)
+        eigenvalues.append(eigenvalue)
+        eigenvectors.append(eigenvector)
+
+    return eigenvalues, eigenvectors