Fortran的快速指南

2018-12-12 14:24 更新

Fortran语言 - 概述

Fortran语言,从公式翻译系统获得,是一种通用的,命令式编程语言。它用于数字和科学计算。

Fortran语言最初是由IBM在20世纪50年代的科学和工程应用的发展。 Fortran语言统治这个规划面积很长一段时间,并成为高性能计算很受欢迎,因为。

它支持:

  • 数值分析和科学计算
  • 结构化编程
  • 阵列编程
  • 模块化编程
  • 泛型编程
  • 在超级计算机的高性能计算
  • 面向对象的程序设计
  • 并行编程
  • 计算机系统之间的可移植性的合理程度

有关Fortran的事实

  • Fortran语言是由一个团队,于1957年由约翰·巴克斯在IBM领导创建的。

  • 最初使用的名字写在所有的资本,但是目前的标准和实现只需要第一个字母要大写。

  • Fortran语言表示的公式转换器。

  • 最初是为科学计算开发的,它必须为字符串和所需的通用编程其他结构的支持非常有限。

  • 后来的扩展和发展,使它成为具有良好的便携高水平的编程语言。

  • 原始版本的Fortran I,II和III现在已经过时了。

  • 最早的版本仍然在使用的Fortran IV标准,和Fortran 66。

  • 最常见的是今天使用的版本是:Fortran 77的,90的Fortran和Fortran 95。

  • Fortran 77的字符串添加作为一个独特的类型。

  • Fortran 90的加入各种各样线程,和直接阵列处理。

Fortran语言 - 环境设置

在Windows中设置的Fortran

G95是GNU的Fortran多architechtural编译器,用于在Windows中设置的Fortran。 Windows版本的模仿windows下MingW平台使用UNIX环境。安装程序完成这个功能并自动添加G95到Windows PATH变量。

您可以从这里得到G95的稳定版本:

安装设置迷你安装设置

如何使用G95

在安装过程中,如果选择“推荐”选项G95会自动添加到您的PATH变量。这意味着,你可以简单地打开一个新的命令提示符窗口,输入“G95”,弹出编译器。下面找到一些基本的命令,让你开始。

命令描述
G95 -c hello.f90 编译hello.f90到目标文件命名为hello.o
G95 hello.f90 编译hello.f90和链接它来生成可执行的a.out
G95 -c h1.f90 h2.f90 h3.f90 编译多个源文件。如果一切顺利的话,目标文件h1.o,h2.o和h3.o创建
G95 -o你好h1.f90 h2.f90 h3.f90 编译多个源文件并将它们链接起来,以一个名为'你好'的可执行文件

对于G95命令行选项:

-c Compile only, do not run the linker.
-o Specify the name of the output file, either an object file or the executable.

多个源和目标文件可以一次指定。 Fortran文件都通过“.F”,“.F”“。对于”结尾的名字所指出的,“.FOR”,“.F90”,“.F90”,“.F95”,“.F95”,“。 F03“和”.F03“。多个源文件可以指定。对象文件也可被指定,并且将被连接以形成一个可执行文件。

Fortran语言 - 基本语法

的Fortran程序是由程序单元像一个主程序,模块和外部子程序或程序的集合。

每个程序包含一个主程序和可以或可以不包含其它程序单元。主程序的语法如下:

program program_name      
implicit none      
! type declaration statements      
! executable statements  
end program program_name

Fortran中一个简单的程序

让我们写一个程序,增加了两个数字,并打印出结果:

program addNumbers                                          
! This simple program adds two numbers     
   implicit none
! Type declarations
   real :: a, b, result 
! Executable statements 
   a = 12.0
   b = 15.0
   result = a + b
   print *, 'The total is ', result                   
end program addNumbers        

当你编译和执行上面的程序,它会产生以下结果:

The total is 27.0000000    

请注意:

  • 所有Fortran程序启动与关键字程序并结束与关键字结束程序,然后该程序的名称。

  • 隐式无语句允许编译器检查你所有的变量类型正确声明。你必须总是在每个节目开始使用隐无

  • 在Fortran语言注释开始与感叹号(!),因为在这之后的所有字符(除了在一个字符串)被编译器忽略。

  • 打印*在屏幕上显示命令数据。

  • 行代码的缩进是保持一个程序读取一个很好的做法。

  • Fortran的同时允许大写和小写字母。 Fortran语言是不区分大小写,除了字符串。

基本

基本字符集的Fortran包含:

  • 字母A到Z和A ... Z
  • 数字0 ... 9
  • 下划线(_)字符
  • 特殊字符=:+空白 - * /()[]。 $'! “%; <>?

令牌在基本字符集字符制成的。令牌可以是一个关键词,一个标识符,常量,字符串文字或符号。

程序语句是由令牌。

识别码

一个标识符是用于标识变量,过程或任何其它用户定义的项目的名称。在Fortran语言的名称必须遵循以下规则:

  • 它不能超过31个字符。

  • 它必须由字母数字字符(字母表中的所有字母和数字0到9)和下划线(_)。

  • 名称的第一个字符必须是字母。

  • 名称不区分大小写

关键词

关键字是特殊的单词,语言的保留。这些保留字不能用作标识符或名称。

下面的表格,列出了Fortran语言的关键字:

非I / O关键字
可分配分配分配分配数据块
呼叫案件字符共同复杂
包含继续周期数据 DEALLOCATE
默认双精度其他否则,如果
别处最终数据块做到底最终功能万一
结束接口前端模块程序结束最终选择结束子程序
结束类型到底哪里条目等价出口
外部功能如果含蓄
进出整数意图接口
固有 LEN 合乎逻辑的
名单废止只要操作者可选的
参数暂停指针私人的
程序上市真实递归结果
返回保存选择案例停止子程序
目标然后类型类型() 使用
哪里
在I / O相关的关键字
退格 ENDFILE 格式查询
打开打印倒带

Fortran语言 - 数据类型

Fortran语言提供了五种内部数据类型,但是,你可以得到你自己的数据类型为好。五个内在的类型有:

  • 整型
  • 房地产类型
  • 复杂类型
  • 逻辑类型
  • 字符类型

整型

整数类型只能容纳整数值。下面的例子中提取,可以在通常的4字节整数中保存的最大值:

program testingInt
implicit none
   integer :: largeval
   print *, huge(largeval)
end program testingInt

当你编译和执行上面的程序它产生以下结果:

2147483647

需要注意的是巨大()函数给出可由特定整数数据类型被保持的最大数目。还可以指定使用的那种符的字节数。下面的例子说明了这一点:

program testingInt
implicit none
   !two byte integer
   integer(kind=2) :: shortval
   !four byte integer
   integer(kind=4) :: longval
   !eight byte integer
   integer(kind=8) :: verylongval
   !sixteen byte integer
   integer(kind=16) :: veryverylongval
   !default integer 
   integer :: defval
        
   print *, huge(shortval)
   print *, huge(longval)
   print *, huge(verylongval)
   print *, huge(veryverylongval)
   print *, huge(defval)
