fortran快速入门

Fortran快速入门:

参考:

https://blog.csdn.net/tyskfs2/article/details/48859857

详细的字典教程:

https://www.yiibai.com/fortran/fortran_data_types.html#article-start

前言

由于是快速入门, 所以就不进行详细的字典级别介绍了, 仅记录常用部分, 充分利用触类旁通的特性

基本程序结构:

program program_name
implicit none      

! type declaration statements      
! executable statements  

end program program_name

1. 头尾标记程序的开始和结束

2. implicit 作用类似using, 用于隐式类型, 是老版本中的东西

   一般不用, 但是不能没有, 所以一般都用的implicit none来关闭隐式类型

3. 注意全部的数据定义需要放到程序的开头

命令行编译程序:

cd "d:\Develop\fortran\fortranTest\"
gfortran -ffree-form helloworld.f -o helloworld.exe 
.\helloworld.exe

注意一个关键参数 -ffree-form 表示自由格式, 否则程序不能随便空格缩进啥的非常傻逼

数据类型:

1. integer
2. real
3. complex
4. character
5. logical

变量声明

变量类型[([kind]=数字)] [::] 变量名[,变量名……]

类型说明:

integer(kind=2) :: shortval
integer(kind=4) :: longval
integer(kind=8) :: verylongval

就是在变量声明的后头 (kind=数字), 这部分对于科学计算很重要, 因为至少需要知道运算时变量的精度, 并且可以通过 kind(标识符) 来获取数据的字节数

program checkKind
implicit none

   integer :: i 
   real :: r 
   character*1 :: c 
   logical :: lg 
   complex :: cp 
   
   print *,' Integer ', kind(i) 
   print *,' Real ', kind(r) 
   print *,' Complex ', kind(cp)
   print *,' Character ', kind(c) 
   print *,' Logical ', kind(lg)
   
end program checkKind

但是, fortran不支持长整型/长小数

逻辑类型:

.true .false 注意要带点

常量

用parameter修饰

real, parameter :: pi = 3.1415927

运算符:

关系运算符:

由于! 变成了注释, 所以!=就变成了 /=

逻辑运算符

这里重点看逻辑运算符, 非常的奇怪

操作符	描述	示例
.and.	所谓逻辑与运算符。如果这两个操作数都为非零，则条件变为真。	(A .and. B) 为 false.
.or.	所谓逻辑OR运算符。如果有两个操作数不为零，则条件变为真。	(A .or. B) 为 true.
.not.	所谓逻辑非运算符。使用反转操作数的逻辑状态。如果条件为真，则逻辑非运算符将返回false。	!(A .and. B) 为 true.
.eqv.	所谓逻辑上相当于运算符。用于检查两个逻辑值等价。	(A .eqv. B) 为 false.
.neqv.	所谓逻辑非对等操作。用于检查两个逻辑值的非对等。	(A .neqv. B) 为 true.

运算优先级:

这里先记着

分类	运算符	关联
逻辑NOT和负号	.not. (-)	从左到右
幂	**	从左到右
乘	* /	从左到右
加	+ -	从左到右
关系	< <= > >=	从左到右
相等	== !=	从左到右
逻辑与	.and.	从左到右
逻辑或	.or.	从左到右
赋值	=	从右到左

分支语句

支持嵌套

if (logical expression) then      
   statement  
end if


if (logical expression) then      
   statement(s)  
else
   other_statement(s)
end if


[name:] 
if (logical expression 1) then 
   ! block 1   
else if (logical expression 2) then       
   ! block 2   
else if (logical expression 3) then       
   ! block 3  
else       
   ! block 4   
end if [name]

[name:] select case (expression) 
   case (selector1)          
   ! some statements          
   ... case (selector2)           
   ! other statements           
   ...       
   case default          
   ! more statements          
   ...   
end select [name]

循环语句

这个类似于for循环, 范围[start, stop] , step为步进

do var = start, stop [,step]    
   ! statement(s)
   …
end do

这个就是while循环

do while (logical expr) 
   statements
end do

循环 break & continue

通过给循环添加name, 并exit name

program nestedLoop 
implicit none

