[转载]Fortran 77, C, C++ 和 Fortran 90 的比较

发信人: quasar (飞贼克斯), 信区: Fortran
标  题: Fortran 77, C, C++ 和 Fortran 90 的比较(转载)
发信站: 南京大学小百合站 (Tue Jun  1 10:59:14 2004)


瀚海星云 -- 文章阅读 [讨论区: MathTools]

发信人: HuiCai (老灰菜), 信区: SciComp
标  题: Fortran 77, C, C++ 和 Fortran 90 的比较(转载)
发信站: 瀚海星云 (2002年12月19日10:40:38 星期四), 站内信件

【 以下文字转载自 Fortran 讨论区 】
【 原文由 HuiCai 所发表 】

Fortran 77, C, C++ 和 Fortran 90 的比较
http://www.csdn.net/develop/article/16/16085.shtm

三十年来, 从 Fortran 77 开始, Fortran 成为了计算科学的主要语言.在这段时间里, Fortran 的数值能力变得非常稳定 而且优于其它计算机语言; 最大的改变来自于不断增长的各种可靠的数值过程库的种类. Fortran 联合(union), 它的使用技巧, 扩充的数值库为计算科学赋予了良好的基础.

可是在过去十几年中, 动态数据结构(特别是动态数组)的重要性不窜上升, UNIX 工作站, 复杂的交互式可视化工具, 以及更近的并行体系结构--Fortran 77 都没有实现--刺激了其它语言作为计算语言的使用, 最明显的一个例子是C. 最近C++ 也已经引起人们的兴趣, Fortran 通过发展到 Fortran 90来弥补它在现代科学计算方面的不足. 这部分的一个通常的工作是比较四种语言对科学计算的适应性的, 这四种语言是两个C 的代表(C, C++) 和两个Fortran的代表(Fortran 77, Fortran 90). 下面的表格总结了这种比较, 后面的内容试图合理地解释这种等级排序, 从最好(1)到最差(4)..

功能 ------------ F77 - C - C++ - F90
数值健壮性 ---- 2 ---- 4 --- 3 ----- 1
数据并行性 ---- 3 ---- 3 --- 3 ----- 1
数据抽象 ------- 4 ---- 3 --- 2 ----- 1
面向对象编程 - 4 ---- 3 --- 1 ----- 2
函数型编程 ---- 4 ---- 3 --- 2 ----- 1
平均等级 ------ 3.4 - 3.2 - 2.2 -- 1.2

1 数值健壮性

 Numeric Polymorphism(数值多态性)中是一个给定一个通用名称的几种版本的图形平滑过程的例子. 这里描述的通用能力是作为Fortran 90提供的一种额外的数值健壮性超过Fortran 77和C的特性. Fortran 77, Fortran 90 , 和 C 版本的SMOOTH子过程也在下面给出, 用于比较. (注意, Fortran 90版使用了第4部分描述的并行性)

数值多态性, 加上实际类型的参数, 小数精度选择, 和数字环境变量检查等, 证明了Fortran 90排在这四种语言中的第一位. Fortran 77 列在第二为的原因在于它支持复杂变量, 这在很多计算科学应用中是很重要的. C++ 把 C 挤出了第三位是由于它在通常领域多态性上的能力.


2 数据并行化部分

在这四种语言中, 只有Fortran 90具有对科学计算有价值的数据并行能力; 其它三种语言在这方面的特性基本上是一样的, 即全都没有. 这解释了四种语言在这个方面的排名.

这里是完成高斯消去的一套Fortran 77 和 C 过程:

*****************************************************************
* 编程决定正确的子过程处理过程: pivot.f , triang.f , 和 back.f. *
* 子过程决定一系列同步方程的解　　　　　　　　　　　　　　　　　*
*****************************************************************
*234567

      PROGRAM testg
      INTEGER IMAX, JMAX
      PARAMETER (IMAX = 3, JMAX = 4)
      REAL matrix(IMAX, JMAX)
      REAL matrix(IMAX)
      INTEGER i, j, n

      DATA ( ( matrix(i,j), j = 1, JMAX), i = 1, IMAX)
      + /-1.0, 1.0, 2.0, 2.0, 3.0, -1.0, 1.0, 6.0,
      + -1.0, 3.0, 4.0, 4.0/

      n = IMAX

      write(*,*) /"The original matrix,/",n,/"by/",n=1,/":/"
      call wrtmat(matrix, n, n +1)
      call pivot(matrix, n)
      write(*,*) /"The matrix after pivoting:/"
      call wrtmat(matrix, n, n +1)
      call triang(matrix, n)
      write(*,*) /"The matrix after lower triangulation:/"
      call wrtmat(matrix, n, n + 1)
      call back(solvec, matrix, n)
      write(*,*) /"The solution vector after back substitution:/"
      write(*,*) /"********************************************/"
      write(*,*) (solvec(i), i = 1, n)
      write(*,*) /"********************************************/"

      end

