C++ c++；和fortran进行相同的计算_C++_Cuda_Fortran

C++ c++；和fortran进行相同的计算

c++ cuda fortran

C++ c++；和fortran进行相同的计算,c++,cuda,fortran,C++,Cuda,Fortran,我正在将FORTRAN程序翻译成CUDA。当我翻译一个子例程时，我发现结果差别很大，从分数中的第三位开始！我已经读到它们确实不同（我已经读到，相对而言，差异将非常小）。我不知道节目里有没有什么不对劲。所以我也在C++中编译了代码，但是得到了与CUDA相同的结果。我正在发布这两个代码（C++和FORTRAN）。请查收 FORTRAN代码（原件） C++代码 #include<iostream> #include<fstream> #include<math.h&g

我正在将FORTRAN程序翻译成CUDA。
当我翻译一个子例程时，我发现结果差别很大，从分数中的第三位开始！我已经读到它们确实不同（我已经读到，相对而言，差异将非常小）。我不知道节目里有没有什么不对劲。所以我也在C++中编译了代码，但是得到了与CUDA相同的结果。我正在发布这两个代码（C++和FORTRAN）。请查收

FORTRAN代码（原件）

C++代码

#include<iostream>
#include<fstream>
#include<math.h>
#include<stdio.h>
#include<stdlib.h>
using namespace std;

void lenjones(int NATOMS, int* N5J, int* N5K, int* NREP, int* MREP, int* LREP, float* ALJ, float* BLJ, float* CLJ, int NLJ,float* Q, float* PDOT){

size_t NLJF = NLJ*sizeof(float);
size_t NLJI = NLJ*sizeof(float);

float* RMB = (float*)malloc(NLJF);
float* RLC = (float*)malloc(NLJF);
float* RNA = (float*)malloc(NLJF);
int *JKA=(int*)malloc(NLJI);
for (int NL=0; NL < NLJ; NL++){
    JKA[NL]= (((N5J[NL]-1)*((2*NATOMS)-N5J[NL]))>> 1) +N5K[NL]-N5J[NL];
    RNA[NL]=-NREP[NL]*ALJ[NL];
    RMB[NL]=-MREP[NL]*BLJ[NL];
    RLC[NL]=-LREP[NL]*CLJ[NL];
}

int J3,K3;
float T1,T2,T3;
float TDUM1,TDUM2,TDUM3,DUM;
size_t RRS = (NATOMS*(NATOMS+1)/2)*sizeof(float);
float* RR = (float*)malloc(RRS);
int JK;
for (int NL=0; NL < NLJ; NL++){
    J3=(3*N5J[NL])-1;
    K3=(3*N5K[NL])-1;
    T1=Q[K3-2]-Q[J3-2];
    T2=Q[K3-1]-Q[J3-1];
    T3=Q[K3]-Q[J3];
    JK=JKA[NL]-1;
    RR[JK]=sqrtf((T1*T1)+(T2*T2)+(T3*T3));
    RR[JK]=1/RR[JK];
    DUM=(RNA[NL]*powf(RR[JK],2+NREP[NL]));
    DUM+=(RMB[NL]*powf(RR[JK],MREP[NL]+2));
    DUM+=(RLC[NL]*powf(RR[JK],LREP[NL]+2));
    TDUM1=T1*DUM;
    TDUM2=T2*DUM;
    TDUM3=T3*DUM;
    PDOT[K3-2]=PDOT[K3-2]+TDUM1;
    PDOT[K3-1]=PDOT[K3-1]+TDUM2;
    PDOT[K3]=PDOT[K3]+TDUM3;
    PDOT[J3-2]=PDOT[J3-2]-TDUM1;
    PDOT[J3-1]=PDOT[J3-1]-TDUM2;
    PDOT[J3]=PDOT[J3]-TDUM3;
}

}


//=========================================
int main(){

int NATOMS,NDA3,ND05;
scanf("%d %d", &NATOMS, &ND05);
printf("\n");
NDA3=3*NATOMS;
size_t QPDOT = NDA3*sizeof(float);
float* h_Q = (float*)malloc(QPDOT);
float* h_PDOT = (float*)malloc(QPDOT);

size_t NLJ = ND05*sizeof(float);

float* h_ALJ = (float*)malloc(NLJ);
float* h_BLJ = (float*)malloc(NLJ);
float* h_CLJ = (float*)malloc(NLJ);

size_t NLJ_i = ND05*sizeof(int);
int* h_LREP = (int*)malloc(NLJ_i);
int* h_MREP = (int*)malloc(NLJ_i);
int* h_NREP = (int*)malloc(NLJ_i);
int* h_N5J = (int*)malloc(NLJ_i);
int* h_N5K = (int*)malloc(NLJ_i);
int* h_JKA = (int*)malloc(NLJ_i);

for (int i=0; i< ND05; i++){
    cin >> h_N5J[i] >> h_N5K[i] >> h_NREP[i] >> h_MREP[i] >> h_LREP[i] >> h_ALJ[i] >> h_BLJ[i] >> h_CLJ[i];
}
for (int i=0; i<NDA3; i++){
    scanf("%f", &h_Q[i]);
}
for (int i=0; i<NDA3; i++){
    h_PDOT[i]=0;
}

lenjones(NATOMS, &h_N5J[0], &h_N5K[0], &h_NREP[0], &h_MREP[0], &h_LREP[0], &h_ALJ[0], &h_BLJ[0], &h_CLJ[0], ND05, &h_Q[0], &h_PDOT[0]);

cout << "i  " << "Q[i]  " << "PDOT[i]" << endl;
for (int i=0; i<NDA3; i++){
    printf("%d  %e  %le \n" , i, h_Q[i], h_PDOT[i]);
}

}

