c - 为什么同一个程序的 c 和 fortran 版本会产生不同的结果？

Question

我用的是gcc (Ubuntu 9.3.0-17ubuntu1~20.04) 9.3.0

C代码是:

// Compile with:
//  gcc -o little_c little.c
#include <stdio.h>  // printf

void main(void) {
    int n = 800;
    float a[n][n], b[n][n], c[n][n];
    int i, j, k;

    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            a[i][j] = (float) (i+j);
            b[i][j] = (float) (i-j);
        }
    }

    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            float t = (float) 0.0;
            for (k = 0; k < n; k++)
                t += a[i][k] * a[i][k] + b[k][j] * b[k][j];
                //t += a[i][k] + b[k][j]; // If I comment the above line and uncomment this, the c and fortran reults are the same
            c[i][j] = t;
        }
    }
    printf("%f", c[n-1][n-1]); // prints the very last element

}

Fortran 代码:

! Compile with:
!  gfortran -o little_fort little.f90 

program little

implicit none

integer, parameter  :: n = 800
real                :: a(n,n), b(n,n), c(n,n)
real                :: t
integer             :: i, j, k  ! Counters

do i = 1, n
    do j = 1, n
        a(i,j) = real(i-1+j-1)      ! Minus one, for it to be like the c version
        b(i,j) = real(i-1-(j-1))    ! because in c, the index goes from 0 to n-1
    end do
end do

do i = 1, n
    do j = 1, n
        t = 0.0
        do k = 1, n
            t = t + a(i,k) * a(i,k) + b(k,j) * b(k,j)
            !t = t + a(i,k) + b(k,j) ! If I comment the above line and uncomment this, the c and fortran reults are the same
        end do
        c(i,j) = t
    end do
end do
    
write (*,"(F20.4)") c(n,n)  ! This is the same as c[n-1][n-1] in c


end program little

c 程序打印:1362136192.000000

Fortran 程序打印:1362137216.0000

如果我不将每个元素与自身相乘，正如我在代码中的注释中所述，我将在两个版本的程序中得到相同的值:

c 程序:639200.000000

Fortran 程序:639200.0000

为什么当我使用乘法时，C 和 Fortran 代码会产生不同的结果？是否必须使用不同的实数实现方式？

Answer 1

差异是由于求值顺序和浮点类型的有限精度造成的。

如果将 Fortran 版本更改为

t = t + (a(i,k) * a(i,k) + b(k,j) * b(k,j))

即使用 a 和 b 在术语周围添加括号，两种语言的结果相同。由于使用了 += 赋值运算符，C 版本已经使用了这种求值顺序。

如评论中所述，这是可用精度限制下的预期行为。