Skip to content
The Chat Archive
gpt-4-0314· OpenAI WildChat-4.8M (AI2)

下面这个多重网格代码是昨天你写的,但是稍微有些问题,请你重新检查修正一下function u = multigrid(N, levels, tol) h = 1 / (N +…

  1. User

    下面这个多重网格代码是昨天你写的,但是稍微有些问题,请你重新检查修正一下function u = multigrid(N, levels, tol) h = 1 / (N + 1); % 计算网格间距 h_coarse = h * 2^(levels-1); % 计算粗网格间距

    % 计算真实解以检查误差
    x_true = linspace(h, 1 - h, N);
    y_true = linspace(h, 1 - h, N);
    [X_true, Y_true] = meshgrid(x_true, y_true);
    u_true = sin(piX_true).sin(piY_true);
    
    u = cell(levels, 1); % 初始化多个层次的解向量u
    f = cell(levels, 1); % 初始化不同层次的离散化后的f(x, y)
    for l = 1:levels
    

    M = 2^(l-1) * N; % 计算每层网格点数 x = linspace(h * 2^(l-1), 1 - h * 2^(l-1), M); y = linspace(h * 2^(l-1), 1 - h * 2^(l-1), M); [X, Y] = meshgrid(x, y); f{l} = -2 * pi^2 * sin(pi * X) . sin(pi * Y); u{l} = zeros(M); end

    % 误差传播迭代
    for v_cycle = 1:levels
        for i = 1:2^(levels - v_cycle)
            u = v_cycle_solve(u, f, 1);
        end
        % 检查是否收敛
        if norm(u{1} - u_true, ‘inf’) < tol
            break;
        end
    end
    u = u{1}; % 提取最细网格的解向量
    

    end

    function u = v_cycle_solve(u, f, current_level) % 预平滑:进行若干次高斯-赛德尔迭代 for it = 1:5 u{current_level} = gauss_seidel_solver(u{current_level}, f{current_level}, h_current_level); end

    % 计算残差r
    

    h_current_level = 1 / (size(u{current_level}, 1) + 1); r = calc_residual(u{current_level}, f{current_level}, h_current_level);

    if current_level < length(u) % 将残差网格限制至下一更粗的层次 r_coarse = restrict®;

    % 在更粗网格上递归调用v_cycle_solve以求解误差方程 e_coarse = v_cycle_solve({zeros(size(r_coarse))}, {r_coarse}, current_level + 1);

    % 将更粗层次上求得的误差方程解精细化并更新当前层次解向量 u{current_level} = u{current_level} + interpolate(e_coarse);

    end

    % 后平滑:再次进行若干次高斯-赛德尔迭代 for it = 1:5 u{current_level} = gauss_seidel_solver(u{current_level}, f{current_level}, h_current_level); end

    end

    解的离散化和迭代公式与之前的高斯-赛德尔迭代相同,代码如下:

    function u = gauss_seidel_solver(u, f, h) [M, N] = size(u); for i = 2:M-1 for j = 2:N-1 u(i, j) = 1/4 * (u(i+1, j) + u(i-1, j) + u(i, j+1) + u(i, j-1) + h^2 * f(i, j)); end end end

    function r = calc_residual(u, f, h) [M, N] = size(u); r = zeros(M, N); for i = 2:M-1 for j = 2:N-1 r(i, j) = f(i, j) - (u(i+1, j) + u(i-1, j) + u(i, j+1) + u(i, j-1) - 4u(i, j)) / h^2; end end end

    function r_coarse = restrict® M = size(r, 1) / 2; N = size(r, 2) / 2; r_coarse = zeros(M, N); for i = 1:M for j = 1:N r_coarse(i, j) = 1/4 * r(2i-1, 2j-1) + 1/2 * (r(2i, 2j-1) + r(2i-1, 2j)) + 1/4 * r(2i, 2j); end end end

    function e_fine = interpolate(e_coarse) M = size(e_coarse, 1) * 2; N = size(e_coarse, 2) * 2; e_fine = zeros(M, N); for i = 1:size(e_coarse, 1) for j = 1:size(e_coarse, 2) e_fine(2i-1, 2j-1) = e_coarse(i, j); e_fine(2i, 2j-1) = 1/2 * (e_coarse(i, j) + e_coarse(i+1, j)); e_fine(2i-1, 2j) = 1/2 * (e_coarse(i, j) + e_coarse(i, j+1)); e_fine(2i, 2*j) = 1/4 * (e_coarse(i, j) + e_coarse(i+1, j) + e_coarse(i, j+1) + e_coarse(i+1, j+1)); end end end

  2. Assistant

    function u = multigrid(N, levels, tol) h = 1 / (N + 1); % 计算网格间距 h_coarse = h * 2^(levels-1); % 计算粗网格间距

    % 计算真实解以检查误差
    x_true = linspace(h, 1 - h, N);
    y_true = linspace(h, 1 - h, N);
    [X_true, Y_true] = meshgrid(x_true, y_true);
    u_true = sin(pi*X_true).*sin(pi*Y_true);
    
    u = cell(levels, 1); % 初始化多个层次的解向量u
    f = cell(levels, 1); % 初始化不同层次的离散化后的f(x, y)
    for l = 1:levels
        M = 2^(l-1) * N; % 计算每层网格点数
        x = linspace(h * 2^(l-1), 1 - h * 2^(l-1), M);
        y = linspace(h * 2^(l-1), 1 - h * 2^(l-1), M);
        [X, Y] = meshgrid(x, y);
        f{l} = -2 * pi^2 * sin(pi * X) .* sin(pi * Y);
        u{l} = zeros(M);
    end
    
    % 误差传播迭代
    for v_cycle = 1:levels
        for i = 1:2^(levels - v_cycle)
            u = v_cycle_solve(u, f, 1);
        end
        % 检查是否收敛
        if norm(u{1} - u_true, 'inf') < tol
            break;
        end
    end
    u = u{1}; % 提取最细网格的解向量
    

    end

    function u = v_cycle_solve(u, f, current_level) % 预平滑:进行若干次高斯-赛德尔迭代 h_current_level = 1 / (size(u{current_level}, 1) + 1); for it = 1:5 u{current_level} = gauss_seidel_solver(u{current_level}, f{current_level}, h_current_level); end

    % 计算残差r
    r = calc_residual(u{current_level}, f{current_level}, h_current_level);
    
    if current_level < length(u)
        % 将残差网格限制至下一更粗的层次
        r_coarse = restrict(r);
    
        % 在更粗网格上递归调用v_cycle_solve以求解误差方程
        e_coarse = v_cycle_solve({zeros(size(r_coarse))}, {r_coarse}, current_level + 1);
    
        % 将更粗层次上求得的误差方程解精细化并更新当前层次解向量
        u{current_level} = u{current_level} + interpolate(e_coarse);
    
    end
    
    % 后平滑:再次进行若干次高斯-赛德尔迭代
    for it = 1:5
        u{current_level} = gauss_seidel_solver(u{current_level}, f{current_level}, h_current_level);
    end
    

    end

    解的离散化和迭代公式与之前的高斯-赛德尔迭代相同,代码如下:

    function u = gauss_seidel_solver(u, f, h) [M, N] = size(u); for i = 2:M-1 for j = 2:N-1 u(i, j) = 1/4 * (u(i+1, j) + u(i-1, j) + u(i, j+1) + u(i, j-1) + h^2 * f(i, j)); end end end

    function r = calc_residual(u, f, h) [M, N] = size(u); r = zeros(M, N); for i = 2:M-1 for j = 2:N-1 r(i, j) = f(i, j) - (u(i+1, j) + u(i-1, j) + u(i, j+1) + u(i, j-1) - 4*u(i, j)) / h^2; end end end

    function r_coarse = restrict(r) M = size(r, 1) / 2; N = size(r, 2) / 2; r_coarse = zeros(M, N); for i = 1:M for j = 1:N r_coarse(i, j) = 1/4 * r(2i-1, 2j-1) + 1/2 * (r(2i, 2j-1) + r(2i-1, 2j)) + 1/4 * r(2i, 2j); end end end

    function e_fine = interpolate(e_coarse) M = size(e_coarse, 1) * 2; N = size(e_coarse, 2) * 2; e_fine = zeros(M, N); for i = 1:size(e_coarse, 1) for j = 1:size(e_coarse, 2) e_fine(2i-1, 2j-1) = e_coarse(i, j); e_fine(2i, 2j-1) = 1/2 * (e_coarse(i, j) + e_coarse(min(i+1, end), j)); e_fine(2i-1, 2j) = 1/2 * (e_coarse(i, j) + e_coarse(i, min(j+1, end))); e_fine(2i, 2j) = 1/4 * (e_coarse(i, j) + e_coarse(min(i+1, end), j) + e_coarse(i, min(j+1, end)) + e_coarse(min(i+1, end), min(j+1, end))); end end end