编写一个接受任何两个数字（任何实数或任何整数）的函数

Question

我有一个接受两个数字的函数，我不在乎它们是整数、实数还是 32 位或 64 位。对于下面的例子，我只是把它写成一个简单的乘法。在 Fortran 90 中，您可以使用接口块来执行此操作，但如果您想涵盖将两个数字相乘的所有可能交互，则必须编写 16 个（！）函数，每个数字可以是 int32、int64、real32 或真正的64。

在 Fortran 2003 中，您还有一些其他选项，例如用于多态性的 class(*)，我找到了一种方法，只需在相乘之前将所有输入转换为实数：

! compiled on linux with gfortran 4.8.5

program main

   integer,   target :: i = 2
   real(4),   target :: x = 2.0
   real(8),   target :: y = 2.0
   character, target :: c = 'a'

   print *, multiply(i,x)
   print *, multiply(x,i)
   print *, multiply(i,i)
   print *, multiply(y,y) 
   print *, multiply(c,c)

contains

function multiply(p,q)

   real :: multiply
   class(*) :: p, q

   real :: r, s

   r = 0.0 ; s = 0.0

   select type(p)

      type is (integer(4)) ; r = p
      type is (integer(8)) ; r = p
      type is (real(4)) ;    r = p
      type is (real(8)) ;    r = p

      class default ; print *, "p is not a real or int"

   end select

   select type(q)

      type is (integer(4)) ; s = q
      type is (integer(8)) ; s = q
      type is (real(4)) ;    s = q
      type is (real(8)) ;    s = q

      class default ; print *, "q is not a real or int"

   end select

   multiply = r * s

end function multiply

end program main

这似乎是一种改进。至少这里的代码量在类型数量上是线性的而不是二次的，但我想知道是否还有更好的方法来做到这一点？如您所见，我仍然需要编写两次select type 代码，将“r”更改为“s”，将“p”更改为“q”。

我尝试将选择类型块转换为函数，但无法使其工作。但我对任何可以进一步改进的替代方案感兴趣。看起来这将是一个常见问题，但到目前为止我还没有找到任何比这更好的通用方法。

编辑添加：显然有计划改进 Fortran w.r.t.正如@SteveLionel 的评论中所指出的那样，将来会出现这个问题。 @roygvib 进一步提供了一个特定提案的链接，该提案也很好地解释了这个问题：https://j3-fortran.org/doc/year/13/13-236.txt

Answer 1

不是泛型的解决方案，而是“将选择类型块转换为函数”，以下代码似乎有效（如果包含一些重要的转换（？），这可能很有用）。

program main
    implicit none
    integer      :: i = 2
    real*4       :: x = 2.0
    real*8       :: y = 2.0
    character(3) :: c = 'abc'

    print *, multiply( i, x )
    print *, multiply( x, i )
    print *, multiply( i, i )
    print *, multiply( y, y )
    print *, multiply( c, c )

contains

function toreal( x ) result( y )
    class(*) :: x
    real :: y

    select type( x )
        type is (integer)      ; y = x
        type is (real(4))      ; y = x
        type is (real(8))      ; y = x
        type is (character(*)) ; y = len(x)
        class default          ; stop "no match for x"
    endselect
end

function multiply( p, q ) result( ans )
    class(*) :: p, q
    real :: ans
    ans = toreal( p ) * toreal( q )
end

end program

! gfortran-8 test.f90 && ./a.out
   4.00000000    
   4.00000000    
   4.00000000    
   4.00000000    
   9.00000000  

另一种方法可能只是将实际参数转换为实数（尽管它可能对更实际的目的没有用......）

program main
    implicit none
    integer   :: i = 2
    real*4    :: x = 2.0
    real*8    :: y = 2.0
    character :: c = 'a'

    print *, multiply( real(i), real(x) )
    print *, multiply( real(x), real(i) )
    print *, multiply( real(i), real(i) )
    print *, multiply( real(y), real(y) )
    ! print *, multiply( real(c), real(c) )  ! error

contains

function multiply( p, q ) result( ans )
    real :: p, q
    real :: ans
    ans = p * q
end

end program

Answer 2

这是一种通过接口块使用静态重载函数的替代方法，正如我的问题和@roygvib 的回答中隐含地提到的那样。 （我认为明确地写出来是有意义的，特别是如果有人可以改进它的话。）

接口块方法的两个优点是：

• 大约快 3 倍（@roygvib 也发现，虽然我 不知道他是怎么写函数的）
• 它只需要 Fortran 90（不是 Fortran 2003）

主要缺点是您必须多次编写函数。如问题中所述，在此示例中，您必须编写乘法函数 16 次，以处理 32 位和 64 位实数和整数的所有组合。这里并没有那么糟糕，函数是一行代码，但您可以很容易地看到，这对于许多实际用例来说更为严重。

下面是我用来测试接口块方法的代码。为了保持相对简洁，我只测试了 32 位实数和整数的 4 种排列。我重新使用了主程序来测试@roygvib 代码。在我 2015 年的 macbook 上，大约需要 16 秒（接口块）与 48 秒（类（*）方法）。

模块：

module mult_mod

use, intrinsic :: iso_fortran_env, only: i4 => int32, r4 => real32

interface mult
   module procedure mult_real4_real4
   module procedure mult_int4_real4
   module procedure mult_real4_int4
   module procedure mult_int4_int4
end interface mult

contains

function mult_real4_real4( p, q ) result( ans )
    real(r4) :: p, q
    real(r4) :: ans
    ans = p * q
end function mult_real4_real4

function mult_int4_real4( p, q ) result( ans )
    integer(i4) :: p
    real(r4)    :: q
    real(r4) :: ans
    ans = p * q
end function mult_int4_real4

function mult_real4_int4( p, q ) result( ans )
    real(r4)    :: p
    integer(i4) :: q
    real(r4) :: ans
    ans = p * q
end function mult_real4_int4

function mult_int4_int4( p, q ) result( ans )
    integer(i4) :: p, q
    real(r4) :: ans
    ans = p * q
end function mult_int4_int4

end module mult_mod

程序：

program main

    use mult_mod

    integer(i4) :: i = 2
    real(r4)    :: x = 2.0

    integer(i4) :: i_end = 1e9
    real(r4)    :: result

    do j = 1, i_end

        result = mult( x, x )
        result = mult( x, i )
        result = mult( i, x )
        result = mult( i, i )

    end do

end program main