FORTRAN90 程序设计基础大纲

基本数据类型I

整型、实型、复型、字符型和逻辑型

变量可以赋初值、说明种别、说明属性。

整型 integer

integer的种别有三种。

kind	Bytes=8bits	range	range	type
1	1B=8b	-128~127	-2⁷~2⁷-1
2	2B=16b	-32768~32767	-2¹⁵~2¹⁵-1	short
4	4B=32b	-2147483648~2147483647	-2³²~2³²-1	long

默认kind=4

实型 real

小数形式指数形式小数点必须有

100.0 .5 5.
87.6e-2=0.876

计算机在保存实数时，会先把它转成科学计数法

kind	Bytes=8bits	range	range	type
4	4B	3.410³⁸,1.1810^-38	6~7位	Single
8	8B	1.7910³⁰⁸,2.2310^-308	15~16位	Double

默认占用4Bytes的单精度实数。

integer,parameter::long=selected_real_kind(8,88)

实数具有误差，因此表示相等应写成：if (abs(A-10.2)<1e-6)。

复型 complex

字符型 character

记录一个英文字符需要一个字节，一个汉字为两个字节。
''内的'字符需要写成''，即'I'' m a student.'

ASCII

空格，数字0~9，大写字母A~Z，小写字母a~z

快速求十进制数的各进制转换python代码：

def f(x):
    print(x,bin(x),oct(x),hex(x))
for i in (32,48,57,65,90,97,122): f(i)

char	dec	bin	oct	hex
space	32	0b100000	0o40	0x20
0	48	0b110000	0o60	0x30
9	57	0b111001	0o71	0x39
A	65	0b1000001	0o101	0x41
Z	90	0b1011010	0o132	0x5a
a	97	0b1100001	0o141	0x61
z	122	0b1111010	0o172	0x7a

字符子串

character(len=80)::row
row(i:i)
row(:i)	!(1:i)
row(i:)	!(i:80)
row(:)	!(1:80)

基本数据类型II

常量 parameter

real::pi
parameter(pi=3.14159)

或者

real,parameter::pi=3.14159

派生 type

program main
    implicit none
    type student
        character(len=20)::department
        character(len=10)::class
        character(len=15)::name
        integer::number
    end type student
    type(student)::person
    person=student("computer","92_2","lilin",21)
    write(*,*) person%class,person%name
end

数组 dimension

integer,dimension(1:50)::X
integer,dimension(5,3)::X

基本语句

注释号是!，位于行中。

类型声明

抑制隐式声明：在主程序开头需要加入该语句，避免获得意料之外的结果。

impilcit none

此时如果有未声明的变量使用，程序会出错。否则使用I-N规则，以I-N开头的为整型，其余为实型。

种别

type	kind
integer	1,2,4(long)
real	4(single),8(double)
logical	1,2,4
complex	4(single),8(double)
character	1

测试整型种别范围

program int_kind
    implicit none
    integer::i
    print *,kind(0)
    do i=1,10
        print *,i,selected_int_kind(i)
    end do
end

 4
 1           1
 2           1
 3           2
 4           2
 5           4
 6           4
 7           4
 8           4
 9           4
10           8

算术表达式与赋值

内在函数

基本函数、转换函数、查询函数

算术运算

乘方**（右向左）乘除*/ 加减+-

注意

三角函数(sin cos tan) 自变量单位为弧度

sin log exp sqrt 要求自变量是实型，不能是整型

'x' argument of 'sin' intrinsic at (1) must be REAL or COMPLEX

整型相除是整除，不会产生浮点数

program main
    implicit none
    integer::a=3,b=4
    print *,a/b
end program main
!0

例如：是

(sin(4.0)+cos(10*3.14/180))*exp(2.5)/(sqrt(2.0)+abs(a*x)+log(3.0*5))

类型的自动转换

整型→实型→双精度→复型 8/5+2.0*5/2=6.0 3.1_4+4.5_8=7.6_8

关系表达式与逻辑表达式

优先级：括号→算术→关系→逻辑

算术** *,/ +,- 关系>,<,>=,<=,==,/= 逻辑.not.,.and.,.or.,.eqv.,neqv.比较逻辑值

A=1.5,B=2.0,C=1.2,D=7.5,X=3.0,Y=5.0,L1=.true.
A>2.8*B.and.X>=Y.or.L1.and..not.(3.6-C)*2>=D/2.5

program main
    implicit none
    real::A=1.5,B=2.0,C=1.2,D=7.5,X=3.0,Y=5.0
    logical::L1=.true.
    print *,A>2.8*B.and.X>=Y.or.L1.and..not.(3.6-C)*2>=D/2.5
end
! F

