Fortran的快速指南

“PQR”“一”“123'abc $％＃@！”

“一帖”“”

“PQR''A''123”ABC $％＃@！

'撇号'''

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

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

下表描述了描述：

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

例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)

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

该文件已被打开后，它是由读写语句访问。一旦这样做，就应该使用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   

指定参数的意图

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

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

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代表真实的或复杂的变量

数值函数

例

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)

数学函数

例

下面的程序一个时间后分别射弹的计算的水平和垂直位置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，它可以是真实的，在某些情况下整数的数的属性。

浮点操作函数

位操作功能

字符函数

种类函数

逻辑功能

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中的一些命令：

在线笔记

App下载

扫描二维码

下载编程狮App

公众号

编程狮公众号

意见反馈