关于python：如何在Fortran中获取先前未知的数组作为函数的输出


How to get priorly-unknown array as the output of a function in Fortran

在 Python 中：

1
2
3
4
5
6
def select(x):
    y = []
    for e in x:
        if e!=0:
            y.append(e)
    return y

的作用是：

1
2
3
x = [1,0,2,0,0,3]
select(x)
[1,2,3]

要翻译成Fortran：

1
2
3
4
5
6
7
8
9
10
11
function select(x,n) result(y)
    implicit none
    integer:: x(n),n,i,j,y(?)
    j = 0
    do i=1,n
        if (x(i)/=0) then
            j = j+1
            y(j) = x(i)
        endif
    enddo
end function

问题在 Fortran 中：

  • 如何声明 y(?)？
  • 如何声明 x 的预定义值
  • 如何避免维度信息 n

    • 对于 1，如果它被定义为 y(n)，输出将是：

    1
    2
    3
    x = (/1,0,2,0,0,3/)
    print *,select(x,6)
    1,2,3,0,0,0

    这是不希望的！
    !--------------------------------
    评论：
    1-所有给出的答案在这篇文章中都很有用。特别是 M.S.B 和 eryksun 的。
    2-我尝试针对我的问题调整想法并使用 F2Py 进行编译，但是没有成功。我已经使用 GFortran 对它们进行了调试，并且一切都成功了。这可能是 F2Py 中的一个错误，或者我不知道如何正确使用它。我将尝试在另一篇文章中讨论这个问题。

    更新：
    可以在此处找到链接的问题。

    相关讨论

    我希望有一个真正的 Fortran 程序员来，但在没有更好的建议的情况下，我只会指定 x(:) 的形状而不是大小，使用临时数组 temp(size(x))，并使输出 y 。然后在第一遍之后， allocate(y(j)) 并从临时数组中复制值。但是我不能强调我不是 Fortran 程序员，所以我不能说该语言是否具有可增长的数组或者是否存在用于后者的库。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    program test
        implicit none
        integer:: x(10) = (/1,0,2,0,3,0,4,0,5,0/)
        print"(10I2.1)", select(x)

    contains

        function select(x) result(y)
            implicit none
            integer, intent(in):: x(:)
            integer:: i, j, temp(size(x))
            integer, allocatable:: y(:)

            j = 0
            do i = 1, size(x)
                if (x(i) /= 0) then
                    j = j + 1
                    temp(j) = x(i)
                endif
            enddo

            allocate(y(j))
            y = temp(:j)
        end function select

    end program test

    编辑：

    根据 M.S.B.\\ 的回答，这里是函数的修订版本，该函数通过过度分配增加 temp y。 和之前一样，它在最后将结果复制到 y。 事实证明，我没有必要以最终大小显式分配一个新数组。相反，它可以通过赋值自动完成。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
        function select(x) result(y)
            implicit none
            integer, intent(in):: x(:)
            integer:: i, j, dsize
            integer, allocatable:: temp(:), y(:)

            dsize = 0; allocate(y(0))

            j = 0
            do i = 1, size(x)
                if (x(i) /= 0) then
                    j = j + 1

                    if (j >= dsize) then         !grow y using temp
                        dsize = j + j / 8 + 8
                        allocate(temp(dsize))
                        temp(:size(y)) = y
                        call move_alloc(temp, y) !temp gets deallocated
                    endif

                    y(j) = x(i)
                endif
            enddo
            y = y(:j)
        end function select
    相关讨论

    这是一个返回可变长度数组的 Fortran 函数示例。这是 Fortran 2003 的一个功能。测试驱动程序中还使用了自动分配分配，这是 Fortran 2003 的另一个功能。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    module my_subs

    contains

    function select(x) result(y)
        implicit none
        integer, dimension (:), intent (in) :: x
        integer, dimension (:), allocatable :: y
        integer :: i, j

        j = 0
        do i=1, size (x)
            if (x(i)/=0) j = j+1
        enddo

        allocate ( y (1:j) )

        j = 0
        do i=1, size (x)
            if (x(i)/=0) then
                j = j+1
                y(j) = x(i)
            endif
        enddo

        return

    end function select

    end module my_subs

    program test

    use my_subs

    implicit none
    integer, dimension (6) :: array = [ 5, 0, 3, 0, 6, 1 ]
    integer, dimension (:), allocatable :: answer

    answer = select (array)

    write (*, *) size (array), size (answer)
    write (*, *) array
    write (*, *) answer

    stop


    end program test

    这是一个替代解决方案，它使用临时数组根据需要"增长"输出数组(函数返回)。虽然避免了两次通过输入数组，但需要数组副本。 Fortran 2003 的另一个特性 move_alloc 减少了所需的副本数量。 move_alloc 还负责输出数组(此处为 "y")的(重新)分配和输入数组(此处为 "temp")的解除分配。也许这更优雅，但由于使用了多个副本，因此效率可能较低。这个版本可能更具教育意义然后有用。 @eryksun\\ 的版本使用一次传递和一份副本，代价是使临时数组变满。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    function select(x) result(y)
        implicit none
        integer, dimension (:), intent (in) :: x
        integer, dimension (:), allocatable :: y, temp
        integer :: i, j

        j = 0
        do i=1, size (x)
            if (x(i)/=0) then
                j = j+1
                allocate (temp (1:j))
                if ( allocated (y) ) temp (1:j-1) = y
                call move_alloc (temp, y)
                y(j) = x(i)
            endif
        enddo

        return

    end function select
    相关讨论

    如果您问题中的示例确实是您想要做的，您可以使用 Fortran90 内在 `pack\\':

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    program pack_example

    implicit none

    integer, dimension(6) :: x

    x = (/ 1,0,2,0,0,3 /)

    ! you can also use other masks than 'x/=0'
    write(*,*) pack(x, x/=0)

    end program pack_example

    示例程序的输出为：1 2 3

    相关讨论