输入与输出

表控输入

read语句（数据→内存）可以留一个*表示表控格式并省略部件号

read (*,*) 输入表
read *, 输入表

read (<设备号>,<格式说明>) <输入表>
read <格式说明>,<输入表>	!部件号可省略

输入语句的七条规则

分隔符是空格或者,，输入类型需要匹配。整型：舍去小数实型：可以接受整数复型：(1,2) 字符型：逻辑：以T或F开头。
输入的数据必须是常数，不能是变量和表达式。
输入数据个数：不得少于变量的个数、可分行输入、多余的数据不起作用、每个read必须从一个新的行输入数据。
空格可以多个，/表示输入结束，*前连接重复因子r。可以使若干编辑符一起重复。
多个read语句，每个read必须从新的行开始输入。

表控输出

print输出到显示器（因此省略设备号，只留一个*格式说明） write输出到任何设备（因此需给定设备号，(*,*)）

print *, 输出表
write (*,*) 输出表

write (<设备号>,<格式说明>) <输出表>
print <格式说明>,<输出表>

固定的输出宽度。
类型：复型：带()输出逻辑型：输出T或F 字符型：左对齐
一行显示不下会换行
多个print语句，每个开始输出一个新的记录

格式化输入输出

整型编辑符`[r]Iw[.m]`

w总宽度，m数字位数（，负数），r重复系数

program main
    implicit none
    integer::a=3,b=4,c=-50
    print "(3I6.4)",a,b,c
end program main

! __0003__0004_-0050

program main
    implicit none
    integer::a=300,b=400,c=-500
    print "(3I3.2)",a,b,c
end program main

! 300400***

负数的符号也包含在字段宽度内，如果应输出的列数超过了规定的字段宽度，则不输出有效数据，以w个*填充。

如果控制符不够，则换行。

program main
    implicit none
    integer::a=3,b=4,c=-50
    print "(2I6.4)",a,b,c
end program main
!   0003  0004
!   -0050

输入与输出格式相同。BN忽略末尾空格，BZ视末尾空格为0。

program main
    implicit none
    integer::a
    read "(BZ,I4)",a
    print "(I5)",a
    ! 543_
    ! 5430
end program main

实型编辑符`[r]Fw.d`

[r]Ew.d[Ee]按指数形式，[r]Gw.d根据数据选择。w包括符号和小数点， d小数位宽度（四舍五入）。若数据小于w位，则左边补空格。当实型数值小于0.0（负数）时，则；当实型数值大于或等于0.0时，则。

program main
    implicit none
    real::a=-378.456
    print "(F8.2)",a
    ! -378.46
end program main

program main
    implicit none
    real::a=2456.78
    print *,a
    print "(F20.15)",a
    print "(E9.3,E12.3)",a,a
    print "(E16.10)",a
    print "(E21.15)",a
end program main
!    2456.78003
! 2456.780029296875000
! 0.246E+04   0.246E+04
! 0.2456780029E+04
! 0.245678002929688E+04

program main
    implicit none
    real::a=2456.78
    print "(E10.3E3)",a
    ! 0.246E+004
end program main

避免大数印错、小数印丢

program main
    implicit none
    real::a=2456.78,b=0.0002345
    print "(E2.3E1)",a
    print "(F5.3)",b
    ! **
    ! 0.000
end program main

使用指数形式，不必事先估计数的大小，能容纳任意大小的数据。正数，负数。

! 数符+0+小数点+小数部分+E+符号+指数
! 一般格式E16.7,便于阅读
program main
    implicit none
    real::a=0
    print "(E6.1E1)",a
    ! 0.0E+0
    print "(E7.1)",a
    ! 0.0E+00
end program main

使用行代码

program main
    implicit none
    real::X=-84.31,Y=3.141592,Z=0.0187
    character(30)::ml
    print 2,X,Y,Z
    2 format (E10.3,E13.6,E15.6)
    ! -0.843E+02 0.314159E+01   0.187000E-01
    ml="(E10.3,E13.6,E15.6)"
    print ml,X,Y,Z
    ! -0.843E+02 0.314159E+01   0.187000E-01
end program main

其他编辑符

X输出空格，输入跳过 H描述字符串（或直接写） /换行 :变量输出结束阻塞后续输出

练习定义个数据，2个整型：、；2个实型：、。用表控格式读入个数字并赋值，求取每个数据的以为底的对数和平方根，并输出原数据和结果（即组，每组个数字）。

要求

每组数据输出前，先输出说明文字，例如”4个原数据为：“或“对应平方根为：”
数据有格式输出，每4个数字按两行输出，每行2个数字。
- 第一行：2个整型，每个数字用6位字符宽输出，数字中间空2格
- 第二行：2格实型，第一个字用F编辑符，6位字符宽输出，小数位2位。第二个字用E编辑符，12位字符宽输出，小数位2位，指数位3位。