integer:: i, j, k
   iloop: do i = 1, 3      
      jloop: do j = 1, 3         
         kloop: do k = 1, 3    
        
         print*, "(i, j, k): ", i, j, k               
         
         if (k==2) then
            exit jloop 
         end if
         
         end do kloop       
      end do jloop  
   end do iloop 
   
end program nestedLoop  

cycle = continue

program cycle_example     
implicit none      

   integer :: i     
   
   do i = 1, 20          
   
      if (i == 5) then 
         cycle          
      end if         
      
   print*, i      
   end do  
   
end program cycle_example

程序突然终止:

program stop_example     
implicit none

   integer :: i     
   do i = 1, 20          
   
      if (i == 5) then 
         stop          
      end if         
      
      print*, i      
   end do  
   
end program stop_example

字符串:

直接一个例子来看:

program hello
implicit none

   character(len=15) :: surname, firstname 
   character(len=6) :: title 
   character(len=25)::greetings
   
   title = 'Mr. ' 
   firstname = 'Rowan ' 
   surname = 'Atkinson'
   greetings = 'A big hello from Mr. Beans'
   
   print *, 'Here is ', title, firstname, surname
   print *, greetings
   
end program hello

字符串拼接:

title = 'Mr. ' 
firstname = 'Rowan ' 
surname = 'Atkinson'

name = title//firstname//surname

常用字符串函数:

函数	描述
len(string)	它返回字符串的长度
index(string,sustring)	在一个字符串找出子串的位置，如果没有找到则返回0。
achar(int)	将整数转换成一个字符
iachar©	它可将一个字符转换为整数
trim(string)	它返回去掉尾随空格的字符串。
scan(string, chars)	它会搜索“string”由左到右（除非back=.true）包含在“string”任何字符的第一次出现。它返回一个整数，该字符，或零的位置，如果没有文字的“字符”已被找到。
verify(string, chars)	它扫描“string”由左到右（除非back=.true）不包含在“string”任何字符的第一次出现。它返回一个整数，该字符的位置，如果只在“字符”的字符被找到，或者没有找则返回零。
adjustl(string)	它留下左截于“string”包含的字符
adjustr(string)	它留下右截于“string”包含的字符
len_trim(string)	它返回一个整数等于“string”(len(string))减去尾随空白的数量
repeat(string,ncopy)	它返回一个字符串长度等于“ncopy”次数“string”的长度，并含有“string”的“ncopy”串联拷贝

函数	描述
lle(char, char)	进行比较的第一个字符是否是词汇上小于或等于所述第二字符
lge(char, char)	进行比较的第一个字符是否是词汇上大于或等于所述第二字符
lgt(char, char)	进行比较的第一个字符是否是词汇上比第二字符大
llt(char, char)	比较第一个字符是否是词汇上比小于第二字符

其他的内容之后有用到再看:

https://www.yiibai.com/fortran/fortran_strings.html#article-start

数组:

Fortran允许最多创建7维数组

program helloworld
implicit none
    integer:: arr(5), matrix(5,5), i, j
    do i=1,5
        do j=1,5
            matrix(i, j)=i+j
        end do
    end do
    do i=1,5
        do j=1,5
            print *,matrix(i, j)
        end do
    end do
end program helloworld

注意, fortran的数组默认起始下标是1, 不是0

可以修改数组的起始下标

integer:: arr(5), matrix(0:5,4:5), i, j

数组切片

使用下标三元组, 默认情况为数组自身的上下限, stride=1 default

array ([lower]:[upper][:stride], ...)

program arraySubsection

   real, dimension(10) :: a, b
   integer:: i, asize, bsize
   
   a(1:7) = 5.0 ! a(1) to a(7) assigned 5.0
   a(8:) = 0.0  ! rest are 0.0 
   b(2:10:2) = 3.9
   b(1:9:2) = 2.5
   
   !display
   asize = size(a)
   bsize = size(b)
   
   do i = 1, asize
      Print *, a(i)
   end do
   
   do i = 1, bsize
      Print *, b(i)
   end do
   
end program arraySubsection

数组内部函数

用于科学计算

