如何在Fortran中高效实现数组元素积之和的计算？

嘿，作为Fortran初学者能想到用循环来规避手动写重复代码的麻烦，这思路太对啦！你要计算的这个B(K)本质上就是对I和J两个维度做双重累加，完全不用纠结DO WHILE——当然它也能实现，但普通的DO循环更直观高效，甚至用Fortran的内置函数还能写得更简洁。

方法一：嵌套DO循环（最直观，适合新手理解） #

这是最基础也最容易调试的写法，不管I/J的范围扩大到多少，只要修改一个参数就行，完全不用手动添加新的累加项：

program calc_B
    implicit none
    ! 定义I/J的上限，以后要扩大范围只改这个数
    integer, parameter :: N = 3  
    ! 声明数组和变量
    real :: A(N,N,N), c(N), B(N)
    integer :: i, j, k

    ! ===== 这里替换成你自己的A和c的赋值逻辑 =====
    ! 示例：给c赋值，给A赋简单的测试值
    c = [1.0, 2.0, 3.0]
    do k = 1, N
        do j = 1, N
            do i = 1, N
                A(i,j,k) = real(i + j + k)
            end do
        end do
    end do

    ! ===== 核心计算部分 =====
    do k = 1, N
        ! 先把当前K对应的B值清零，避免累加残留
        B(k) = 0.0  
        ! 遍历所有I和J，累加c(I)*c(J)*A(I,J,K)
        do i = 1, N
            do j = 1, N
                B(k) = B(k) + c(i)*c(j)*A(i,j,k)
            end do
        end do
    end do

    ! 打印结果验证
    do k = 1, N
        print *, "B(", k, ") = ", B(k)
    end do
end program calc_B

代码说明：

• 用integer, parameter :: N = 3定义维度上限，以后要扩展到100甚至更大，只需要把3改成对应数字就行，循环逻辑完全不用动
• 外层循环遍历K，因为每个B(K)对应A数组中第K层的二维切片的累加
• 内层的I和J循环顺序可以互换，Fortran是列优先存储，如果你处理超大数组，把J放在外层可能会稍微快一点，但新手先保证逻辑正确就好

方法二：用Fortran内置sum函数（更简洁） #

Fortran的内置数组操作非常强大，我们可以利用广播特性让代码更简洁，可读性也更高：

program calc_B_with_sum
    implicit none
    integer, parameter :: N = 3
    real :: A(N,N,N), c(N), B(N)
    integer :: k

    ! 同样先赋值A和c（示例逻辑）
    c = [1.0, 2.0, 3.0]
    do k = 1, N
        A(:,:,k) = reshape([(real(i+j+k), i=1,N), j=1,N], [N,N])
    end do

    ! 核心计算一行搞定
    do k = 1, N
        ! c(:,None)把c转成列向量，c(None,:)转成行向量，相乘得到N×N的矩阵（元素为c(i)*c(j)）
        ! 再和A(:,:,k)逐元素相乘，最后sum整个二维数组得到B(k)
        B(k) = sum( c(:,None) * c(None,:) * A(:,:,k) )
    end do

    ! 打印结果
    do k = 1, N
        print *, "B(", k, ") = ", B(k)
    end do
end program calc_B_with_sum

这种写法编译器会自动优化，效率和循环写法差不多，但代码更短，逻辑更清晰。

关于DO WHILE的补充 #

你提到的DO WHILE其实也能实现，但它更适合循环次数不确定的场景（比如直到某个条件满足才停止）。如果用DO WHILE写这个固定次数的累加，代码会更啰嗦，比如：

do k = 1, N
    B(k) = 0.0
    i = 1
    do while (i <= N)
        j = 1
        do while (j <= N)
            B(k) = B(k) + c(i)*c(j)*A(i,j,k)
            j = j + 1
        end do
        i = i + 1
    end do
end do

可以看到，比普通DO循环多了手动更新循环变量的步骤，容易出错，所以不推荐用在这种固定次数的迭代上。

内容的提问来源于stack exchange，提问作者idladle