第六讲 Fortran中的子程序
FORTRAN90第6章子程序
Fortran 90
子程序程序体的写法
分为说明部分和执行部分。 1、说明部分应对程序体内一切变量、数组等实体 （包括虚元）作出说明，同时还要说明函数结果 变量名，但不可说明函数名。 2、执行部分中必须对函数结果名至少赋值一次。
例2．计算y=f（x）+g（x）值。
其中
f（x）=x+sin30° x+1，f(x)>0 g（x）= 0， f(x)=0 x-1， f(x)<0 要求用外部函数求g（x）的值。
Fortran 90
PROGRAM MAIN IMPLICIT NONE REAL::X,Y,F,G,GF READ*,X F=X+SIN(30*3.1415926/180) G=GF(X,F) Y=F+G G,GF不能同名 PRINT*,Y END
Fortran 90
最简单的源程序的结构
主程序： 单位定义 说明部分 子程序： 计算或处理
输入
调用子程序 输出 END
Fortran 90
子程序分类
用于完成复杂的计算
1、函数子程序
分为内部函数子程序 外部函数子程序 2、子例行子程序 分为内部子例行子程序 外部子例行子程序
返回 一个或多个值
用于完成复杂计算 ，返回一个或多个 值，或用于其它数 据处理
247.0
4.0
Fortran 90
6.3 完成复杂 计算任务，返回一个或多个值，或用于其它数 据处理
Fortran程序设计之子程序
•
前者用双撇号作定界符，后者用单撇号作定界符， 而将字符串的单撇号用两个单撇号表示，系统会 自动将其处理为字符串的一个单撇号字符。
5
字符串中含有单引号或双引号的处理
•
当字符串中又含有单撇号时例如要将I'M A STUDENT作为一个字符串来处理，为了区分'是 字符串中的字符还是定界符，可采用两种方式表 示：
!
•
直接常量
•
用单引号或双引号（有的地方又称单撇号、 双撇号）括起来的字符串
4
字符常量
•
!
符号常量
program hello implicit none character(len=*), parameter :: & message = "Hello, I am a computer." print *, message end program
6
字符变量赋值
program test_sign implicit none real :: number character(len=8) :: number_sign read *, number if (number > 0) then number_sign = "positive" else if (number == 0) then number_sign = "zero" else number_sign = "negative" end if print *, number, "is ", number_sign end program
第6章子程序
6.3.2 外部子例行子程序的调用
• 一般形式 CALL 子例行程序名[(实参数表)] • 说明 – ⑴ 当外部子例行子程序没有虚参数， 调用子例行子程序时实参数表连同括号 一起省略。 – ⑵ 实参数与虚参数的名字可以不同。
6.3.2 外部子例行子程序的调用
• 外部子例行子程序的调用过程 – ⑴ 在主调程序中当执行到CALL语句时，将 实参数与子例行子程序中的虚参数一一结合； – ⑵ 然后将执行控制转移到子例行子程序，开 始执行子例行子程序体内的语句； – ⑶ 当执行到END SUBROUTINE语句之 后，再将控制返回到主调程序中CALL语句 的下一条语句继续执行。
6.3.3 内部子例行子程序
【例6-7】编写一个内部子例行子程序ABC， 其功能是求一元二次方程的两个实数根。
6.3.3 内部子例行子程序
• 子例行子程序与函数子程序主要差别 – ⑴ 函数子程序由FUNCTION语句定义。子 例行子程序由SUBROUTINE语句定义。 – ⑵ 函数子程序通常有返回值。而子例行子程 序的计算结果只能通过虚参数传递给主调程 序，也可以没有返回值。 – ⑶ 函数子程序的调用如同固有函数一样，直 接通过函数名进行调用，并且可以参与表达 式的运算。而子例行子程序的调用由CALL 语句来完成。
6.5.2 局部标识符
6.6 虚参数与实参数之间的数据 传递
• 虚实结合的一般原则
– 实参数与虚参数的个数相等、类型一致、 顺序对应。 – 虚参数可以是变量名、数组名、子程序 名和指针等。
6.6.1 变量作为虚参数
FORTRAN90 语言程序设计
第6章 子程序
12:42:12
主要内容
子程序的概念 函数子程序 子例行子程序 内部子程序和外部子程序 虚参与实参之间数据传递 模块化程序设计的一般方法
第六讲 Fortran中的子程序
一、子例行程序的定义
子例行程序是以Subroutine 语句开头，并以End语句结束的一 个程序段，其定义的一般格式为：
Subroutine 子例行程序名（虚参表）
子例行程序体 end
2015/12/20 12
注意： （1）子例行程序的命名方法与变量相同。虚参由变量、数组 名（不能是数组元素，常数、表达式）充当，当有多个虚参 时，之间用“ ,” 分隔，没有虚参时子例行程序名后面的一对 括号可以省略； （2）子例行程序的设计方法与函数子程序相同，但不能有对 子例行程序名的赋值语句（因为其名字没有值）。
第六讲 Fortran中的子程序
实际中的程序由若干个程序单元组成，但是有且只有一个主 程序（ Program main ），其它的都是子程序。子程序是构造 大型实用程序的有效工具，设计程序要善于利用子程序，因 此，本讲学习Fortran中的子程序：函数子程序和子例行程序。 此外，在Fortran中还有一种类似与函数子程序的语句函数。
2015/12/20 15
分析：牛顿迭代公式为：
program newton f(x)=7*x**4+6*x**3-5*x**2+4*x+3 f ( xn ) df(x)=28*x**3+18*x**2-10*x+4 xn 1 xn ' f ( xn ) read*,x0,e !x0=-1.0,e=0.0001 x1=x0 首先要给个迭代初值 x0 ， x2=x1-f(x1)/df(x1) 代入公式的右边计算 x1 ， do while(abs(x1-x2)>e) 再把 x1 代入计算出 x2 ， … ， x1=x2 x2=x1-f(x1)/df(x1) 当第n次和第(n+1)次计算 end do 结果差不多时（在规定的 print*,x1,f(x1) 精度内），则计算结果就 end
第2章Fortran程序设计基础.ppt
• 子程序是构造大型程序的有效工具，一个实用程序(不 管是系统程序还是应用程序)，一般都含有多个子程序。
• FORTRAN 90 中的子程序按子程序完成的功能划分有子 例行程序、函数子程序、数据块子程序等，按是否定义 在某个特定的程序单元内部来划分有程序单元子程序、 模块子程序以及内部(INTERNAL)子程序等，这些通称为 子程序。
FUNCTION SM(M,N,L) SM=0 DO I=M,N
IF (L>0) THEN SM=SM+I**L
ELSE
PROGRAM EXAM2
！开始主程序单元定义
WRITE(*,*)'S1=',SM(1,100,2) ！调用函数子程序SM完成S1的计算
WRITE(*,*)'S2=',SM(100,140,3)
PROGRAM EXAM1B
INTEGER X
6.2 函数子程序
语句函数由于要求在一个语句中完成函数的定义，因而它只能解决一些较 简单的问题，当函数关系比较复杂，用一个语句无法定义时，语句函数就 无能为力了，这时需要用到函数子程序。
6．2．1 函数子程序的定义
函数子程序是以保留字 FUNCTION 开头，并以保留字 END结束的 一个程序段，该程序段可以独立存储为一个文件，也可以和调用 它的程序单元合并存储为一个程序文件。函数子程序的定义格式 是：
INTEGER F(X，Y)=X**2+Y**2 ! 定义了一个整型函数F
NF(X，Y)=X**2+Y**2 F
! 也同样定义了一个整型函数
2.语句函数的虚参
在语句函数定义语句中的函数参数称为虚参，他们本身是没有值的，只有在 函数调用时才用实际参数(称为实参)代替。实参或是常数、或是一个有确定 值的变量、或是一个可以计算值的表达式。虚参在形式上与普通变量相同， 一个语句函数中的虚参不能同名。不同语句函数中的虚参可以同名，虚参也 可以和程序中的变量同名。
FORTRAN95第六章 Fortran 过程程序设计
普通的外部函数子程序形式之二为:
例6.2 利用函数子程序，计算N的阶乘。
! 计算N!的函数子程序
function fact (n)
!fact为外部函数子程序名， n为哑元
implicit none
integer:: n，i
! 说明哑元n和函数体中所用变量i的类型
real*8:: fact
! 说明函数名的类型
fact=1d0
!函数名作为变量名使用
do
write(*，*)'输入正整数m:'
read (*，*)m
if (m>0) exit
write(*，*)'输入了一个负整数或零，重输!'
end do
do
write(*，"('输入正整数n(n<='，i4，'):')")m
read (*，*)n
if (n>0 .and. n<m) exit
read *，n
h=(b-a)/n
do i=1，n-1
s=s+f (a+i*h) !调用语句函数f的语句
end do
s=h*(f (a)+f (b)+2.0*s)/2.0 !调用语句函f
write ( *，"('定积分的值为: '，f10.6)")s
fortran子程序【精选】
parameter (n1=3,n2=3,n3=3)
dimension a(n1,n2)
dimension b(n2,n3),c(n1,n3)
open(5,file='input.dat')
call getmat(a,n1,n2)
call getmat(b,n2,n3)
call matpro(a,n1,n2,b,n3,c)
20 continue end
real w(5,5) call readin(w)
输入矩阵 1,2,3,4,5 2,3,4,5,1
call opp(w,x1,x2) write(*,100) x1,x2 100 format(1x,'The two sum of',
3,4,5,1,2
$ ' oppusite angles elements:',
subroutine sub(ch) charact...er*(*) ch end
11
（4）如果实参是变量或数组元素，在调用子程序时， 对应的虚实参数实际上将共用同一存储单元。
program main
subroutine sub(x,a)
integer a,c(3)
integer x,a
data c/3*0/
4,5,1,2,3 5,1,2,3,4
$ /1x,'x1=',f8.2,' x2=',f8.2) end
9
主要区别：
1. 形式不一样（function、subroutine、call），无虚参 时括号使用不一样。
2. 子程序名的意义不一样。函数子程序名代表函数值， 通过其传递数据，需要类型说明；而子例行程序名仅 为了调用使用，通过虚实参传递数据。
Fortran子程序
函数与子程序
子程序和主程序之间最大不同在于：主程序的程序代码，在程序一开始 就自动被执行，而子程序的代码只有在被‚调用‛才会执行。
一个包含子程序的Fortran程序在结构上大致如下：
program main ← 主程序 „„ „„ ←主程序代码 „„ end program main ←主程序结束 subroutine sub1() ←第1个子程序 „„ „„ ←子程序码 „„ end subroutine sub1 ←第1个子程序结束 subroutine sub2() ←第2个子程序 „„ „„ ←子程序码 „„ end subroutine sub2 ← 第2个子程序结束
函数与子程序
使用common还有一些技巧，见下面实例。主程序中有全局变量ａ，ｂ， 子程序中有大小为２的数组a(2)，根据使用相同内存空间的策略，ａ等于 a(1)，而ｂ等于a(2)。
program ex0814 implicit none real :: a,b common a,b ! 把浮点数a,b放在全局变量中 a = 1.0 b = 2.0 call ShowCommon() stop end subroutine ShowCommon() implicit none real :: a(2) common a ! 把数组a放在全局变量中 write(*,*) a(1), a(2) return end
传递参数与使用全局变量都可以在 不同程序之间共享数据，简单的说，当 需要共享的变量不多，而且只由少数几 个程序需要使用这些数据时，就使用参 数；当共享大笔数据，或是有很多个不 同程序都要使用这些数据时，就使用全 局变量。
函数与子程序
2、BLOCK DATA 的使用 关于common设臵初值的方法，common变量不能直接在子 程序或主程序中使用DATA来设臵初值，要在BLOCK DATA程序模块中使用DATA命令来设臵初值，看一个程序：
fortran知识点总结
fortran知识点总结一、语法结构Fortran语言的语法结构遵循一套严格的规则。
下面是一些常见的语法结构：1. 程序单元：Fortran程序由一个或多个程序单元组成。
每个程序单元由一个或多个声明和执行语句组成。
2. 注释：在Fortran中，注释可以用来提高代码的可读性。
注释以感叹号（!）开头，直到行末为止。
3. 标识符：Fortran中的标识符由字母、数字和下划线组成，且区分大小写。
标识符用于表示变量、函数、子程序等。
4. 变量声明：在Fortran中，变量声明使用关键字“REAL”、“INTEGER”、“LOGICAL”等来指定变量的数据类型。
例如，REAL :: x 表示声明了一个实数类型的变量x。
5. 程序控制结构：Fortran提供了多种控制结构，包括顺序结构、条件结构和循环结构。
这些结构提供了程序的流程控制和逻辑控制。
6. 函数和子程序：Fortran支持函数和子程序的定义和调用。
函数和子程序可以帮助程序员组织和重用代码。
7. 模块和接口：Fortran中的模块和接口提供了一种组织代码的方式。
模块可以包含多个子程序和全局变量，接口可以用来定义子程序的接口。
二、数据类型在Fortran中，数据类型用于表示数据的类型和大小。
Fortran提供了多种数据类型，包括整数、实数、逻辑值、字符、复数等。
下面是一些常见的数据类型：1. 整数：整数类型用于表示整数值。
在Fortran中，整数类型包括“INTEGER”、“LOGICAL” 和“CHARACTER”类型。
2. 实数：实数类型用于表示实数值。
在Fortran中，实数类型包括“REAL”和“COMPLEX”类型。
REAL类型用于表示实数，COMPLEX类型用于表示复数。
3. 字符：字符类型用于表示字符值。
在Fortran中，字符类型使用CHARACTER关键字进行声明。
字符类型可以表示单个字符或者字符数组。
4. 数组：数组类型用于表示多个相同类型的数据。
FORTRAN90-子程序浅
100
Program Main REAL MYEXP WRITE(*,*) ‘Enter X:’ READ(*,*)X Y=(MYEXP(X)-MYEXP(-X))/2.0 WRITE(*,100)’Sinh(‘,X,’)=‘,Y FORMAT(1X, A, F5.2, A, E13.6) END
9
f(x) = x * x + 2 * x + 5 x = 3.0 y = x * f(1.0) WRITE(*,*) y END
24.00000
10
四、语句函数的应用
例：利用二分法求方程x3-x2-1=0在[0，3]上的实根。
Real::a=0.0,b=3.0,m Fa=a**3-a*a-1.0; Fb=b**3-b*b-1.0 m=(a+b)/2; Fm=m**3-m*m-1.0 Do while (Fm>1.0e-6) If(fm*fa>0) then a=m;Fa=Fm Else b=m Endif m=(a+b)/2.0; Fm=m**3-m*m-1.0 Enddo Write(*,*)’方程的根为：‘，m End
Program Main
REAL W(5,5)
CALL READIN(W) CALL OPP(W,X1,X2) WRITE(*,100)X1,X2 100 FORMAT(1X, ‘The two sum of opposite angles &
elements:’/1X,’X1=‘,F8.2,’X2=‘,F8.2)
(1)
SUBROUTINE SUB(B) DIMENSION B(-1：5) . . . END
B(-1) B(0) B(1) B(2) B(3) B(4) B(5)
Fortran程序总结
1.行的书写(行的长度、分行、续行)一行可以是0~132个字符，空格有意义，语句最长不超过2640个字符一行可以有多个语句，用“;”分隔一个语句可分行写，读行标记为&（放在尾部），但如为关键字，首尾均加&。
最多可有511个续行。
2.说明语句必须出现在可执行语句之前，格式说明语句（FORMAT语句）除外。
3.注释标志符：自由格式：！固定格式：C *语句分隔符：分号；（仅自由格式可以使用）续行符：自由格式：&申明标号：1到5位无符号整数空格：关键字、变量、常量内部不能用空格，但相邻两者之间须用空格4.信息处理的分类：数值处理和信息处理现代计算机工作原理：程序存储和程序控制（冯·诺依曼）1、运算器——算术运算、逻辑运算2、控制器——根据指令控制计算机工作运算器、控制器和寄存器称为中央处理器CPU3、I/O设备——提供数据传输服务4、总线——数据传输的公共通道1.机器语言：二进制代码形式，可以被计算机直接执行，不可移植2.汇编语言：用助记符来代替机器指令，容易记忆，不可移植3.高级语言：接近自然语言（英语）的程序设计语言，又称算法语言，易学、易用、易维护，可移植性好例：FORTRAN、BASIC、PASCAL、C、LISP、PROLOG等5.FORTRAN90程序是一种分块结构，由若干个程序单元块组成：主程序、外部子程序、模块、块数据单元无论是主程序单元，还是子程序单元，都是独立的程序单位，应该独立编写，它们的形式相似。
非语句行：注释语句：！后的所有字符都被编译器忽略。
可独占一行，也可在其它语句之后，空行为注释行（固定格式用C和*）6.常量的定义：常量是程序执行过程中不能变化的量。
基本数据类型有五种：整型、实型、复型、字符型和逻辑型前三种属于数值类型，后两种为非数值类型，主要用于文字处理和控制。
FORTRAN 90通过KIND值确定整数的存储开销、最大位数和取值范围，如表所示。
aspen fortran子程序的编译、连接、运行
Aspen plus fortran子程序的编译、连接与运行Aspen Plus 可以用来模拟反应精馏，但提供的动力学方程形式比较死板，很多类型的动力学方程都不能直接输入，不得不外接一个fortran子程序。
本来用到fortran的机会就不多，所以会的人也不多。
何况编写好fortran子程序后，还要用fortran编译器来编译生成obj文件，而且每次运行的时候都得连接一次，比较麻烦。
我的电脑以前是装了编译器这些软件的，但最近出了问题，只能编译fortran子程序，运行aspen外接fortran子程序的时候就会出错。
恰好这几天要帮师兄写个fortran子程序，写完后需要调试，但又运行不了，重装呢也没把握，想起网上有兄弟说过可以用asplink命令生成一个dll文件，这样就不用运行aspen的时候每次都连接编译器了。
于是找来资料学习学习，居然成功了，欣喜之余，分享给大家。
第一步当然是编写动力学子程序了（此处省略若干字）第二步编译写好的动力学子程序（以网友soaty的动力学子程序为例）打开Aspen Plus Simulation Engine打开后是这样的接下来改变文件夹路径，转到存放动力学子程序的那个文件夹比如我的文件路径是C:\ProgramData\AspenTech\Aspen Plus V7.1\IPP于是输入cd C:\ProgramData\AspenTech\Aspen Plus V7.1\IPP回车后就转到这个文件夹了，这时候就可以进行编译了:编译命令:aspcomp 输入命令aspcomp RIPPA.f,回车到文件夹一看你会发现已经生成了obj文件了，第二步就完成了第三步：生成obj文件的OPT文件这个很简单，只需要在文件夹里面先新建一个文本文件，然后把名字改为RIPPA_LIST_OBJ，双击打开文本文件，在里面先添加上刚刚生成的obj文件的路径（就是我们第一步提到的那个文件夹路径加上最后生成的RIPPA.obj就可以了最后把txt格式改成opt格式就行了第四步：链接第二步生成的OBJ文件，生成dll文件命令格式：ASPLINK [DLOPT dloptfile] libnameDloptfile是在刚刚生成的OPT文件的文件名，Libname是给要生成的dll文件指定一个文件名于是我们输入asplink [dlopt RIPPA_LIST_OBJ.opt] RIPPA 回车（这里如果输入的命令是ASPLINK libname 就会链接这个文件夹下所有的OBJ文件，如果你的文件夹下刚好有多个OBJ文件，那么一般不能成功生成dll文件）第五步：生成dll文件的opt文件，和第三步类似贴个图好了，大家参考第三步把txt格式改成opt格式，这时所有的编译链接都完成了，我们就可以在没有安装fortran编译器的电脑上运行带fortran的子程序的Aspen Plus文件了首先打开BKP文件后，点击RUN——settings——Engine Files——Linker填入dll文件的OPT文件名RIPPA_LOC_DLL.opt点击确定，这时，不出意外，就可以运行aspen了注意：上面提到的这些文件必须放到一个文件夹里面，如果您下载了我的文件更改了文件夹的目录就需要在那两个OPT文件中更改成您自己的文件夹目录。
fortran语言教程第6章
第6章数组应用6.1 数组与数组元素数组是由任何一种简单数据类型按照一定的组织规则构造出来的数据类型，是有序数据的集合。
数组中可以包含很多个同类型的变量，我们把这些变量叫做“数组元素”或“数组分量”或“下标变量”。
在机器中数组占用一片连续的存贮单元，每个单元都用同样的名字（即数组名）但编号不同。
数组的命名方式与简单（基本）变量命名方式相同。
假设有数组A，占据4个存储单元，元素在内存中的排列可形象表示出来：AA（1），A（2），A（3），A（4）A（1，1），A（1，2），A（2，1），A（2，2）每个单元的编号方式可以有多种，第一种用一个数字来编号称为一维数组，第二种用两个数字来编号称二维数组。
可以推广，用N个数字对数组的元素编号则称为N维数组。
数组使用之前一定要说明，事先告诉机器数组的类型，包含分量的个数，分量的编号方式等，以便机器为数组预留内存空间。
6.1.1数组的说明数组的说明应该包括以下几个方面的内容：•确定数组的名称；•确定数组元素的类型；•确定数组的结构(包括数组维数，每一维的取值范围等内容)。
说明语句的形式有：(1)类型说明语句：说明数组的类型和元素个数类型标识符数组名1 (维说明1[，维说明2，．．．])[，数组名2．．．](2)DIMENSION语句：只说明数组元素个数DIMENSION数组名1 (维说明1[，维说明2，．．．])[，数组名2．．．]其中“维说明”的形式：维下界∶维上界(或下标下界∶下标上界)例如：REAL A(1:10)，B(80:90)，C(-5:4)，NUM1(1:2,1:5)INTEGER D(0:1,0:4)，NUM2(2:5)DIMENSION S(3:5), M(1:10)说明语句中的A，B，C，D，NUM1，NUM2等都是数组名，数组名不能与本程序单位中的其他任何标识符重复。
通过“维说明”可以确定数组维数，每一维的取值范围等内容。
同一维的上下界之间用冒号分开；括号中至少要有一个维说明，也可以有多个。
多重积分Fortran子程序------
多重积分Fortran子程序-------VEGAS.F流程图说明：这里只是对子程序的算法和如何分层做详细介绍，对打印输出和其他一些东西都做略过。
还有这个子程序中涉及的变量很多，而且变量的意义也变化，所以下面涉及到的变量我都会在画流程图前加以适当的说明。
1．子程序所涉及的变量及其的意义：有用输入参数：FXN：被积函数。
ACC：所要求的精度。
NDIM：被积函数的变量的个数。
NCALL：投点的总数。
ITMX：要求的叠代的次数。
NPRN：打印的要求（具体要求略过）。
子程序内部的参数及其意义：TI（A VGI）：数值积分的结果。
IT：叠代的次数。
X（I，J）：各随机变量的分布，J表示各个变量。
ERR（SD）：数值积分的误差。
ALPH0：变化区间的参数。
RAND（20）：[0，1]的随机数列。
X（J）：用于积分的坐标等。
2．主要的程序模块和各模块的功能总的流程图：3．各模块的流程图1）初始化设定各个参数该部分的主要工作就是给各参数输入初始值，下面简述各个初始化的参数以及各参数的意义或在以下何模块里要用到。
ALPH=1.5; 这是在7中用到，作为变换分布的参数。
CALLS=NCALL；投点的总数。
XND=ND=50；区间分为50份。
NDM=ND-1=49；为以下处理方便。
IT=0；叠代初始为零。
SI=0；SI2=0；SWGT=0；SCHI=0；SCALLS=0；以上五个变量均是叠代参数，在5中用。
2）初始化内部分布：变量的意义：RC：分层的间隔。
NDIM：变量的个数。
XI（I，J）：变量的区间的分布。
XND：区间分层数。
XNDM=XND-1。
DR：求和号。
初始化的分布是一个均匀分布，实现的流程图如下：3) 初始叠代参数：这不仅仅是初始化的过程了，而是大的循环的一部分，每改变一次变量的分布，就需要初始化叠代参数一次。
下面简述各个初始化的参数以及各参数的意义或在以下何模块里要用到。
IT=IT+1；叠代的次数。
TI=0；积分值清零。
FORTRAN90第6章1
real::a,f
READ*,a
print *,f(a) END
例6-3求出20-50间的素数，调用函数实现
6.2.3函数子程序应用举例：
例6-3、编写判断素数的函数子程序，调用它实现例 5-11的功能：求出20～50之间的全部素数。 FUNCTION PRIME(M) RESULT(PRIME_RESULT) IMPLICIT NONE INTEGER::M,I,PRIME_RESULT DO I=2,M/2 IF(MOD(M,I)==0) EXIT ENDDO IF(I>M/2) THEN PRIME_RESULT=1 ELSE PRIME_RESULT=0 ENDIF END FUNCTION PRIME
FUNCTION PRIME(M) RESULT(PRIME_RESULT) IMPLICIT NONE 说明结果 为逻辑类 INTEGER::M,I 型 LOGICAL::PRIME_RESULT
先假定是 PRIME_RESULT=.TRUE. 素数 DO I=2,sqrt(real(m)) IF(MOD(M,I)==0) PRIME_RESULT=.FALSE. ENDDO END FUNCTION PRIME
用一个主程序求1！+2！+3!+4！则代码为：
PROGRAM MAIN INTEGER::FACT=1,SUM=0,I,N N=4 DO I=1,N 计算I！ FACT=FACT*I 累加I！ SUM=SUM+FACT ENDDO 所有功能都在主 PRINT*,SUM 程序单位内完成 END
例：编写求N！的函数子程序。
表示函 数开始
函数名字 N是虚元
表示函 数结果
存放函数结 果的变量
ABAQUS中Fortran子程序调用方法
第一种方法：/ o/ J5 @6 U/ ^- o$ 1. 建立工作目录/ ]"2. 将Abaqus安装目录\6.4-pr11\site下的aba_param_dp.inc或aba_param_sp.inc拷贝到工作目录，并改名为aba_param.inc；# ~/ |0 I0 E6 {, @4 X3 q: W3. 将编译的fortran程序拷贝到工作目录；4. 将.obj文件拷贝到工作目录；5. 建立好输入文件.inp；6. 运行abaqusjob=inp_name user=fortran name即可。
第二种方法：在Job模块里，创建工作，在EditJob对话框中选择General选项卡，在Usersubroutine file中点击Select 按钮，从弹出对话框中选择你要调用的子程序文件（后缀为.for或.f）。
, D8 i7 d/r c6 @" |以下是网上摘录的资料，供参考：. |$ t/ }$W7 Y6 m4 h6 D6 j用户进行二次开发时，要在命令行窗口执行下面的命令：4 O. R+ ^,@( ? abaqus job=job_name user=sub_nameABAQUS会把用户的源程序编译成obj文件，然后临时生成一个静态库standardU.lib和动态库standardU.dll，还有其它一些临时文件，而它的主程序（如standard.exe和explicit.exe等）则没有任何改变，由此看来ABAQUS是通过加载上述2个库文件来实现对用户程序的连接，而一旦运行结束则删除所有的临时文件。
这种运行机制与ANSYS、LS-DYNA、marc等都不同。
: j6 g' R-o( {0 [* N2 J3 X这些生成的临时文件要到文件夹C:\Documentsand Settings\Administrator\Local Settings\Temp\中才能找到，这也是6楼所说的藏了一些工作吧，大家不妨试一下。
fortran函数定义与子例子程序
fortran函数定义与子例子程序Fortran 语法备忘录 (中级1)——转载2010-03-10 19:12转载于目录：【主程序】【语句函数】【内在过程】【内部过程】【外部过程】◆外部函数◆外部子程序◆EXTERNAL属性和哑过程◆INTENT属性◆OPTIONAL属性◆哑元改名◆关键字变元INTRINSIC属性◆类属过程◆过程接口INTERFACE◆超载操作符◆自定义操作符◆超载赋值号【模块】【块数据】【指针】【主程序】!-----------------------------------------------------------------------[PROGRAM [程序名]][说明部分][可执行部分][CONTAINS内部过程]END [PROGRAM [程序名]]!-----------------------------------------------------------------------【语句函数】 f(x)=x**2+1【内在过程】 max，abs，sin，char。
【内部过程】 Contains与宿主程序共享变量名, 外部过程FUNCTION, SUBROUTINE都可以有自己的内部过程。
通常没有说明语句。
没有哑元，无哑实结合。
使用内部过程的规则：在宿主中不要定义子程序名和函数名的类型，也不能指定它们是有EXTERNAL属性。
宿主中的变量名和数组名等在内部过程中有效，有相同的数值。
但同一名若在内部过程中又进行了类型声明，则此名被视为其过程中的独立变量，无相同的数值。
内部过程中也可引用另一内部过程。
例：!-----------------------------------------------------------------------program internalreal a,b,ccall findprint *,ccontainssubroutine findread *, a,bc=sqrt(a**2+b**2)end subroutine findend!-----------------------------------------------------------------------【外部过程】过程=函数&子程序哑元调用方式：传址调用call by adress，即传递4字节的变量的内存地址。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实际中的程序由若干个程序单元组成，但是有且只有一个主 程序（ Program main ），其它的都是子程序。子程序是构造 大型实用程序的有效工具，设计程序要善于利用子程序，因 此，本讲学习Fortran中的子程序：函数子程序和子例行程序。 此外，在Fortran中还有一种类似与函数子程序的语句函数。
7
程序说明： 1 、整个程序由主程序和 1 个函数子程序组成，二者的位置不 分先后，因为程序执行时总是从主程序开始的； 2、函数子程序Function SM(m,n,l)中，缺省类型说明时，则 函数SM及其虚参标量m、n、l的类型遵守I～N规则； 3、主程序中的第2～4语句都要输出SM的值，其调用了函数子 程序SM。 函数子程序的定义还应注意以下问题： 1、函数值的类型说明方法可使用：
2015/12/20
5
§2
函数子程序
语句函数的不足是必须要在一条语句中完成对函数的定义， 因此只能用于较简单的函数，对于复杂的函数关系、无法用 一条语句完成时，需要用到本节的函数子程序。
一、函数子程序的定义
函数子程序是以Function 语句开头，并以End语句结束的一个 程序段，其可以独立自成一个程序文件，也可以和调用它的 程序单元合并成一个程序文件。其定义的一般格式为： [类型说明符] Function 函数名（虚参表）
Integer Function f(x1,x2,…,xn) 函数体 end
等
价
Function f(x1,x2,…,xn) Integer f 函数体 end
如果没有这样的显式说明，则按照I-N规则。
2015/12/20 8
2、函数不能有同名虚参。而虚参的类型可以在函数体中说 明，没有说明则服从I-N规则； 3、在函数体中至少要有一个语句给函数名赋值，这种赋值 语句的格式为： 函数名＝表达式 切莫在函数名后加入括号，错误地写成： 句定义一个函数，比如：f ( x, y ) x 2 y x 2 2 y 2
就可以用Fortran的一条语句写出来：
f ( x, y) x * *2 * y sqrt ( x * *2 y * *2)
2015/12/20 1
一、语句函数的格式
f ( x1 , x2 , x3 ,, xn ) e
二、函数子程序的调用
定义函数子程序的目的是为了调用，在 Fortran 中不仅主程 序可以调用函数子程序，而且函数子程序也可调用其它的函 数子程序，甚至调用本身（叫递归调用）。常把调用程序叫 主调程序单元，而被调用的函数子程序叫被调程序单元。 调用函数子程序的方法与调用内部函数及语句函数基本相同： （1）调用时应该用实参（可以是常量、变量、表达式等）代 替函数子程序中的虚参，实参和虚参的类型要相同；
二、语句函数的调用
语句函数一经定义，就可以在同一程序单元中调用它，调用 的方法与内部函数相同，即：
2015/12/20
函数名（实参表）
4
需要注意下面2个问题： 1、调用时可以使用常量、变量、内部函数及其表达式作为实 参代替对应的虚参位置，但要保证实参和虚参具有完全相同 的类型，并且实参是可以计算值的（即调用前实参中包含的 变量全部已经赋值）； 2、实参和虚参个数相同。 比如： integer x,f f(x)=5*x**3-2*x**2+7*x+6 print*,f(-1),f(0),f(1) End 运行结果为：－8 6 16
其中：f 称为函数名，x1、x2、…、xn称为虚参，e是关于虚参 的一个有效表达式。
（1）语句函数名：其取名及数据类型与变量相同。
比如：
F(x,y)=x**2+y*y→定义了一个实型函数F NF(x,y)=x**2+y*y→则定义了一个整型函数NF
又比如：Double precision FF FF(x,y)=x**2+y**2→定义了一个双精度型函数FF 注意在同一程序单元中，语句函数名不能与某个变量同名。
2015/12/20 3
此外，还需注意的是：
1、只有当函数关系简单到，可以用一条语句描述函数与参数 的对应关系时，才能使用语句函数；
2、语句函数是非执行语句，要放在一个程序单元的所有其它 说明语句之后，并放在所有可执行语句之前； 3、语句函数只有在本程序单元中才有意义，即不能使用其它 程序单元中的语句函数； 4、语句函数中的虚参必须是变量，不能是常量、数组元素和 内部函数等； 5、语句函数是有类型的，因此语句函数表达式的类型一定要 与其函数名同类型。
2015/12/20
2
（2）语句函数的虚参---即语句函数的自变量
1、称其为“虚参”是因为其本身是没有值的，只有在函数被 调用时才用实际意义（叫实参）代替； 2、可以按照普通变量对待虚参，但是一个语句函数中虚参不 能同名，但不同语句函数中虚参可以同名，虚参也可以和程 序中的变量同名； 3、虚参的类型说明与变量的类型说明方法与规则相同，而且 对与虚参同名变量同时有效； 4、当存在多个虚参时，之间用“,”分隔，如果没有虚参则函 数名后的括号是不能省略的。 （3）语句函数表达式 给出函数与参数之间的对应关系，可由虚参（必须包含所有的 虚参）、常量、变量、数组、 Fortran 的内部函数及在其前面 说明了的语句函数。
函数体
end
2015/12/20 6
其中，类型说明用于说明函数名的类型；函数名的命名方法 与变量名相同；虚参可以是简单变量和数组变量，但不能是 常数、数组元素、表达式。 function sm(m,n,l) sm=0 比如：求 do i=m,n if(l>0)then 100 S1 n 2 sm=sm+i**l n 1 else 140 S2 n3 sm=sm+(1.0*i)**l n 100 end if 30 1 end do S3 n 20 n end program main 程序的运行结果为： write(*,*)'s1=',sm(1,100,2) S1=338350.000000 write(*,*)'s2=',sm(100,140,3) S2=7.291440E+07 write(*,*)"s3=",sm(20,50,-1) S3=9.514656E-01 end 2015/12/20