program main
    implicit none
    integer::a,b
    real::c,d
    ! 12 115 45.6 123.4
    read *,a,b,c,d
    print 1, '四个原数据为',a,b,c,d
    print 1, '以10为底的对数为',int(log10(real(a))),int(log10(real(b))),log10(c),log10(d)
    print 1, '平方根为',int(sqrt(real(a))),int(sqrt(real(b))),sqrt(c),sqrt(d)
    1 format (A,/,I6,2X,I6,/,F6.2,2X,E12.2E3)
end
! encoding=GB2312

结果

12 115 45.6 123.4
四个原数据为
    12     115
 45.60     0.12E+003
以10为底的对数为
     1       2
  1.66     0.21E+001
平方根为
     3      10
  6.75     0.11E+002

基本程序结构

程序单元

主程序、子程序、模块

主程序`program`

program main
	implicit none
	print *,"Hello"
end

例华氏度转摄氏度

program H_to_C
    implicit none
    real::TC,TH
    read *,TH
    TC = 5*(TH-32)/9
    print *,TH,TC
end

主程序格式

program main    !主程序main开始
    implicit none   ! 声明部分
    real,dimension(10,10)::a,b
    a=1.0   !执行部分
    b=a*3
    call find
    !...
    contains
         subroutine find    !内部过程（子例子程序）
            !...
         end subroutine find
  end program main

练习有一长5m，宽3m的长方形铁皮，在四角对称挖去了四个半径为0.5m的圆洞，现需要对这块铁皮镀一层铜（单面），铜的单价为每平方米50元，计算镀铜的费用，并输出。（要求：在程序中铜的单价和圆周率用常数声明方法声明；铁皮的长、宽和圆洞的半径大小从键盘输入）

program main
    implicit none
    real,parameter::pi=3.14
    integer,parameter::m=50
    integer::a,b
    real::r,ans
    read *,a,b,r
    ans=m*(a*b-4*pi*r*r)
    print *,ans
end program main

! 5 3 0.5
! 593.000000

子程序

函数子程序、子例子程序

函数子程序`function`

[recursive] function f(x1,x2) result(y)
    implicit none
end [function [f]]

f(x1,x2)

recursive函数递归虚元表结果名

必须有且仅有一个返回值

所有变量均需声明 主程序中需要声明被调函数的类型 子程序中出现的变量在主程序中赋初值无效，否则无法释放变量 子程序中的变量声明需要单独赋值

例编程求，用函数子程序实现。

function factor(N) result(fac_result)
    implicit none
    integer::N,fac_result,i
    fac_result=1
    do i=1,N
        fac_result=fac_result*i
    end do
end

program cal_factor
    implicit none
    integer::factor,s=0,i
    do i=4,8
        s=s+factor(i)
    end do
    print *,'S=',s
end

输出s=46224

练习编写子程序，求

function item(n,x) result(item_result)
    implicit none
    integer::n,i
    real::x,item_result,T
    T=0
    do i=1,n
        T=T+i
    end do
    item_result=x**n/T
end
program main
    implicit none
    integer::n,i
    real::item,x,s
    read *,n,x
    s=0
    do i=1,n
        s=s+item(i,x)
    end do
    print *,s
end

子例子程序`subroutine`

[recursive] subroutine f[(x1,x2)]
    implicit none
end [subroutine [f]]

call f(x1,x2)

给虚元加上intent(in)或者intent(out)属性，限制输入变量或者输出变量（不必须）

integer,intent(in)::n
integer,intent(out)::s

练习使用子例子程序求

subroutine fact(n,value)
    implicit none
    integer,intent(in)::n
    integer::i
    integer,intent(out)::value
    value=1
    do i=1,n
        value=value*i
    end do
end
program main
    implicit none
    integer::s=0,i,value
    do i=1,5
        call fact(i,value)
        s=s+value
    end do
    print *,s
end

练习使用子程序求，要求的通项小于1e-6时停止

subroutine fact(n,value)
    implicit none
    integer,intent(in)::n
    integer::i
    real(kind=selected_real_kind(16,100)),intent(out)::value
    value=1
    do i=1,n
        value=value*i
    end do
end
program main
    implicit none
    real(selected_real_kind(16,100))::s=0,value,exp_=0,x,sinh_
    integer::i=2
    read *,x
    s=1+x
    do
        call fact(i,value)
        exp_=x**i/value
        s=s+exp_
        if (exp_<=1e-6) then
            exit
        end if
        i=i+1
    end do
    sinh_=(s-(1/s))/2
    print *,sinh_