end program testingInt

当你编译和执行上面的程序,它会产生以下结果:

32767
2147483647
9223372036854775807
170141183460469231731687303715884105727
2147483647

实型

它存储浮点数,例如2.0,3.1415,-100.876等

传统上有两种不同的现实类型,默认型和双精度型。

然而,Fortran语言90/95提供了真实和整数数据类型通过一种说明,我们将在数字章节中研究精密的控制。

下面的例子说明了如何使用真实的数据类型:

program division   
implicit none  
   ! Define real variables   
   real :: p, q, realRes 
   ! Define integer variables  
   integer :: i, j, intRes  
   ! Assigning  values   
   p = 2.0 
   q = 3.0    
   i = 2 
   j = 3  
   ! floating point division
   realRes = p/q  
   intRes = i/j
   
   print *, realRes
   print *, intRes
end program division  

当你编译和执行上面的程序它产生以下结果:

0.666666687    
0

复杂类型

这个用于存储复数。一个复杂的数字有两部分,实部和虚部。两个连续的数字存储单元存储这两个部分。

例如,该复数(3.0,-5.0)等于3.0 - 5.0i

我们将详细讨论复杂类型,在数字章节。

逻辑类型

仅存在两个逻辑值:.TRUE。.FALSE。

字符类型

字符类型存储字符和字符串。字符串的长度可以通过LEN说明指定。如果未指定长度,它是1。

例如,

character (len=40) :: name  
name = “Zara Ali”

表达, 域名(1:4),将给予串“扎拉”。

隐式类型

Fortran语言的旧版本允许一个叫做隐式类型,也就是说,你不必在使用前声明变量功能。如果变量未声明,那么它的名字的第一个字母,将决定其类型。

开始以i的变量名,J,K,L,M,或n,被认为是为整数变量,其余都是真实的变量。但是,你必须为它良好的编程习惯声明所有的变量。对于您的发言开始你的程序:

implicit none

这个语句关闭隐式类型。

Fortran语言 - 变量

变量是什么,但给我们的程序可以操纵一个存储区的名称。每个变量应该具有特定的类型,它决定了大小和变量的存储器的布局;可以存储该存储器内的值的范围内;和该组操作可以施加到可变。

变量的名称可以由字母,数字和下划线。在Fortran语言的名称必须遵循以下规则:

  • 它不能超过31个字符。

  • 它必须由字母数字字符(字母表中的所有字母和数字0到9)和下划线(_)。

  • 名称的第一个字符必须是字母。

  • 名称不区分大小写。

基于基本类型前面的章节中介绍,下面是变量类型:

类型描述
整数它只能容纳整数值。
真实它存储浮点数。
复杂它用于存储复数。
合乎逻辑的它存储逻辑布尔值。
字符它存储的字符或字符串。

变量声明

变量在一个类型声明语句一个程序(或子程序)的开头声明。

语法变量声明如下:

type-specifier :: variable_name

例如,

integer :: total  	
real :: average 
complex :: cx  
logical :: done 
character(len=80) :: message ! a string of 80 characters

稍后,您可以将值分配给这些变量一样,

total = 20000  
average = 1666.67   
done = .true.   
message = “A big Hello from Tutorials Point” 
cx = (3.0, 5.0) ! cx = 3.0 + 5.0i

您也可以使用内部函数CMPLX,赋值给一个复数变量:

cx = cmplx (1.0/2.0, -7.0) ! cx = 0.5 – 7.0i 
cx = cmplx (x, y) ! cx = x + yi

下面的示例演示屏幕上变量声明,分配和显示:

program variableTesting
implicit none

   ! declaring variables
   integer :: total      
   real :: average 
   complex :: cx  
   logical :: done 
   character(len=80) :: message ! a string of 80 characters
   
   !assigning values
   total = 20000  
   average = 1666.67   
   done = .true.   
   message = "A big Hello from Tutorials Point" 
   cx = (3.0, 5.0) ! cx = 3.0 + 5.0i

   Print *, total
   Print *, average
   Print *, cx
   Print *, done
   Print *, message
end program variableTesting

当上述代码被编译和执行时,它产生了以下结果:

20000
1666.67004    
(3.00000000, 5.00000000 )
T
A big Hello from Tutorials Point         

Fortran语言 - 常量

常数指的是程序不能在执行期间改变的固定值。这些固定值也被称为文字

常量可以是任何基本的数据类型,如整型常量,一个浮点常量,字符常量,复杂的常量或字符串文本。只有两个逻辑常量:.TRUE。.FALSE。

该常量将被视为就像普通变量,但它们的值不能将其定义后进行修改。

命名常量和文字

有两种类型的常量:

  • 字面常量
  • 命名常量

文字常量有值,但没有名字。

例如,以下是文字常量:

类型
整型常量 01-1 300 123456789
实常数 0.0 1.0 -1.0 123.456 7.1E + 10 -52.715E-30
复常数 (0.0,0.0)(-123.456E + 30,987.654E-29)
逻辑常量 。真正。 。假。
字符常量

“PQR”“一”“123'abc $%#@!”

“一帖”“”

“PQR''A''123”ABC $%#@!

'撇号'''

命名常量的值以及名称。

命名常量应当在程序或过程的开始进行声明,就像一个变量的类型声明,表明其名称和类型。命名常量声明的参数属性。例如,

real, parameter :: pi = 3.1415927

下面的程序计算位移,由于在重力作用下垂直运动。

program gravitationalDisp
! this program calculates vertical motion under gravity 
implicit none  
   ! gravitational acceleration
   real, parameter :: g = 9.81   
   ! variable declaration
   real :: s ! displacement   
   real :: t ! time  
   real :: u ! initial speed  
   ! assigning values 
   t = 5.0   
   u = 50  
   ! displacement   
   s = u * t - g * (t**2) / 2  
   ! output 
   print *, "Time = ", t
   print *, 'Displacement = ',s  
end program gravitationalDisp

当上述代码被编译和执行时,它产生了以下结果:

Time = 5.00000000    
Displacement = 127.374992    

Fortran语言 - 操作员

运算符是告诉执行特定数学或逻辑操作的编译器的符号。 Fortran语言提供了以下类型的运算符:

  • 算术运算符
  • 关系运算符
  • 逻辑运算符

让我们来看看所有这些类型的运营商逐一。

算术运算符

下表列出了所有的Fortran支持的算术运算符。假设变量A持有5,然后变量B持有3:

显示示例

操作者描述
+ 除了运营商,增加了两个操作数。 A + B将给8
- 减法操作,减去从所述第一第二操作数。 A - B就给予2
* 乘法运算,乘两个操作数。 A * B将给予15
/ 除法运算符,由去分子分裂分子。 A / B将给予1
** 乘方运算引发一个操作数到其他的力量。 A ** B就给予125

关系运算符