函数	描述
dot_product(vector_a, vector_b)	函数返回两个输入向量，它必须具有相同长度的标量积。
matmul (matrix_a, matrix_b)	它返回两个矩阵的矩阵乘积，它必须是一致的，即具有相似大小 (m, k) 和 (k, n)

函数	描述
all(mask, dim)	它返回一个逻辑值，指明掩码的所有关系是 .true。以及只有所需的维度，如果第二个参数是给定的。
any(mask, dim)	它返回一个逻辑值，指明掩码的任何关系是.true。以及只有所需的维度，如果第二个参数是给定的。
count(mask, dim)	它返回一个数字值，该值为掩码为 .true 关系的数目。以及所需的维数，如果第二个参数给出。
maxval(array, dim, mask)	它返回 的数组的数组中最大的值，那些遵守于第三个参数掩码的关系，如果一个给定的，以及具有只有所需的维数，如果第二个参数 dim给出的。
minval(array, dim, mask)	它返回数组的数组中那些遵守于第三个参数掩码的关系的最小值，如果一个给定的，以及具有仅在第二个参数 dim 给出所期望的维度。
product(array, dim, mask)	它返回该产品遵守于第三个参数掩码的关系，如果一个给定的，以及具有只有所需的维数，如果第二个参数 dim 给出的所有数组的数组中的元素，。
sum (array, dim, mask)	它返回 遵守于第三个参数掩码关系的总和，如果给定以及具有只有所需的维数，如果第二个参数 dim给出的所有数组的数组中的元素。

函数	描述
allocated(array)	它是一个逻辑功能，它指示该阵列被分配。
lbound(array, dim)	它返回的数组的维数较低的限制。如果dim(尺寸)不给出一个参数，会得到一个整数向量，如果dim计算在内，得到的整数值正好具有较低维数的限制。
shape(source)	它返回一个阵列源为一个整数向量的形状。
size(array, dim)	它返回在数组元素的数目。如果dim没有给出，并在相关维数的元素个数，如果dim也包括在内。
ubound(array, dim)	它返回尺寸的限制。

函数	描述
merge(tsource, fsource, mask)	该功能连接两个阵列。它给出了tsource及元素，如果mask条件是.true。如果掩码的条件是.false。这两个字段tsource 和fsource 必须是相同的类型并具有相同的形状。其结果也就是这种类型和形状。还掩码必须具有相同的形状。
pack(array, mask, vector)	它包一个阵列，以使用掩码的控制向量。逻辑阵列掩模的形状，具有以符合一个用于阵列，要不然掩码必须是一个标量。如果载体被包括在内，它必须是秩1与至少一样多的元素是在掩码为真，并且具有相同的类型的数组的数组(即一个向量)。如果掩码的值为.true。然后矢量代替必须的元件阵列的数量相同。
spread(source, dim, ncopies)	它返回相同类型作为参数源与秩增加一个阵列。参数dim 和ncopies都是整数。如果ncopies是负则用零值来代替。如果source是一个标量，然后扩散变得所有具有相同值 ncopies 元素的向量。参数dim 指示哪个索引将被延长。它必须是范围为1和1+(源级)中，如果 source 是一个标量，dim 必须是1。参数 ncopies 是在新的尺寸元素的数量。
unpack(vector, mask, array)	它散射一个载体，掩码下的控制阵列。逻辑阵列掩模的形状具有以符合一个用于数组。阵列载体必须具有等级1(即它是一个向量)与至少一样多的元素是那些掩码内值都为true，并且还必须具有相同类型阵列。如果阵列被给定为一个标量，然后它被认为是使用相同形状的掩码，并在同一标量元素无处不在的阵列。其结果将是具有相同形状的掩码和类型相同的矢量阵列。该值将是那些从所接受的载体，而在阵列的剩余位置的旧值被保留。

函数	描述
reshape(source, shape, pad, order)	它构造一个特定形状的形状，从一个给定source阵列中的元素开始的数组。如果垫不包含则soure的尺寸必须至少为产物(形状)。如果pad包括在内，它必须具有相同的类型的soure。如果order被包括，它必须使用相同的形状的形状的整数数组，值必须是一个排列(1,2,3，…，n)，其中n是在形状要素的数量，它必须小于或等于7。