end

! 5
! 74.2032105178825331163

接口块`interface`

类型声明之前，implicit none语句之后

interface
	function func(x) result(f)
		real::x,f
	end function
end interface

以下情形必须使用接口块：

实元是关键字变元
实元是缺省的可选变元
通过接口块改变虚元名称
函数返回结果为数组，或过程虚元为一个假定形状数组

虚实结合

关键字变元
可选变元 optional属性声明该元为可选变元 present(x)函数返回虚元是否结合实元
通过接口块更改虚元名称
虚数组（与实元形相同）
虚过程 intrinsic属性：实元为内在函数 external或接口块interface：实元为外部过程

虚元按顺序借用实元储存单元，子程序运行时造成的实元值的改变将保留。

练习编写通用子程序求定积分（虚过程应用于数值计算实例）以为例

function f(x) result(y)
    implicit none
    real::x,y
    y=x**2+4*x+7
end
subroutine int_(a,b,f,delta_x,s)
    implicit none
    real::delta_x,a,b,s,a0,b0
    real::f
    s=0
    a0=a
    b0=a+delta_x
    do while(b0<=b)
        s=s+((f(b0)+f(a0))/2)*delta_x
        a0=a0+delta_x
        b0=b0+delta_x
    end do
end
program main
    implicit none
    real::a,b,delta_x,s
    real,external::f
    read *,a,b,delta_x
    call int_(a,b,f,delta_x,s)
    print *,s
end

模块`module`

module m
    implicit none
	integer[,save]::r
	[contains
	内部过程子程序]
end module [m]
program main
	use m
	implicit none
	a=1
end

implicit none需要在各个程序单元中书写；使用save属性（默认添加）声明全局变量

模块和子程序的区别：模块应先定义；模块使用use语句引用；模块中无可执行语句

use m, only:a,b,c
use m, x=>a,y=>b

only只共享部分变量；x=>a将模块中的a更名为x private：专用属性；public：公用属性

类

选择

`if`结构

单分支：

if 条件 一条语句

多分支：

if 条件 then
	语句块
else if 条件 then
	语句块
else
	语句块
end if

例输入三角形三边，输出边长或不能构成三角形。

例排序：给定输入的abcd，按升序输出。

program main
    implicit none
    real::a,b,c,d,t
    read *,a,b,c,d
    if (a>b) then
        t=a
        a=b
        b=t
    end if
    if (c<=a) then
        t=c
        c=b
        b=a
        a=t
    else if (a<=c .and. c<=b) then
        t=b
        b=c
        c=t
    end if
    if (d<=a) then
        print *,d,a,b,c
    else if (a<=d .and. d<=b) then
        print *,a,d,b,c
    else if (b<=d .and. d<=c) then
        print *,a,b,d,c
    else
        print *,a,b,c,d
    end if
end

`case`结构

情况表达式为数值型（只能整型）：

program main
    implicit none
    integer::s
    read *,s
    select case(s)
        case(90:100)
            print *,'A'
        case(80:89)
            print *,'B'
        case default
            print *,'N'
    end select
end

情况表达式为字符型（或者字符数组）：

program main
    implicit none
    character::s
    read *,s
    select case(s)
        case('A')
            print *,'90:100'
        case('B')
            print *,'80:90'
        case default
            print *,'None'
    end select
end

情况表达式为逻辑型：

program main
    implicit none
    integer::s
    read *,s
    select case(s>=90)
        case(.true.)
            print *,'A'
        case(.false.)
            print *,'B'
    end select
end

练习输入一个数，判断能否被3整除。

! if
program main
    implicit none
    integer::x
    read *,x
    if (mod(x,3)==0) then
        print *,'Yes'
    else
        print *,'No'
    end if
end

! case logical
program main
    implicit none
    integer::x
    read *,x
    select case (mod(x,3)==0)
        case(.true.)
            print *,'Yes'
        case(.false.)
            print *,'No'
    end select
end

! case integer
program main
    implicit none
    integer::x
    read *,x
    select case (mod(x,3))
        case(0)
            print *,'Yes'
        case default
            print *,'No'
    end select
end

练习求一元二次方程的根

program main
    real::a,b,c,delta
    read *,a,b,c
    delta=b**2-4*a*c
    if (a==0) then
        if (b==0) then
            if (c==0) then
                print *,"Any"
            else
                print *,"None"
            end if
        else
            print *,-(c/b)
        end if
    else
        if (delta>0) then
            print *,(-b+sqrt(delta))/2*a,(-b-sqrt(delta))/2*a
        else if (delta==0) then
            print *,-(b/2*a)
        else
            print *,cmplx(-(b/2*a),sqrt(-delta)/2*a),cmplx(-(b/2*a),-sqrt(-delta)/2*a)
        end if
    end if