下表列出了所有的Fortran支持的关系运算符。假设变量A持有10和变量B持有20,则:

显示示例

=
操作者当量描述
== .EQ。 检查,如果两个操作数的值相等与否,如果是,则条件变为真。 (A == B)是不正确的。
/ = .NE。 检查,如果两个操作数的值相等与否,如果值不相等,则条件变为真。 (A!= B)为真。
> .GT。 检查左操作数的值大于右操作数的值,如果是,则条件为真。 (A> B)是不正确的。
.GE。 检查左操作数的值大于或等于右边的操作数的值,如果是,则条件为真。 (A> = B)是不正确的。
T1 P1 = 1打印*,P1打印*,T1 P1 = P1 + 4 *打印,打印P1 *,T1 T1 = 8打印*,P1打印*,T1结束程序pointerExample

当上述代码被编译和执行时,它产生了以下结果:

1
1
5
5
8
8

一个指针可以是:

  • 未定义
  • 关联的
  • 解除关联

另外,在上述程序中,我们已关联的指示器p1,与目标T1,使用=>运算符。相关的功能,测试指针的关联状态。

废止声明的关联从一个目标的指针。

抵消不清空目标,因为可能存在一个以上的指针指向同一目标。然而,排空指针意味着无效也。

例1

下面的示例演示的概念:

program pointerExample
implicit none
   integer, pointer :: p1
   integer, target :: t1 
   integer, target :: t2
   p1=>t1
   p1 = 1
   Print *, p1
   Print *, t1
   p1 = p1 + 4
   Print *, p1
   Print *, t1
   t1 = 8
   Print *, p1
   Print *, t1
   nullify(p1)
   Print *, t1
   p1=>t2
   Print *, associated(p1)
   Print*, associated(p1, t1)
   Print*, associated(p1, t2)
   !what is the value of p1 at present
   Print *, p1
   Print *, t2
   p1 = 10
   Print *, p1
   Print *, t2
end program pointerExample

当上述代码被编译和执行时,它产生了以下结果:

1
1
5
5
8
8
8
T
F
T
952754640
952754640
10
10

请注意,每次运行代码时,内存地址会有所不同。

例2

program pointerExample
implicit none
   integer, pointer :: a, b
   integer, target :: t
   integer :: n
   t= 1
   a=>t
   t = 2
   b => t
   n = a + b
   Print *, a, b, t, n 
end program pointerExample

当上述代码被编译和执行时,它产生了以下结果:

2  2  2  4

Fortran语言 - 基本输入输出

迄今为止,我们已经看到,我们可以使用打印*语句读取分别使用读取*语句键盘和显示输出数据到屏幕上。输入输出的形式是自由格式的 I / O,它被称为列表控制的输入输出。

自由格式简单的I / O的形式为:

read(*,*) item1, item2, item3...
print *, item1, item2, item3
write(*,*) item1, item2, item3...

然而,格式化I / O让您的数据传输更多的灵活性。

格式化输入输出

格式化输入输出有语法如下:

read fmt, variable_list 
print fmt, variable_list 
write fmt, variable_list 

哪里,

  • FMT是格式规范

  • 可变列表被从键盘被读或写在屏幕上的变量的列表

格式规范定义,其中显示格式化的数据的方式。它由一个字符串,包含编辑描述符的括号中的列表。

一个编辑描述符指定的精确格式,例如,宽度,其中显示后小数点等,数字字符和数字。

例如:

Print "(f6.3)", pi

下表描述了描述:

描述符描述
一世这是用于整数输出。此采用的形式为“rIw.m',其中的R,W和M的含义在下面的表中给出。整数值是在他们的视场科幻权JUSTI网络版。如果场宽度不是大到足以容纳一个整数那么场是网络连接有星号LLED。 打印“(3i5)”,I,J,K
F 这是用于实数输出。此采用的形式为“rFw.d',其中的R,W和D的含义在下面的表中给出。真正的价值在他们的网络的视场右侧JUSTI网络版。如果场宽度不够大以容纳实数则场是音响LLED以星号。 打印“(f12.3)”,圆周率
Ë

这是用于指数符号实际产出。在'E'描述语句的形式为'rEw.d',其中的R,W和D的含义如下表所示。真正的价值在他们的网络的视场右侧JUSTI网络版。如果场宽度不够大以容纳实数则场是音响LLED以星号。

请注意,打印出三位小数,需要至少十的场宽度的实数。一个用于尾数,两个零,四项尾数和两个用于指数本身的符号。一般来说,W≥D + 7。

打印“(e10.3)”,123456.0给出了'0.123e + 06'
ES 这是用于实际产出(科学记数法)。此采用的形式为“rESw.d',其中的R,W和D的含义在下面的表中给出。在“E”上面的描述符迪FF ERS稍微从传统的著名“科学的C表示法”介绍。科学的C表示法具有范围1.0尾数〜10.0不像其具有在0.1到1.0的尾数对E描述符。真正的价值在他们的网络的视场右侧JUSTI网络版。如果场宽度不够大以容纳实数则场是音响LLED以星号。这里还,宽度场必须满足表达W¯¯≥D + 7 打印“(es10.3)”,123456.0给出了'1.235e + 05'
一个这是用于字符输出。这需要其中r和W的含义如下表中给出的形式“原始”。性格类型是在他们的网络的视场右侧JUSTI网络版。如果场宽度不足够大以容纳字符串则场是音响与第一个“W”的字符串的字符LLED。 打印“(A10)”,STR
X 这是用于空间输出。这种形式定义的NX“,其中”n“是所需空间的数量。 打印“(5倍,A10)”,STR
/ 斜线描述 - 用于插入空行。这需要的形式'/',并强制下一个数据输出为一个新行。 打印“(/,5倍,A10)”,STR

以下符号用于与格式描述符:

