2

所以我一直像瘟疫一样避免Fortran，但终于我的时间到了......我需要参与别人的Fortran代码（我们称之为程序A）并用它做两件事：

（1）将其与第三人的Fortran代码合并（我们称其为程序B），以便B可以调用A

(2) 将它与我的 C++ 代码（程序 C）合并，以便 C 可以调用 A

B 和 C 是优化算法，A 是基准函数的集合......但在所有这些令人敬畏的事情发生之前，我必须首先编译我需要的 A 部分。我需要的 A 的所有子程序都包含在一个文件中。我一直在根据我在网上获得的信息（例如，在代码中添加“IMPLICIT NONE”并使其适用于 gfortran）来调整它。但是我有两个顽固的错误和一个警告（我将把警告留到另一篇文章中）。

这是我目前的编译方式（通过 Makefile）：

all:
    gfortran progA.FOR
    g++ -c progC.cpp
    g++ -o Program.out progA.o progC.o
    rm *.o

但是第一行未能完成并出现以下错误，

第一个错误：

SUBROUTINE TP1(MODE)
1
Error: Unclassifiable statement at (1)

相关代码（从文件顶部开始）：

      IMPLICIT NONE  
      INTEGER    NMAX,MMAX,LMAX,MNNMAX,LWA,LIWA,LACTIV,N,NILI,NINL,
     /           NELI,NENL,NEX, MODE              
      PARAMETER (NMAX   = 101, 
     /           MMAX   = 50, 
     /           LMAX   = 50, 
     /           MNNMAX = NMAX + NMAX + MMAX + 2,
     /           LWA    = 2*NMAX*NMAX + 33*NMAX + 10*MMAX + 200,
     /           LIWA   = MMAX + NMAX + 150,
     /           LACTIV = 2*MMAX + 15)  
      LOGICAL    INDEX1,INDEX2

      SUBROUTINE TP1(MODE)      
      COMMON/L1/N,NILI,NINL,NELI,NENL   
      COMMON/L2/X(2)   
      COMMON/L4/GF(2)   
      COMMON/L6/FX      
      COMMON/L9/INDEX1  
      COMMON/L10/INDEX2 
      COMMON/L11/LXL    
      COMMON/L12/LXU    
      COMMON/L13/XL(2)  
      COMMON/L20/LEX,NEX,FEX,XEX(2)     
      REAL*8 X,G,GF,GG,FX,XL,XU,FEX,XEX 
      LOGICAL LXL(2),LXU(2),LEX 
      GOTO (1,2,3,4,4),MODE     
1     N=2       
      NILI=0    
      NINL=0    
      NELI=0    
      NENL=0    
      X(1)=-2.D0
      X(2)=1.D0 
      LXL(1)=.FALSE.    
      LXL(2)=.TRUE.     
      LXU(1)=.FALSE.    
      LXU(2)=.FALSE.    
      XL(2)=-1.5D0      
      LEX=.TRUE.
      NEX=1     
      XEX(1)=1.D0       
      XEX(2)=1.D0       
      FEX=0.D0  
      RETURN    
2     FX=100.D0*(X(2)-X(1)**2)**2+(1.D0-X(1))**2
      RETURN    
3     GF(2)=200.D0*(X(2)-X(1)**2)       
      GF(1)=-2.D0*(X(1)*(GF(2)-1.D0)+1.D0)      
4     RETURN    
      END

我不明白为什么会出现这个错误，因为有超过 300 个其他子程序以完全相同的方式声明（例如 SUBROUTINE TP2(MODE), ..., SUBROUTINE TP300(MODE) ）。

第二个错误：

HX=TP273A(X)
1
Error: Return type mismatch of function 'tp273a' at (1) (REAL(4)/REAL(8))

相关代码：

      SUBROUTINE TP273(MODE) 
      COMMON/L1/N,NILI,NIML,NELI,NENL 
      COMMON/L2/X 
      COMMON/L4/GF 
      COMMON/L6/FX 
      COMMON/L11/LXL 
      COMMON/L12/LXU 
      COMMON/L20/LEX,NEX,FEX,XEX 
      LOGICAL LEX,LXL(6),LXU(6) 
      REAL*8 X(6),FX,GF(6),FEX,XEX(6),HX,DFLOAT
      GOTO (1,2,3,4,4)MODE 
 1    N=6 
      NILI=0 
      NINL=0 
      NELI=0 
      NENL=0 
      DO 6 I=1,6 
      X(I)=0.D+0 
      XEX(I)=0.1D+1 
      LXL(I)=.FALSE. 
6     LXU(I)=.FALSE. 
      LEX=.TRUE. 
      NEX=1 
      FEX=0.D+0 
      RETURN 
 2    HX=TP273A(X) 
      FX=0.1D+2*HX*(0.1D+1+HX) 
      RETURN 
 3    HX=TP273A(X) 
      DO 7 I=1,6 
 7    GF(I)=0.2D+2*(0.16D+2-DFLOAT(I))*(X(I)-0.1D+1) 
     1       *(0.1D+1+0.2D+1*HX) 
 4    RETURN 
      END       

      REAL*8 FUNCTION TP273A (X) 
      REAL*8 X(6),DFLOAT
      TP273A=0 
      DO 10 I=1,6 
10    TP273A=TP273A+(0.16D+2-DFLOAT(I))*(X(I)-0.1D+1)**2 
      RETURN
      END

阅读物理论坛后，我尝试将变量“TP273A”重命名为“TP273Avar”，这样它就不会与函数同名。这没有解决错误。此外，我将“1”替换为“7 GF(I) = ...”下方的“F”并重新编译。没有改变。我很确定我刚才提到的更改无论如何都是必要的，但肯定还有其他事情发生。

我还阅读了 fortran 中的 Data type mismatch和Function return type mismatch，所以我天真地尝试将“module mycode”添加到文件的顶部，将“end module mycode”添加到文件的底部，但无济于事。

在这一切都说完之后，我的目标是使用类似于以下的代码从 C++ 调用这些子例程：

#include <kitchensink>

extern"C"
{
void TP1_(int *mode);
}

int main()
{
    TP1_(2);
    return 0;
}

一旦 Fortran 代码编译，我想修改子例程，以便 C++ 可以将 std::vector X 传递给 TP#_(2,*X,*Y) 并取回 Y 的计算值。我的 std::vector X将替换每个子程序中的 COMMON/L2 X，Y 将是子程序中计算的 FX 值。我使用混合 Fortran 和 C作为上述 C++ 代码的指导。

至于B调用A部分，我希望它就像编译A和B一样简单，并在我需要的地方添加“CALL TP1（MODE）”行。

任何和所有的指导将不胜感激！！！

4

1 回答 1

6

您不能仅在编译单元之外的文件中包含语句。这些可以是子程序、函数、模块或程序。在您的情况下，您有一些语句（其中第一个是implicit none），并且只有在它们之后才有子例程 TP1 的开始。

要么将过程组织在一个模块中，并将公共部分放在该部分之前contains（如果您是 Fortran 新手，将进行更多的 C++ 互操作性工作），或者您必须implicit none在每个子例程中分别包含 the 和 other。如果代码以前有效，你确定你甚至需要这个吗？

于 2013-08-19T18:40:12.677 回答