end

循环

`do`循环

do [i=start,stop[,step]]
	...
end do

exit退出循环，cycle退出本次

start,stop[,step]可以为整型、实型、变量、表达式；类型可以不一致（按赋值的原则转换）；

循环体语句次数 exit出口、正常出口

循环变量不能赋值

进入循环时，将初值赋给循环变量i；退出循环时，循环变量i增加一个步长；未通过正常出口退出时，循环变量i保持不变

练习采用迭代法求一元二次方程的根

将含的式子写成形式，令
估计的范围，给定初值，求出近似值
将代入上式，求出近似值，继续迭代
当$$时，认为达到精度；如果循环次数足够大时仍未收敛，则认为发散divergent

练习求阶乘的和

do-while循环

do while 条件
	...
end do

练习用三种do循环求

program main
    implicit none
    integer::i=0
    real(kind=selected_real_kind(32,64))::sum=0
    !1    
    do i=0,63
        sum=sum+2.0**i
    end do
    print *,sum
    !2
    i=0
    sum=0
    do while (i<=63)
        sum=sum+2.0**i
        i=i+1
    end do
    print *,sum
	!3
    i=0
    sum=0
    do
        sum=sum+2.0**i
        i=i+1
        if (i>63) exit
    end do
    print *,sum
end

! 18446744073709551615.0000000000000000

练习寻找100~999之内的回文数

program main
    implicit none
    integer::i,ans
    ans=1
    do i=100,999
        if (i/100==mod(i,10)) then
            ans=ans+1
        end if
    end do
    print *,ans
end

隐式`do`循环

在输入输出中使用，左括号等于do，右括号等于end do

print *,(x, i=1,10,2)

注：只能应用于输入、输出、数组赋值

递归

高级数据类型

数组 dimension

一维数组

练习输入10个整数，并按输入时的逆序输出，每行5个数。

数组构成器：是表达式，使用(/和/)定界其中可以是值的序列、隐含do循环、数组片段

A=(/1,2,3,4/)
A=(/sqrt(real(i)),i=1,4/)
A=(/D(3:9:3)/)

二维数组

声明

integer,dimension(1:4,1:5)::A

逻辑结构：二维表；物理结构：先列后行，线性存放

输入输出 格式编辑符可复用

read *,A按列依次输入
双重显do，多行输入
双重隐do，一行输入，先外后内
read *,((A(i,j),j=1,3),i=1,2)
一重隐do+数组片段，一行输入
read *,(A(i,1:3),i=1,2)

练习数组输出矩阵形状，求主对角线元素之和

program main
    implicit none
    integer,dimension(4,4)::A
    integer::i,s
    read *,(A(i,1:4),i=1,4)
    print '(1X,4I5)',(A(i,1:4),i=1,4)
    s=0
    do i=1,4
        s=s+A(i,i)
    end do
    print *,s
end
! 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
!      1    2    3    4
!      5    6    7    8
!      9   10   11   12
!     13   14   15   16
!           34

数组构造器给二维数组赋初值：reshape函数改变形状 source为一维数组，shape为二维数组的形，order改变行列顺序，默认列优先前两参数名可省略，order不可省略

integer,dimension(2,3)::A
1 3 5
2 4 6
A=reshape(source=(/1,2,3,4,5,6/),shape=(/2,3/))
A=reshape((/1,2,3,4,5,6/),(/2,3/))
1 2 3
4 5 6
A=reshape(source=(/1,2,3,4,5,6/),shape=(/2,3/),order=(/2,1/))
A=reshape((/1,2,3,4,5,6/),(/2,3/),order=(/2,1/))

数组形式

常数组

维界为数值或常数parameter 用于主程序，函数子程序、子例行子程序。既可作为实数组，也可以作为虚数组

可调数组

声明大小时使用整型变量 只在子程序中作虚数组使用

假定形状数组

integer,dimension(:,:)::D

用于子程序中作虚数组，只用:表示大小或只写一个维界

调用时必须写接口块，调用时从实数组获得形状参数，要求虚实维数一致，维界可不一致

动态数组

只用:表示大小，带有allocatable可分配属性 allocate分配内存，deallocate释放内存，未释放前不能再分配

real,dimension(:),allocatable::A1
real,dimension(:,:),allocatable::A2
allocate(A1(2),A2(2,3))
deallocate(A1,A2)

练习把个整数中最大的数找出来，并指出它在队列中的位置。数组大小未知。

