【问题标题】:Fortran 77 Real to Int rounding Direction?Fortran 77 Real 到 Int 舍入方向?
【发布时间】:2019-05-02 14:37:56
【问题描述】:

移植一些 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?

【问题讨论】:

    标签: fortran rounding


    【解决方案1】:

    INT 总是四舍五入向下:

    来自GCC documentation:

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

    (A) 如果 A 是 INTEGER 类型,则 INT(A) = A

    (B) 如果 A 是 REAL 类型并且 |一个|

    (C) 如果 A 是 COMPLEX 类型,规则 B 是 应用于 A 的实部。

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

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

    【讨论】:

    • 太棒了。也感谢您提供指向文档的链接 - 我通过 GNU 走在正确的轨道上,而不是 1995 年左右的大学教程页面。
    【解决方案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 编译

    【讨论】:

    • 我认为这取决于您真正需要什么,从某种意义上说要完成的操作和要获得的结果
    • 好吧,我只是想说,假设 int() 总是给出预期的整数有时是危险的。 software.intel.com/en-us/forums/…
    【解决方案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 代码,希望这对您有所帮助。

    【讨论】:

      猜你喜欢
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 2013-06-27
      • 2023-03-27
      • 1970-01-01
      • 1970-01-01
      • 2016-12-15
      • 1970-01-01
      相关资源
      最近更新 更多