Fortran导引
1、Fortran学习的一些建议
相信大家都对C语言有一定的了解，其实Fortran跟C相差不是很多。
我把自己认为比较合理快速学习Fortran的方法说下。
学习Fortran，会遇到Fortran77&Fortran90等等，两者差别不大，建议学习Fortran90或更高，更加自由些（仅对一般用而言，其他优势可能体现不出来），对自己以后学习他的程序包也会有好处。
大家一般只是为了编程，为了计算而学Fortran，而不是为了学习Fortran而学Fortran，所以我的建议是学习Fortran不要像学C那样拿一本很详细的教材从头至尾学下来，一个大家都有不错的C语言基础，而且也没有太多的精力去专门研究这些，倒不如看些简易的教材（我会附上），掌握基本语句之后直接从看最简单的程序开始。这样，很快就会体会到Fortran的格式，可以开始自己写程序了。学习的顺序我建议如下：
1、 编一些仅含输入输出的程序，然后可以尝试把输入输出同文件结合起来（从文件里读数据、写数据）；
2、 然后可以学条件判断、循环语句，通过几个实例也可以很快掌握；
3、 再往后就是写子程序，就是程序的调用，相信那个时候，看了我的第一个例子（PROGRAM A）就应该能写出简单的含函数调用的程序，到了这里，基本上可以算告一段落，可以进行结构上复杂的程序的编写；
4、 最后，可以学一下多个程序的编译甚至是多种语言程序的混编（如既有C又有Fortran的多个程序一起编译）。多个程序的编译我不并不熟悉，就留给siriusbobo同志来解说吧:-)
在编程中遇到困难然后再去查找资料和用法不失为一种好的方法，不必刻意去求学全。当然，有足够时间和精力的同学强烈建议好好看教材，不必急于求成，有一个好的基础总是一件很好的事。Fortran相比C的优势的话在于它丰富的资源，C的优势可能是更加简洁，编译效率更高。但对于我的平时使用来说，这两者的优势、劣势都体现不出来，自己的感觉是Fortran更接近平时的科学语言，比较严谨些，更容易读懂不出错，比较符合习惯，变量、函数的声明上也比C更方便灵活，以外函数的使用为例：
******************************************************************************
PROGRAM A
real z
read *,z
call f(z)
y=z
print *,y
end
subroutine f(x)
x=x**2
return
end
******************************************************************************
只需要加一个"subroutine"程序段，主函数即可用"call"调用，当然也可以写多个子程序，其中一个子程序也可以通过"call"来调用其他子程序。就一般学习而言，除了子程序的编写，另外一个用得比较多的是文件的读写操作，读用"read",写用"write"，如下：
******************************************************************************
PROGRAM B
real x
open (1,file='in.dat',status='unknown')
open (2,file='out.dat',status='unknown')
read (1,100) x
100 format (1e12.7)
close(1)
write (2,200) x
200 format (1e15.8)
close(2)
end
******************************************************************************
如果用"*"的话，就为默认形式，更具体的可以查看帮助或有关资料，比较好的方法是随时做一个test程序，用来检测所学或所想。对于上程序，出现的"100","200"是语句标号，这些标号为方便语句的跳转而出现，可以实
现循环、条件控制等，但也为了使程序结构化而不推荐使用，用goto语句和语句标号实现语句的跳转如下：
******************************************************************************
PROGRAM C
integer n
real z
n=0
read *,z
1 call f(z)
y=z
n=n+1
if (n<10) goto 1
print *,y
end
subroutine f(x)
x=x**2
return
end
******************************************************************************
这类跳转在F77里经常用到，F90以后并不多见，但对于"100 format (1e12.7)"之类还是经常用到，这是用来表示存储读取的数据的格式的，可以放在程序任何位置，更具体的用法要参看说明。
有关注释：
Fortran里注释用"!"或"C"，其中，一般在Windows下使用"Compad Visual Fortran"编译，有两种格式，一个是"Free Format"，生成".f90"，另外一个"Fixed Format"，生成".for"，只有".for"里两种注释都可用（"!"或"C"），但在".f90"里只能用"!"。
有关学习的困难：
算法是语言的灵魂没错，是最麻烦的，但想必大家都学过C，遇到过不少算法，这些可以用C实现的，用Fortran 实现都不是很困难，所以这里不主要讨论这个“灵魂”性质的东西。
常量、变量、数组的数据类型，以及数据类型的读写控制倒是经常容易出错的。下面主要讲一些我认为需要注意的和我曾经犯过和看到过的错误。
Fortran跟C一样，也分整型(INTEGER)，实型(REAL)，双精度(REAL*8或REAL(8)或DOUBLE PRECISION)，这些在科学计算中还是比较重要的，以实型数为例：一般REAL等价于REAL*4或REAL(4),是单精度的；
而双精度在F77中表示为DOUBLE PRECISION，在F90中可以表示为REAL*8或REAL(8)，在高精度计算中，双精度的变量是很有必要的，对于一般实数可以表示为小数形式或指数形式，而双精度都表示成指数形式，但指数E要改成D，如：
REAL:100.0或1e2,双精度下就得表示成1D2
由于Fortran中不需要对每个变量都进行声明，所以有时候会在每个程序或子程序开头做个说明，如下： IMPLICIT DOUBLE PRECISION(A-H,O-Z)
代表以A-H以及O-Z字母开头的变量默认（在不声明的情况下）是双精度的，否则则是整型的，如下：
******************************************************************************
PROGRAM D
IMPLICIT DOUBLE PRECISION(A-H,O-Z)
J1=1D-2
J2=-0.5D-1
x=J1+J2
print *,x
end
******************************************************************************
PROGRAM E
implicit double precision (A-I,O-Z)
double precision a,i,e1,e2
data j2 /0.87450547081842D-3/
data j3 /-0.11886910646016D-4/
data j5 /-0.17242068505339D-5/
data j7 /0.10566966079622D-6/
write(*,*) "please input a"
read(*,*) a
write(*,*) "please input i"
read(*,*) i
e1=(j3*sin(i)/(2*a*j2)-5*j5*sin(i)*(1-7*sin(i)**2/2+21*sin(i)**4/8)&
&/(2*a**3*(2-5*sin(i)**2/2))+35*j7*sin(i)*(1-27*sin(i)**2/4+99&
&*sin(i)**4/8-429*sin(i)**6/64)/(3*a**5*(2-5*sin(i)**2/2)))
e2=-(j3*sin(i)/(2*a*j2)-5*j5*sin(i)*(1-7*sin(i)**2/2+21*sin(i)**4/8)&
&/(2*a**3*(2-5*sin(i)**2/2))+35*j7*sin(i)*(1-27*sin(i)**2/4+99&
&*sin(i)**4/8-429*sin(i)**6/64)/(3*a**5*(2-5*sin(i)**2/2)))
write(*,"(E9.2E3)") e1,e2
stop
end
******************************************************************************
第一个程序输出不是-0.4而是0.000000000000000E+000
第二个程序任意输入a、i，并未得到希望得到的结果，而是输出NAN和NAN，关于NAN这个错误，有时候函数定义域不符合的时候，运行并不报错而是输出NAN，这个时候检查程序这些地方是检查的重点，当然，会有其他情况，但我碰到的不多，只好就我所知跟大家交流一下。
这两个程序都因为J开头的变量不属于默认双精度变量，而用双精度表示给它们赋值了，导致结果跟预期不一致，在程序中把这些以J开头的变量用REAL*8声明一下，或把implicit double precision (A-I,O-Z)改为：
implicit double precision (A-J,O-Z)，或把这个语句去掉就可以得到预期的结果了。
对于数组，可以用DIMENSION定义，但需要注意的是，若在程序头未做声明（implicit none）时，用DIMENSION 定义数组时，当数组名首字母不属于(A-J,O-Z)里时，其值输出时为整型，当然做了如下声明情况也会如此：（implicit double precision (A-I,O-Z)）
如下：
******************************************************************************
PROGRAM F
dimension m(2)
m(1)=1.5
m(2)=2.5
print *,m(1),m(2)
end
******************************************************************************
输出的结果是“1，2”而不是“1.500000,2.500000”
当把程序中m改为a时，输出“1.500000,2.500000”
所以，比较好的方法是尝试用REAL来定义数组（当然也可以用REAL*8）：
******************************************************************************
PROGRAM G
real m(2)
m(1)=1.5
m(2)=2.5
print *,m(1),m(2)
end
******************************************************************************
另外，要说的是，变量可以不定义而直接赋值，但会出现如上面PROGRAM D-E的问题，所以建议大家在编程的时候对非整型变量声明一下，尽管麻烦，但不容易出错，有时候正是这类错误会让初学者困扰好久。
定义变量时，经常会看到两种定义的写法：以REAL为例：可以有
real m和 real:: m
第一种方式不可以直接赋值，必须写成这样：
******************************************************************************
PROGRAM H
real m
m=1.0
print *,m
end
******************************************************************************
第二种则可以：
******************************************************************************
PROGRAM I
real:: m=1.0
print *,m
end
******************************************************************************
2、一些免费的Fortran编译器
Free Fortran Compilers
取自https://www.doczj.com/doc/ba11303264.html,/compilers/fortran.shtml
This page lists free Fortran compilers for various operating systems. Some of the compilers are compliant
with the ANSI Fortran 77 specifications, others with Fortran 95, and so on. Some of them may also come complete with debuggers, editors and an integrated development environment (IDE).
If you need a book on Fortran, you may want to check out the selection of books available at https://www.doczj.com/doc/ba11303264.html,.
3、我的Fortran基本用法小结
目录：
一、说明
二、概述
三、数据类型及基本输入输出
四、流程控制
五、循环
六、数组
七、函数
八、文件
3.1、说明
本文多数内容是我读彭国伦《Fortran 95 程序设计》的笔记。只读到第九章，主要是3~9
章，都是最基本的用法（原书共16章）。这里主要摘录了我看书过程中总结的一些Fortran和C不
同的地方，主要是语法方面。希望这份笔记能够给学过C但没有接触过Fortran的同学带去一些帮
助。要想得更清楚些，推荐看一下原书，觉得作者真的写得很好，很清楚；如果有C语言的基础，
看完前九应该很快的，花一两天就行了。觉得如果耐心看完本文，基本功能应该也可以顺利用起
来了。外，由于我之前没有用过Fortran，这次为了赶文档看书又看得很粗浅，大多数东西看过
之后都没得及仔细想，只是按着作者的意思去理解。所以这份笔记还处于纸上谈兵的层次。如果
有不妥的方，希望大家指正。谢谢！
文中蓝色的部分是程序代码，!后面的内容为注释。
3.2、概述
1、名词解释
Fortran=For mula Tran slator/Translation
一看就知道有什么特色了：可以把接近数学语言的文本翻译成机械语言。的确，从一开始
，IBM设计的时候就是为了方便数值计算和科学数据处理。设计强大的数组操作就是为了实现这一
目标。ortran奠定了高级语言发展的基础。现在Fortran在科研和机械方面应用很广。
2、Fortran的主要版本及差别
按其发展历史，Fortran编译器的版本其实很多。现在在广泛使用的是Fortran 77和Fortr
an90。ortran 90在Fortran 77基础上添加了不少使用的功能，并且改良了77编程的版面格式，
所以编程时推荐使用90。鉴于很多现成的程序只有77版本，有必要知道77的一些基本常识，至少保
证能够看77程序。以下是77和90的一些格式上的区别。
Fortran 77： 固定格式（fixed format），程序代码扩展名：.f或.for
（1）若某行以C,c或*开头，则该行被当成注释；
（2）每行前六个字符不能写程序代码，可空着，或者1~5字符以数字表明行代码（用作格
式化输入出等）；7~72为程序代码编写区；73往后被忽略；
（3）太长的话可以续行，所续行的第六个字符必须是"0"以外的任何字符。
Fortran 90：自由格式（free format）， 扩展名：.f90
（1）以"!"引导注释；
（2）每行可132字符，行代码放在每行最前面；
（3）以&续行，放在该行末或下行初。
以下都是讨论Fortran 90。
3、Fortran的一些特点，和C的一些不同
其实很多，在下面涉及具体方面时可以看到。这里只是大致提一些。
（1）不分大小写
（2）每句末尾不必要写分号
（3）程序代码命令间的空格没有意义
（4）不像C，Fortran不使用{ }
（5）数据类型多出了复数和逻辑判断类型。比如复数类型
complex :: a !声明复数的方法。复数显然方便了科学计算，满足了工程方面需求
a=(1.0,2.0) ! a=1+i
（6）多出了乘幂运算（**）。乘幂除了整数还可以是实数形式。如开方，开立方
a=4.0**0.5，a=8.0**(1.0/3.0)。
（7）数组有一些整体操作的功能；可以方便的对部分元素进行操作
（8）有些情况下可以声明大小待定的数组，很实用的功能
4、Fortran的基本程序结构
先看一看所谓的"Hello Fortran"程序。
program main !程序开始，main是program的名字，完全自定义
write(*,*) "Hello" !主程序
stop !终止程序
end [program[main]] !end用于封装代码，表示代码编写完毕。[ ]中的内容可省略，下同。
再看一段实用一些的程序，好有点感性认识。程序用于计算圆柱的表面积，要求输入底面
半径和。其中展示了Fortran的一些特色用法。程序摘自维基。其实是一个叫https://www.doczj.com/doc/ba11303264.html,/的网上引的维基的网页。推荐去看看!能查到不少有意思的东西。
program cylinder !给主函数起个名字
! Calculate the area of a cylinder.
! Declare variables and constants.
! constants=pi
! variables=radius squared and height
implicit none ! Require all variables to be explicitly declared
!这个一般都是要写上的。下面会进一步说明。
integer :: ierr
character :: yn
real :: radius, height, area
real, parameter :: pi = 3.1415926536 !这是常量的声明方法
interactive_loop: do !do循环，Fortran中的循环可以加标签，如d前面的
!interactive_loop就是标签
! Prompt the user for radius and height
! and read them.
write (*,*) 'Enter radius and height.' !屏幕输出
read (*,*,iostat=ierr) radius,height !键盘输入。isotat的值用判断输入成功否。
! If radius and height could not be read from input,
! then cycle through the loop.
if (ierr /= 0) then
write(*,*) 'Error, invalid input.'
cycle interactive_loop !cycle 相当于C里的continue
end if
! Compute area. The ** means "raise to a power."
area = 2 * pi * (radius**2 + radius*height) ! 指数运算比C方便
! Write the input variables (radius, height)
! and output (area) to the screen.
write (*,'(1x,a7,f6.2,5x,a7,f6.2,5x,a5,f6.2)') &
!"&"表示续行。这里还显示了格式化输出
'radius=',radius,'height=',height,'area=',area
yn = ' '
yn_loop: do !内嵌的另一个do循环
write(*,*) 'Perform another calculation? y[n]'
read(*,'(a1)') yn
if (yn=='y' .or. yn=='Y') exit yn_loop
if (yn=='n' .or. yn=='N' .or. yn==' ') exit interactive_loop
end do yn_loop !结束内嵌do循环
end do interactive_loop
end program cylinder
Fortran程序的主要结构就是这样了。一般还会有些module的部分在主函数前，函数在主函数后。
三、数据类型及基本输入输出
1、数据类型，声明及赋初值
（1）integer： 短整型kind=2, 长整型kind=4
integer([kind=]2) :: a=3
如果声明成integer:: a，则默认为长整型。
!"::" 在声明并同时赋初值时必须要写上；类型名后面有形容词时也必须保留::；其他情况可略去 !所谓形容词，可以看一下这个。比如声明常数
real，parameter :: pi=3.1415926 。parameter就是形容词。
（2）real：单精度kind=4（默认），双精度kind=8
real([kind=]8) :: a=3.0
还有指数的形式，如1E10为单精度，1D10为双精度
（3）complex 单精度和双精度
complex([kind=]4) b
（4）character
character([len=]10) c !len为最大长度
（5）logical
logical*2 :: d=.ture. (等价于logical(2)::d=.ture.)
（6）自定义类型type：类似于C中的struct
Fortran 77中给变量赋初值常用DATA命令，可同时给多个变量赋初值
data a,b,string /1, 2.0, 'fortran'/
与C不同的是，Fortran中变量不声明也能使用,即有默认类型（跟implicit命令有关）。按
照默认的定，以i,j,k,l,m,n开头的变量被定义为integer,其余为real。取消该设置需在程序声明 部分之前implicit none。彭国伦建议一般都使用该语句。
另一点关于声明的不同是Fortran有"等价声明"：
integer a,b
equivalence(a,b)
使得a,b使用同一块内存。这样可以节省内存；有时可精简代码。如：equivalence(很长名
字的变量如三维数组的某个元素，a)，之后使用a来编写程序就简洁多了。
2、基本输入输出
输入：read(*,*) a !从键盘读入
输出：write(*,*) "text" !在屏幕上输出。Fortran 77用' text'。Fortan 90中一般" "和' '都可 print *，"text" !只能用于屏幕输出
（*,*）完整写为（unit=*,fmt=*）。其中unit为输入/输出位置，如屏幕，文件等；fmt为
格式。如这两项都写成*，则按默认的方式进行，即上面描述的。print后面的*表示按默认格式输 出。
四、流程控制
1、运算符
（1）逻辑运算符
== /= > >= < <= !Fortran 90用法
.EQ. .NE. .GT. .GE. .LT. .LE. !Fortran 77用法
（2）涉及相互关系的集合运算符
.AND. .OR. .NOT. .EQV. .NEQV.
! 仅.NOT.连接一个表达式，其余左右两边都要有表达式（可以是logical类型的变量）
!.EQV.：当两边逻辑运算值相同时为真， .NEQV.：当两边逻辑运算值不同时为真
2、IF
(1) 基本 ：
if(逻辑判断式) then
……
end if
如果then后面只有一句，可写为
if(逻辑判断式) …… !then和end if可省略
(2) 多重判断：
if（条件1） then
……
else if（条件2）then
……
else if （条件3）then
……
else
……
end if
(3) 嵌套：
if(逻辑判断式) then
if(逻辑判断式) then
if(逻辑判断式) then
else if(逻辑判断式) then
……
else
……
end if
end if
end if
(4) 算术判断：
program example
implicit none
real c
write (*,*) "input a number"
read (*,*) c
if(c) 10,20,30 !10,20和30为行代码,根据c小于/等于/大于0，执行10/20/30行的程 10 write (*,*) "A"
goto 40 !goto可实现跳到任意前面或后面的行代码处，但用多了破坏程序结
20 write (*,*) "B"
goto 40
30 write (*,*) "C"
goto 40
40 stop
end
3、SELECT CASE
类似于C的switch语句
select case(变量)
case（数值1） ! 比如case(1:5)代表1<=变量<=5会执行该模块
…… !case（1，3，5）代表变量等于1或3或5会执行该模块
case（数值2） !括号中数值只能是integer,character或logical型常量，不能real型 …
case default
……
end case
4、PAUSE, CONTINUE
pause暂停程序执行，按enter可继续执行
continue貌似没什么用处，可用作封装程序的标志
五、循环
1、DO
do counter=初值, 终值, 增/减量 !counter的值从初值到终值按增/减量变，
…… !counter每取一个值对应着一次循环。增/减量不写则认为1
……
…… !循环主体也没有必要用{}
……
end do
Fortran 77中不是用end do来终止，而是下面这样子：
do 循环最后一行的行代码 counter=初值, 终值, 增/减量
……
行代码 …… !这是do的最后一行
2、DO WHILE
do while(逻辑运算)
……
……
end do
类似于C中的while(逻辑运算) {……}。
一开始那个计算圆柱表面积的程序中，应该也算是这一类。不过它是通过内部的if语句来控制循。看来也是可以的，不过在这本书上没看到这样写。其实应该也可以归于下面这种。3、没看到和C里面的do{……}while(逻辑运算); 相对应的循环语句，不过可以这样，保证
至少做一循环：
do while(.ture.)
……
……
if(逻辑运算) exit !exit就好比C里面的break。C里的continue在Fortran里是cycle
end do
4、Fortran的一个特色：带署名的循环
可以这样，不易出错：
outer: do i=1,3
inner: do j=1,3
……
end do inner
end do outer
还可以这样，很方便：
loop 1: do i=1,3
loop2: do j=1,3
if(i==3) exit loop1 !exit终止整个循环loop1
if(j==2) cycle loop2 !cycle跳出loop2的本次循环，进行loop2的下次循环
write(*,*) i,j
end do loop2
end do loop1
还有一些循环主要用于Fortran中的数组运算，为Fortran特有，很实用。
六、数组
1、数组的声明
和C不同的是，Fortran中的数组元素的索引值写在（）内，且高维的也只用一个（），如
integer a(5) !声明一个整型一维数组
real :: b(3,6) !声明一个实型二维数组
类型可以是integer, real, character, logical或type。最高可以到7维。
数组大小必须为常数。但是和C语言不同，Fortran也有办法使用大小可变的数组，方法如：
integer, allocatable :: a(:)
!声明小可变经过某个途径得知所需数组大小size之后，用下面的语句：
allocate(a(size)) !配置内存空间
之后该数组和通过一般方法声明的数组完全相同。
与C不同，Fortran索引值默认为从1开始，而且可以在声明时改变该规则：
integer a(-3:1) ! 索引值为-3，-2，-1，0，1
integer b(2:3,-1:3) !b(2~3,-1~3)为可使用的元素
2、数组在内存中的存放
和C不同，Fortran中的数组比如a(2,2)在内存中存放顺序为a(1,1),a(2,1),a(1,2),a(2,2)。原则是放低维的元素，再放高维的元素。此规则称为column major。
3、赋初值
（1）最普通的做法：
integer a(5)
data a /1,2,3,4,5/
或integer :: a(5)=(/1,2,3,4,5/)
若integer :: a(5)=5，则5个元素均为5
对于integer :: a(2,2)=(/1,2,3,4/)
根据数组元素在内存中存放的方式，等价于赋值a(1,1)=1,a(2,1)=2,a(1,2)=3,a(2,2)=4
（2）利用Fortran的特色：隐含式循环。看例子就明白了。
integer a(5)
integer i
data (a(i),i=2,4)/2,3,4/ !(a(i),i=2,4)表示i从2到4循环，增量为默认值1
还可以这样：
integer i
integer :: a(5)=(/1,(2,i=2,4),5/) !五个元素分别赋值为1，2，2，2，5
integer :: b(5)=(/i, i=1,5/) !五个元素分别赋值为1，2，3，4，
还可以嵌套
data ((a(i,j),i=1,2),j=1,2)=/1,2,3,4/ !a(1,1)=1,1(2,1)=2,a(1,2)=3,a(2,2)=4
4、操作整个数组
设a，b为相同类型、维数和大小的数组
a=5 !所有元素赋值为5
a=(/1,2,3/) !这里假设a为一维，a(1)=1,a(2)=2,a(3)=3
a=b !对应元素赋值，要求a,b,c维数和大小相同，下同
a=b+c
a=b-c
a=b*c
a=b/c
a=sin(b) !内部函数都可以这样用
5、操作部分数组元素
a为一维数组
a(3:5)=(/3,4,5/) !a(3)=3,a(4)=4,a(5)=5
a(1:5:2)=3 !a(1)=3,a(3)=3,a(5)=3
a(3:)=5 !a(3)以及之后的所有元素赋值为5
a(1:3)=b(4:6) !类似于这种的要求左右数组元素个数相同
a(:)=b(:,2) !a(1)=b(1,2),a(2)=b(2,2)，以此类推
6、WHERE
where形式上类似于if，但只用于设置数组。设有两个同样类型、维数和大小的数组a,b
where(a<3)
b=a !a中小于3的元素赋值给b对应位置的元素
end where
再如：where(a(1:3)/=0) c=a !略去了end where,因为只跟了一行where可嵌，也
!可类似do循环有署名标签。
7、FORALL
有点像C中的for循环：
forall(triplet1[,triplet2 [,triplet3…]],mask)
其中triplet形如i=2：6：2，表示循环，最后一个数字省略则增量为1
例如：
forall(i=1:5,j=1:5,a(i,j)<10)
a(i,j)=1
end forall
又如： forall(i=1:5,j=1:5,a(i,j)/=0) a(i,j)=1/a(i,j)
forall也可以嵌套使用，好比C中for循环的嵌套。
七、函数
Fortran中函数分两类：子程序（subroutine）和自定义函数（function）。自定义函数本质上就是学上的函数，一般要传递自变量给自定义函数，返回函数值。子程序不一定是这样，可以没有返值。传递参数要注意类型的对应，这跟C是一样的。
1、子程序
目的：把某一段经常使用的有特定功能的程序独立出来，可以方便调用。
习惯上一般都把子程序放在主程序结束之后。
形式：
subroutine name (parameter1, parameter2)
!给子程序起一个有意义的名字。可以传递参数，这样可以有返回值。括号内也可以空着，代不传递参数。
implicit none
integer:: parameter1, parameter2 !需要定义一下接收参数的类型。
…… !接下来的程序编写跟主程序没有任何别。
……
mreturn !跟C不同，这里表示子程序执行后回到调用它的地方继续执行下面的程序。不一定放
!在最后。可以放在子程序的其他位置，作用相同；子程序中return之后的部分不执行。
end [subroutine name]
调用：使用call命令直接使用，不需要声明。在调用处写：
call subroutine name(parameter1,parameter2)
注意点：
a.子程序之间也可相互调用。直接调用就是了，像在主程序中调用子程序一样。
b.传递参数的原理和C中不同。Fortran里是传址调用(call by address/reference)，就是传递时用参数和子程序中接收时用的参数使用同一个地址，尽管命名可以不同。这样如果子程序的执行改子程序中接收参数的值，所传递的参数也相应发生变化。
c.子程序各自内部定义的变量具有独立性，类似于C。各自的行代码也具有独立性。因此各个子程序主程序中有相同的变量名、行代码号，并不会相互影响。
2、自定义函数
和子程序的明显不同在于：需要在主程序中声明之后才能使用。调用方式也有差别。另外
按照惯例用函数不去改变自变量的值。如果要改变传递参数的值，习惯上用子程序来做。
声明方式：real, external :: function_name
一般自定义函数也是放在主程序之后。
形式：
function function_name(parameter1, parameter2)
implicit none
real:: parameter1, parameter2 !声明函数参数类型，这是必需的
real::function_name !声明函数返回值类型，这是必需的
……
……
function_name=…. !返回值的表达式
return
end
也可以这样直接声明返回值类型，简洁些：
real function function_name(parameter1, parameter2)
implicit none
real:: parameter1, parameter2 !这个还是必需的
……
……
function_name=…. !返回值表达式
return
end
调用：function_name(parameter1,parameter2)
不需要call命令。
自定义函数可以相互调用。调用时也需要事先声明。
总之，调用自定义函数前需要做声明，调用子程序则不需要。
3、关于函数中的变量
（1）注意类型的对应。Fortran中甚至可以传递数值常量，但只有跟函数定义的参数类型对应才会到想要的结果。如call ShowReal(1.0)就必须用1.0而不是1。
（2）传递数组参数，也跟C一样是传地址，不过不一定是数组首地址，而可以是数组某个指定元素地址。比如有数组a(5)，调用call function(a)则传递a(1)的地址，调用call function(a(3))则递a(3)的地址。
（3）多维数组作为函数参数，跟C相反的是，最后一维的大小可以不写，其他维大小必须写。这决于Fortran中数组元素column major的存放方式。
（4）在函数中，如果数组是接收用的参数，则在声明时可以用变量赋值它的大小，甚至可以不指定小。例如： subroutine Array(num,size)
implicit none
integer:: size
integer num(size) !可以定义一个数组，其大小是通过传递过来的参数决定的。这很实用
……
……
return
end
（5）save命令：将函数中的变量值在调用之后保留下来，下次调用此函数时该变量的值就是上次保的值。只要在定义时加上save就行：
integer, save :: a=1
（6）传递函数（包括自定义函数、库函数、子程序都是可以的）。类似于C中的函数指针需要在主程序和调用函数的函数中都声明作为参数传递的函数。如
real, external :: function !自定义函数
real, intrinsic :: sin !库函数
external sub !子程序
（7）函数使用接口（interface）：一段程序模块。以下情况必需：
a.函数返回值为数组
b.指定参数位置来传递参数时
c.所调用的函数参数个数不固定
d.输入指标参数时
e.函数返回值为指针时。
具体用法结合例子容易看懂。例子都很长。看书吧。
4、全局变量
功能就不用说了。原理：根据声明时的相对位置关系而取用，不同与C中根据变量名使用。
如果在主程序中定义：
integer :: a,b
common a,b !就是这样定义全局变量的
在子程序或自定义函数中定义：
integer :: c,d
common c,d
则a和c共用相同内存，b和d共用相同内存。
全局变量太多时会很麻烦。可以把它们人为归类，只需在定义时在common后面加上区间名。如common /groupe1/ a, common /group2/ b。这样使用时就不必把所有全局变量都列出来，再声明common /groupe1/ c就可以用a、c全局变量了。可以使用block data程序模块。在主程序和函数中不能直接使用前面提到的data命令给全局变量赋初值。可以给它们各自赋初值；如果要使用data命令必须要这样：
block data [name]
implicit none
integer a,b,c
real d,e
common a b c
common /group1/ d,e
data a,b,c,d,e /1,2,3,4.0,5.0/
end [block data [name]]
5、Module
Module不是函数。它用于封装程序模块，一般是把具有相关功能的函数及变量封装在一起。用法很单，但能提供很多方便，使程序变得简洁，比如使用全局变量不必每次都声明一长串，写在odule里调用就行了。Module一般写在主程序开始之前。形式：
module module_name
……
……
end [module [module_name]]
使用：在主程序或函数中使用时，需要在声明之前先写上一行：use module_name.
Module中有函数时必须在contains命令之后（即在某一行写上contains然后下面开始写数，多所有函数都写在这个contains之后）。并且module中定义过的变量在module里的函数中可直接使用，函数之间也可以直接相互调用，连module中的自定义函数在被调用时也不用先声明。
6、include放在需要的任何地方，插入另外的文件(必须在同一目录下)。如：
include 'funcion.f90'
八、文件
1、文本文件
Fortran里有两种读取文件的方式，对应于两种文件
顺序读取：用于文本文件
直接读取：用于二进制文件
这里只摘录关于文本文件的读取。一般模式如下。
character(len=20)::filenamein="in.txt", filenameout="out.txt" !文件名
logical alive
integer::fileidin=10,fileidout=20
!10，20是给文件编的号，除1，2，5，6的正整数都可，因为2、6是默认的输出位置（屏幕
），1、5是默认的输入位置（键盘）
integer::error
real::in,out
!下面这一段用于确认指定名字的文件是否存在
inquire(file=filenamein, exist=alive) !如果存在，alive赋值为0
if(.NOT. alive) then
write(*,*) trim(filenamein), " doesn't exist."!trim用于删去filenamein中字串
!后面的stop多余空格，输出时好看些
end if
open([unit=]fileidin, file=filenamein, status="old")
open([unit=]fileidout,file=filenameout[,status="new"])
!unit指定输入/输出的位置。打开已有文件一定要用status="old"；打开新文件用status="new"；
!不指定status，则默认status="unknown"，覆盖已有文件或打开新文件……
read([unit=]fileidin, [fmt=]100,iostat=error )in !error=0表示正确读入数据。
100 format(1X,F6.3)
!按一定格式输入输出，格式可以另外写并指定行代码，也可以直接写在read/write中
write(([unit=]fileidout, "(1X,F6.3)")out
close(fileidin)
close(fileidout)
!1X代表一个空格。F6.3代表real型数据用占6个字符（含小数点），其中小数点后三位。
!常用的还有I3，用于整型数据，共占三个字符；A8，字符型，占8个字符。换行用 /
二进制文件的读取有所不同。不再列举。
2、内部文件
另一个很实用的读写功能是内部文件（internal file）。看看这个例子就明白了。
integer::a=1,b=2
character(len=20)::string
write(unit=string,fmt="(I2,'+',I2,'=',I2)")a,b,a+b
write(*,*)string
则结果输出1+2=3。反过来也是可以的：
integer a
character(len=20)::string="123"
read(string,*)a
write(*,*)a
则输出123。
!全文结束。
1 FORTRAN77四则运算符 + - * / ** (其中**表示乘方) 在表达式中按优先级次序由低到高为：+或-→*或/→**→函数→() 2 FORTRAN77变量类型 2.1 隐含约定：I-N规则 凡是以字母I，J，K，L，M，N六个字母开头的，即认为是整型变量，其它为实型变量。 如IMPLICIT REAL (I,J) 三种定义的优先级别由低到高顺序为：I-N规则→IMPLICIT语句→类型说明语句，因此，在程序中IMPLICIT语句应放在类型说明语句之前。 2.4 数组的说明与使用 使用I-N规则时用DIMENSION说明数组，也可在定义变量类型同时说明数组，说明格式为：数组名(下标下界,下标上界），也可省略下标下界，此时默认为1，例： DIMENSION IA(0:9),ND(80:99),W(3,2),NUM(-1:0),A(0:2,0:1,0:3) REAL IA(10),ND(80:99)使用隐含DO循环进行数组输入输出操作：例如WRITE(*,10) ('I=',I,'A=',A(I),I=1,10,2) 10FORMAT(1X,5(A2,I2,1X,A2,I4)) 2.5 使用DATA语句给数组赋初值 变量表中可出现变量名,数组名,数组元素名,隐含DO循环，但不许出现任何形式的表达式：例如 DATA A,B,C/-1.0,-1.0,-1.0/ DATA A/-1.0/,B/-1.0/,C/-1.0/ DATA A,B,C/3*-1.0/CHARACTER*6 CHN(10)
DATA CHN/10*' '/INTEGER NUM(1000) DATA (NUM(I),I=1,500)/500*0/,(NUM(I),I=501,1000)/500*1/ 3 FORTRAN77程序书写规则 程序中的变量名，不分大小写； 变量名称是以字母开头再加上1到5位字母或数字构成，即变更名字串中只有前6位有效； 一行只能写一个语句； 程序的第一个语句固定为PROGRAM 程序名称字符串 某行的第１个字符至第５个字符位为标号区，只能书写语句标号或空着或注释内容； 某行的第１个字符为Ｃ或＊号时，则表示该行为注释行，其后面的内容为注释内容； 某行的第６个字符位为非空格和非０字符时，则该行为上一行的续行，一个语句最多可有19个续行； 某行的第７至７２字符位为语句区，语句区内可以任加空格以求美观； 某行的第７３至８０字符位为注释区，８０字符位以后不能有内容。 4 FORTRAN77关系运算符 .GT. 大于 .GE. 天于或等于 .LT. 小于 .LE. 小于或等于 .EQ. 等于 .NE. 不等于 .AND. 逻辑与 .OR. 逻辑或 .NOT. 逻辑非 .EQV. 逻辑等 .NEQV. 逻辑不等 运算符优先级由高到低顺序为:()→**→*或/→+或-→.GT.或.GE.或.LT. 或.LE.或.EQ.或.NE.→.NOT.→.AND.→.OR.→.EQV.或.NEQV 5 FORTRAN77语句
FORTRAN内部函数 用FORTRAN解题往往要用到一些专门运算，如求三角函数sinx, cosx,对数lnx,指数ex,求一组数中最大数和最小数等。 FORTRAN提供了一些系统函数（称为内部函数）来完成这些运算。程序设计者不必自己设计进行这些运算的语句组（即程序段或子程序），只需写出一个函数的名字以及给出一个或若干个自变量，就可以得到所需的值，例如： SQRT(4.0)求出4.0的平方根， SIN(2.0)求出2（弧度）的正弦值， EXP(3.5)求出e3.5, LOG(3.0)求出3， 常用的函数如下表，FORTRAN77提供的全部函数明细见FORTRAN77内部函数。 函数名含义应用例子相当于数学上的运算 ABS 求绝对值ABS(A) |a| EXP 指数运算EXP(A) e^a SIN 正弦值SIN(X) sin x COS 余弦值COS(X) cos x ASIN 反正弦ASIN(X) sin^(-1)a ACOS 反余弦ACOS(X) cos-1a TAN 正切TAN(X) tan x ATAN 反正切ATAN(A) tan^(-1)a LOG 自然对数LOG(A) lna,或loge(a) LOG10 常用对数LOG10(A) log10a INT 取整INT(A) int(a),取a的整数部分 MOD 求余MOD(A1,A2) a - int(a1/a2)*a2 SIGN 求符号SIGN(A1,A2) |a1|(若a2>0) -|a1|(若a2<0) REAL 转换为实型REAL(I) MAX 求最大值MAX(A1,A2,A3) max(a1,a2,a3) MIN 求最小值 MIN(A1,A2,A3) min(a1,a2,a3) 说明： （1）FORTRAN77将这些系统函数分别编成一个个子程序，组成函数库，存贮于外部介质（如磁盘）上。在完成源程序的编译之后，用LINK命令实现连接，即将已翻译成二进制指令的目标程序与函数库连接。也就是将程序中出现函数名的地方用函数库中相应的一组指令代入之，组成一个统一的“可执行目标块”。例如，程序中出现一个SIN函数，在连接时就将一组二进制指令（它们是实现求正弦值的运算的）直接插入到程序中出现SIN的地方。由于是插入到程序内部的，所以称为“内部函数”。 （2）一个内部函数要求一个或多个自变量。例如，SQRT函数只能有一个自变量SQRT(4.6)，MOD函数要求两个自变量MOD(8,3)，MAX和MIN函数要求两个以上自变量MAX(6,-8,10),MIN(-6,8,0)。当自变量个数规定为2个时，自变量的顺序不应任意颠倒，MOD(8,3)表示8被3除的余数，其值为2，而MOD(3,8)则表示3被8除的余数，其值为3。当自变量个数>2时，自变量的顺序无关，MAX(6,8,10)和MAX(8,10,6)结果是一样的。
FORTRAN笔记 2014.10.07 目录 第七讲_FORTRAN的基本知识.ppt (2) FORTRAN语言程序设计初步 (2) FORTRAN源程序的书写格式（以77为例） (2) 变量 (2) 变量类型 (2) 算术运算符和运算优先级 (3) 赋值语句 (3) 参数语句（PARAMETER语句） (3) END语句 (3) PAUSE语句 (3) 逻辑运算和选择结构 (4) 关系表达式 (4) FORTRAN中数组的定义及使用 (4) 其他 (5) 1. fortran语言定义CHARACTER*6 TTL(14,3),CNAM(400)是什么意思? (5) 2. fortran里character*10 是什么意思 (5) 3. Fortran中kind是什么函数？ (5)
第七讲_FORTRAN的基本知识.ppt FORTRAN语言程序设计初步 FORTRAN是Formula Translation的缩写，意为“公式翻译”，它是为科学、工程问题或企事业管理中的那些能够用 数学公式表达的问题而设计的，其数值计算的功能较强。 常用的是FORTRAN77和FORTRAN90两种标准。 1、一个程序由若干个程序单位组成。主程序和每一个子程序分别是一个独立的程序单位。 2、每一个程序单位都是以“END”结束的。 3、一个程序单位包括若干行。 1）语句行。由一个FORTRAN语句组成。 2）非语句行，即注释行。 4、FORTRAN程序中的语句可以没有标号，也可以有标号，根据需要而定。标号的作用是标志一个语句以便被其 他语句引用。 5、一个程序单位中各类语句的位置是有一定规定的。 6、FORTRAN源程序必须按一定的格式书写。 FORTRAN源程序的书写格式（以77为例） 每一行有80列，分别如下： 1、第1-5列为标号区。一行中第一列为“C”或“*”，该行即被认为是注释行。 2、第6列为“续行标志区”，如果在一行的第6列上写一个非空格和非零的字符，则该行作为其上一行的续行。 3、第7-72列为语句区。 4、第73-80列，注释区。 变量 变量名：一个变量需要用一个名字（变量名）来识别。在同一个程序单位中不能用同一个变量名代表两个不同的变 量。 FORTRAN的变量名按以下规则选定： 1）第一个字符必须是字母，即变量名必须以字母开头； 2）在一个字母后面可以跟1-5为数字或字母。 如果选定的变量名超过6个字符，则只有前面6个字符有效。 注：在变量名中大写与小写字母是等价的。 变量类型 整型变量Integer、实型变量Real、双精度变量Double Precision、复型变量Complex、逻辑型变量Logical和字符型变量Character。 1、隐含约定（I-N规则） FORTRAN规定：在程序中的变量名，凡以字母I，J，K，L，M，N六个字母开头的，即认为该变量为整型变量。 在程序中，凡是变量名以字母I,J,K,L,M,N,i,j,k,l,m,n开头的变量被默认为整型变量，以其他字母开头的变量被 默认为实型变量。 2、用类型说明语句确定变量类型 1）INTEGER语句（整型说明语句） 2）REAL语句（实型说明语句） 3）DOUBLE PRECISION语句（双精度说明语句） 4）COMPLEX语句（复型说明语句） 5）LOGICAL语句（逻辑型说明语句）
FORTRAN 90标准函数（一） (2012-07-03 17:14:57) 转载▼ 分类：学习 标签： fortran 函数 教育 符号约定： ●I代表整型;R代表实型;C代表复型;CH代表字符型;S代表字符串;L代表逻辑型;A代表数组;P代表指针;T代表派生类型;AT为任意类型。 ●s:P表示s类型为P类型(任意kind值)。s:P(k)表示s类型为P类型(kind值=k)。 ●[…]表示可选参数。 ●*表示常用函数。
注：三角函数名前有C、D的函数为复数、双精度型函数。 注：指数函数名、平方根函数名、对数函数名前有C、D的函数为复数、双精度型函数。 表4 参数查询函数
atan2函数的值域是多少？我从网上找到一个fortran函数的日志，说此值域是-π~π，但正常反正切函数的值域应该是-π/2~π/2。对atan2函数不够了解，所以不知道你的答案对不对，我个人认为不对。我是用正常的反正切函数atan(v/u)来算的： FORTRAN： if (u>0..and.v>0.) dir=270-atan(v/u)*180/pi if (u<0..and.v>0.) dir=90-atan(v/u)*180/pi if (u<0..and.v<0.) dir=90-atan(v/u)*180/pi if (u>0..and.v<0.) dir=270-atan(v/u)*180/pi if (u==0..and.v>0.) dir=180 if (u==0..and.v<0.) dir=0 if (u>0..and.v==0.) dir=270 if (u<0..and.v==0.) dir=90 if (u==0..and.v==0.) dir=999 其中uv等于零的五种情况要单独挑出来，不然程序会有瑕疵。atan函数换成atand函数的话直接是度数，不用*180/pi 我四个象限和轴都试了，应该没错。 最需要注意的问题，一个是函数值域，另一个是uv矢量方向和风向是反着的，并且风向角度数是从正Y轴开始顺时针算，和三角函数里度数从正X轴开始逆时针算不一样。
1、RANDOM_NUMBER Syntax ['sint?ks] n. 语法 CALL RANDOM_NUMBER (harvest结果) Intrinsic Subroutine（固有子程序）：Returns a pseudorandom number greater than or equal to zero and less than one from the uniform distribution. 返回大于或等于0且小于1，服从均匀分布的随机数 2、RNNOA/ DRNNOA （Single/Double precision） Generate pseudorandom numbers from a standard normal distribution using an acceptance/rejection method. 产生服从标准正态分布的随机数 Usage（用法） CALL RNNOA (NR, R) Arguments（参数） NR— Number of random numbers to generate. (Input) 要产生随机数的个数 R— Vector of length NR containing the random standard normal deviates. (Output) 输出长度为NR，随机正态分布的向量 Comments（注解） The routine RNSET can be used to initialize the seed of the random number generator. The routine RNOPT can be used to select the form of the generator. 程序RNSET可以用来初始化随机数发生器的种子 Example In this example, RNNOA is used to generate five pseudorandom deviates from a standard normal distribution. INTEGER ISEED, NOUT, NR REAL R(5) EXTERNAL RNNOA, RNSET, UMACH C CALL UMACH (2, NOUT) NR = 5 ISEED = 123457 CALL RNSET (ISEED) CALL RNNOA (NR, R) WRITE (NOUT,99999) R 99999 FORMAT (' Standard normal random deviates: ', 5F8.4) END Output Standard normal random deviates: 2.0516 1.0833 0.0826 1.2777 -1.2260
F O R T R A N 第2章FORTRAN90基础知识： 程序单元的概念: fortran90程序是一种分块形式的程序，整个程序由若干程序单元块组成。每个程序只有一个主程序单元。各单元体的程序体形式上相同。 程序单元可以是主程序、子程序（外部过程或内部过程）、模块MODULE （供其他程序单元引用即把该程序单元内的全部语句复制到程序单元中）或块数据程序单元BLOCK 。 语言元素：指在程序设计中用到的基本成分，如字符集、常量、变量、记号（标号、关键字、名字、常数、运算符和定界符）以及其他的基本结构等。 字符集：英文字母、阿拉伯数字、下划线、21个特殊字符（$和？没有规定用法）。 数据结构： 整型INTEGER （34-2下划线后面是种别参数），n 位字长的计算机的数据表示范围一般为12~211-+---n n ，种别参数由内在询问函数KIND 送回，种别值提供的最小范围由内在函数SELECTED-INT-KIND 送回，表示十进制幂的范围由内在函数RANGE 送回； 实型REAL ，小数形式和指数形式；复型COMPLEX （种别类
型参数值取实部与虚部中较大者）； 字符型CHARACTER，由一对单撇号或双撇号之间的字符序列组成； 逻辑型LOGICAL。 派生数据类型TYPE； 数组INTEGER,DIMENSION(1,50)::A，可直接对数组元素进行运算如3*A,SQRT(A)； 字符子串，在字符串CHARACTER(LEN=80)::ROW中，ROW(1:3)就表示字符串ROW中第1到第3个元素组成的子串。 变量名的命名规则：不能超过31个字符；组成成分是字母、数字、下划线；第一个字符必须是字母。 第3章基本语句： 类型说明语句：类型说明（种别说明），属性说明：：变量名表 尽量避免把两个实数作相等或不相等的比较。淘汰隐式说明IMPLICIT NONE 种别说明：种别参数即对可移植数据精度和范围进行选择的机制 KIND(X) 返回变元X的种别参数值 SELECTED-REAL-KIND(n,m) 产生一个种别值，它表示某一精度和范围。N指十进制有效位数，m指明值范围内以10为底的幂次。
Read 的规则： 按行读取，每次读一行，读完后光标自动跳到下一行的开头，空格和逗号代表结束（所以空格和逗号也是读取的一部分的话，需要使用“输入输出格式”） 如果想要将一行数据读入数组，代码为： Read(10,*) s(:,:,:) 不用规定输入输出格式，因为会根据s(:,:,:)确定需要读入的数字的个数，然后fortran会按部就班的读取，甚至文件中当前这一行的数字个数不足以填满s(:,:,:)的时候，read会自动跳到下一行继续搜索数字，直到填满s(:,:,:)为止。 但是需要注意给数组赋值的顺序：read会把它搜索到的第一个数字给s(1,1,1),第二个给s(2,1,1),第三个给s(3,1,1)… 程序9 1: 将read(unit=field,fmt="(A79)",iostat=status)buffer 中的A79改为A2，结果只输出每行的前两个字符，说明read是按整行整行读取的。 中间空了几行之后，空行之后的内容还是能被读取和输出，这说明，空行和空白是不一样的：空行也算是一种文本内容，因此不会终止读取，而空白意味着结束。 !读取文件 program main implicit none character(len=79)::filename="number.txt",buffer integer,parameter::field=10 integer::status=0 logical alive inquire(file=filename,exist=alive) if(alive)then open(unit=field,file=filename) do while(.true.) read(unit=field,fmt="(A79)",iostat=status)buffer if(status/=0)exit write(*,"(A79)")buffer end do else write(*,*)filename,"does't exist." end if pause stop end program main ============================================= 附number.txt =============================== 1234555666
第3 章FORTRAN 77 和VMS 内函数 本章列出了FORTRAN 77 f95 接受的一系列内函数，旨在帮助将传统的FORTRAN 77 程序迁移至Fortran 95。 在f95 中，本章列出的所有FORTRAN 77 和VMS 函数以及前一章列出的所有Fortran 95 函数都识别为内函数。为了帮助从传统的FORTRAN 77 程序迁移至f95，使用-f77=intrinsics 进行编译会让编译器只将FORTRAN 77 和VMS 函数识别为内函数，但Fortran 95 函数不会识别为内函数。 属于Sun 扩展的ANSI FORTRAN 77 标准的内函数标有¤ 符号。使用非标准内函数和库函数的程序可能无法移植到其他平台。 内函数在接受多种数据类型的参数时，有通用名称和专用名称。通常，通用名称返回与参数具有相同数据类型的值。但也有一些例外，如类型转换函数（表3–2）和查询函数（表3–7）。这些函数也可以通过函数的某个专用名称进行调用，以便处理专用参数数据类型。 对于处理多个数据项的函数（例如sign(a1,a2)），所有数据参数的类型必须相同。 下表按以下几方面列出FORTRAN 77 内函数： 内函数－描述函数的作用 定义－数学定义 参数数量－函数接受的参数的数量 通用名称－函数的通用名称 专用名称－函数的专用名称 参数类型－与每个专用名称关联的数据类型 函数类型－针对专用参数数据类型返回的数据类型 注– 编译器选项-xtypemap 会更改变量的缺省大小，并且对内在引用产生影响。请参见3.4 备注以及《Fortran 用户指南》中有关缺省大小和对齐方式的介绍。 3.1 算术和数学函数 本节详细介绍算术函数、类型转换函数、三角函数以及其他函数。“a”代表函数的单个参数，“a1”和“a2”代表两个参数函数的第一个参数和第二个参数，“ar”和“ai”代表函数的复数参数的实部和虚部。 3.1.1 算术函数
FORTRAN 90 程序编程规范 Fortran 90 编程规范，使程序代码高度组织化，更加易读、易懂、易于维护，程序更加高效。使编出的程序更易懂、易于维护。 1 语言选择 数值预报创新系统软件开发应避免使用Fortran77 的某些过时特征以Fortran 90不一致的特征。选择Fortran 90 作为开发语言，并采用Fortran 90 的新功能，如动态内存的分配(dynamic memory allocation)、递归（recursion ）, 模块(modules)、POINTER 、长变量名、自由格式等。 Fortran 77其中某些只是一些冗余的功能，这些功能已经过时，另外，还有一些在Fortran90 中被证明是不好的用法，建议不要使用。 2 Fortran 90 的新特性 2.1.1 建议使用的Fortran 90 新特性 建议使用Fortran 90 提供的模块（module ），并用Use ONLY 指定module 中哪些变量或派生类型定义可用于调用程序。 尽量使用数组下标三元组，这样可优化并减少所需的代码行数。为提高可读性，要在括号内表明数组的维数，例如： 1dArrayA(:) = 1dArrayB(:) + 1dArrayC(:) 2dArray(: , :) = scalar * Another2dArray(: , :) 当访问数组的子集时，例如在有限差分等式中，可以通过使用下标三元组实现。例如：2dArray(: , 2:len2) = scalar *（ & Another2dArray(:, 1:len2 -1) & - Another2dArray(:, 2:len2) & ) 对程序单元（program units ）命名，并使用End program ，End subroutine ，End interface ，End module 等结构再次指定“program unit ”的名称。 在逻辑表达式中使用>、 >=、 ==、 <、 <=、 /=，它们分别代 替.gt.、.ge.、.eq.、.lt.、.le.、.ne. 。新的表示方法更接近标准的数学符号 在变量定义中始终使用“：：”；始终用“DIMENSION ”定义数组形状；始终用（len=）的语法格式声明字符变量的长度。
R语言基本函数 一、数据管理 vector：向量 numeric：数值型向量 logical：逻辑型向量 character；字符型向量 list：列表 data.frame：数据框 c：连接为向量或列表 length：求长度 subset：求子集 seq，from:to，sequence：等差序列 rep：重复 NA：缺失值 NULL：空对象 sort，order，unique，rev：排序 unlist：展平列表 attr，attributes：对象属性 mode，typeof：对象存储模式与类型 names：对象的名字属性 二、字符串处理 character：字符型向量 nchar：字符数 substr：取子串 format，formatC：把对象用格式转换为字符串paste，strsplit：连接或拆分 charmatch，pmatch：字符串匹配 grep，sub，gsub：模式匹配与替换 三、复数 complex，Re，Im，Mod，Arg，Conj：复数函数 四、因子 factor：因子 codes：因子的编码 levels：因子的各水平的名字 nlevels：因子的水平个数 cut：把数值型对象分区间转换为因子 table：交叉频数表 split：按因子分组 aggregate：计算各数据子集的概括统计量 tapply：对“不规则”数组应用函数 数学 一、计算 +, -, *, /, ^, %%, %/%：四则运算 ceiling，floor，round，signif，trunc，zapsmall：舍入 max，min，pmax，pmin：最大最小值 range：最大值和最小值 sum，prod：向量元素和，积 cumsum，cumprod，cummax，cummin：累加、累乘 sort：排序 approx和approx fun：插值 diff：差分 sign：符号函数 二、数学函数 abs，sqrt：绝对值，平方根 log, exp, log10, log2：对数与指数函数 sin，cos，tan，asin，acos，atan，atan2：三角函数 sinh，cosh，tanh，asinh，acosh，atanh：双曲函数 beta，lbeta，gamma，lgamma，digamma，trigamma，tetragamma，pentagamma，choose ，lchoose：与贝塔函数、伽玛函数、组合数有关的特殊函数 fft，mvfft，convolve：富利叶变换及卷积 polyroot：多项式求根 poly：正交多项式 spline，splinefun：样条差值 besselI，besselK，besselJ，besselY，gammaCody：Bessel函数 deriv：简单表达式的符号微分或算法微分
1F O R T R A N77四则运算符+ - */ ** (其中**表示乘方) 在表达式中按优先级次序由低到高为：+或-→*或/→**→函数→() 2 FORTRAN77变量类型 隐含约定：I-N规则 凡是以字母I，J，K，L，M，N六个字母开头的，即认为是整型变量，其它为实型变量。 如IMPLICIT REAL (I,J) 三种定义的优先级别由低到高顺序为：I-N规则→IMPLICIT语句→类型说明语句，因此，在程序中IMPLICIT语句应放在类型说明语句之前。 数组的说明与使用 使用I-N规则时用DIMENSION说明数组，也可在定义变量类型同时说明数组，说明格式为：数组名(下标下界,下标上界），也可省略下标下界，此时默认为1，例：DIMENSION IA(0:9),ND(80:99),W(3,2),NUM(-1:0),A(0:2,0:1,0:3) REAL IA(10),ND(80:99)使用隐含DO循环进行数组输入输出操作：例如 WRITE(*,10) ('I=',I,'A=',A(I),I=1,10,2) 10FORMAT(1X,5(A2,I2,1X,A2,I4)) 使用DATA语句给数组赋初值 变量表中可出现变量名,数组名,数组元素名,隐含DO循环，但不许出现任何形式的表达式：例如 DATA A,B,C/,, DATA A/,B/,C/ DATA A,B,C/3*CHARACTER*6 CHN(10) DATA CHN/10*''/INTEGER NUM(1000) DATA (NUM(I),I=1,500)/500*0/,(NUM(I),I=501,1000)/500*1/ 3 FORTRAN77程序书写规则
FORTRAN是世界上最早出现的高级编程语言，是工程界最常用的编程语言，它在科学计算中（如航空航天、地质勘探、天气预报和建筑工程等领域）发挥着极其重要的作用。经过40多年的发展，伴随着FORTRAN语言多次版本的更新及相应开发系统的出现，其功能不断完善，最新版本的开发系统几乎具备了VC、VB的所有特点，如图形界面编程、数据库等。目前，工科院校开设的计算机编程语言课首选仍然是FORTRAN :< 说实话，从科技发展的趋势来说这不是好事。您可以设想一下，如果需要用鹅毛笔抄写大量的古籍是什么感受！ 强烈建议阅读《发掘C#特性赋予科学计算项目以威力》 1 FORTRAN77四则运算符 + - * / ** (其中**表示乘方) 在表达式中按优先级次序由低到高为： +或-→*或/→**→函数→() 2 FORTRAN77变量类型 隐含约定：I-N规则 凡是以字母I，J，K，L，M，N六个字母开头的，即认为是整型变量，其它为实型变量。 用类型说明语句确定变量类型：可以改变I-N规则
用IMPLICIT语句将某一字母开头的全部变量指定为所需类型 如IMPLICIT REAL (I,J) 三种定义的优先级别由低到高顺序为：I-N规则→IMPLICIT语句→类型说明语句，因此，在程序中IMPLICIT语句应放在类型说明语句之前。 数组的说明与使用 使用I-N规则时用DIMENSION说明数组，也可在定义变量类型同时说明数组，说明格式为：数组名(下标下界,下标上界），也可省略下标下界，此时默认为1，例：DIMENSION IA(0:9),ND(80:99),W(3,2),NUM(-1:0),A(0:2,0:1,0:3)
********************************************* fortran中批处理命令的实现函数： 利用systemqq命令（需要调用DFLIB 数据库） ********************************************* 例1： USE DFLIB character*100 CMD LOGICAL(4) res CMD="dir/a-d/b/s "//trim(fPath)//" >"//trim(outPut) res=SYSTEMQQ(CMD) 例2： USE DFLIB LOGICAL(4) result result = SYSTEMQQ('copy e:\dir.txt e:\test\dir.txt') !将e:\dir.txt 复制到e:\test\dir.txt文件中。！****************实例3:复制文件************************* 例3： programmain_pro USE DFLIB implicit none integer,parameter::sta_num=123 character(5),dimension(sta_num)::sta_ID character(500)::filein,fileout character(5000)::cmd logical(4)::judge
integer::status,is open(1,file='山东.txt',status='old',action='read',iostat=status) read(1,*) do is=1,sta_num read(1,*) sta_ID(is) filein='Z:\data\降水逐小时数据-戴至修\precip_data\'//sta_ID(is)//'_precip.txt' open(2,file= filein,status='old',action='read',iostat=status) if(status/=0) goto 1000 fileout='Z:\data\降水逐小时数据-戴至修\山东省-降水数据\'//sta_ID(is)//'_precip.txt' cmd='copy '//filein//' '//fileout judge=SYSTEMQQ( cmd) 1000 continue enddo end program
Fortran90关于变量说明的新功能： 1.在变量说明的同时，可以给变量赋初值。 INTEGER::I=5，J=126 REAL::X=7.2，Z，W=774.2 2.在说明变量的同时也可说明其种别 REAL(KIND=4)::X,Y 或REAL(4)::X,Y 3.在说明变量的同时，还可说明变量的属性 INTEGER，PARAMETER::I=5，J=123 Ps :PARAMETER 属性 （1）功能：用一个符号代表一个常量，称为符号常量（常数） （2）写法： Real，Parameter ：：G=9.8 &&说明类型时赋值 （3）位置：位于可执行语句之前 REAL，DIMENSION(1:10)::A 2.3.6 派生数据类型 根据需要而由基本数据类型定义新的数据类型。在一个派生类型中可包含多个基本类型。 如：TYPE STUDENT (定义开始) CHARACTER(LEN=20)::DEPARTMENT CHARACTER(LEN=10)::CLASS CHARACTER(LEN=15)::NAME INTEGER::NUMBER （成员定义） END TYPE STUDENT （定义结束）
派生类型变量的定义： TYPE（STUDENT）::PERSON 变量的赋值： PERSON=（”COMPUTER”，”92_2”，”LI LIN”，21） 成员的表示： PERSON%CLASS=“92_2” PERSON%NAME=“LI LIN” 主程序其他限制 主程序的可执行部分不能包含有RETURN语句或者ENTRY语句。 程序名对可执行程序是全局的，而且不得于该可执行程序中的任何其它程序单元名、外部过程名或公用块名相同，也不得于主程序内的任何局部名相同。 在主程序的作用范围内的说明不得包含OPTIONAL语句、INTENT语句、PUBLIC语句或它们的等价属性，在主程序内SAVE语句不起作用。 主程序内的任何内部过程的定义必须跟在CONTAINS语句之后。 2.3.2 子程序 子程序是可以完成某一独立算法或功能的程序单元，但它功能的具体体现要通过主程序（或子程序）的调用来实现。 按子程序与主程序的位置关系分为内部过程和外部过程。 2.4.3 模块 模块也是一种在程序单元之外独立编写的程序单元。它有独特的形式，即模块程序单元内没有可执行语句，除了说明语句外，最多包含内部过程。模块的主要作用是供其它程序单元引用。 程序单元引用模块，实际是将模块内的全部语句复制到本程序单元。因此模块起共享及复制的作用。 模块的引用采用语句： USE 模块1，模块2，…
我的Fortran基本用法小结 周日, 10/14/2007 - 21:00 — gator 一、说明 二、概述 三、数据类型及基本输入输出 四、流程控制 五、循环 六、数组 七、函数 八、文件 一、说明 本文多数内容是我读彭国伦《Fortran 95 程序设计》的笔记。只读到第九章，主要是3~9 章，都是最基本的用法（原书共16章）。这里主要摘录了我看书过程中总结的一些Fortran和C不同的地方，主要是语法方面。希望这份笔记能够给学过C但没有接触过Fortran的同学带去一些帮助。要想得更清楚些，推荐看一下原书，觉得作者真的写得很好，很清楚；如果有C语言的基础， 看完前九应该很快的，花一两天就行了。觉得如果耐心看完本文，基本功能应该也可以顺利用起 来了。外，由于我之前没有用过Fortran，这次为了赶文档看书又看得很粗浅，大多数东西看过 之后都没得及仔细想，只是按着作者的意思去理解。所以这份笔记还处于纸上谈兵的层次。如果 有不妥的方，希望大家指正。谢谢！ 文中蓝色的部分是程序代码，!后面的内容为注释。 二、概述 1、名词解释 Fortran=For mula Tran slator/Translation 一看就知道有什么特色了：可以把接近数学语言的文本翻译成机械语言。的确，从一开始 ，IBM设计的时候就是为了方便数值计算和科学数据处理。设计强大的数组操作就是为了实现这一 目标。ortran奠定了高级语言发展的基础。现在Fortran在科研和机械方面应用很广。 2、Fortran的主要版本及差别 按其发展历史，Fortran编译器的版本其实很多。现在在广泛使用的是Fortran 77和Fortr an90。ortran 90在Fortran 77基础上添加了不少使用的功能，并且改良了77编程的版面格式， 所以编程时推荐使用90。鉴于很多现成的程序只有77版本，有必要知道77的一些基本常识，至少保证能够看77程序。以下是77和90的一些格式上的区别。 Fortran 77：固定格式（fixed format），程序代码扩展名：.f或.for （1）若某行以C,c或*开头，则该行被当成注释； （2）每行前六个字符不能写程序代码，可空着，或者1~5字符以数字表明行代码（用作格 式化输入出等）；7~72为程序代码编写区；73往后被忽略； （3）太长的话可以续行，所续行的第六个字符必须是"0"以外的任何字符。 Fortran 90：自由格式（free format），扩展名：.f90 （1）以"!"引导注释； （2）每行可132字符，行代码放在每行最前面； （3）以&续行，放在该行末或下行初。 以下都是讨论Fortran 90。 3、Fortran的一些特点，和C的一些不同 其实很多，在下面涉及具体方面时可以看到。这里只是大致提一些。
附录 FORTRAN 90标准函数 符号约定： ●I代表整型;R代表实型;C代表复型;CH代表字符型;S代表字符串;L代表逻辑型;A代表数组;P代表指针;T代表派生类型;AT为任意类型。 ●s:P表示s类型为P类型(任意kind值)。s:P(k)表示s类型为P类型(kind值=k)。 ●[…]表示可选参数。 ●*表示常用函数。 表1 数值和类型转换函数 函数名说明 ABS(x)*求x的绝对值∣x∣。x:I、R,结果类型同x; x:C,结果:R AIMAG(x)求x的实部。x:C,结果:R AINT(x[,kind])*对x取整,并转换为实数(kind)。x:R, kind:I,结果:R(kind) AMAX0(x1,x2,x3,…)*求x1,x2,x3,…中最大值。x I:I,结果:R AMIN0(x1,x2,x3,…)*求x1,x2,x3,…中最小值。x I:I,结果:R ANINT(x[,kind])*对x四舍五入取整,并转换为实数(kind)。x:R, kind:I,结果:R(kind) CEILING(x)*求大于等于x的最小整数。x:R,结果:I CMPLX(x[,y][,kind]))将参数转换为x、(x,0.0)或(x,y)。x:I、R、C, y:I、R,kind:I,结果:C(kind) CONJG(x)求x的共轭复数。x:C,结果:C DBLE(x)*将x转换为双精度实数。x:I、R、C,结果:R(8) DCMPLX(x[,y])将参数转换为x、(x,0.0)或(x,y)。x:I、R、C, y:I、R,结果:C(8) DFLOAT(x)将x转换为双精度实数。x:I,结果:R(8) DIM(x,y)*求x-y和0中最大值,即MAX(x-y,0)。x:I、R, y的类型同x,结果类型同x DPROD(x,y)求x和y的乘积,并转换为双精度实数。x:R, y:R,结果:R(8)
Fortran基本用法小结 目录： 一、说明 二、概述 三、数据类型及基本输入输出 四、流程控制 五、循环 六、数组 七、函数 八、文件 一、说明 本文多数内容是我读彭国伦《Fortran 95 程序设计》的笔记。只读到第九章，主要是3~9章，都是些最基本的用法（原书共16章）。这里主要摘录了我看书过程中总结的一些Fortran和C不同的地方，主要是语法方面。希望这份笔记能够给学过C但没有接触过Fortran的同学带去一些帮助。要想弄得更清楚些，推荐看一下原书，觉得作者真的写得很好，很清楚；如果有C语言的基础，看完前九章应该很快的，花一两天就行了。觉得如果耐心看完本文，基本功能应该也可以顺利用起来了。 另外，由于我之前没有用过Fortran，这次为了赶文档看书又看得很粗浅，大多数东西看过之后都没来得及仔细想，只是按着作者的意思去理解。所以这份笔记还处于纸上谈兵的层次。如果有不妥的地方，希望大家指正。谢谢！ 文中蓝色的部分是程序代码，!后面的内容为注释。 二、概述 1、名词解释 Fortran=Formula Translator/Translation 一看就知道有什么特色了：可以把接近数学语言的文本翻译成机械语言。的确，从一开始，IBM设计它的时候就是为了方便数值计算和科学数据处理。设计强大的数组操作就是为了实现这一目标。Fortran奠定了高级语言发展的基础。现在Fortran在科研和机械方面应用很广。 2、Fortran的主要版本及差别 按其发展历史，Fortran编译器的版本其实很多。现在在广泛使用的是Fortran 77和Fortran90。Fortran 90在Fortran 77基础上添加了不少使用的功能，并且改良了77编程的版面格式，所以编程时推荐使用90。鉴于很多现成的程序只有77版本，有必要知道77的一些基本常识，至少保证能够看懂77程序。以下是77和90的一些格式上的区别。
FORTRAN 心得 第一部分：一些小心得 1 Fortran不区分大小写 2 Fortran有5种基本数据类型，integer，real, character, logical, complex 3 fortran fixed format格式中的变量赋初值一般用DATA，因为它不能用:: 4 real(kind=8) a这种格式只使用于Fortran90，Fortran77中要使用real*8或real(8) 5 FORTRAN中FREE与FIXED两种格式do循环的区别： Fortran 95使用end do来结束循环。 ： Fortran 77使用DO循环要麻烦一点，它不使用END DO来结束循环，而是使用行号来结束循环，程序代码要在DO的后面写清楚这个循环到哪一行程序代码结束。 Fortran 77中，经常会使用CONTINUE这个命令来结束循环。因为CONTINUE这个命令没有实际的用途，刚好可以拿来做封装使用。 6 循环的流程控制： 循环中的cycle命令相当于c++里的continue命令，用于结束一次循环 循环中的exit命令好比c里面的break，用于结束循环 7 不使用do循环，单纯用GOTO语句也能设计循环程序，但不推荐使用GOTO语句 7 fortran有等价声明：即用equivalence(a,b),这样使得a,b使用同一块内存，这样可以节省内存，有时可精简代码。 、 8 fortran77中只能用单引号。（还有疑问，因为fixed format能用双引号） 9 逻辑运算符 == /= > >= < <= !Fortran90用法 .EQ. .NE. .GT. GE. .LT. .LE. !Fortran77用法 9 PAUSE,CONTINUE，STOP pause 暂停程序执行，按enter可继续执行 continue 貌似没什么用处，可用作封装程序的标志 % STOP 命令用来结束程序，要谨慎使用 10 数组元素之间要用逗号分隔，而不能像matlab一样既可以用逗号也可以用空格，fortran 的数组元素之间不能用空格。 11 数组的声明： Fortran 77中数组的声明，必须使用DIMENSION命令 Integer a; !先声明a是整型 Dimension a(10) !再声明a是大小为10的数组 Fortran 95中可以用简单的方法： `