program main
    implicit none
    integer,dimension(:),allocatable::A !声明动态数组
    integer::max,k,i,n
    read *,n
    allocate(A(n)) !分配存储空间
    read *,A
    max=A(1)
    k=1
    do i=2,n
        if (A(i)>max) then
            max=A(i)
            k=i
        end if
    end do
    print *,max,k
    deallocate(A)   !释放空间
end

! 5        
! 4 6 9 12 3
!           12           4

数组运算

筛选有序置数

交换数组两行

数组片段；元素循环

排序

选择排序；冒泡排序

查找

顺序；二分

矩阵运算

乘法或matmul(A,B)

矩阵转置

B=transpose(A)或B(i,j)=A(j,i)或方阵按主对角线交换

数组的移动

1 2 3 4 5
5 1 2 3 4

练习给定一个的二维数组，按行读入，求每一列的和，并排序。

for _ in range(8): print(*[random.randint(1,15) for i in range(9)])
4 12 13 13 1 12 3 11 7
5 3 1 13 9 13 4 1 7
13 3 8 10 3 3 14 12 2
6 6 15 10 5 2 6 3 12
14 2 9 6 7 8 8 10 2
9 2 6 4 12 3 6 3 14
1 10 4 12 15 4 15 14 8
11 2 8 7 12 5 15 6 2
列和
63 40 64 75 64 50 71 60 54

冒泡排序

subroutine sort(A)
    implicit none
    integer,dimension(9)::A
    integer::i,j,t,flag
    do j=1,8
        flag=0
        do i=1,8-j+1
            if (A(i)>A(i+1)) then
                t=A(i);A(i)=A(i+1);A(i+1)=t
                ! print '(9I2)',A
                flag=1
            end if
        end do
        if (flag==0) then
            exit
        end if
    end do
end
program main
    integer,dimension(8,9)::D
    integer,dimension(9)::S=0
    integer::i,s_l
    interface
        subroutine sort(A)
            implicit none
            integer,dimension(9)::A
            integer::i,j,t,flag
        end
    end interface
    read *,(D(i,:),i=1,8)
    do i=1,9
        s_l=0
        do j=1,8
            s_l=s_l+D(j,i)
        end do
        S(i)=s_l
    end do
    print '(9I3)',(S)
    call sort(S)
    print '(9I3)',(S)
end

选择排序

subroutine sort(A)
    implicit none
    integer,dimension(9)::A
    integer::i,j,t
    do j=1,8
        do i=j+1,9
            if (A(j)>A(i)) then
                t=A(j);A(j)=A(i);A(i)=t
            end if
        end do
    end do
end

插入排序

字符

练习输出如下图形

    *******
   *******
  *******
 *******
*******

练习验证一串字符是否为回文

去除尾部空格；首尾对应字符比较；不同退出

派生

指针

文件

基本操作

打开文件、读/写文件、关闭文件

打开/关闭文件

open(unit,file,status,access,form,recl,action,blank,iostat,err)

unit文件号，无符号整数，在第一位时可省略名称
file文件名，字符型，将文件号与文件连接

status文件状态，缺省值为unknown，包括

old
new 新文件
replace 不存在时新建；存在时覆盖
scratch 临时文件
unknown 存在则打开；不存在则新建

access，顺序文件sequential、直接文件direct（需要recl指定长度），缺省值sequential
form，有格式formatted（顺序文件）、无格式unformatted（直接文件）

其他

action = read,write,readwrite,缺省readwrite
blank = null缺省空格 
iostat
err 出错转到

有格式顺序文件open(2,file="A.dat") 有格式直接文件open(2,file="A.dat",access="direct",form="formatted",recl=12) 无格式顺序文件无格式直接文件临时文件

close(unit,iostat,status)
status=keep,delete 默认保留

close(2)

文件读/写

read (unit,fmt,rec,iostat,advance) 输入表
iostat <0文件结束 >0操作错误 =0执行成功
advance "Yes"换行读取 "No"不换行读取

有格式文件

read (2,*) a,b,c
read (2,fmt='(3F4.1)') a,b,c 带读取
read (2,*,rec=5) a,b,c 带记录号

无格式文件

read (2) i,j
read (20,rec=3) i,j

练习从键盘输入N个学生的姓名和考试成绩，把它写入到一个顺序文件中，并把建立的文件中的数据显示到终端显示器上。

program creat_file
    implicit none
    character(20)::name
    real::score
    integer::n,i
    open(1,file="student.dat",status="replace")
    read *,n
    do i=1,n
        read *,name,score
        write (1,'(A20,F6.1)') name,score
    end do
    close(1)
end

A                     50.0
B                     70.0
C                    100.0