符号描述
C 列号
ð 中位数为实际输入或输出的小数位的权
要显示的最小位数
ñ 空格数跳过
- [R 重复计数 - 的次数要使用的描述符的描述符或一组
W¯¯ 域宽度 - 的字符数用于输入或输出

例1

program printPi
   pi = 3.141592653589793238 
   
   Print "(f6.3)", pi 
   Print "(f10.7)", pi
   Print "(f20.15)", pi 
   Print "(e16.4)", pi/100 
end program printPi

当上述代码被编译和执行时,它产生了以下结果:

3.142
3.1415927
3.141592741012573
0.3142E-01

例2

program printName
implicit none
character (len=15) :: first_name
   print *,' Enter your first name.' 
   print *,' Up to 20 characters, please'
   read *,first_name 
   print "(1x,a)",first_name
end program printName

当上述代码被编译和执行时,它产生了以下结果:(假设用户输入的名称扎拉)

Enter your first name.
   Up to 20 characters, please
   Zara 

例3

program formattedPrint
implicit none
real :: c = 1.2786456e-9, d = 0.1234567e3 
integer :: n = 300789, k = 45, i = 2
character (len=15) :: str="Tutorials Point"
print "(i6)", k 
print "(i6.3)", k 
print "(3i10)", n, k, i 
print "(i10,i3,i5)", n, k, i 
print "(a15)",str 
print "(f12.3)", d
print "(e12.4)", c 
print '(/,3x,"n = ",i6, 3x, "d = ",f7.4)', n, d
end program formattedPrint

当上述代码被编译和执行时,它产生了以下结果:


45
045
300789 45  2
300789 45  2
Tutorials Point
123.457
0.1279E-08

n = 300789 d = *******

该声明的格式

格式语句允许您在一个声明中混合和匹配字符,整数和实输出。下面的例子说明了这一点:

program productDetails 
implicit none 
   character (len=15) :: name
   integer :: id 
   real :: weight
   name = 'Ardupilot'
   id = 1
   weight = 0.08
   print *,' The product details are' 
   print 100
   100 format (7x,'Name:', 7x, 'Id:', 1x, 'Weight:')
   print 200, name, id, weight 
   200 format(1x, a, 2x, i3, 2x, f5.2) 
end program productDetails

当上述代码被编译和执行时,它产生了以下结果:

The product details are
Name:       Id:    Weight:
Ardupilot   1       0.08

Fortran语言 - 文件输入输出

Fortran语言,您可以读取数据,并将数据写入到文件中。

在最后一章,你看到了如何读取数据,并将数据写入到终端。在本章中,您将学习用Fortran语言提供的文件输入和输出功能。

可以读取和写入到一个或多个文件。开放,写入,读取和CLOSE语句,可以实现这一目标。

打开和关闭文件

使用文件之前,必须先打开该文件。 打开命令用来打开文件进行读取或写入。该命令的最简单的形式是:

open (unit = number, file = "name").

然而,开放的声明可能有一个一般形式:

open (list-of-specifiers)

下表介绍最常用的指示符:

说明描述
[UNIT =]ù 单元号ü可以是任何数量范围9-99,它表明该文件,你可以选择任何号码,但在程序中每个打开的文件必须有一个唯一的编号
IOSTAT = IOS 它是在I / O状态标识符和应为整数的变量。如果打开语句成功,则返回的IOS值为零其他非零值。
ERR = ERR 这是任何错误的情况下,控制跳转的标签。
FILE = FNAME 文件名,一个字符串。
STATUS =站它显示了该文件的先前状态。一个字符串,可以有三个值新的,旧的或SCRATCH之一。划痕文件被创建和删除关闭时或程序结束。
ACCESS = ACC 它是该文件的访问模式。可以有两个值,顺序或直销。默认值是连续的。
FORM = FRM 它给该文件的格式的状态。可以有格式化或者非格式化两个值。默认值为UNFORMATTED
RECL = RL 它指定每个记录中直接访问文件的长度。

该文件已被打开后,它是由读写语句访问。一旦这样做,就应该使用CLOSE语句关闭。

close语句的语法如下:

close ([UNIT=]u[,IOSTAT=ios,ERR=err,STATUS=sta])

请注意,括号中的参数是可选的。

本实施例说明打开一个新文件的某些数据写入到文件中。

program outputdata   
implicit none   
real, dimension(100) :: x, y  
real, dimension(100) :: p, q
integer :: i  
   ! data  
   do i=1,100  
   x(i) = i * 0.1 
   y(i) = sin(x(i)) * (1-cos(x(i)/3.0))  
   end do  
   ! output data into a file 
   open(1, file='data1.dat', status='new')  
   do i=1,100  
   write(1,*) x(i), y(i)   
   end do  
   close(1) 
end program outputdata

当上述代码被编译和执行时,它创建的文件data1.dat和x和y数组值写入到其中。然后关闭该文件。

读取和写入到文件

的读写语句分别用于读和分别写入到文件中。

他们的语法如下:

read ([UNIT=]u, [FMT=]fmt, IOSTAT=ios, ERR=err, END=s)
write([UNIT=]u, [FMT=]fmt, IOSTAT=ios, ERR=err, END=s)

大多数符的已在上表中进行讨论。

结束= S说明是一个语句标号所在的程序跳转,当它到达档案结尾。

此示例演示读取和写入到文件中。

在这个项目中,我们从文件中读取,我们在最后一个例子创建,data1.dat,并在屏幕上显示。

program outputdata   
implicit none   
real, dimension(100) :: x, y  
real, dimension(100) :: p, q
integer :: i  
   ! data  
   do i=1,100  
   x(i) = i * 0.1 
   y(i) = sin(x(i)) * (1-cos(x(i)/3.0))  
   end do  
   ! output data into a file 
   open(1, file='data1.dat', status='new')  
   do i=1,100  
   write(1,*) x(i), y(i)   
   end do  
   close(1) 
  
   ! opening the file for reading
   open (2, file='data1.dat', status='old')
  
   do i=1,100  
   read(2,*) p(i), q(i)
   end do 
   close(2)
   do i=1,100  
   write(*,*) p(i), q(i)
   end do 
end program outputdata

当上述代码被编译和执行时,它产生了以下结果:

0.100000001  5.54589933E-05
0.200000003  4.41325130E-04
0.300000012  1.47636665E-03
0.400000006  3.45637114E-03
0.500000000  6.64328877E-03
0.600000024  1.12552457E-02
0.699999988  1.74576249E-02
0.800000012  2.53552198E-02
0.900000036  3.49861123E-02
1.00000000   4.63171229E-02
1.10000002   5.92407547E-02
1.20000005   7.35742599E-02
1.30000007   8.90605897E-02
1.39999998   0.105371222    
1.50000000   0.122110792    
1.60000002   0.138823599    
1.70000005   0.155002072    
1.80000007   0.170096487    
1.89999998   0.183526158    
2.00000000   0.194692180    
2.10000014   0.202990443    
2.20000005   0.207826138    
2.29999995   0.208628103    
2.40000010   0.204863414    
2.50000000   0.196052119    
2.60000014   0.181780845    
2.70000005   0.161716297    
2.79999995   0.135617107    
2.90000010   0.103344671    
3.00000000   6.48725405E-02
3.10000014   2.02930309E-02
3.20000005  -3.01767997E-02
3.29999995  -8.61928314E-02
3.40000010  -0.147283033    
3.50000000  -0.212848678    
3.60000014  -0.282169819    
3.70000005  -0.354410470    
3.79999995  -0.428629100    
3.90000010  -0.503789663    
4.00000000  -0.578774154    
4.09999990  -0.652400017    
4.20000029  -0.723436713    
4.30000019  -0.790623367    
4.40000010  -0.852691114    
4.50000000  -0.908382416    
4.59999990  -0.956472993    
4.70000029  -0.995793998    
4.80000019  -1.02525222    
4.90000010  -1.04385209    
5.00000000  -1.05071592    
5.09999990  -1.04510069    
5.20000029  -1.02641726    
5.30000019  -0.994243503    
5.40000010  -0.948338211    
5.50000000  -0.888650239    
5.59999990  -0.815326691    
5.70000029  -0.728716135    
5.80000019  -0.629372001    
5.90000010  -0.518047631    
6.00000000  -0.395693362    
6.09999990  -0.263447165    
6.20000029  -0.122622721    
6.30000019   2.53026206E-02
6.40000010   0.178709000    
6.50000000   0.335851669    
6.59999990   0.494883657    
6.70000029   0.653881252    
6.80000019   0.810866773    
6.90000010   0.963840425    
7.00000000   1.11080539    
7.09999990   1.24979746    
7.20000029   1.37891412    
7.30000019   1.49633956    
7.40000010   1.60037732    
7.50000000   1.68947268    
7.59999990   1.76223695    
7.70000029   1.81747139    
7.80000019   1.85418403    
7.90000010   1.87160957    
8.00000000   1.86922085    
8.10000038   1.84674001    
8.19999981   1.80414569    
8.30000019   1.74167395    
8.40000057   1.65982044    
8.50000000   1.55933595    
8.60000038   1.44121361    
8.69999981   1.30668485    
8.80000019   1.15719533    
8.90000057   0.994394958    
9.00000000   0.820112705    
9.10000038   0.636327863    
9.19999981   0.445154816    
9.30000019   0.248800844    
9.40000057   4.95488606E-02
9.50000000  -0.150278628    
9.60000038  -0.348357052    
9.69999981  -0.542378068    
9.80000019  -0.730095863    
9.90000057  -0.909344316    
10.0000000  -1.07807255    

Fortran语言 - 程序

过程是一组执行一个明确的任务,可以从你的程序中调用语句。信息(或数据)被传递给调用的程序,向步骤作为参数。

有两种类型的程序:

  • 功能
  • 子程序

功能

函数是返回一个单一的量的过程。函数不应该修改其参数。

返回的数量被称为函数值 ,并且它由函数名表示。

句法:

语法功能如下:

function name(arg1, arg2, ....)  
   [declarations, including those for the arguments]   
   [executable statements] 
end function [name]

下面的示例演示一个名为功能area_of_circle。它计算半径为r的圆的面积。

program calling_func
   real :: a
   a = area_of_circle(2.0) 
   Print *, "The area of a circle with radius 2.0 is"
   Print *, a
end program calling_func

function area_of_circle (r)  
! this function computes the area of a circle with radius r     
   implicit none      
! function result     
   real :: area_of_circle   
! dummy arguments     
   real :: r     
! local variables     
   real :: pi    
   pi = 4 * atan (1.0)     
   area_of_circle = pi * r**2  
end function area_of_circle

当你编译和执行上面的程序,它会产生以下结果:

The area of a circle with radius 2.0 is
   12.5663710   

请注意:

  • 必须指定在两个主程序隐无以及程序。

  • 在被调用函数的参数r被称为伪参数

结果选项

如果你想返回的值存储在其它一些名称与功能名称,您可以使用结果选项。

您可以指定返回变量名:

function name(arg1, arg2, ....) result (return_var_name)  
   [declarations, including those for the arguments]   
   [executable statements] 
end function [name]

子程序

子程序没有返回值,但可以修改其参数。

句法

subroutine name(arg1, arg2, ....)    
   [declarations, including those for the arguments]    
   [executable statements]  
end subroutine [name]

调用子程序

您需要使用呼叫语句调用的子程序。

下面的例子演示了一个子程序交换,改变其参数值的定义和使用。

program calling_func
implicit none
   real :: a, b
   a = 2.0
   b = 3.0
   Print *, "Before calling swap"
   Print *, "a = ", a
   Print *, "b = ", b
   call swap(a, b)
   Print *, "After calling swap"
   Print *, "a = ", a
   Print *, "b = ", b
end program calling_func

   subroutine swap(x, y) 
   implicit none
   real :: x, y, temp   
   temp = x  
   x = y 
   y = temp  
end subroutine swap

当你编译和执行上面的程序,它会产生以下结果:

Before calling swap
a = 2.00000000    
b = 3.00000000    
After calling swap
a = 3.00000000    
b = 2.00000000   

指定参数的意图

这样做的目的属性允许你指定与参数在程序中使用的意图。下表提供的意图属性的值:

作为说明
意图(中) 用作输入值,而不是在功能改变
意图(出) 用作输出值,它们都将被覆盖
进出意图(INOUT) 参数都是使用和覆盖

下面的例子演示了这个概念:

program calling_func
implicit none
   real :: x, y, z, disc
   x= 1.0
   y = 5.0
   z = 2.0
   call intent_example(x, y, z, disc)
   Print *, "The value of the discriminant is"
   Print *, disc
end program calling_func

subroutine intent_example (a, b, c, d)     
   implicit none     
   ! dummy arguments      
   real, intent (in) :: a     
   real, intent (in) :: b      
   real, intent (in) :: c    
   real, intent (out) :: d   
   d = b*b - 4.0*a*c 
end subroutine intent_example

当你编译和执行上面的程序,它会产生以下结果:

The value of the discriminant is
   17.0000000    

递归过程

递归当编程语言,您可以调用同一个函数内的函数发生。这就是所谓的函数的递归调用。

当一个过程调用本身,直接或间接地被称为递归过程。你应该通过其声明之前递归字前面的声明这种类型的程序。

当一个函数被递归使用, 结果选项被使用。

以下是一个例子,它计算阶乘用于使用递归过程的给定数量:

program calling_func
implicit none
   integer :: i, f
   i = 15
   Print *, "The value of factorial 15 is"
   f = myfactorial(15)
   Print *, f
end program calling_func

recursive function myfactorial (n) result (fac)  
   ! computes the factorial of n (n!)      
   implicit none     
   ! function result     
   integer :: fac     
   ! dummy arguments     
   integer, intent (in) :: n     
   select case (n)         
   case (0:1)         
   fac = 1         
   case default    
   fac = n * myfactorial (n-1)  
   end select 
end function myfactorial

内部程序

当一个过程被包含在程序中,它被称为程序的内部程序。包含的内部程序的语法如下:

program program_name     
   implicit none         
   ! type declaration statements         
   ! executable statements    
   . . .     
   contains         
   ! internal procedures      
   . . .  
end program program_name

下面的例子演示了这个概念:

program mainprog  
implicit none 
real :: a, b 
   a = 2.0
   b = 3.0
   Print *, "Before calling swap"
   Print *, "a = ", a
   Print *, "b = ", b
   call swap(a, b)
   Print *, "After calling swap"
   Print *, "a = ", a
   Print *, "b = ", b
 
   contains   
   subroutine swap(x, y)     
   real :: x, y, temp      
   temp = x 
   x = y  
   y = temp   
   end subroutine swap 
end program mainprog   

当你编译和执行上面的程序,它会产生以下结果:

Before calling swap
a = 2.00000000    
b = 3.00000000    
After calling swap
a = 3.00000000    
b = 2.00000000   

Fortran语言 - 模块

模块就像一个包,你可以保持你的功能和子程序,如果你正在编写一个非常大的项目,或者你的函数或子程序可以在多个程序中使用。

模块为您提供多个文件之间的分裂你的程序的方式。

模块用于:

  • 包装子程序,数据和接口块。
  • 限定,可以由一个以上的程序中使用的全局数据。
  • 宣称可以选择的任何程序内提供的变量。
  • 导入模块完全,使用,到另一个程序或子程序。

一个模块的语法

一个模块由两部分组成:

  • 规范一部分语句声明
  • 一个包含子程序和函数定义的一部分

模块的一般形式是:

module name     
   [statement declarations]  
   [contains [subroutine and function definitions] ] 
end module [name]

使用一个模块到你的程序

您可以将在通过使用语句程序或子程序模块:

use name  

请注意

  • 您可以添加尽可能多的模块可以根据需要,将各自在不同的文件,并单独编译。

  • 模块可以以各种不同的程序中使用。

  • 模块可以在同一程序中可使用多次。

  • 在模块规范部分中声明的变量是全局的模块。

  • 一个模块中声明的变量成为在使用的模块的任何程序或常规全局变量。

  • 使用声明可以出现在主程序中,或它使用的程序或特定的模块中定义的变量的任何其他子程序或模块。

下面的例子演示了这个概念:

module constants  
implicit none 
   real, parameter :: pi = 3.1415926536  
   real, parameter :: e = 2.7182818285 
contains      
   subroutine show_consts()          
   print*, "Pi = ", pi          
   print*,  "e = ", e     
   end subroutine show_consts 
end module constants 

program module_example     
use constants      
implicit none     
   real :: x, ePowerx, area, radius 
   x = 2.0
   radius = 7.0
   ePowerx = e ** x
   area = pi * radius**2     
   call show_consts() 
   print*, "e raised to the power of 2.0 = ", ePowerx
   print*, "Area of a circle with radius 7.0 = ", area  
end program module_example

当你编译和执行上面的程序,它会产生以下结果:

Pi = 3.14159274    
e =  2.71828175    
e raised to the power of 2.0 = 7.38905573    
Area of a circle with radius 7.0 = 153.938049   

模块中的变量和子程序的无障碍

缺省情况下,一个模块中的所有的变量和子程序被提供给正在使用该模块的代码,通过使用语句的程序。

但是,你可以控制的模块代码使用私人公共属性的可访问性。当你声明一些变量或子程序为私有,这不是可用的模块外。

下面的例子说明了这一概念:

在前面的例子中,我们有两个模块变量,e圆周率。让我们把他们的私人和观察输出:

module constants  
implicit none 
   real, parameter,private :: pi = 3.1415926536  
   real, parameter, private :: e = 2.7182818285 
contains      
   subroutine show_consts()          
   print*, "Pi = ", pi          
   print*, "e = ", e     
   end subroutine show_consts 
end module constants 

program module_example     
use constants      
implicit none     
   real :: x, ePowerx, area, radius 
   x = 2.0
   radius = 7.0
   ePowerx = e ** x
   area = pi * radius**2     
   call show_consts() 
   print*, "e raised to the power of 2.0 = ", ePowerx
   print*, "Area of a circle with radius 7.0 = ", area  
end program module_example

当你编译和执行上面的程序,它提供了以下错误信息:

   ePowerx = e ** x
   1
Error: Symbol 'e' at (1) has no IMPLICIT type
main.f95:19.13:

   area = pi * radius**2     
   1
Error: Symbol 'pi' at (1) has no IMPLICIT type

由于e圆周率,既被声明为私有,module_example无法再访问这些变量程序。

然而,其他模块的子程序可以访问它们:

module constants  
implicit none 
   real, parameter,private :: pi = 3.1415926536  
   real, parameter, private :: e = 2.7182818285 
contains      
   subroutine show_consts()          
   print*, "Pi = ", pi          
   print*, "e = ", e     
   end subroutine show_consts 
   function ePowerx(x)result(ePx) 
   implicit none
   real::x
   real::ePx
   ePx = e ** x
   end function ePowerx
    
   function areaCircle(r)result(a)  
implicit none
   real::r
   real::a
   a = pi * r**2  
   end function areaCircle
    
end module constants 

program module_example     
use constants      
implicit none     
   call show_consts() 
   Print*, "e raised to the power of 2.0 = ", ePowerx(2.0)
   print*, "Area of a circle with radius 7.0 = ", areaCircle(7.0)  
end program module_example

当你编译和执行上面的程序,它会产生以下结果:

Pi = 3.14159274    
e = 2.71828175    
e raised to the power of 2.0 = 7.38905573    
Area of a circle with radius 7.0 = 153.938049   

Fortran语言 - 内部函数

征函数是被提供作为Fortran语言的一部分的一些常见和重要的功能。我们的阵列,字符和字符串的章节已经讨论其中的一些功能。

本征函数可以被归类为:

  • 数值函数
  • 数学函数
  • 数字查询函数
  • 浮点操作函数
  • 位操作功能
  • 字符函数
  • 种类函数
  • 逻辑函数
  • 阵列功能。

我们在阵列章节讨论的阵列功能。在下面的部分,我们提供的其他类别所有这些功能的简要说明。

在功能名称列,

  • A代表任何类型的数值变量
  • R代表真实或整数变量
  • X和Y代表实际变量
  • Z表示复变
  • W代表真实的或复杂的变量

数值函数

功能描述
ABS(A) 它返回一个绝对值
AIMAG(Z) 它返回一个复杂的数Z的虚部
AINT(A [,KIND]) 它截断的小数部分趋向于零,返回一个真正的,整数。
ANINT(A [,KIND]) 它返回一个真正的价值,最近的整数或整数。
CEILING(A [,KIND]) 它返回最小整数大于或等于号A.
CMPLX(X [,Y,KIND]) 它转换成真正的变量X和Y以复数X + IY;如果Y不存在,则使用0。
CONJG(Z) 它返回任何复数Z的复共轭
DBLE(A) 把一路为双精度实数。
DIM(X,Y) 它返回X和Y的正差
DPROD(X,Y) 它返回X和Y的双精度真实的产品
FLOOR(A [,KIND]) 它提供了小于或等于数A的最大整数
INT(A [,KIND]) 将其转换为数字(真实或整数)为整数,朝零截断的实部。
MAX(A1,A2 [,A3,...]) 它返回从参数的最大值,一切存在相同类型。
MIN(A1,A2 [,A3,...]) 它返回从参数的最小值,都存在相同类型。
MOD(A,P) 它被P返回A的剩余部分上师,这两个参数是相同类型的(A-INT(A / P)×P)
MODULO(A,P) 它返回一个模p:(A楼(A / P)×P)
NINT(A [,KIND]) 它返回一个数字的最接近的整数
REAL(A [,KIND]) 将其转换为真正的类型
SIGN(A,B) 它返回一个乘以P的标志的绝对值基本上它传输的B标志的为A.

program numericFunctions
implicit none  
   ! define constants  
   !define variables
   real :: a, b 
   complex :: z
   !values for a, b 
   a = 15.2345
   b = -20.7689
    
   write(*,*) 'abs(a): ',abs(a),' abs(b): ',abs(b)   
   write(*,*) 'aint(a): ',aint(a),' aint(b): ',aint(b) 
   write(*,*) 'ceiling(a): ',ceiling(a),' ceiling(b): ',ceiling(b)   
   write(*,*) 'floor(a): ',floor(a),' floor(b): ',floor(b)  
    
   z = cmplx(a, b)
   write(*,*) 'z: ',z   
end program numericFunctions

当你编译和执行上面的程序,它会产生以下结果:

abs(a): 15.2344999   abs(b): 20.7688999    
aint(a): 15.0000000  aint(b): -20.0000000    
ceiling(a): 16  ceiling(b): -20
floor(a): 15  floor(b): -21
z: (15.2344999, -20.7688999)

数学函数

功能描述
ACOS(X) 它返回反余弦在范围(0π,),以弧度表示。
ASIN(X) 它返回反正弦在范围(-π/ 2,π/ 2),以弧度表示。
ATAN(X) 它返回该范围中的反正切(-π/ 2,π/ 2),以弧度表示。
ATAN2(Y,X) 它返回反正切的范围(-π,π),以弧度表示。
COS(X) 它返回的参数以弧度的余弦值。
COSH(X) 它返回参数的弧度的双曲余弦值。
EXP(X) 它返回X的指数值
LOG(X) 它返回X的自然对数值
LOG10(X) 它返回常用对数(基数为10)X的值
SIN(X) 它返回的参数以弧度的正弦值。
SINH(X) 它返回的参数以弧度的双曲正弦值。
SQRT(X) 它返回X的平方根
TAN(X) 它返回参数的弧度正切。
TANH(X) 它返回参数的弧度的双曲正切值。

下面的程序一个时间后分别射弹的计算的水平和垂直位置x和y,叔:

其中,X = UT COS A和Y = UT罪 - 克T2 / 2

program projectileMotion  
implicit none  
   ! define constants  
   real, parameter :: g = 9.8  
   real, parameter :: pi = 3.1415927  
   !define variables
   real :: a, t, u, x, y   
   !values for a, t, and u 
   a = 45.0
   t = 20.0
   u = 10.0
   ! convert angle to radians  
   a = a * pi / 180.0  
   x = u * cos(a) * t   
   y = u * sin(a) * t - 0.5 * g * t * t  
   write(*,*) 'x: ',x,'  y: ',y   
end program projectileMotion

当你编译和执行上面的程序,它会产生以下结果:

x: 141.421356  y: -1818.57861  

数字查询函数

这些功能与整数的某型号和浮点运算工作。该函数返回相同种类的变量X,它可以是真实的,在某些情况下整数的数的属性。

功能描述
数字(X) 它返回的模型的显著位数。
EPSILON(X) 它返回相比一个是几乎可以忽略不计的数目。换句话说,它返回最小值,使得实(1.0,种类(X))+ EPSILON(x)不等于实(1.0,种类(X))。
巨大的(X) 它返回模型的数量最多
MAXEXPONENT(X) 它返回该模型的最大指数
MINEXPONENT(X) 它返回模型的最低指数
PRECISION(X) 它返回小数精度
基数(X) 它返回该模型的基
RANGE(X) 它返回十进制指数范围
TINY(X) 它返回该模型的最小正数

浮点操作函数

功能描述
指数(x) 它返回一个型号的指数部分
分数(X)的它返回一个数的小数部分
NEAREST(X,S) 它返回给定方向最近的不同处理器编号
RRSPACING(X) 它返回型号的邻近给定数量的相对间距的倒数
SCALE(X,I) 它乘以它的基地实到的整数次幂
SET_EXPONENT(X,I)的它返回一个数的指数部分
间距(X) 它返回型号附近给定数量的绝对间距

位操作功能

功能描述
BIT_SIZE(I) 它返回该模型的比特数
BTEST(I,POS) 位测试
IAND(I,J) 逻辑与
IBCLR(I,POS) 清除位
IBITS(I,POS,LEN) 比特提取
IBSET(I,POS) 设置位
IEOR(I,J) 异或
IOR(I,J) 包容OR
ISHFT(Ⅰ,SHIFT) 逻辑移位
ISHFTC(I,SHIFT [,SIZE]) 循环移位
NOT(Ⅰ) 逻辑补

字符函数

功能描述
ACHAR(Ⅰ) 它返回ASCII码排序序列的第i个字符。
ADJUSTL(STRING) 它通过调节移除任何前导空格和插入尾随空白左弦
ADJUSTR(STRING) 它的权利通过删除尾随空格和插入前导空格调整字符串。
CHAR(I [,KIND]) 它返回特定机器科幻ç整理序列中的第i个字符
IACHAR(C) 它返回ASCII排序序列中字符的位置。
ICHAR(C) 它返回机器(处理器)特定网络ç整理序列中的字符的位置。
INDEX(STRING,SUBSTRING [,BACK]) 它返回子串的字符串中最左边(最右边如果返回.TRUE。)起始位置。
LEN(STRING) 它返回字符串的长度。
LEN_TRIM(STRING) 它返回一个字符串的长度没有结尾的空白字符。
LGE(STRING_A,STRING_B) 词法大于或等于
LGT(STRING_A,STRING_B) 词法上大于
LLE(STRING_A,STRING_B) 词法小于或等于
LLT(STRING_A,STRING_B) 词法上小于
REPEAT(STRING,NCOPIES) 串联重复
SCAN(STRING,SET [,BACK]) 它返回属于集,或者0,如果没有属于字符串的最左边(最右边如果返回.TRUE。)字符的索引。
TRIM(STRING) 删除结尾的空白字符
VERIFY(STRING,SET [,BACK]) 验证字符集的字符串

种类函数

功能描述
KIND(X) 它返回的那种类型的参数值。
SELECTED_INT_KIND(R)的它返回的那种特定网络版的指数范围类型的参数。
SELECTED_REAL_KIND([P,R]) 实样类型的参数值,指定精度和范围

逻辑功能

功能描述
逻辑(L [,KIND]) 逻辑与不同种类类型参数类型的对象之间的转换

Fortran语言 - 数字精度

我们已经讨论了,在旧版本的Fortran,有两个真正的类型:默认的实型和双精度型。

然而,Fortran语言90/95提供了真实和整数数据类型通过一种 specifie精确的控制。

那种属性

不同类型的数字是计算机内部存储方式不同。 那种属性允许您指定一个数字在内部存储。例如,

real, kind = 2 :: a, b, c
real, kind = 4 :: e, f, g
integer, kind = 2 :: i, j, k
integer, kind = 3 :: l, m, n

在上述声明中,实变量E,F和g具有比真实变量a,b和c更精确。整数变数l,m和n,可以存储较大的值,并具有用于存储比整数变量I,J和k多个数字。虽然这是依赖于机器。

program kindSpecifier
implicit none
   real(kind = 4) :: a, b, c
   real(kind = 8) :: e, f, g
   integer(kind = 2) :: i, j, k
   integer(kind = 4) :: l, m, n
   integer :: kind_a, kind_i, kind_e, kind_l
   kind_a = kind(a)
   kind_i = kind(i)
   kind_e = kind(e)
   kind_l = kind(l)
   print *,'default kind for real is', kind_a
   print *,'default kind for int is', kind_i
   print *,'extended kind for real is', kind_e
   print *,'default kind for int is', kind_l
end program kindSpecifier

当你编译和执行上面的程序它产生以下结果:

default kind for real is 4
default kind for int is 2
extended kind for real is 8
default kind for int is 4

查询变量的大小

有许多内在的功能,使您可以询问数字的大小。

例如,BIT_SIZE(ⅰ)内部函数指定用于存储的位数。对于实数, 精度(x)的内部函数,返回的精度小数位数,而范围(x)的内部函数返回指数的十进制范围内。

program getSize
implicit none
   real (kind = 4) :: a
   real (kind = 8) :: b
   integer (kind = 2) :: i
   integer (kind = 4) :: j

   print *,'precision of real(4) =', precision(a)
   print *,'precision of real(8) =', precision(b)
   
   print *,'range of real(4) =', range(a)
   print *,'range of real(8) =', range(b)
   

   print *,'maximum exponent of real(4) =' , maxexponent(a)
   print *,'maximum exponent of real(8) =' , maxexponent(b)
  
   print *,'minimum exponent of real(4) =' , minexponent(a)
   print *,'minimum exponent of real(8) =' , minexponent(b)
   
   print *,'bits in integer(2) =' , bit_size(i)
   print *,'bits in integer(4) =' , bit_size(j)
   
end program getSize

当你编译和执行上面的程序它产生以下结果:

precision of real(4) = 6
precision of real(8) = 15
range of real(4) = 37
range of real(8) = 307
maximum exponent of real(4) = 128
maximum exponent of real(8) = 1024
minimum exponent of real(4) = -125
minimum exponent of real(8) = -1021
bits in integer(2) = 16
bits in integer(4) = 32

获取种类值

Fortran语言提供了两个内部函数来获得一种价值整数和实数的精度要求:

  • selected_int_kind(r)的
  • selected_real_kind([P,R])

该selected_real_kind函数返回一个整数,是必要的一个给定的小数精度p和小数指数范围r的那种类型的参数值。小数精度是显著的位数,而小数指数范围规定了最小和最大可表示数。因此,该范围是从10-R 10 + R。

例如,selected_real_kind(P = 10,R = 99)返回需要10精确到小数点的那种价值,射程至少10-99到10 + 99。

program getKind
implicit none
   integer:: i
   i = selected_real_kind (p = 10, r = 99) 
   print *,'selected_real_kind (p = 10, r = 99)', i
end program getKind

当你编译和执行上面的程序它产生以下结果:

selected_real_kind (p = 10, r = 99) 8

Fortran语言 - 程序库

有各种各样的Fortran工具和库。有些是免费的,有些是有偿服务。

以下是一些免费的库:

  • RANDLIB,随机数和统计分布发电机
  • BLAS
  • EISPACK
  • GAMS-NIST指南可用数学软件
  • 从NIST一些统计数据和其他程序
  • LAPACK
  • LINPACK
  • MINPACK
  • 泥敷美容面膜
  • NCAR数学库
  • 入Netlib集合的数学软件,文件和数据库。
  • ODEPACK
  • ODERPACK,一组例程的排名和排序。
  • Expokit计算矩阵指数
  • SLATEC
  • SPECFUN
  • STARPAC
  • StatLib统计库
  • TOMS
  • 排序和合并字符串

以下库是不是免费的:

  • 在NAG Fortran数值库
  • 在Visual Numerics的IMSL库
  • 数字食谱

Fortran语言 - 编程风格

编程风格是所有关于在开发项目如下一些规则。这些好的做法传授像可读性价值观和明确性到您的程序。

一个好的程序应该具有以下特点:

  • 可读性
  • 正确的逻辑结构
  • 自注释和评论

例如,如果你做类似下面的评论,它不会有很大帮助:

! loop from 1 to 10 
do i=1,10  

不过,如果你正在计算二项式系数,需要这个循环NCR的那么像这样的评论会有所帮助:

! loop to calculate nCr 
do i=1,10
  • 缩进代码块,使代码明确各级。

  • 自我检查代码,以确保零会有像师没有数值误差,负实数的负实数或对数的平方根。

  • 包括确保变量不采取非法或超范围值,即输入验证规范。

  • 不把检查哪里会是不必要的,减慢执行。例如:

real :: x 
x = sin(y) + 1.0
if (x >= 0.0) then
z = sqrt(x)
end if
  • 显然,采用适当的算法编写的代码。
  • 使用拆分延续标记'和'长表达式。
  • 做有意义的变量名。

Fortran语言 - 调试程序

调试器工具被用来搜索在程序中的错误。

调试器程序通过代码几步之遥,可以让你的程序的执行过程中检查变量和其他数据对象的值。

它加载的源代码,你都应该运行调试器内的程序。调试器调试程序是:

  • 设置断点,
  • 通过源代码步进,
  • 设置观察点。

断点指定程序就停止了,代码的临界线后,专门。这些变量后,程序执行在断点处进行检查。

调试程序也被检查行源代码行。

观看点是在需要某些变量的值进行检查,特别是后一个读或写操作的各点。

gdb调试器

gdb调试器,GNU调试自带的Linux操作系统。对于X窗口系统,GDB带有一个图形界面和程序被命名为xxgdb。

下表列出了GDB的一些命令:

命令目的
打破设置断点
开始执行
继续执行
下一个只执行源代码的下一行,没有踏进任何函数调用
由跨入一个函数在函数调用的情况下执行的源代码中的下一行。

dbx调试器

还有另外一个调试器,dbx调试器的Linux版本。

下表列出了dbx中的一些命令:

命令目的
停止[VAR] 设置断点时的变量var的值更改。
停止[PROC] 输入一个程序进程内,当它停止执行
停在[行] 它设置在指定行断点。
开始执行。
继续执行。
下一个只执行源代码的下一行,没有踏进任何函数调用。
由跨入一个函数在函数调用的情况下执行的源代码中的下一行。

以上内容是否对您有帮助:
在线笔记
App下载
App下载

扫描二维码

下载编程狮App

公众号
微信公众号

编程狮公众号