********************************************************************
*　子过程决定第一列系数矩阵的最大值, 把最大值所在的行和第一行交换, *
*　处理器然后重复对其他的行和列做这种处理, 对于每一次叠代, 列的位置*
*　和行的位置增加一(即, 第1行-第1列, 然后第2行-第2列, 然后第3行-第 *
*　3列, 等　　　　　　　　　　　　　　　　　　　　　　　　　　　　 *
********************************************************************
*234567

      SUBROUTINE pivot(matrix, n)
      INTEGER i, j, k, n
      REAL matrix(n, n + 1), maxval, tempval

      do 10, j = 1, n
      　maxval = matrix(j,j)
      　do 20, i = j + 1, n
      　　if (maxval .lt. matrix(i,j)) then
      　　　maxval = matrix(i,j)
      　　　do 30, k = 1, n + 1
      　　　　tempval = matrix(i,k)
      　　　　matrix(i,k) = matrix(j, k)
      　　　　matrix(j,k) = tempval
      30　　continue
      　　endif
      20 continue
      10 continue

      end

***************************************
*　完成一个输入矩阵的低级分解的子过程 *
***************************************
*234567

      SUBROUTINE triang(matrix, n)
      INTEGER i, j, k, n
      REAL matrix(n, n + 1), pivot, pcelem

      do 10, j = 1, n
      　pivot = matrix(j,j)
      　do 20, k = j + 1, n + 1
      　　　matrix(j,k) = matrix(j,k) / pivot

20　　 continue

      　do 30, i = j + 1, n
      　　　pcelem = matrix(i,j)
      　　　do 40, k = j + 1, n + 1
      　　　　　matrix(i,k) = matrix(i,k) - pcelem * matrix(j,k)

40　　　　 continue

30　　　continue

      end

**********************************************************
* 子过程从一个已经经历了低级分解的参数矩阵计算一个解向量 *
**********************************************************
*234567

      SUBROUTINE back(solvec, matrix, n)
      INTEGER n
      REAL solvec(n), matrix(n, n + 1), sum

      solvec(n) = matrix(n, n + 1)

      do 10, i = n -1, 1, -1
      　　　sum = 0.0
      　　　do 20, j = i + 1, n
      　　　　sum = sum + matrix(i, j) * solvec(j)

20 　　　　continue
　　　　　 solvec(i) = matrix(i, n + 1) - sum

10　 continue

      end

***********************************************************
* 测试子过程bisec.f的程序, bisec.f 决定一个方程(f.f中)的解*
* 可是这个函数确实假设函数-f由两个值支撑. 即在用户给定的终*
* 点之间的解不超过一个　　　　　　　　　　　　　　　　　　*
***********************************************************
*234567

      PROGRAM testbs
      REAL xleft, xright
      REAL f
      EXTERNAL f

      write(*,*) /"Please enter an initial left and right value:/"
      read(*,*) xleft, xright
      call bisec(f, xleft, xright)

      end

这里是同一个算法的C 过程:

/********************************************************
* 决定三个函数(pivot.c, triang.c, back.c)正确处理的程序 *
* 这些函数决定了一系列同步方程的解　　　　　　　　　　　*
********************************************************/

#include <stdio.h>
#define IMAX 3
#define JMAX 4

float matrix[IMAX][JMAX] = {

                        {-1.0, 1.0, 2.0, 2.0 },

                        {3.0, -1.0, 1.0, 6.0 },

                        {-1.0, 3.0, 4.0, 4.0 }

                        　　　};

float solvec[IMAX] = { 0.0, 0.0, 0.0 };

main()

{

      void wrt_output(void);
      void pivot(void);
      void triang(void);
      void back(void);
      void wrt_vector(void);

      (void)printf("The original matrix %d by %d :/n", IMAX, JMAX);
      (void)wrt_output();
      (void)pivot();
      (void)printf("The matrix after pivoting:/n");
      (void)wrt_output();
      (void)triang();
      (void)printf("The matrix after lower decomposition:/n");
      (void)wrt_output();
      (void)back();
      (void)printf("The solution vector after back substitution:/n");
      (void)wrt_vector();

}

/***********************************************************
* 决定参数矩阵中第一列的最大元素并移动第一列含有最大值的行 *
* 到第一行. 然后重复对其他的行和列做这种处理, 对于每一次叠 *
* 代, 列的位置和行的位置增加一(即, 第1行-第1列, 然后第2行- *
* 第2列, 然后第3行-第3列, 等*
************************************************************/

void pivot()

{

int i, j, k;
float maxval, tempval;

for(j = 1; j < IMAX; j++) {
　maxval = matrix[j][j];
　for ( i = (j + 1); i < IMAX; i++) {
　　if ( maxval < matrix[i][j] ) {
　　　maxval = matrix[i][j];
　　　for( k = 0; k <= IMAX; k++) {
　　　　tempval = matrix[i][k];
　　　　matrix[i][k] = matrix[j][k];
　　　　matrix[j][k] = tempval;
　　　}
　　　}
　　}
　}
}

/***********************************
* 完成一个输入矩阵的低级分解的函数 *
************************************/

void triang(void)

{

int i, j, k;
float pivot, pcelem;

for ( j = 0; j < IMAX; j++) {

      pivot = matrix[j][j];

      for ( k = ( j + 1 ); k <= IMAX; K++) {

            matrix[j][k] = matrix[j][k] / pivot;

      }

      for ( i = ( j + 1 ); i < IMAX; i++) {

            pcelem = matrix[i][j];

            for ( k = ( j + 1 ); k <= IMAX; k++) {

                  matrix[i][k] = matrix[i][k] - ( pcelem * matrix[j][k] );

            }

      }

}

}

/*********************************************************
* 子过程从一个已经经历了低级分解的参数矩阵计算一个解向量 *
*********************************************************/

void back(void)

{

int i, j;

      float sum;
      solvec[IMAX - 1] = matrix[IMAX - 1][JMAX -1];

      for ( i = (IMAX -1); i > -1; i--) {
      　　sum = 0.0;
      　　for ( j = (i + 1); j < IMAX; j++) {
      　　　　sum = sum + matrix[i][j] * solvec[j];
      　　}
      　　solvec[i] = matrix[i][IMAX] - sum;

      }

}

void wrt_output(void)
{

　int i, j;

　(void)printf("**************************************/n");

      for ( i = 0; i < IMAX; i++) {
      　　for ( j = 0; j < (JMAX - 1); j++) {
      　　　　(void)printf("%f", matrix[i][j]);
      　　}
      　　(void)printf("%f/n", matrix[i][JMAX - 1]);

      }

      (void)printf("****************************************/n");

}

void wrt_vector(void);
{

(void)printf("*************************************/n");
　　(void)printf("%f", solvec[0]);
　　(void)printf(" %f", solvec[1]);
　　(void)printg(" %f/n", solvec[2]);

(void)printf("****************************************/n");
}

/***********************************************************
* 测试函数bisec.f的程序, bisec.f 决定一个方程(f中)的解 　　*
* 可是这个函数确实假设函数-f由两个值支撑. 即在用户给定的终 *
* 点之间的解不超过一个　　　　　　　　　　　　　　　　　　 *
************************************************************/

#include <stdio.h>
#include <math.h>

main()
{

　void bisec(float init_left_val, float init_right_val);
　float f(float value):
　　　　float xleft, xright;
　　　　char line[100];

　　　　(void)printf("Please enter an initial left and right value:");
　　　　(void)fgets(line, sizeof(line), stdin);
　　　　(void)sscanf(line, "%f %f", &xleft, &xright );

　　　　(void)bisec(xleft, xright);
　　　　return(0);

}

3 数据抽象

Fortran 90有一个非常使用的， 使用简单的数据抽象能力。 C ++作为面向对象程序设计的一个重要部分，也有很出色的数据抽象能力. 对于计算科学来说, 很多好处可以从数据抽象中获得, 而不需要面向对象编程的带来的额外的复杂性, 因此Fortran 90 在这个方面有微弱的优势. 在这一点上Fortran 77和C要比 Fortran 90 和 C++逊色许多, 尽管 C 由于对数据结构的支持而在这里的排名在 Fortran 77的前面.

4 面向对象编程

因为Fortran 90 不支持自动继承, C ++ 在这一点上显然领先于其它语言. Fortran 90的多态性(一般的)特性是它具有手工的(而不是自动的)继承能力, 这种能力使它在这一点上领先于C 和 Fortran 77. 同样, C 由于其数据结构方面的能力使得它在这个一般的领域领先于Fortran 77.

5 函数型程序设计

由于缺少递归和数据结构, Fortran 77显然在这方面又一次排在最后. 其它三种语言都具有这些对于函数型程序设计来说是基本的方面. 不过在这三种语言中, 只有Fortran 90允许"lazy evaluation"; 标准C(因此包括C++)说明一种函数参数求值和函数本身求值之间的一个"顺序点", 妨碍了函数参数的"lazy evaluation". 因此在这个标准上, Fortran 90理应排在第一位. 多态性在函数性程序设计中同样是重要的, C++在这一点上要比C 好.
--
※ 来源:·瀚海星云 bbs.ustc.edu.cn·[FROM: 210.45.124.65]
--
※ 转载:·瀚海星云 bbs.ustc.edu.cn·[FROM: 210.45.124.65]

[上一篇][本讨论区][下一篇][同主题阅读]

--

※ 来源:．南京大学小百合站 http://bbs.nju.edu.cn [FROM: 221.226.2.24]