函数	描述
cshift(array, shift, dim)	它执行循环移位由移位置的左边，如果移位是正和到右侧，如果它是负的。如果阵列是一个矢量移位正在做以自然的方式中，如果它是一个较高级的阵列则移是沿着维数dim的所有部分。若dim缺少它被认为是1，在其它情况下它必须是1和n(其中n等于阵列的等级)之间的标量整数。该参数换档是一个标量整数或秩n-1个整数的数组和形状相同的阵列中，除沿维数dim(在较低级的，因为它被移除)。不同的部分，因此可以转移在各个方向上，并与各种数目的位置。
eoshift(array, shift, boundary, dim)	这是端关闭的转变。它执行向左移动，如果移位是正和到右侧，如果它是负的。相反的元素移出新元素均取自边界。如果阵列是一个矢量移位正在做以自然的方式中，如果它是一个较高级的阵列，在所有各节中的移位是以及该维度暗淡。若 dim 丢失，它被认为是1，但在其它情况下，它为1和n(其中n等于阵列的秩)之间有一个标量的整数值。该参数换档是一个标量整数，如果阵列具有秩1，在其他情况下，它可以是一个标量整数或秩n-1和形状相同的阵列排列的与除沿维数dim 的整数数组(其被取出因为较低级的)。
transpose (matrix)	其转置矩阵，这是秩2的阵列它取代了的行和列矩阵。

函数	描述
maxloc(array, mask)	它返回数组中的最大元素的位置上，如果掩码仅包含那些其中满足条件的掩码，则返回位置，其结果是一个整数向量。
minloc(array, mask)	它返回数组的数组中的最小元素的位置，如果掩码仅包含那些其中满足条件的掩码，则返回位置，其结果是一个整数向量。

动态数组

实际上就好C++ 中使用malloc动态申请内存一样

但不是变长数组

real, dimension (:,:), allocatable :: darray
allocate ( darray(s1,s2) )   
deallocate (darray)   

数组初始化

data初始化

data variable / list / ...

program dataStatement
implicit none

   integer :: a(5), b(3,3), c(10),i, j
   data a /7,8,9,10,11/ 
   
   data b(1,:) /1,1,1/ 
   data b(2,:)/2,2,2/ 
   data b(3,:)/3,3,3/ 
   data (c(i),i=1,10,2) /4,5,6,7,8/ 
   data (c(i),i=2,10,2)/5*2/
   
   Print *, 'The A array:'
   do j = 1, 5                
      print*, a(j)           
   end do 
   
   Print *, 'The B array:'
   do i = lbound(b,1), ubound(b,1)
      write(*,*) (b(i,j), j = lbound(b,2), ubound(b,2))
   end do

   Print *, 'The C array:' 
   do j = 1, 10                
      print*, c(j)           
   end do      
   
end program dataStatement

The A array:
7
8
9
10
11
The B array:
1  1  1
2  2  2
3  3  3
The C array:
4
2
5
2
6
2
7
2
8
2

结构体

语法

type type_name      
   declarations
end type 

定义

type Books
   character(len=50) :: title
   character(len=50) :: author
   character(len=150) :: subject
   integer :: book_id
end type Books

创建

type(Books) :: book1 

访问

book1%title = "C Programming"
book1%author = "Nuha Ali"
book1%subject = "C Programming Tutorial"
book1%book_id = 6495407

结构体数组

创建

type(Books), dimension(2) :: list

访问

list(1)%title = "C Programming"
list(1)%author = "Nuha Ali"
list(1)%subject = "C Programming Tutorial"
list(1)%book_id = 6495407

指针

声明

integer, pointer :: p1 ! pointer to integer  
real, pointer, dimension (:) :: pra ! pointer to 1-dim real array  
real, pointer, dimension (:,:) :: pra2 ! pointer to 2-dim real array

简单的指针malloc分配空间

program pointerExample
implicit none

   integer, pointer :: p1
   allocate(p1)
   
   p1 = 1
   Print *, p1
   
   p1 = p1 + 4
   Print *, p1
   
end program pointerExample

指针指向变量:

program pointerExample
implicit none

   integer, pointer :: p1
   integer, target :: t1 
   
   p1=>t1
   p1 = 1
   
   Print *, p1
   Print *, t1
   
   p1 = p1 + 4
   
   Print *, p1
   Print *, t1
   
   t1 = 8
   
   Print *, p1
   Print *, t1
   
end program pointerExample

1
1
5
5
8
8

基本输入输出

自由格式简单I/O

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

格式化IO

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

格式化标准

描述符	描述	示例
I	这是用于整数输出。此采用的形式为“rIw.m’，其中 r, w 和m 的含义在下面的表格中给出。真正的值在它们字段右侧适应。如果字段宽度不足以容纳一个整数则用星号代替。	print “(3i5)”, i, j, k
F	这是用于实数输出。此采用的形式为“rFw.d’，其中r, w 和 d 的含义在下面的表格中给出。真正的值在它们字段右侧适应。 如果字段宽度不足够大以容纳所述实数则字段用星号表示。	print “(f12.3)”,pi
E	这是用于指数形式实时输出。在“E”描述语句的形式为’rEw.d’，其中r，w和d的含义如下表中给出。真正的值在它们字段右侧适应. 如果字段宽度不足够大以容纳所述实数则字段用星号表示。请注意，打印出与三位小数，实数至少10需要一个字段宽度。一个用于尾数，2为零，4为尾数部分和两个用于指数本身的符号。在一般情况下，w≥ d +7。	print “(e10.3)”,123456.0 gives ‘0.123e+06’
ES	这是用于实时输出（科学计数法）。此采用的形式为“rESw.d’，其中 r, w 和 d的含义在下面的表格中给出。上述的“E”描述从传统的众所周知的“科学表示法”略有不同。科学表示法具有尾数范围为1.0至10.0对E描述符，它具有在范围0.1到1.0的尾数不同。真实的值在字段的右侧。如果字段宽度不足够大以容纳所述实数则字段用星号表示。这里，字段宽度必须满足 w ≥ d +7	print “(es10.3)”,123456.0 gives ‘1.235e+05’
A	这是用于字符输出。 此采用的形式为“rAw”，其中r和w的含义在下面的表格中给出。字符类型是在它们的字段右侧。如果字段宽度不足于以容纳该字符串则字段的第一个“w”字符的字符串。	print “(a10)”, str
X	这是用于空间输出。这需要形式’nX’，其中“n”是所需的空间数量。	print “(5x, a10)”, str
/	斜杠描述 - 用于插入空行。这需要的形式’/’，并强制下一个数据输出为一个新行。	print “(/,5x, a10)”, str

符号	描述
c	列数
d	右侧的小数位数为真正的输入或输出
m	要显示的最小位数
n	跳过的空格数
r	重复次数 - 使用描述或组描述符的次数
w	字段宽度- 字符数用于输入或输出

常用格式化方法:

指定浮点输出位数

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

留空x格

program printName
implicit none

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

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

数字格式化

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 = *******

文件输入输出:

打开 & 关闭文件

open (list-of-specifiers)

详细的修饰符还是建议看这里比较好:

http://blog.sina.com.cn/s/blog_12bc540820102xuhn.html

修辞符	描述
[UNIT=] u	设备号说明, 必须是>=0的正整数, 就相当于文件标识符
IOSTAT= ios	它是在I/O状态标识符和应为整数的变量。如果打开的语句是成功，则返回IOS值为零，否则为一个非零值。
ERR = err	它是一个标签到该控制跳以防有错误。
FILE = fname	文件名，一个字符串。
STATUS = sta	它示出了该文件的先前状态。一个字符串，可以有三个值NEW, OLD 或 SCRATCH。一个临时文件被创建和删除，当关闭或程序结束。
ACCESS = acc	文件的访问模式, APPEND追加模式, SEQUENTIAL顺序访问, DIRECT直接访问 默认值是SEQUENTIAL。
FORM= frm	它给该文件的格式的状态。可以有FORMATTED 或UNFORMATTED两个值。默认值是UNFORMATTED
RECL = rl	它指定的每个记录中的一个直接访问文件的长度。

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

demo

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

读写文件

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

实际使用方式和之前的print 差不多

demo

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

函数 & 子程序