#包括
#包括
#包括
#包括
#包括
使用名称空间std；
void lenjones（整数纳图、整数*N5J、整数*N5K、整数*NREP、整数*MREP、整数*LREP、浮点*ALJ、浮点*BLJ、浮点*CLJ、整数NLJ、浮点*Q、浮点*PDOT）{
尺寸NLJF=NLJ*sizeof（浮动）；
尺寸NLJI=NLJ*sizeof（浮动）；
浮动*人民币=（浮动*）马洛克（NLJF）；
float*RLC=（float*）malloc（NLJF）；
float*RNA=（float*）malloc（NLJF）；
int*JKA=（int*）malloc（NLJI）；
对于（int-NL=0；NL>1）+N5K[NL]-N5J[NL]；
RNA[NL]=-NREP[NL]*ALJ[NL]；
人民币[NL]=-MREP[NL]*BLJ[NL]；
RLC[NL]=-LREP[NL]*CLJ[NL]；
}
int J3，K3；
浮动T1、T2、T3；
浮动TDUM1、TDUM2、TDUM3、DUM；
大小（NATOMS*（NATOMS+1）/2）*大小（浮动）；
浮动*RR=（浮动*）malloc（RRS）；
int-JK；
对于（int-NL=0；NL>h_N5J[i]>>h_N5K[i]>>h_NREP[i]>>h_MREP[i]>>h_ALJ[i]>>h_BLJ[i]>>h_CLJ[i]；
}
对于（int i＝0；i＜p），如果你想得到更好的数学精度，你应该使用C++中的代码>双< /> >不是<代码>浮点 C++。不知道Fortran给了你什么精度（好，我猜是因为它广泛用于计算），但是<代码>浮点< /代码>对于C++数学来说是不精确的。
检查你的C++ /CUDA编译器选项，以获得最佳的数学精度，例如，对于相同的输入，输出<中间值>，并跟踪它们在哪一点开始发散。< /P> < P> >我注意到，在你的FORTRAN和C++代码之间，很可能引入数值差异：

FORTRAN的强大（**
）与C语言中的powf
）++
FORTRAN的sqrt
与C语言中的sqrt
相比++
在Fortran和C++之间对SSE的编译器选择（应该禁用它们的优化，然后检查数值差异）
浮点模式的编译器选择（快速与精确）
FORTRAN选项，用于模拟一些较旧的浮点模式（在非规范化情况下，VAX浮点数会随着truncate向0移动而出现）
这里到底是什么问题？我希望你不要让我们仔细检查你的未注释的C++是否相当于你的未注释的FORTRAN！我怀疑C标签可能在这里更好。我不能看到任何C++特定的东西（除了<代码>使用命名空间< /代码>以获得MALOC）还有许多C语言惯用的项目，如printf
和malloc
。哪个FORTRAN编译器？Compaq？您使用的浮点模型是什么？VAX“style”将truncate改为0而不是非非规范化？这里可能会出很多问题。@Mark B他将“using namespace”这一事实放在这里“安得烈不能：被标记为C，很快就被转换成C++。”问题应该标注“代码> C++ <代码>，使用命名空间STD < /C> > <代码>，因为没有使用这些C++标题，这是解决方案，而不是保持无意义的代码> C++< /Cult>标签。<代码>隐式实数 <代码>实数（A类＝4）。

在我遇到的几乎每一个编译器上。因此它应该相当于

float

。我的Nvidia gpu体系结构是1.0，不支持双精度。我用real在FORTRAN中尝试了单精度。FORTRAN的结果保持不变。@sixlettervariables-这个结论中有几个缺陷。首先，隐式real可以但不必等于（种类=4）。第二，更重要的是，种类值（它甚至不应该被称为值，而是种类“标记”）并不意味着任何东西，更不用说对允许值的精度和范围施加任何影响。因此，一个平台上的（种类=4）可以不同于（种类=4）在另一个平台上，F90/95引入了选定的实数类型和…用于准确处理该问题-跨平台的可移植精度。只有在不知道代码将在哪个平台上运行时，人们才意识到这一点的真正用处。@Rook:即使在Cray PVP上，我也使用了默认实数类型为4（可能较新的X1 w/CAF使用8）一吨F66/77依赖于默认的实数4。否则，我同意，如果作者有F90/95，他应该每次都使用