program read_file
    implicit none
    character(20)::name
    real::score
    integer::is
    open(1,file="student.dat")
    read (1,'(A20,F6.1)',iostat=is) name,score
    do while (is==0)
        write (*,'(A20,F6.1)') name,score
        read (1,'(A20,F6.1)',iostat=is) name,score
    end do
    close(1)
end

文件操作

rewind反绕、backspace退格

inquire查询：按文件号查询、按文件名查询、按长度查询

练习检查文件student.dat中学生的数据后发现第K1个记录的学生姓名有错，第K2个记录的学生的成绩有误。编写程序修改原来的文件。

拾遗

甲、乙、丙同时开始放鞭炮，甲每隔秒放一次，乙每隔秒放一次，丙每隔秒放一次。每个人各放个鞭炮，编写程序求出总共能听到多少次鞭炮声。

思路

可以使用数组模拟该过程或者使用数学方法运算。数组方法十分简单，可以将每一秒离散地看作数组的一个元素，只需要开一个长度不小于max(t1,t2,t3)*(n-1)+1的数组模拟即可。置初值为0，设1为有响声。最后将整个数组求和即可。

数学方法：首先将3个时间从小到大排列，假设从小到大为甲、乙、丙，周期分别是。现在需要确定哪些时段甲乙丙三人都有可能放，哪些时段乙丙可能放，有哪些时段只剩下丙在放。必然是甲先完，接下来是乙完，最后是丙完。

接下来考虑三个时段应该如何分配。考虑甲、乙、丙的最后一声：设时刻为，如果时是甲乙丙第一次齐放的时候，那么甲响最后一声的时间为：，乙响最后一声的时间为：，丙响最后一声的时间为：。其中丙响最后一声的时间就是结束的时间。可以以此类推将的时间分成3份：；因为不能排除在时刻三声齐响，或者时刻两声齐响，同时为了把第n次响声放入前区间内方便计数，因此右区间设为闭。

在区间内，甲乙丙均可能发出响声。由于响声在某一时刻会重叠，导致多个响声听上去是一个，因此可以先计算出来实际响了几次，再减去重复的即可。 实际响的次数：n+(t1t/t2)+(t1t/t3)，其中/为整除，三项分别为甲乙丙的次数，且时的第一次只计一次。

但其中会有重复。先计算甲乙两者的重复，因为甲乙两者同时开始，因此考虑甲乙周期的最小公倍数数，甲乙同时响的次数为t1t/t12，可以为0，且已去掉第一次。

同理，乙丙的重复为t1t/t23，甲丙重复的次数为t1t/t13，有，。

但是若有甲乙丙三者同时响的可能（比如在时），则会被减去三次。但原来也被加过三次，因此还需要再加一次即可，考虑，则重复次数为t1t/t123。

因此在区间内听到总响声为
t1t=t1*(n-1);t12=lcm(t1,t2);t13=lcm(t1,t3);t23=lcm(t2,t3);t123=lcm(t1,t2,t3)
n1=n+(t1t/t2)+(t1t/t3)-t1t/t12-t1t/t23-t1t/t13+t1t/t123
在区间内，只有乙丙可能会有重复。但此时应注意，乙和丙此时的起始点不一定是对齐的，所以应该计算乙和丙的下一次相遇在哪个时间点。已知乙和丙的最小公倍数是，而乙丙的重复为t1t/t23即$t_{1t} $，因此在$ [0,t_{1t}]$区间内乙丙最后一次相遇的时间为因此乙丙的下一次相遇，也是在区间内的第一次相遇的时刻是因此可以计算出，乙丙总共会重复的次数为区间长度整除周期数，即但注意到的是，这一公式有前提是假设乙丙在之后的第一次相遇在之前。因此如果没有相遇，其中的分子会小于0，该值会为负数。因此修改为（这一步似乎没有必要）而在区间内，乙总共会响n-t1t/t2-1次，丙总共会响t2t/t3-t1t/t3-1次，因此区间内听到总响声为
n2=(n-t1t/t2-1)+(t2t/t3-t1t/t3-1)-max(((t2t-t1t+mod(t1t,t23))/t23),0)
丙还剩下n-t2t/t3-1次，故
n3=n-t2t/t3-1

综上所述已经求出了在全部区间之内甲乙丙的次数，只需要编写代码即可。

在此之前需要做预处理，即写出gcd(a,b)和lcm(a,b,c)，其中c可以作为可选变元来处理。

recursive function gcd(a,b) result(g)
    implicit none
    integer::a,b,g
    if (mod(a,b)==0) then
        g=b
    else
        g=gcd(b,mod(a,b))
    end if