函数

标准语法
这样要使用返回值的话需要用 dummy argument

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

指定返回值的变量名, 代替dummy argument

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

demo

注意, 这里主程序里没有implicit none

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


! this function computes the area of a circle with radius r  
function area_of_circle (r)  result(argv)

! function result     
implicit none      

   ! dummy arguments        
   real :: argv   
   
   ! local variables 
   real :: r     
   real :: pi
   
   pi = 4 * atan (1.0)     
   argv = pi * r**2  
   
end function area_of_circle

子程序

与function的几个不同

1. 子程序没有返回值, 但是可以修改参数

   即function中的参数都是形参, 除非是指针传递, 否则无法修改外部变量的值, 而子程序可以直接修改

2. 需要使用call调用子程序

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

模块

其实就是包package

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

在一个文件中调用一个模块 (就是include / import)

use name

use 模块之后就和 include / import 的效果基本相同

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

访问控制

模块中的变量可以设置为private, 之后在模块之外就无法被访问, 就像类的private成员

内部函数 (库函数)

数值函数

Function	描述
ABS (A)	返回A的绝对值
AIMAG (Z)	返回复数Z的虚部
AINT (A [, KIND])	截断Z小数部分接近零，返回一个实数。
ANINT (A [, KIND])	返回一个实数值，最接近的整数或整数。
CEILING (A [, KIND])	返回比最小整数大于或等于数A.
CMPLX (X [, Y, KIND])	其转换实数变量X和Y的一些复数X + iY; 如果Y不存在，则使用0。
CONJG (Z)	返回复数Z的复共轭
DBLE (A)	转换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-FLOOR(A/P)*P)
NINT (A [, KIND])	返回一个最接近整数A的数
REAL (A [, KIND])	将其转换为实数类型
SIGN (A, B)	返回一个乘以P. 符号的绝对值基本上它转移B的标志为A.

数学函数

函数	描述
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)	返回参数弧度的双曲正切值。

数字查询函数

函数	描述
DIGITS (X)	返回显著模型的位数。
EPSILON (X)	返回相比一个是几乎可以忽略不计的数目。换句话说，它返回最小值，使得REAL( 1.0, KIND(X)) + EPSILON(X)为不等于REAL( 1.0, KIND(X))。
HUGE (X)	返回模型最多数量
MAXEXPONENT (X)	返回该模型的最大指数
MINEXPONENT (X)	返回该模型的最小指数
PRECISION (X)	返回小数精度
RADIX (X)	返回该模型的基数
RANGE (X)	返回十进制指数范围
TINY (X)	返回该模型的最小正数

浮点操作函数

函数	描述
EXPONENT (X)	返回一个模型数的指数部分
FRACTION (X)	返回一个数的小数部分
NEAREST (X, S)	返回给定的方向最近的不同处理器编号
RRSPACING (X)	返回型号的邻近给定数量的相对间隔的倒数
SCALE (X, I)	乘以一个实数由基数的整数次幂
SET_EXPONENT (X, I)	返回一个数的指数部分
SPACING (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)	包括或
ISHFT (I, SHIFT)	逻辑移位
ISHFTC (I, SHIFT [, SIZE])	循环移位
NOT (I)	逻辑补

字符函数

函数	描述
ACHAR (I)	它返回ASCII整理序列中的第i个字符。
ADJUSTL (STRING)	它通过调节删除任何前导空格和插入尾随空白留下的字符串
ADJUSTR (STRING)	它去除右尾随空白和插入前导空格调整字符串。
CHAR (I [, KIND])	它返回特定机器整理序列中的第i个字符
IACHAR ©	它返回字符的ASCII码排序序列中的位置。
ICHAR ©	它返回字符在机器（处理器）特定排序序列中的位置。
INDEX (STRING, SUBSTRING [, BACK])	它返回SUBSTRING内STRING最左边（最右边如果返回.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])	它返回STRING属于集，或者0，如果都不属于最左边（最右边如果返回.TRUE。）字符的索引。
TRIM (STRING)	删除结尾的空白字符
VERIFY (STRING, SET [, BACK])	验证字符集的字符串

类型函数

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

逻辑函数

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