选定的\u real\u kind

。仍在尝试。我尝试使用电子表格进行评估

#include<iostream>
#include<fstream>
#include<math.h>
#include<stdio.h>
#include<stdlib.h>
using namespace std;

void lenjones(int NATOMS, int* N5J, int* N5K, int* NREP, int* MREP, int* LREP, float* ALJ, float* BLJ, float* CLJ, int NLJ,float* Q, float* PDOT){

size_t NLJF = NLJ*sizeof(float);
size_t NLJI = NLJ*sizeof(float);

float* RMB = (float*)malloc(NLJF);
float* RLC = (float*)malloc(NLJF);
float* RNA = (float*)malloc(NLJF);
int *JKA=(int*)malloc(NLJI);
for (int NL=0; NL < NLJ; NL++){
    JKA[NL]= (((N5J[NL]-1)*((2*NATOMS)-N5J[NL]))>> 1) +N5K[NL]-N5J[NL];
    RNA[NL]=-NREP[NL]*ALJ[NL];
    RMB[NL]=-MREP[NL]*BLJ[NL];
    RLC[NL]=-LREP[NL]*CLJ[NL];
}

int J3,K3;
float T1,T2,T3;
float TDUM1,TDUM2,TDUM3,DUM;
size_t RRS = (NATOMS*(NATOMS+1)/2)*sizeof(float);
float* RR = (float*)malloc(RRS);
int JK;
for (int NL=0; NL < NLJ; NL++){
    J3=(3*N5J[NL])-1;
    K3=(3*N5K[NL])-1;
    T1=Q[K3-2]-Q[J3-2];
    T2=Q[K3-1]-Q[J3-1];
    T3=Q[K3]-Q[J3];
    JK=JKA[NL]-1;
    RR[JK]=sqrtf((T1*T1)+(T2*T2)+(T3*T3));
    RR[JK]=1/RR[JK];
    DUM=(RNA[NL]*powf(RR[JK],2+NREP[NL]));
    DUM+=(RMB[NL]*powf(RR[JK],MREP[NL]+2));
    DUM+=(RLC[NL]*powf(RR[JK],LREP[NL]+2));
    TDUM1=T1*DUM;
    TDUM2=T2*DUM;
    TDUM3=T3*DUM;
    PDOT[K3-2]=PDOT[K3-2]+TDUM1;
    PDOT[K3-1]=PDOT[K3-1]+TDUM2;
    PDOT[K3]=PDOT[K3]+TDUM3;
    PDOT[J3-2]=PDOT[J3-2]-TDUM1;
    PDOT[J3-1]=PDOT[J3-1]-TDUM2;
    PDOT[J3]=PDOT[J3]-TDUM3;
}

}


//=========================================
int main(){

int NATOMS,NDA3,ND05;
scanf("%d %d", &NATOMS, &ND05);
printf("\n");
NDA3=3*NATOMS;
size_t QPDOT = NDA3*sizeof(float);
float* h_Q = (float*)malloc(QPDOT);
float* h_PDOT = (float*)malloc(QPDOT);

size_t NLJ = ND05*sizeof(float);

float* h_ALJ = (float*)malloc(NLJ);
float* h_BLJ = (float*)malloc(NLJ);
float* h_CLJ = (float*)malloc(NLJ);

size_t NLJ_i = ND05*sizeof(int);
int* h_LREP = (int*)malloc(NLJ_i);
int* h_MREP = (int*)malloc(NLJ_i);
int* h_NREP = (int*)malloc(NLJ_i);
int* h_N5J = (int*)malloc(NLJ_i);
int* h_N5K = (int*)malloc(NLJ_i);
int* h_JKA = (int*)malloc(NLJ_i);

for (int i=0; i< ND05; i++){
    cin >> h_N5J[i] >> h_N5K[i] >> h_NREP[i] >> h_MREP[i] >> h_LREP[i] >> h_ALJ[i] >> h_BLJ[i] >> h_CLJ[i];
}
for (int i=0; i<NDA3; i++){
    scanf("%f", &h_Q[i]);
}
for (int i=0; i<NDA3; i++){
    h_PDOT[i]=0;
}

lenjones(NATOMS, &h_N5J[0], &h_N5K[0], &h_NREP[0], &h_MREP[0], &h_LREP[0], &h_ALJ[0], &h_BLJ[0], &h_CLJ[0], ND05, &h_Q[0], &h_PDOT[0]);

cout << "i  " << "Q[i]  " << "PDOT[i]" << endl;
for (int i=0; i<NDA3; i++){
    printf("%d  %e  %le \n" , i, h_Q[i], h_PDOT[i]);
}

}