def main(): """Die main-Methode zur Demonstration der Module. Input ----- None """ d_1 = 1 d_2 = 2 d_3 = 3 n_error = 15 n_hilbert = 20 n_solution = 4 n_sparsity = 15 test = np.array([1,2,3]) values = range(3, n_error) matrix = block_matrix.BlockMatrix(d_1, n_error) list_1 = rhs.compute_error_list(d_1, n_error, functions.f_1, functions.u_1) list_2 = rhs.compute_error_list(d_2, n_error, functions.f_2, functions.u_2) list_3 = rhs.compute_error_list(d_3, n_error, functions.f_3, functions.u_3) rhs.plot_all_errors(values, list_1, list_2, list_3) block_matrix.graph_cond_hilbert(n_hilbert) plot_analytical_3d(n_solution, u) plot_approximate_3d(n_solution, functions.f_2) matrix.graph_abs_non_zero(n_sparsity)
def solve_poisson_sor(d, n, f, x0=None, params=PRESET, omega=1.5): """ Solves the poisson problem using the SOR algorithm. Params: ------- d : int The dimension of the domain. n : int The number of grid points. f : callable The right hand side of the equation will be build from this function. x0 : numpy.ndarray, optional The initial guess for the algorithm. params : dict, optional A dictionary containing the termination conditions. omega : float The omega for the algorithm. Returns: -------- numpy.ndarray The solution of the equation. """ A = block_matrix.BlockMatrix(d, n).data.tocsr() b = rhs.rhs(d, n, f) if x0 is None: x0 = np.array([0 for _ in range((n - 1)**d)]) return linear_solvers.solve_sor(A, b, x0=x0, params=params, omega=omega)
def plot_approximate_3d(n, f): """Plottet die approximierte Lösung des Poisson Problems zu einer gegebenen Funktion f mit Diskretisierung n. Input ----- n : int Die Feinheit der Diskretisierung f : callable die Funktion f, die gleich dem negativen Laplace Operators der zu approximierenden Funktion ist """ fig = plt.figure() ax = fig.add_subplot(111, projection="3d") x = [] y = [] for i in range(n-1): for j in range(n-1): x.append(i/n) y.append(j/n) b = rhs.rhs(2, n, f) matrix = block_matrix.BlockMatrix(2, n) z = linear_solvers.solve_lu(*matrix.lu, b) ax.plot_trisurf(x, y, z, linewidth=0.2, antialiased=True) ax.set_xlabel("x") ax.set_ylabel("y") ax.set_zlabel("z") plt.title("Plot der approximierten Lösung des Poisson-Problems für \ n = " + str(n)) plt.show()
def draw_error(max_n=15): """ This function draws the error for u and u_hat. Parameters ---------- max_n : int The plot is drawn from 2 upto this int. """ for d in [1, 2, 3]: errors = [] for n in range(2, max_n): hat_u = linear_solvers.solve_lu( *block_matrix.BlockMatrix(d, n).get_lu(), rhs(d, n, functions.f)) errors.append(compute_error(d, n, hat_u, functions.u)) plt.loglog([x for x in range(2, max_n)], errors, label="error for d = {}".format(d), linewidth=3) plt.xlabel("Number of Grid Points", fontsize=18) plt.ylabel("Error", fontsize=18) plt.legend(fontsize=24) # pylint: disable=anomalous-backslash-in-string plt.title("Plot of error of $u$ and $\hat{u}$ depending on n", fontsize=24) plt.show()
def compute_error_list(d, high_N, f, u): """ Computes the errors of the approximate solution of the poisson-problem in dependency of n. Input ----- d : int the dimension of the space high_N : int the highest N we want to plot the error for f : callable the f which is the negative of the laplace-operator u : callable Solution of the Possion problem Return ------ error_list : list list of maximal errors between the approxmative solution of the poisson problem and the real solution. """ error_list = [] for n in range(3, high_N): matrix = block_matrix.BlockMatrix(d, n) b = rhs(d, n, f) hat_u = linear_solvers.solve_lu(*matrix.lu, b) error_list.append(compute_error(d, n, hat_u, u)) return error_list
def plot_error(u, f, d, n_list): #pylint: disable=invalid-name """ Plots the maxima of absolute errors of the numerical solution of the Poisson-problem for a given list of n-values. N = (n-1)^d is the dimension of the block matrix. Parameters ---------- u : callable Solution of the Poisson-problem The calling signature is u(x). Here x is a scalar or array_like of numpy. The return value is a scalar. f : callable Input function of the Poisson-problem The calling signature is f(x). Here x is a scalar or array_like of numpy. The return value is a scalar. d: int Dimension of the Poisson-problem n_list: list of ints The n-values for which to plot the errors. """ numbers_of_points = [] errors = [] for n in n_list: A = block_matrix.BlockMatrix(d, n) b = rhs(d, n, f) lu = A.get_lu() hat_u = linear_solvers.solve_lu(lu[0], lu[1], lu[2], lu[3], b) errors.append(compute_error(d, n, hat_u, u)) numbers_of_points.append((n - 1)**d) numbers_of_points_pow1 = [np.float_(N)**(-1) for N in numbers_of_points] numbers_of_points_pow2 = [np.float_(N)**(-2) for N in numbers_of_points] numbers_of_points_pow3 = [ np.float_(N)**(-1 / 2) for N in numbers_of_points ] plt.loglog(numbers_of_points, numbers_of_points_pow3, label='$N^{-1/2}$', color='lightgray', linestyle=':') plt.loglog(numbers_of_points, numbers_of_points_pow1, label='$N^{-1}$', color='lightgray') plt.loglog(numbers_of_points, numbers_of_points_pow2, label='$N^{-2}$', color='lightgray', linestyle='-.') plt.loglog(numbers_of_points, errors, 'go--') plt.xlabel('$N$') plt.ylabel('maximum of absolute error') plt.title('Maxima of absolute errors for $d$ = ' + str(d)) plt.legend() plt.grid() plt.show() plt.figure()
def solve_poisson_sor(cs): A = block_matrix.BlockMatrix(cs.d, cs.n).data.tocsr() b = rhs.rhs(cs.d, cs.n, cs.f) print("d = {}, n = {}, omega = {}".format(cs.d, cs.n, cs.omega)) return linear_solvers.solve_sor(A, b, cs.x0, params=cs.params, omega=cs.omega)
def test_validity(n_upto=20, num_test=20, show=False): """ CHECKS THE ABOVE FUNCTION FOR CORECTNESS. Loops through some random values for b and compares the function above with the spsolve from SciPy. Parameters ---------- n_upto : int Checks the correctness from 2 to this integer. num_test : int Number of tests for each n. show : boolean Option to print out the values. Returns ------- boolean True if no wrongness was encountered, False if an error was seen. """ for d in [1, 2, 3]: for n in range(2, n_upto): for i in range(0, num_test): mat = block_matrix.BlockMatrix(d, n) b = np.array( [random.randint(-20, 20) for _ in range(0, mat.extend)]) x_demo = solve_lu(*mat.get_lu(), b) x_true = slina.spsolve(sm.csc_matrix(mat.data), b) if np.all((x_demo, x_true)): print("d = {} | n = {} | TEST {}/{} PASSED!".format( d, n, i + 1, num_test)) if show: print() print("A = {}".format(mat.data.toarray())) print("b = {}\n".format(b)) print("x = {}".format(x_demo)) print() print( "============================================================\n" ) else: print() print("d = {} | n = {} | TEST {}/{} FAILED FOR".format( d, n, i + 1, num_test)) print("A = {}".format(mat.data.toarray())) print("b = {}\n".format(b)) print("x = {}".format(x_demo)) print() return False return True
def draw_error_both(f, u, dlist=[1, 2, 3], max_n=MAX_N): """ This function draws a plot to compare the SOR algorithm and the LU-decomposition. Params: ------- f : callable The right hand side of the equation will be build from this function. u : callable The analytic solution of x will be build from this function. dlist : list, optional A list containing dimension for which the plot is drawn. max_n : int, optional The maximum number of n for which the plot is drawn. """ for d in dlist: errors_sor = [error_sor(d, n, f, u) for n in range(2, max_n)] plt.loglog([n for n in range(2, max_n)], errors_sor, label="error SOR for $d$ = {}".format(d), linewidth=3) errors_lu = [] for n in range(2, max_n): hat_u = linear_solvers.solve_lu( *block_matrix.BlockMatrix(d, n).get_lu(), rhs.rhs(d, n, functions.f)) errors_lu.append(rhs.compute_error(d, n, hat_u, functions.u)) plt.loglog([n for n in range(2, max_n)], errors_lu, label="error LU for $d$ = {}".format(d), linewidth=3, linestyle="--") plt.xlabel("Number of Grid Points, $N$", fontsize=18) plt.ylabel("Error", fontsize=18) plt.legend(fontsize=24) # pylint: disable=anomalous-backslash-in-string plt.title("Plot of error of $u$ and $\hat{u}$ depending on $N$", fontsize=24) plt.show()
def main(): """ A main function for demo. """ d, n = 2, 4 print("DEMONSTRATION OF MODULE") print("Consider sum_{l = 1}^d x_l * sin(k * pi * x_l).") print( "We have d = {} and n = {}, then the right hand side of Ax = b would be:" .format(d, n)) print(np.array(rhs(d, n, functions.f))) print("And the error would be:") hat_u = linear_solvers.solve_lu(*block_matrix.BlockMatrix(d, n).get_lu(), rhs(d, n, functions.f)) print(compute_error(d, n, hat_u, functions.u)) print() print("We can also the plot for the error.") print() print("See protocol for more information.") draw_error() draw_hilbert_cond()
def plot_iterates_error(u, f, d, n, params=dict(eps=1e-8, max_iter=1000, min_red=1e-4)): """ Plots the development of absolute errors of the numerical solution of the Poisson-problem with CG for the different iteration steps. Parameters ---------- u : callable Solution of the Poisson-problem The calling signature is u(x). Here x is a scalar or array_like of numpy. The return value is a scalar. f : callable Input function of the Poisson-problem The calling signature is f(x). Here x is a scalar or array_like of numpy. The return value is a scalar. d: int Dimension of the Poisson-problem n: int Number of intervals of the discretization. """ A = block_matrix.BlockMatrix(d, n).get_sparse() b = rhs(d, n, f) cg = linear_solvers.solve_cg(A, b, np.zeros((n - 1)**d), params) print(cg[0]) errors = [compute_error(d, n, sol, u) for sol in cg[1]] plt.plot(range(len(errors)), errors, 'm.--') plt.xlabel('number of iteration') plt.ylabel('absolute error') plt.title('Development of absolute error for d = %d and n = %d' % (d, n)) plt.grid() plt.show() plt.figure()
def plot_approximation_3d(N): """ This function draws the analytic solution for the poissons equation for d = 2. Parameters: N : int The number of grid points. """ grid = np.linspace(0.0, 1.0, N + 1, endpoint=True) # grid_length = len(grid) x_grid, y_grid = np.meshgrid(grid, grid) b = linear_solvers.solve_lu(*block_matrix.BlockMatrix(2, N).get_lu(), rhs.rhs(2, N, f)) z_grid = np.zeros((N + 1, N + 1)) for i in range(N + 1): for j in range(N + 1): if i != 0 and i != N and j != 0 and j != N: z_grid[i][j] = b[0] b = np.delete(b, 0) print("z axis (approximation)\n{}".format(z_grid)) fig = plt.figure() ax = fig.add_subplot(111, projection='3d') if N >= 10: ax.plot_surface(x_grid, y_grid, z_grid, cmap=plt.cm.CMRmap, linewidth=0) else: ax.plot_surface(x_grid, y_grid, z_grid, linewidth=0) lim = (-0.1, 1.1) ax.set_xlabel("$x$", fontsize=14), ax.set_xlim(lim) ax.set_ylabel("$y$", fontsize=14), ax.set_ylim(lim) ax.set_zlabel("$\hat{u}(x, y)$", fontsize=14), ax.set_zlim(lim) plt.title("Plot of the Approximated Solution (N = " + str(N) + ")", fontsize=18) plt.show()
def graph_error(d, high_N, f, u): """Plots the errors of the approximate solution of the Poisson Problem in dependency of N. d : int the dimension of the space high_N : int the highest N we want to plot the error for f : callable the f which is the negative of the laplace-operator u : callable Solution of the Possion problem """ error_list = [] plt.style.use("seaborn-white") plt.figure(figsize=(14, 7)) plt.gcf().canvas.set_window_title("Graph des Fehlers \ in Abhängigkeit von N") plt.title("Fehlerplot in Abhängigkeit von N") axis = plt.gca() for n in range(3, high_N): matrix = block_matrix.BlockMatrix(d, n) b = rhs(d, n, f) hat_u = linear_solvers.solve_lu(*matrix.lu, b) error_list.append(compute_error(d, n, hat_u, u)) axis.plot(range(3, high_N), error_list, label="Fehlerplot in Abhängigkeit\ von N für d = " + str(d)) plt.xlabel("n-Werte") plt.ylabel("Fehler") plt.grid(True) #axis.set_xscale('log') #axis.set_yscale('log') plt.legend() plt.show()
def plot_error_comp(u, f, d, n_list): """ Plots the maxima of absolute errors of the numerical solution of the Poisson-problem with LU and CG for a given list of n-values. N = (n-1)^d is the dimension of the block matrix. Parameters ---------- u : callable Solution of the Poisson-problem The calling signature is u(x). Here x is a scalar or array_like of numpy. The return value is a scalar. f : callable Input function of the Poisson-problem The calling signature is f(x). Here x is a scalar or array_like of numpy. The return value is a scalar. d: int Dimension of the Poisson-problem n_list: list of ints The n-values for which to plot the errors. """ numbers_of_points = [] errors_cg = [] errors_lu = [] for n in n_list: A = block_matrix.BlockMatrix(d, n) b = rhs(d, n, f) lu = A.get_lu() hat_u = linear_solvers.solve_lu(lu[0], lu[1], lu[2], lu[3], b) errors_lu.append(compute_error(d, n, hat_u, u)) cg = linear_solvers.solve_cg(A.get_sparse(), b, np.zeros((n - 1)**d), params=dict(eps=1e-8, max_iter=(2 * (n - 1)**2 * d), min_red=0)) print(cg[0]) errors_cg.append(compute_error(d, n, cg[1][-1], u)) numbers_of_points.append((n - 1)**d) # numbers_of_points_pow1 = [np.float_(N)**(-1) for N in numbers_of_points] # numbers_of_points_pow2 = [np.float_(N)**(-2) for N in numbers_of_points] # numbers_of_points_pow3 = [np.float_(N)**(-1/2) for N in numbers_of_points] # # plt.loglog(numbers_of_points, numbers_of_points_pow3, label='$N^{-1/2}$', # color='lightgray', linestyle=':') # plt.loglog(numbers_of_points, numbers_of_points_pow1, label='$N^{-1}$', # color='lightgray') # plt.loglog(numbers_of_points, numbers_of_points_pow2, label='$N^{-2}$', # color='lightgray', linestyle='-.') plt.loglog(numbers_of_points, errors_cg, 'gX-', label='CG') plt.loglog(numbers_of_points, errors_lu, 'r.--', label='LU') plt.xlabel('$N$') plt.ylabel('maximum of absolute error') plt.title('Maxima of absolute errors for $d$ = ' + str(d)) plt.legend() plt.grid() plt.show() plt.figure()
def plot_functions(u, f, n): #pylint: disable=invalid-name, too-many-locals """ Plots the numerical, the exact solution of our Poisson-problem (dimension d=2) for a given value of n (n is the number of intersections in each dimension and their absolute and their relative difference. Parameters ---------- u : callable Solution of the Poisson-problem The calling signature is u(x). Here x is a scalar or array_like of numpy. The return value is a scalar. f : callable Input function of the Poisson-problem The calling signature is f(x). Here x is a scalar or array_like of numpy. The return value is a scalar. n: int The n-value for which to plot the functions. """ x = np.linspace(0, 1, n + 1) y = np.linspace(0, 1, n + 1) X, Y = np.meshgrid(x, y) exact = u((X, Y)) A = block_matrix.BlockMatrix(2, n) b = rhs(2, n, f) lu = A.get_lu() hat_u = linear_solvers.solve_lu(lu[0], lu[1], lu[2], lu[3], b) approx = np.reshape(hat_u, (-1, n - 1)) vzeroes = [] for _ in range(n - 1): vzeroes.append([0]) hzeroes = np.zeros(n + 1) approx = np.hstack((vzeroes, approx, vzeroes)) approx = np.vstack((hzeroes, approx, hzeroes)) fig = plt.figure() ax1 = fig.add_subplot(221, projection='3d') ax2 = fig.add_subplot(222, projection='3d') ax3 = fig.add_subplot(223, projection='3d') #ax4 = fig.add_subplot(224, projection='3d') ax1.set_xlabel('$x_1$') ax1.set_ylabel('$x_2$') ax1.set_zlabel('$\hat{u}(x)$') #pylint: disable=anomalous-backslash-in-string ax1.plot_surface(X, Y, approx, cmap='viridis', edgecolor='none') ax1.set_title('Approximate solution') difference = abs(approx - exact) ax2.set_xlabel('$x_1$') ax2.set_ylabel('$x_2$') ax2.set_zlabel('$|\hat{u}(x)-u(x)|$') #pylint: disable=anomalous-backslash-in-string ax2.plot_surface(X, Y, difference, cmap='viridis', edgecolor='none') ax2.set_title('Difference') ax3.set_xlabel('$x_1$') ax3.set_ylabel('$x_2$') ax3.set_zlabel('$u(x)$') ax3.plot_surface(X, Y, exact, cmap='viridis', edgecolor='none') ax3.set_title('Exact solution') #rel_difference = difference/(exact+np.mean(difference)) #ax4.plot_surface(X, Y, rel_difference, cmap='viridis', edgecolor='none') #ax4.set_title('Relative Difference') plt.show()
def plot_error_list(u_list, f_list, n_list_list): #pylint: disable=invalid-name, too-many-locals """ Plots the maxima of absolute errors of the numerical solution of the Poisson-problem for a given list of n-values and for the dimension d = 1, 2, 3. Parameters ---------- n_list_list: list of list of ints The n-values for which to plot the errors. u_list : list of callable functions Solution of the Poisson-problem The calling signature is u(x). Here x is a scalar or array_like of numpy. The return value is a scalar. f_list : list of callable functions Input function of the Poisson-problem The calling signature is f(x). Here x is a scalar or array_like of numpy. The return value is a scalar. """ numbers_of_points_1 = [] errors_1 = [] for n in n_list_list[0]: A = block_matrix.BlockMatrix(1, n) b = rhs(1, n, f_list[0]) lu = A.get_lu() hat_u = linear_solvers.solve_lu(lu[0], lu[1], lu[2], lu[3], b) errors_1.append(compute_error(1, n, hat_u, u_list[0])) numbers_of_points_1.append((n - 1)**1) numbers_of_points_2 = [] errors_2 = [] for n in n_list_list[1]: A = block_matrix.BlockMatrix(2, n) b = rhs(2, n, f_list[1]) lu = A.get_lu() hat_u = linear_solvers.solve_lu(lu[0], lu[1], lu[2], lu[3], b) errors_2.append(compute_error(2, n, hat_u, u_list[1])) numbers_of_points_2.append((n - 1)**2) numbers_of_points_3 = [] errors_3 = [] for n in n_list_list[2]: A = block_matrix.BlockMatrix(3, n) b = rhs(3, n, f_list[2]) lu = A.get_lu() hat_u = linear_solvers.solve_lu(lu[0], lu[1], lu[2], lu[3], b) errors_3.append(compute_error(3, n, hat_u, u_list[2])) numbers_of_points_3.append((n - 1)**3) numbers_of_points_pow1 = [np.float_(N)**(-1) for N in numbers_of_points_3] numbers_of_points_pow2 = [np.float_(N)**(-2) for N in numbers_of_points_3] numbers_of_points_pow3 = [ np.float_(N)**(-1 / 2) for N in numbers_of_points_3 ] plt.loglog(numbers_of_points_3, numbers_of_points_pow3, label='$N^{-1/2}$', color='lightgray') plt.loglog(numbers_of_points_3, numbers_of_points_pow1, label='$N^{-1}$', color='lightgray', linestyle='-.') plt.loglog(numbers_of_points_3, numbers_of_points_pow2, label='$N^{-2}$', color='lightgray', linestyle=':') plt.loglog(numbers_of_points_1, errors_1, label='$d=1$', linestyle='--', color='blue') plt.loglog(numbers_of_points_2, errors_2, label='$d=2$', linestyle='--', color='magenta') plt.loglog(numbers_of_points_3, errors_3, label='$d=3$', linestyle='--', color='red') plt.xlabel('$N$') plt.ylabel('maximum of absolute error') plt.legend() plt.title('Maxima of absolute errors for $d=1,2,3$') plt.grid() plt.show()
def plot_error_eps(u, f, d, n_list): """ Plots the maxima of absolute errors of the numerical solution of the Poisson-problem with CG for a given list of n-values and for different values of epsilon = n^(-k). Parameters ---------- u : callable Solution of the Poisson-problem The calling signature is u(x). Here x is a scalar or array_like of numpy. The return value is a scalar. f : callable Input function of the Poisson-problem The calling signature is f(x). Here x is a scalar or array_like of numpy. The return value is a scalar. d: int Dimension of the Poisson-problem n_list: list of ints The n-values for which to plot the errors. """ k_list = [-2, 0, 2, 4, 6] markers = ['s', 'X', 'H', '^', '.'] i = 0 for k in k_list: numbers_of_points = [] errors_cg = [] for n in n_list: A = block_matrix.BlockMatrix(d, n) b = rhs(d, n, f) cg = linear_solvers.solve_cg(A.get_sparse(), b, np.zeros((n - 1)**d), params=dict(eps=float(n)**(-k), max_iter=(2 * (n - 1)**2 * d), min_red=0)) print(cg[0]) errors_cg.append(compute_error(d, n, cg[1][-1], u)) numbers_of_points.append((n - 1)**d) if i == 0: if d == 1: conv0 = [(10 * float(N))**(1 / 8) for N in numbers_of_points] conv2 = [float(N)**(-2) for N in numbers_of_points] plt.loglog(numbers_of_points, conv0, label='$(10N)^{1/8}$', color='lightgray') plt.loglog(numbers_of_points, conv2, label='$N^{-2}$', color='lightgray', linestyle='-.') elif d == 2: conv0 = [(10 * float(N))**(1 / 8) for N in numbers_of_points] conv1 = [(10 * float(N))**(-1 / 2) for N in numbers_of_points] conv2 = [(10 * float(N))**(-1) for N in numbers_of_points] plt.loglog(numbers_of_points, conv0, label='$(10N)^{1/8}$', color='lightgray') plt.loglog(numbers_of_points, conv1, label='$(10N)^{-1/2}$', color='lightgray', linestyle='--') plt.loglog(numbers_of_points, conv2, label='$(10N)^{-1}$', color='lightgray', linestyle='-.') else: conv0 = [(0.000000001 * float(N))**(1 / 8) for N in numbers_of_points] conv1 = [(1000 * float(N))**(-1 / 2) for N in numbers_of_points] conv2 = [(10000 * float(N))**(-1 / 4) for N in numbers_of_points] plt.loglog(numbers_of_points, conv0, label='$(10^{-8}N)^{1/8}$', color='lightgray') plt.loglog(numbers_of_points, conv2, label='$(1000N)^{-1/4}$', color='lightgray', linestyle='--') plt.loglog(numbers_of_points, conv1, label='$(10000N)^{-1/2}$', color='lightgray', linestyle='-.') plt.loglog(numbers_of_points, errors_cg, '--', marker=markers[i], label='k=' + str(k)) i = i + 1 plt.xlabel('$N$') plt.ylabel('maximum of absolute error') plt.title('Maxima of absolute errors for $d$ = ' + str(d)) plt.legend(loc='lower left') plt.grid() plt.show() plt.figure()
def plot_error_list_comp(u_list, f_list, n_list_list): """ Plots the maxima of absolute errors of the numerical solution of the Poisson-problem with LU and CG for a given list of n-values and for the dimension d = 1, 2, 3. Parameters ---------- n_list_list: list of list of ints The n-values for which to plot the errors. u_list : list of callable functions Solution of the Poisson-problem The calling signature is u(x). Here x is a scalar or array_like of numpy. The return value is a scalar. f_list : list of callable functions Input function of the Poisson-problem The calling signature is f(x). Here x is a scalar or array_like of numpy. The return value is a scalar. """ numbers_of_points_1 = [] errors_1 = [] errors_cg1 = [] for n in n_list_list[0]: A = block_matrix.BlockMatrix(1, n) b = rhs(1, n, f_list[0]) lu = A.get_lu() hat_u = linear_solvers.solve_lu(lu[0], lu[1], lu[2], lu[3], b) errors_1.append(compute_error(1, n, hat_u, u_list[0])) cg = linear_solvers.solve_cg(A.get_sparse(), b, np.zeros((n - 1)), params=dict(eps=1e-8, max_iter=(2 * (n - 1)**2), min_red=0)) print(cg[0]) errors_cg1.append(compute_error(1, n, cg[1][-1], u_list[0])) numbers_of_points_1.append((n - 1)**1) numbers_of_points_2 = [] errors_2 = [] errors_cg2 = [] for n in n_list_list[1]: A = block_matrix.BlockMatrix(2, n) b = rhs(2, n, f_list[1]) lu = A.get_lu() hat_u = linear_solvers.solve_lu(lu[0], lu[1], lu[2], lu[3], b) cg = linear_solvers.solve_cg(A.get_sparse(), b, np.zeros((n - 1)**2), params=dict(eps=1e-8, max_iter=(2 * (n - 1)**2 * 2), min_red=0)) print(cg[0]) errors_cg2.append(compute_error(2, n, cg[1][-1], u_list[1])) errors_2.append(compute_error(2, n, hat_u, u_list[1])) numbers_of_points_2.append((n - 1)**2) numbers_of_points_3 = [] errors_3 = [] errors_cg3 = [] for n in n_list_list[2]: A = block_matrix.BlockMatrix(3, n) b = rhs(3, n, f_list[2]) lu = A.get_lu() hat_u = linear_solvers.solve_lu(lu[0], lu[1], lu[2], lu[3], b) cg = linear_solvers.solve_cg(A.get_sparse(), b, np.zeros((n - 1)**3), params=dict(eps=1e-8, max_iter=(2 * (n - 1)**2 * 3), min_red=0)) print(cg[0]) errors_cg3.append(compute_error(3, n, cg[1][-1], u_list[2])) errors_3.append(compute_error(3, n, hat_u, u_list[2])) numbers_of_points_3.append((n - 1)**3) numbers_of_points_pow1 = [np.float_(N)**(-1) for N in numbers_of_points_3] numbers_of_points_pow2 = [np.float_(N)**(-2) for N in numbers_of_points_3] numbers_of_points_pow3 = [ np.float_(N)**(-1 / 2) for N in numbers_of_points_3 ] plt.loglog(numbers_of_points_3, numbers_of_points_pow3, label='$N^{-1/2}$', color='lightgray') plt.loglog(numbers_of_points_3, numbers_of_points_pow1, label='$N^{-1}$', color='lightgray', linestyle='-.') plt.loglog(numbers_of_points_3, numbers_of_points_pow2, label='$N^{-2}$', color='lightgray', linestyle=':') plt.loglog(numbers_of_points_1, errors_1, label='LU $d=1$', linestyle='-', color='cornflowerblue', marker='X') plt.loglog(numbers_of_points_2, errors_2, label='LU $d=2$', linestyle='-', color='blue', marker='X') plt.loglog(numbers_of_points_3, errors_3, label='LU $d=3$', linestyle='-', color='navy', marker='X') plt.loglog(numbers_of_points_1, errors_cg1, label='CG $d=1$', linestyle='-.', color='tomato', marker='.') plt.loglog(numbers_of_points_2, errors_cg2, label='CG $d=2$', linestyle='-.', color='red', marker='.') plt.loglog(numbers_of_points_3, errors_cg3, label='CG $d=3$', linestyle='-.', color='darkred', marker='.') plt.xlabel('$N$') plt.ylabel('maximum of absolute error') plt.legend() plt.title('Maxima of absolute errors for $d=1,2,3$') plt.grid() plt.show()
def compute_error_lu(d, n): algorithm = linear_solvers.solve_lu( *block_matrix.BlockMatrix(d, n).get_lu(), rhs.rhs(d, n, functions.f)) exact = true_solution(cs.change(d=d, n=n)) return max([abs(ai - bi) for ai, bi in zip(exact, algorithm)])