end
recursive function lcm(a,b,c) result(y)
    implicit none
    integer::a,b,y,gcd,t0
    integer,optional::c
    if (present(c)) then
        t0=lcm(a,b)
        y=t0*c/gcd(t0,c)
    else
        y=a*b/gcd(a,b)
    end if
end

接下来便可求解。首先需要将t1,t2,t3排序。

if (t1>t2) then
    t=t1;t1=t2;t2=t
end if
if (t3<t1) then
    t=t3;t3=t2;t2=t1;t1=t
else if (t3<t2) then
    t=t2;t2=t3;t3=t
end if

接下来求三个n，并求总n。

t1t=t1*(n-1)
t2t=t2*(n-1)
t3t=t3*(n-1)
t12=lcm(t1,t2)
t13=lcm(t1,t3)
t23=lcm(t2,t3)
t123=lcm(t1,t2,t3)
n1=n+(t1t/t2)+(t1t/t3)-t1t/t12-t1t/t23-t1t/t13+t1t/t123
n2=(n-t1t/t2-1)+(t2t/t3-t1t/t3)-max(((t2t-t1t+mod(t1t,t23))/t23),0)
n3=n-t2t/t3-1
print *,n1+n2+n3

使用该方法的完整代码如下：

recursive function gcd(a,b) result(g)
    implicit none
    integer::a,b,g
    if (mod(a,b)==0) then
        g=b
    else
        g=gcd(b,mod(a,b))
    end if
end
recursive function lcm(a,b,c) result(y)
    implicit none
    integer::a,b,y,gcd,t0
    integer,optional::c
    if (present(c)) then
        t0=lcm(a,b)
        y=t0*c/gcd(t0,c)
    else
        y=a*b/gcd(a,b)
    end if
end
program main
    implicit none
    interface
        recursive function lcm(a,b,c) result(y)
            integer::a,b,y,gcd,t0
            integer,optional::c
        end function
    end interface
    integer::t1,t2,t3,n,t
    integer::t1t,t2t,t3t,t12,t13,t23,t123,n1,n2,n3
    read *,t1,t2,t3,n
    if (t1>t2) then
        t=t1;t1=t2;t2=t
    end if
    if (t3<t1) then
        t=t3;t3=t2;t2=t1;t1=t
    else if (t3<t2) then
        t=t2;t2=t3;t3=t
    end if
    t1t=t1*(n-1)
    t2t=t2*(n-1)
    t3t=t3*(n-1)
    t12=lcm(t1,t2)
    t13=lcm(t1,t3)
    t23=lcm(t2,t3)
    t123=lcm(t1,t2,t3)
    n1=n+(t1t/t2)+(t1t/t3)-t1t/t12-t1t/t23-t1t/t13+t1t/t123
    n2=(n-t1t/t2-1)+(t2t/t3-t1t/t3)-max(((t2t-t1t+mod(t1t,t23))/t23),0)
    n3=n-t2t/t3-1
    print *,n1+n2+n3
end

使用动态数组进行模拟方法如下：

program main
    implicit none
    integer::t1,t2,t3,n,t,i,s=0
    integer,dimension(:),allocatable::A
    read *,t1,t2,t3,n
    t=max(t1,t2,t3)*(n-1)+1
    allocate(A(t))
    A=0
    A(1)=1
    A(1:t1*n:t1)=1
    A(1:t2*n:t2)=1
    A(1:t3*n:t3)=1
    do i=1,t
        s=A(i)+s
    end do
    deallocate(A)
    print *,s
end

! 1 2 4 4
!            8

基本数据类型I

整型 integer

实型 real

复型 complex

字符型 character

ASCII

基本数据类型II

常量 parameter

派生 type

数组 dimension

基本语句

类型声明

种别

算术表达式与赋值

内在函数

算术运算

关系表达式与逻辑表达式

输入与输出

表控输入

表控输出

格式化输入输出

整型编辑符[r]Iw[.m]

实型编辑符[r]Fw.d

其他编辑符

基本程序结构

程序单元

主程序program

子程序

函数子程序function

子例子程序subroutine

接口块interface

虚实结合

模块module

类

选择

if结构

case结构

循环

do循环

隐式do循环

递归

高级数据类型

数组 dimension

一维数组

二维数组

数组形式

常数组

可调数组

假定形状数组

动态数组

数组运算

筛选有序置数

交换数组两行

排序

查找

矩阵运算

数组的移动

字符

派生

指针

文件

基本操作

打开/关闭文件

文件读/写

文件操作

拾遗

整型编辑符`[r]Iw[.m]`

实型编辑符`[r]Fw.d`

主程序`program`

函数子程序`function`

子例子程序`subroutine`

接口块`interface`

模块`module`

`if`结构

`case`结构

`do`循环

隐式`do`循环