Question

移植一些Fortran 77代码。似乎REAL变量被分配给INTEGER变量。我没有运行此代码的方法，并想知道在以下情况下的行为是什么：

REAL*4 A
A = 123.25
B = INT(A)

B = 123或B = 124？

在0.5分处怎么样？

REAL*4 C
C = 123.5
D = INT(C)

D = 123或D = 123.5？

Answer 1

INT始终围绕向下：

来自GCC documentation：

这些函数根据以下规则返回INTEGER变量或数组：

（A）如果A的类型为INTEGER，则INT（A）= A

（B）如果A是REAL类型   | A | ＆LT; 1，INT（A）等于0.如果| A | \ geq 1，然后INT（A）等于   最大整数，不超过A的范围，其符号为   与A的标志相同。

（C）如果A是COMPLEX类型，则规则B是   适用于A的实际部分。

如果要舍入到最接近的整数，请使用NINT。

因此，在您的情况下，B和D始终为123（如果它们被声明为integer）。

Answer 2

以下是代码和输出的一个示例，它是之前答案的扩展：

PROGRAM test
implicit none
integer               :: i=0
real                  :: dummy = 0.

do i = 0,30
       dummy = -1.0 + (i*0.1)
       write(*,*) i, dummy , int(dummy) , nint(dummy) ,floor(dummy)
enddo
stop
end PROGRAM test

这是输出：

 $ ./test
      0  -1.000000              -1          -1          -1
      1 -0.9000000               0          -1          -1
      2 -0.8000000               0          -1          -1
      3 -0.7000000               0          -1          -1
      4 -0.6000000               0          -1          -1
      5 -0.5000000               0          -1          -1
      6 -0.4000000               0           0          -1
      7 -0.3000000               0           0          -1
      8 -0.2000000               0           0          -1
      9 -9.9999964E-02           0           0          -1
     10  0.0000000E+00           0           0           0
     11  0.1000000               0           0           0
     12  0.2000000               0           0           0
     13  0.3000001               0           0           0
     14  0.4000000               0           0           0
     15  0.5000000               0           1           0
     16  0.6000000               0           1           0
     17  0.7000000               0           1           0
     18  0.8000001               0           1           0
     19  0.9000000               0           1           0
     20   1.000000               1           1           1
     21   1.100000               1           1           1
     22   1.200000               1           1           1
     23   1.300000               1           1           1
     24   1.400000               1           1           1
     25   1.500000               1           2           1
     26   1.600000               1           2           1
     27   1.700000               1           2           1
     28   1.800000               1           2           1
     29   1.900000               1           2           1
     30   2.000000               2           2           2

我希望这可以更好地澄清问题

编辑：在xeon上使用ifort 2013编译

Answer 3

仅作为现有答案的补充，我想举一个示例，说明如何在不使用NINT的情况下通过以下方式实现商业回合

      L = INT(F + 0.5)

其中L是INTEGER，而F是正REAL。我已经在上个世纪的 FORTRAN 77 代码示例中找到了这一点。

将此数字扩展为负REAL，

      L = SIGN(1.0,F)*INT(ABS(F) + 0.5)

回到上世纪80年代，最小代码示例如下所示：

      PROGRAM ROUNDTEST
      DO 12345 I=0,30
      F = -1.0 + I * 0.1
      J = INT(F)
      K = NINT(F)
      L = SIGN(1.0,F)*INT(ABS(F) + 0.5)
      PRINT *, I, F, J, K, L
12345 CONTINUE
      END

创建输出

$ ./ROUNDTEST
           0  -1.00000000              -1          -1          -1
           1 -0.899999976               0          -1          -1
           2 -0.800000012               0          -1          -1
           3 -0.699999988               0          -1          -1
           4 -0.600000024               0          -1          -1
           5 -0.500000000               0          -1          -1
           6 -0.399999976               0           0           0
           7 -0.300000012               0           0           0
           8 -0.199999988               0           0           0
           9  -9.99999642E-02           0           0           0
          10   0.00000000               0           0           0
          11  0.100000024               0           0           0
          12  0.200000048               0           0           0
          13  0.300000072               0           0           0
          14  0.399999976               0           0           0
          15  0.500000000               0           1           1
          16  0.600000024               0           1           1
          17  0.700000048               0           1           1
          18  0.800000072               0           1           1
          19  0.899999976               0           1           1
          20   1.00000000               1           1           1
          21   1.10000014               1           1           1
          22   1.20000005               1           1           1
          23   1.29999995               1           1           1
          24   1.40000010               1           1           1
          25   1.50000000               1           2           2
          26   1.60000014               1           2           2
          27   1.70000005               1           2           2
          28   1.79999995               1           2           2
          29   1.90000010               1           2           2
          30   2.00000000               2           2           2

ROUNDTEST由gfortran版本7.4.0的

编译和链接

$ gfortran.exe ROUNDTEST.FOR -o ROUNDTEST

希望这对您必须处理旧的FORTRAN代码有帮助。

Fortran 77 Real到Int舍入方向？

3 个答案: