Fortran Training Course

Fortran Training Course
KISTI Supercomputing Center

http://www.ksc.re.kr
http://edu.ksc.re.kr
Reference Resources
http://seismic.yonsei.ac.kr/fortran/
http://www.cs.mtu.edu/~shene/COURSES/cs201/NOTES/fortran.html
http://ihlee.kriss.re.kr/compphys/f90module.htm
http://blog.npol.net/116
http://www.star.le.ac.uk/~cgp/f90course/f90.html
http://www.fortran.com/tutorials.html
Etc.
SUPERCOMPUTING EDUCATION CENTER 1

Agenda
1 Day
09:30 - 10:30 Environment Setup
10:30 - 10:40 Break
10:40 - 12:00 Fortran Introduction
Selective Statement
12:00 - 13:30 Lunch
13:30 - 14:50 Derived Data Type
Loop Statement
14:50 - 15:00 Break
15:00 - 16:30 Array

Agenda
2 Day
Dynamic Allocation
09:30 - 10:30
Subprogram
10:30 - 10:40 Break
10:40 - 12:00 Module
12:00 - 13:30 Lunch
13:30 - 14:40 Recursive
File I/O
14:40 - 14:50 Break
14:50 - 16:30 Advanced Lab
Summary & Closing

Index
What is Fortran
Basic Grammar
Formatted Output
Selective Statement
Derived Data Type
Loop
Array, Dynamic Allocation, Array Function
Subprogram
Module
File I/O
Advanced Lab & Summary
2014-04-14
Connect to edu system
Environment Setup
2014-04-14
Basic User Environment
L ogin
– 사용자의 초기 접속은 총 4대의 로그인 노드로 한정됨
– 컴퓨팅 노드로의 액세스 불가
– 액세스 인터페이스는 ssh, sftp, ftp, X11 만 허용됨
U nix or Linux
– $ ssh -l user_id xxx.xxx.xxx.xxx or
– $ ssh -l user_id IP address
W indows
– putty 나 SSH Secure Shell Client 등의 ssh 접속 유틸리티를 이용함
• Free Download Site : http://www.putty.org/

Login to Education System
Host Name : xxx.xxx.xxx.xxx (PuTTY Usage)

SSH -> X11 Tab - “Enable X11 forwarding” Check
X display location : localhost:0.0
Save <Be careful>
Xming must be started
in XP or Win7

PuTTY Security Alert “Yes(Y)” Click

login as : edun## (## is your table number at the corner)
edun##@ xxx.xxx.xxx.xxx’s password :

Login to lab node (s0001, s0002, s0003, s0004)
– $ ssh s0003
GNU Fortran Compiler Selection

01. What is Fortran
What is Fortran
2014-04-14
What is Fortran?
FORmula (수식) TRANslation (변환기)
초기 개발
– 1950년대 초반 IBM에서 개발
– 가장 오래된 최초의 고급 언어(High Level Language)
C 언어와 같은 고급 언어의 탄생에 막대한 영향을 줌
표준화
– 1966 Fortran V (Fortran77) by ANSI, ISO
– 미국 표준 채택, 국제표준 채택(1980, ISO) FORTRAN 77
Fortran 90 (1991년도 표준제정, 가장 널리 사용됨)
Fortran 95
Fortran 2003

Fortran 언어의 특징
상호 호환성
– 컴퓨터의 기종에 관계없이 공통으로 사용
쉽고 간단한 문법과 명령어

– 단기간에 활용가능
– 명령은 문장으로 표현, 문장은 실행문과 비 실행문으로 구성
다양한 프로그램 라이브러리 지원

– 많은 공개 소스 (legacy code)
활용 영역
– 많은 입‧출력을 요구하는 문제보다는 많은 양의 계산이 필요한 공학, 통
계학, 수학, 그리고 경영과학 등에 널리 사용
Software Inertia

First Fortran Code
Hello, World
PROGRAM HELLO
Program
IMPLICIT NONE Name
WRITE (*, *) ‘Hello, World’
STOP ! [STOP] is optional
END PROGRAM HELLO ! [PROGRAM] [hello] is optional
$ gfortran –o hello.x hello.f90

$ ./hello.x

02. Basic Fortran Grammar
Basic Fortran Grammar
2014-04-14
Fortran77 기본구조 (1/2)
포트란77 작성시 지켜야 하는 규칙
– 1 Column : 참고문 작성시 c, * 표기 후 2~72 column 에 기술
– 1~5 Column : 문번호(1~99999), Optional
– 6 Column : 연결문장 (0, 공백을 제외한 문자로 연결된 문장임을 표시),
Optional
– 7~72 : 명령문 기술
– 73~80 Column : 메모용 기술, Optional (거의 사용하지 않음)
1 2~5 6 7~72 73~80
Total=x_value+y_value
& +z_value
C Comment line
9 9999 FORMAT(‘Answer =‘,I4)

Fortran77 의 단점 (2/2)
고정 형식 소스코드 포맷
– 72열 까지만 허용
– 제 5열은 줄 번호
– 제 6열은 줄 연결 표시
– 주석은 1열에서 특정 문자로 시작, 프로그램 코드와 같은 줄에 올 수 없음
– 변수 길이 제한(6글자)
병렬 연산 표현 불가능
동적 메모리 기능 없음 (Fortran90 에서 가능)
수치적 이식성 부족
– 시스템 간 정밀도 표현 차이
사용자 정의 자료구조 불가능
함수(루틴)의 재귀적 호출(Recursive) 불가능 (Factorial)
COMMON 블록, EQUIVALENCE 문 등의 불안정성

Fortran77 vs Fortran90
Fortran90 새로운 기능 소개
– 개선된 문법
– Type Declaration과 attributing
– New control structure
– Numeric Processing
– Dynamic Memory Allocation
– Array Processing
– Pointers
– 데이터 타입과 연산자의 사용자 정의
– 프로시저
– 모듈
– 프로그램 단위

Example Code
Fortran77 Style (Fixed Format) Fortran90 Style (Free Format)
C234567890123456789012345678901234 ! This is a Fortran 90 Style
C This is a Fortran 77 Style 컬럼표시 PROGRAM ex2_f90

PROGRAM ex2_f77 IMPLICIT NONE
INTEGER i
REAL r INTEGER :: i = 10
CHARACTER*10 str REAL :: r = 20.0
CHARACTER*10 :: str = “I study Fortran90”
i = 10
r = 20.0 WRITE(*, *) 'i = ', i
str = “I study Fortran90” WRITE(*, *) 'r = ', r
WRITE(*, *) 'str = ', str
C Show Messages
WRITE(*, *) 'i = ', i STOP
WRITE(*, *) 'r = ', r END
WRITE(*, *) 'str = ‘,
& str
STOP
END
$ gfortran –o ex2_f77.x ex2_f77.f $ gfortran –o ex2_f90.x ex2_f90.f90

$ ./ex2_f77.x $ ./ex2_f90.x

Fortran 90
(http://www.comphys.uni-duisburg.de/Fortran90/pl/pl.html)

Fortran 90 Improved Syntax (1/3)
개선된 문법
– 자유형식 – 문장의 시작위치 제한 없음
– 한 줄에 132열까지 가능
• IBM XL Fortran은 한 줄에 최대 6700문자 가능
– 한 줄에 여러 문장 가능 – 문장 분리 기호 ‘;’
– 문장 내에 주석 가능 – 주석 시작 기호 ‘!’
– 줄 바꿈 표시 – 문장 마지막에 ‘&’
– 변수 길이 31자까지 가능(반드시 문자로 시작)
• IBM XL Fortran은 최대 250자 까지 가능
관계 연산자 표현
• .LT., .LE., .EQ., .NE., .GE., .GT. : Fortran77 스타일
• <, <=, ==, /=, =>, > : Fortran90 허용
Fortran : /=
C/C++ : !=

Fortran 90 Improved Syntax (2/3)
Fortran 90에서 사용 가능한 문자 집합
– 문자-숫자 조합 : a-z, A-Z, 0-9, _ (underscore)
Symbol Description Symbol Description
Space = Equal
+ Plus - Minus
* Asterisk / Slash
( Left parenthesis ) Right parenthesis
, Comma . Period
‘ Single quote “ Double quote
: Colon ; Semi colon
! Shriek & Ampersand
% Percent < Less than
> Greater than $ Dollar
? Question mark

Fortran90 Improved Syntax (3/3)
Improved Syntax
Fortran90 Style
PROGRAM free_source_form
IMPLICIT NONE
REAL :: tx, ty, tz ! Trailing statements
tx=1.0 ; ty=2.0 ; tz=tx*ty ! Multiple statements
PRINT*, &
tx,ty,tz ! Continuation symbol on line to be continued
END PROGRAM free_source_form

Fortran90 Data Type, Variable (1/2)
Fortran’s 5 Data Types
Size
Type Description Example
(64bit OS기준)
Integer 정수형 4 Byte 0, 120, -235, +32856
3.141592654, 0.2353
Real 실수형 4 Byte
123.45E0, 1234.3E-3
1Byte (문자) ‘A’

Character 문자형
?Byte (문자열) ”Sunday”
Logical 논리형 4 Byte .TRUE. , .FALSE.
Complex 복소수형 4 Byte C = (1.4, 3.2)

Fortran90 Data Type, Variable (2/2)
Variable Declaration
– INTEGER :: score = 10, rank = 5
– REAL :: average, total = 10.23
– CHARACTER(LEN=10) :: str = ‘ABCDEFGHI’
or
– CHARACTER(10) :: str, msg*20
Fortran77 Fortran90
INTEGER n IMPLICIT NONE

PARAMETER(n=1000) INTEGER, PARAMETER :: n=1000
INTEGER pixels(n, n), encode(n, n) INTEGER, DIMENSION(n, n) :: pixels,
REAL x(n), y(n) encode
INTEGER*8 call REAL, DIMENSION(n) :: x, y
call = 0 INTEGER(8) :: call=0

Variable Names
Variable Naming Rule

– Must be at least one alphabetic character long, up to a maximum of 6
alphanumeric characters (Fortran77)
– Must start with an alphabetic character
– Alphanumeric characters are : a-z,0-9 and the underscore (_)
– Capital letters are treated the same way as lower-case letters
Valid Invalid
X X*Z
THEDAY THE TIME
Min_cur 7YEARS
Time28 _no_way$

Assignment
<variable> = <value> | <variable>| <expression>

– Expressions follow the BODMAS precedence rule
– Operators +, -, *, /, **
– Only round bracket
Assignment
radius = 2.5
y=z
test = value+loop-temp
volume = (4.0*pi*radius**3.0) / 3.0

Implicit None (F90)
변수형이 명시적으로 선언되지 않은 어떤 지정자가 I, J, K, L, M, N이
나 이들의 소문자로 시작하면, 그 변수는 정수형 (INTEGER)
그 외의 문자로 시작되는 변수들은 실수형 (REAL)
Fortran 90에서는 IMPLICIT NONE으로 하여금 변수선언을 해야만
사용할 수 있도록 해서 오류를 방지하기 위한 목적
Ok Not Ok
! Fortran77 ! Fortran90
I = 10 IMPLICIT NONE
K=5
J=I+K I = 10 ! Error, Not declared
K=5 ! Error , Not declared
J=I+K ! Error , Not declared
POW = 3.0
C/C++ 에서는 선언되지 않은 변수 사용 불가

Example Code
Fortran77 Fortran90
PROGRAM ex2a_f77 PROGRAM ex2a_f90
INTEGER i IMPLICIT NONE
REAL r
CHARACTER*10 str INTEGER :: i = 10
REAL :: r = 20.0
i = 10 CHARACTER*10 :: str = ‘1234567890’
r = 20.0
str = '1234567890' WRITE(*, *) 'i = ', i
WRITE(*, *) 'r = ', r
WRITE(*, *) 'i = ', i WRITE(*, *) 'str = ', str
WRITE(*, *) 'r = ', r
WRITE(*, *) 'str = ', str STOP
END
STOP
END
$ gfortran –o ex2a_f77.x ex2a_f77.f $ gfortran –o ex2a_f90.x ex2a_f90.f90

$ ./ex2a_f77.x $ ./ex2a_f90.x

Parameter
Parameter is constants(상수), their value, once defined, can not
be changed with new values
C/C++에서의 const
Located in front of the Executable statement
Parameter type
REAL gamma, pi
INTEGER, PARAMETER :: days = 365 ! Fortran90 Style
PARAMETER(gamma=1.4, pi=3.14) ! Fortran77 Style
pi = pi * 3 ! Error - Not allowed

days = days + 3 ! Error – Not allowed

Example Code
Fortran77 Fortran90
PROGRAM ex2b_f77 PROGRAM ex2b_f90
IMPLICIT NONE
REAL r, area, pi
PARAMETER (pi=3.141592) REAL :: r = 5, area
REAL, PARAMETER :: pi = 3.141592
r=5
area = pi * r * r pi = pi + 0.3
area = pi * r * r
WRITE (*, *) 'Area =', area
WRITE (*, *) 'Area =', area
STOP
END STOP
END
$ gfortran -o ex2b_f77.x ex2b_f77.f $ gfortran -o ex2b_f90.x ex2b_f90.f90

$ ./ex2b_f77.x $ ./ex2b_f90.x

Operation
Fortran에서의 수식 표현
– B2 – 4AC B ** 2 – 4 * A * C
Data type에 따른 연산 결과
– Integer 7 / 4 = 1
– Real 7.0 / 4.0 = 1.75
Mixed-Mode Expressions
– 7.0 / 4 7.0 / 4.0 = 1.75
– 7.0 + 7 / 4 7.0 + 1.0 8.0
– 7 + 7.0 / 4 7 + 7.0 / 4.0 7 + 1.75 7.0 + 1.75 = 8.75
형변환 함수 사용 – real, int, etc.

03. Formatted Output
Formatted Output
2014-04-14
Formatted Output
Fortran 입/출력의 종류
– 자동서식형태 : 컴퓨터에 의해 자동적으로 서식이 지정
– 서식지정형태 : 프로그래머에 의해 서식이 지정
Fortran의 두가지 출력문

– PRINT : 간단함
– WRITE
PRINT 사용법
PRINT 서식지정자, 출력목록
– * (별표) : 서식을 컴퓨터가 정하도록 하는 자동서식 출력

– 출력 서식을 지정해 주는 문자형 상수나 변수
– FORMAT문의 번호 ( 1 ~ 99999 사이의 정수)

Formatted Output
Edit Descriptions Purpose
A Aw 문자 데이터
Iw Iw.m 정수 데이터
Fw.d 10진수 형식의 실수 데이터
Ew.d Ew.dEe 지수 형식의 실수 데이터
ESw.d ESw.dEe 과학전용 형식의 실수 데이터
ENw.d ENw.dEe 공학전용 형식의 실수 데이터
nX 수평 공백
/ 수직 (New Line)
Tc Tab
– w : 필드길이 (양의 정수)
– m : 읽어들이거나 출력될 최소의 자리수를 지정 (양의정수)
– d : 소수점 미만의 자리수 (양의정수)
– e : 지수의 자리수 (양의정수)
– x, n, c : 양의정수
– 필드들에 대해서 우측 정렬

Formatted Output - 정수
정수 출력 기술자 ( I )
INTEGER :: alpha = 5, beta = 5290, gamma = -32768
WRITE (*, 200) '1234567890123456789012345678901234567890'

WRITE (*, 100) alpha, alpha-5, beta, gamma
100 FORMAT (1X, 2I5, I7, I10) ! 2I5 is same I5, I5

101 FORMAT (1X, 2I5.2, I7, I10.7)
102 FORMAT (1X, 2I5.0, I7, I10)
200 FORMAT(A)
결과 화면

Example Code
Fortran90
PROGRAM ex8a
IMPLICIT NONE
INTEGER :: alpha = 5, beta = 5290, gamma = -32768
WRITE (*, 200) '1234567890123456789012345678901234567890'

100 FORMAT (1X, 2I5, I7, I10) ! 2I5 is same I5, I5 (Repetion Indicatior)
101 FORMAT (1X, 2I5.2, I7, I10.7)
102 FORMAT (1X, 2I5.0, I7, I10)
200 FORMAT(A)
STOP
END
$ gfortran –o ex8a.x ex8a.f90

$ ./ex8a.x

Formatted Output - 실수
실수 출력 기술자 ( F, E, ES, EN )
INTEGER :: red = 127, blue = -23

REAL :: a = 8.3, b = .231, c = 238.129
WRITE (*, 200) '1234567890123456789012345678901234567890'

WRITE (*, 100) red, blue, a, b, c F8.3
100 FORMAT (1X, 2I4, 2F6.3, F8.3) 2 3 8 . 1 2 9

200 FORMAT(A)
결과 화면

Example Code
Fortran90
PROGRAM ex8b
IMPLICIT NONE E 출력형식
마이너스부호, 0, 소수점, d개의 유효자리수, E, 4자리공간
INTEGER :: red = 127, blue = -23
REAL :: a = 8.3, b = .231, c = 238.129
REAL :: alpha = .12345E8, beta = .0139, gamma = -4.5E-12
WRITE (*, 200) '1234567890123456789012345678901234567890'

WRITE (*, 100) red, blue, a, b, c
WRITE (*, 101) alpha, beta, gamma
100 FORMAT (1X, 2I4, 2F6.3, F8.3)

101 FORMAT (1X, 2E15.5, E15.4)
Result
200 FORMAT(A)
STOP
END
$ gfortran –o ex8b.x ex8b.f90

$ ./ex8b.x

Formatted Output - 문자
문자 출력 기술자 ( A )
REAL :: x = 0.4, y = 8.7
WRITE (*, 100) “x = “, x, “y = “, y
100 FORMAT (2X, A, F6.2, ,2X,A, F6.2) ! 2X is two spaces
결과 화면
x = 0 . 4 0 y = 8 . 7 0

Formatted Output - 줄바꿈
Format 형식
– 문자형 변수 출력
character*20 A
A =‘format test’
write(*, 100) A
100 format(a20)
– D 배정밀도
– E 실수 (지수)
– F 실수 (고정) 일반적으로 F(또는 D, E) Fw.d (w:숫자적을 전체칸, d:유효숫
자)
– I 정수
– 줄바꿈 표시’/’ : 입/출력시 다음줄로 이동
write(*, 400) (ii(j), j=1,4)
400 format(4(i2,/))
– 한칸 이동 ‘x’

Example Code
Fortran90
PROGRAM ex2c_format
IMPLICIT NONE
INTEGER :: i = 10, tt = 128

REAL :: rr = 3.141592654
CHARACTER*10 :: str = '1234567890'
WRITE(*, *) 'i = ', i

WRITE(*, 100) 'rr = ', rr
100 FORMAT(A, F13.6)
WRITE(*, *) 'str = ', str

WRITE(*, 200) 'str = ', str
200 FORMAT(A, A20)
WRITE(*, 300) tt, tt

300 FORMAT(2(I3, /)) ! / is new line

301 FORMAT(I4, 5X, I4) ! 5X is five spaces

302 FORMAT(2I4) ! (2I4) = (I4, I4)
STOP
END
$ gfortran –o ex2c_format.x ex2c_format.f90

$ ./ex2c_format.x

03. Selective Statement
Selective Statement
2014-04-14
Relational Expression
Logical return with True or False value
– Left to right order
Operator Math Meaning e.g.
.LT. ＜ Less than A .LT. B
.LE. <= Less than or equal to A .LE. B
.EQ. = Equal to A .EQ. B
.NE. /= Not Equal to A .NE. B
.GT. ＞ Greater than A .GT. B
.GE. >= Greater than or equal to A .GE. B

Logical Expression
Complex conditions
– Order : .NOT. .AND. .OR. .EQV. .NEQV.
– .TRUE. and .FALSE. 값만 가능
Operator Meaning e.g. Results
.NOT. 부정 .NOT. A A가 참아면 거짓, 거짓이면 참
.AND. 논리곱 A .AND. B A, B가 모두 참일때만 참, 그 이외는 거짓
.OR. 논리합 A .OR. B A, B가 모두 거짓일때만 거짓, 그 이외는 참
.EQV. 논리등가 A .EQV. B A, B가 모두 거짓이거나 모두 참일때 참
.NEQV. 논리비등가 A .NEQV. B A, B가 모두 참이거나 모두 거짓일때 거짓

Control Structure
제어문을 사용한 제어 구조
– 분기구조(branches structure)
• 지정된 문 번호로 실행을 이동
• 조건식의 결과에 따라 프로그램을 선택적으로 수행
• IF문, GOTO문
– 순환구조(loops structure)
• 프로그램의 일부분을 반복 실행하는 명령문
• DO ~ CONTINUE문, GOTO문과 IF문을 사용한 구조
– 기타 제어문
• STOP : 주 프로그램에서 실행을 종료
• CALL : 서브루틴 프로그램의 호출
• RETURN : 서브루틴 실행을 종료
• END : 하나의 프로그램이나 서브루틴 프로그램을 끝냄

IF Statement (1/3)
Logical IF statement
– 한 줄에 적어야 한다.
IF (expression) statement
– IF 내부에서 한 문장 이상을 수행하여야 하는 경우
IF (expression) THEN
statement
...
ENDIF
Example Code
IF (num .LT. 0) num = -num
IF (num .LT. 0) THEN

num = -num
num = num + 2
ENDIF

Example Code
Fortran90
PROGRAM ex3a
IMPLICIT NONE
INTEGER :: num = -3 ! Fortran90 Style
WRITE(*, *) 'Before num = ', num
IF (num .LT. 0) num = -num
WRITE(*, *) 'After num = ', num
IF (num > 0) THEN ! > == .GT.

WRITE (*, *) 'Num > 0'
END IF
STOP
END
$ gfortran -o ex3a.x ex3a.f90

$ ./ex3a.x

If Statement (2/3)
Block IF statement (가장 일반적인 경우)
IF (expression1) THEN
statements
ELSEIF (expression2) THEN
statements
ENDIF
Example Code
IF (a > b) THEN
max = a
ELSEIF (b < a) THEN
min = b
ENDIF

Example Code
Fortran90
PROGRAM ex3b
IMPLICIT NONE WRITE(*, *) 'min = ', min
WRITE(*, *) 'max = ', max
INTEGER :: a = 10, b = 20
INTEGER min, max
STOP
IF (a > b) THEN END
max = a
min = b
ELSEIF (a < b) THEN
max = b
min = a
ELSE
min = a
max = a
ENDIF
$ gfortran –o ex3b.x ex3b.f90

$ ./ex3b.x

If Statement (3/3)
Arithmetic IF statement
IF(expression) Negative, Zero, Positive
– Expression의 결과가 양(+),음(-),영(0) 인가에 따라 세방향으로 분기한다.

Example Code
Fortran90
PROGRAM ex3c
IMPLICIT NONE
INTEGER :: NUM = 100
IF (NUM-100) 10, 20, 30

10 PRINT *,'NUM is less than 100.'
GO TO 40
20 PRINT *,'NUM equals 100.'
GO TO 40
30 PRINT *,'NUM is greater than 100.'
40 CONTINUE
STOP
END
$ gfortran –o ex3c.x ex3c.f90

$ ./ex3c.x

Example Code (Quadratic Equation)
Fortran90
PROGRAM quadratic_equation ELSE
IMPLICIT NONE WRITE(*, *) "There are no real roots"
END IF
REAL :: a, b, c, delta, z1, z2
STOP
WRITE(*, *) "Enter a, b, c" END
READ(*, *) a, b, c
Ax2 + Bx + C = 0
delta = b**2 - 4 * a * c
− B ± B2 − 4 AC
IF (delta >= 0) THEN 2A
delta = SQRT(delta)
z1 = (-b + delta) / (2.0 * a)

z2 = (-b - delta) / (2.0 * a)
WRITE(*, *) "The roots = ", z1, z2
$ gfortran -o quadratic_equation.x -Wall quadratic_equation.f90

$ ./quadratic_equation.x

Select-Case
SELECT-CASE (Fortran90)
– IF 문과 같은 순차적 선택이 아닌 병렬적 선택 수행
– IF 문보다 간결하고 효율적

• Expression은 integer, character, logical 등이 가능
SELECT CASE (expression)
CASE(value-list)
statements
CASE(value-list)
statements
END SELECT

Example Code
Fortran90
PROGRAM ex3d
IMPLICIT NONE
INTEGER :: n, k
WRITE (*, *) 'Enter the value n = '

READ *, n
SELECT CASE (n)

CASE ( :0 ) ! ~ 0
k = -n
CASE ( 10: ) ! 10 ~
k = n + 10
CASE DEFAULT ! 0 ~ 10
k=n
END SELECT
WRITE (*, *) ‘ k = ‘, k
END
$ gfortran –o ex3d.x ex3d.f90

$ ./ex3d.x

04. Derived Data Type
Derived Data Type
2014-04-14 58
Derived Data Type
Derived Data Type 사용 예
TYPE COORDS_3D
REAL :: x, y, z
END TYPE COORDS_3D
TYPE (COORDS_3D) :: var

var%x = 10
TYPE (COORDS_3D), DIMENSION(10), TARGET :: var_arr

var_arr(1)%x = 10
TYPE/END TYPE을 이용해 새로운 타입 정의

– 기본 타입과 같은 attribute(dimension, allocatable, target, intent,..)를
가질 수 있으나 PARAMETER attribute를 가질 수 없음
– 구조화 : 의미가 연결되어 있는 데이터들을 하나의 덩어리로 다룸

– Derived Data Type를 사용하여 구조화 된 데이터를 처리

Derived Data Type
정의된 derived type을 이용해 새로운 derived type 정의
TYPE COORDS_3D
REAL :: x, y, z
END TYPE COORDS_3D
TYPE SPHERE
TYPE ( COORDS_3D ) :: center
REAL :: radius
END TYPE SPHERE
TYPE ( SPHERE ) :: s_var

s_var%center%x
s_var%center%y
s_var%center%z
s_var%radius

Derived Data Type
Derived Data Type 값 할당하기
1. ‘%’ 연산자 이용

s_var%center%x = 10.0
s_var%radius = 5.0
2. Derived data type 이용
TYPE( COORDS_3D ) :: var

var = COORDS_3D(1.0, 2.0, 3.0)

s_var%center = COORDS_3D(1.0, 2.0, 3.0)
s_var = SPHERE(COORDS_3D(1.0, 2.0, 3.0), 4.0)
s_var = (1.0, 2.0, 3.0, 4.0) ( X )

Derived Data Type
배열을 포함하는 Derived Data Type
TYPE SCORE
CHARACTER ( LEN = 10 ) :: name
INTEGER, DIMENSION(2,2) :: record
END TYPE SCORE
TYPE(SCORE), DIMENSION(20) :: teamA
teamA(1)%record(2,2)
teamA(4)%record(:, :)
teamA(:)%record(1,2)
– Allocatable or pointer 배열은 사용 불가능

Derived Data Type
derived_data_type.f90
PROGRAM derived_data_type
TYPE POINT
REAL :: x,y
END TYPE POINT
TYPE(POINT) :: a, b
REAL :: c = 0.0
a = POINT(1.0,1.0)
b = POINT(2.0,2.0)
c = SQRT((a%x-b%x) * (a%x-b%x) + (a%y-b%y) * (a%y-b%y))
PRINT *, "a=", a, "b=", b, "c=", c
END PROGRAM derived_data_type
gfortran -o derived_data_type .x derived_data_type.f90

05. Loop Statement
Loop Statement
2014-04-14
Do Loops (1/5) – F77
비슷한 작업을 반복할 때 사용, C/C++ 언어의 for 반복문과 동일
Fortran 77에서는 한가지 Loop, 즉 Do-loop 뿐이다
DO label, variable = e1, e2, e3
{block of statement}
label CONTINUE
– Label : 문장번호
– Variable : 제어변수 명 (정수형 변수나 실수 형 변수)
– e1:초기값, e2:최종 값 (정수형,실수 형 변수,상수,산술 식 등)
– e3:증분값 (양수나 음수)
Example Code (Fortran77)
PROGRAM ex4a_f77_do
INTEGER i, total
total = 0
DO 100 i = 1, 100
total = total + i
100 CONTINUE
WRITE (*, *) ‘total = ‘, total
END

Loops in Fortran90
DO variable = e1, e2, e3
{block of statement}
ENDDO
– Variable : 제어변수 명(정수형 변수나 실수 형 변수)
– e1:초기값, e2:최종값 (정수형,실수 형 변수,상수,산술 식 등)
– e3:증분값 (양수 or 음수), 생략하면 1씩 증가

PROGRAM ex4a_do
IMPLICIT NONE
INTEGER :: i, total = 0
DO i = 1, 100
total = total + i
ENDDO
END

Loops & IF in Fortran90 (인덱스가 없는 DO 구문 1)
DO
statements
IF (expression) exit
statements
ENDDO
– DO ~ ENDDO 안에 IF 조건문을 넣어서 특정조건이 참이면 반복 실행
PROGRAM ex4b_do
IMPLICIT NONE
INTEGER :: i = 0, total = 0
DO
total = total + i
IF (i > 100) exit
i=i+1
ENDDO
END

Loops & While in Fortran90 (인덱스가 없는 DO 구문 2)
DO WHILE (expression)
statements
ENDDO
– WHILE 문에 있는 조건이 참이면 반복 실행

PROGRAM do_while
IMPLICIT NONE
DO WHILE( i <= 100 )

total = total + i
i=i+1
ENDDO
END

Loops & IF in Fortran90
DO
cycle은 C/C++
statements1 의 continue 와
IF (expression) cycle 동일
statements2
ENDDO
– DO ~ ENDDO 안에 IF 조건문을 넣어서 특정조건이 참이면 statements1로 가고,
statements2를 실행하지 않는다
PROGRAM ex4c_do
IMPLICIT NONE
DO
i=i+1
IF ( i > 100) exit
IF (MOD(i, 2) == 0) cycle
total = total + i
ENDDO

END

Go To
여러방향의 선택
GO TO (label 1 , label 2 , … , label n) integer-expression
– label 1, label2: 분기될 명령문의 문장번호
– integer-expression : 정수형 수식 또는 정수변수
• integer-expression=1 이면 label1실행 (goto label1)
• integer-expression=2 이면 label1실행 (goto label2)
• integer-expression 이 범위를 벗어나면 GOTO문의 다음문을 실행

Example Code
Fortran90
PROGRAM gugudan
IMPLICIT NONE
INTEGER :: i, j, first, last, result
WRITE (*, *) 'Enter the two numbers (ex) 3 9 : '

READ *, first, last
DO i = 1, first
DO j = 1, last
result = i * j
IF (result /= 0) THEN
WRITE (*, *) i, '*', j, '=', result
END IF
END DO
END DO
END
$ gfortran -o gugudan.x gugudan.f90

$ ./gugudan.x

06. Array, Dynamic Allocation
Array, Dynamic Allocation
2014-04-14
Array (1/5) – F77
FORTRAN77의 배열 선언
REAL a, b, c
DIMENSION a(100), b(10, 10), c(2, 3, 4)
or
REAL a(100), b(10, 10), c(2, 3, 4) ! Recommend
C/C++ Array
int ar[10];
Index는 ar[0] ~
a[9]
– 배열을 구성하는 변수명의 Index 시작값은 default가 1

• V(c1:c2)로 선언가능 : c1은 차원의 하한값, c2는 차원의 상한값
– Multi-dimensional array 7D까지 가능

– C언어와의 배열구조 차이를 이해하는 것이 중요

Example Code (F77 Style)
Fortran77
PROGRAM ex5a_f77_array
INTEGER i, j
INTEGER buf(3, 3)
DO 20 i = 1, 3
DO 10 j = 1, 3
buf(i, j) = i * j
WRITE(*, *) 'buf(', i, ',', j, ') = ', buf(i, j)
10 CONTINUE
20 CONTINUE
END
$ gfortran –o ex5a_f77_array.x ex5a_f77_array.f90

$ ./ex5a_f77_array.x

Array (2/5) – F77
다양한 Array 선언 방법
– INTEGER ar(10) ! ar(1), ar(2), … , ar(10)

– REAL ar(0:19) ! ar(0), ar(1), … , ar(19)
– DOUBLE ar(-100:100) ! ar(-100), … ar(0), … , ar(100)
– INTEGER max
PARAMETER (max=100)
REAL buf(max, max)

Fortran77
PROGRAM ex5b_f77_array
INTEGER i, j, max
PARAMETER (max=3)
INTEGER buf(max, max)
DO 20 i = 1, max
DO 10 j = 1, max
buf(i, j) = i * j
10 CONTINUE
20 CONTINUE
END
$ gfortran –o ex5b_f77_array.x ex5b_f77_array.f90

$ ./ex5b_f77_array.x

Array (3/5) – F90
FORTRAN90의 배열 선언
– INTEGER, DIMENSION(100) :: ar ! ar(1), ar(2), … , ar(10)
– REAL, DIMENSION(0:19) :: ar ! ar(0), ar(1), … , ar(19)
– DOUBLE, DIMENSION(-100:100) :: ar ! ar(-100), … ar(0), … , ar(100)
– INTEGER, PARAMETER :: max = 100

REAL, DIMENSION(max, max) :: buf
– INTEGER, DIMENSION(100, 100) :: a, b, c
– REAL :: array(5,6,7), scalar, vector(100) ! Declare array, scalar, vector
– INTEGER :: buf(5) = ( / 1, 2, 3, 4, 5 / ) ! Set initial value

– CHARACTER(LEN=3), PARAMETER :: day(0:6) = &
( / ‘Sun’, ‘Mon’, ‘Tue’, ‘Wed’, ‘Thu’, ‘Fri’, ‘Sat’ / )

Fortran90
PROGRAM ex5c
IMPLICIT NONE
INTEGER i, j
INTEGER, PARAMETER :: max=3
INTEGER, DIMENSION(max, max) :: buf
DO i = 1, max
DO j = 1, max
buf(i, j) = i * j

ENDDO
ENDDO
STOP
END
$ gfortran –o ex5c.x ex5c.f90

$ ./ex5c.x

Array (4/5) – Fortran & C Memory 구조의 차이점
FORTRAN Array의 Memory Address 구조 (순서)
Fortran C
INTEGER, DIMENSION(0:2, 0:2) :: a int a[3][3];
Memory
Address
a(0,0) a(0,1) a(0,2) a(0,0) a(0,1) a(0,2)
1000 1012 1024 1000 1004 1008
a(1,0) a(1,1) a(1,2) a(1,0) a(1,1) a(1,2)

1004 1016 1028 1012 1016 1020
a(2,0) a(2,1) a(2,2) a(2,0) a(2,1) a(2,2)

1008 1020 1032 1024 1028 1032
DO i=0, 2
DO j=0, 2 for (i=0; i<3; i++)
a(j, i) = ?
for (j=0; j<3; j++)
END DO
END DO a(i, j) = ?

Example Code
Before After
PROGRAM ex5d_before PROGRAM ex5d_after
IMPLICIT NONE IMPLICIT NONE
INTEGER i, j INTEGER i, j
INTEGER, PARAMETER :: max=10000 INTEGER, PARAMETER :: max=10000
INTEGER, DIMENSION(max, max) :: buf INTEGER, DIMENSION(max, max) :: buf
DO i=1, max DO j=1, max

DO j=1, max DO i=1, max
buf(i, j) = i * j buf(i, j) = i * j
! WRITE(*, *) 'buf(', i, ',', j, ') = ', buf(i, j) ! WRITE(*, *) 'buf(', i, ',', j, ') = ‘, & buf(i, j)
ENDDO ENDDO
ENDDO ENDDO
STOP STOP
END END
$ gfortran –o ex5d_before.x ex5d_before.f90 $ gfortran –o ex5d_after.x ex5d_after.f90

$ time ./ex5d_before.x $ time ./ex5d_after.x

Array (5/5) – F90 Array Intrinsic Functions
Array Functions description
ALLOCATED(A) A logical function which indicates if the array is allocated.

( return .TRUE. or .FALSE. )
DOT_PRODUCT(A, Returns the dot product of the elements in the array A and B
B)
MAXVAL(A) Returns the largest value in the array A
MAXLOC(A) Returns the location(index) of largest value in the array A
MINVAL(A) Returns the smallest value in the array A
MINLOC(A) Returns the location(index) of smallest value in the array A
PRODUCT(A) Returns the product of all the elements in the array A
SIZE(A) A function which returns the number of elements in an array A
SUM(A) Returns the sum of all the elements in the array A

Data 문 (1/2)
변수나 배열요소에 초기치 부여

– 지정문과 같은 효과를 가지며 다수의 초기치를 한 줄로 부여
DATA nlist /clist/, nlist /clist/ …..
– nlist : 변수명,배열명,
– clist : nlist에 기억시킬 숫자나 문자, 논리 상수 리스트
DATA문 사용의 규칙
– DATA문은 선언문 뒤에, 최초의 실행문 보다 앞에 와야 한다.
– nlist의 항목수는 clist의 항목수와 일치 : 일대일 대응
• clist의 type은 nlist항목의 type형태로 변환되어 입력된다.
• nlist중의 어떤 항목의 형이 문자형이나 논리형인 경우는 clist도 같은 형
이어야 한다.

Data 문 (2/2)
Example
A = 10.5
B = 21.3
C = ‘IN’
D ATA A / 1 0 . 5 / , B / 2 1 . 3 / , C / ’ I N ’ / or
D ATA A , B , C / 1 0 . 5 , 2 1 . 3 , ’ I N ’ /
DIMENSION a(5)
D ATA a / 1 . 0 , 2 . 0 , 3 . 0 , 4 . 0 , 5 . 0 /
DIMENSION b(10)
D ATA b / 5 * 1 2 . 0 , 5 * 2 1 . 0 /
DIMENSION d(5)
D ATA d ( 2 ) , d ( 3 ) , ( d ( i ) , i = 4 , 5 ) / 11 . 0 , 2 2 . 0 , 3 3 . 0 , 4 4 . 0 /

Allocatable Array – F90
가변할당 배열 (Allocatable Array) C/C++의
malloc(),
REAL, DIMENSION(:, :), ALLOCABABLE :: buf free()
ALLOCATE(buf(10, 10)) ! allocate memory

...
DEALLOCATE(buf) ! free memory
– 배열의 사이즈를 컴파일 하는 동안 할당하는 대신에 실행도중에 할당
– 필요한 크기만큼 메모리를 할당해서 메모리 낭비를 방지
REAL, TARGET :: B(100,100) ! 배열 B는 target 속성을 가진다.

REAL, POINTER :: U(:,:),V(:) ! 포인터 배열 선언
....
U => B ! U는 B를 aliasing
….

Example Code
Fortran90
PROGRAM ex5e_dyalc
IMPLICIT NONE
INTEGER i, j
INTEGER, PARAMETER :: max = 50000
INTEGER, ALLOCATABLE, DIMENSION(:, :) :: buf
ALLOCATE(buf(max, max))
DO j = 1, max
DO i = 1, max
buf(i, j) = i * j
ENDDO
ENDDO
DEALLOCATE(buf)
END
$ gfortran –o ex5e_dyalc.x ex5e_dyalc.f90

$ ./ex5e_dyalc.x

Example Code
Fortran90
PROGRAM ex5f_pointer
IMPLICIT NONE
REAL, POINTER :: ptr1

REAL, TARGET :: num = 3.0
REAL, DIMENSION(:), POINTER :: ptr2
REAL, DIMENSION(3), TARGET :: b
b = (/1.0, 2.0, 3.0/) ! b(1) = 1.0; b(2) = 2.0; b(3) = 3.0
ptr1 => num

ptr2 => b
PRINT *, 'num =', num

PRINT *, 'ptr1 =', ptr1
PRINT *, 'b(1)=', b(1), 'b(2)=', b(2), 'b(3)=', b(3)

PRINT *, 'ptr2 =', ptr2(1), ptr2(2), ptr2(3)
PRINT *, 'size of b(3) is', size(b)
PRINT *, 'sum of b(3) is', sum(b)
STOP
END
$ gfortran -o ex5f_pointer.x ex5f_pointer.f90
$ ./ex5f_pointer.x

etc.
Implied DO, where construct
2014-04-14
Implied DO
DO 문의 간략화
A(5)
WRITE(*,*) (a(i), i=1, 5, 1)
READ(*,*) (a(i), i=1, 5)
– 입출력문의 반복 수행할 때 DO문에 관련된 응용 명령문

Where Construct
Where 구문
where (expression)
statements
elsewhere ! optional...
statements
end where
– 논리배열식의 값에 따라 배열에 값을 할당하는데 사용한다.

Example Code
Reverse Array
PROGRAM Reverse
IMPLICIT NONE
INTEGER, PARAMETER :: SIZE = 30 ! maximum array size
INTEGER, DIMENSION(1:SIZE) :: a ! input array
INTEGER :: Head, Tail ! pointer moving forward and backward
INTEGER :: Temp, i, n
READ(*,*) n ! read in the input array
READ(*,*) (a(i), i = 1, n)
WRITE(*,*) "Input array:" ! display the input array
WRITE(*,*) (a(i), i = 1, n)
Head = 1 ; Tail = n ! start with the beginning and with the end
DO ! for each pair...
IF (Head >= Tail) EXIT ! if Head crosses Tail, exit
Temp = a(Head) ! otherwise, swap them
a(Head) = a(Tail) ; a(Tail) = Temp
Head = Head + 1 ! move forward
Tail = Tail - 1 ! move backward
END DO ! loop back
WRITE(*,*) ! display the result
WRITE(*,*) "Reversed array:"
WRITE(*,*) (a(i), i = 1, n)
END PROGRAM Reversed

$ gfortran -o ex_reverse.x ex_reverse.f90
$ ./ex_reverse.x

Example Code
Array Operation
PROGRAM ARRAY2 AVERAGE=CSUM/8
IMPLICIT NONE WRITE(*,'(//,'' RESULTS FOR ELEMENTS 2 THROUGH 9
OF C'')')
INTEGER I,J WRITE(6,2002)AVERAGE,CMIN,CMAX
REAL, DIMENSION (10) :: A=(/(J,J=1,10)/), B, C 2002 FORMAT(' AVERAGE OF SELECTED ELEMENTS IN C =
REAL CSUM,CMAX,CMIN,AVERAGE ', F8.3,/,' MINIMUM OF SELECTED ELEMENTS IN C = ',
F8.3,/, &
DATA B/3*1.,4*2.,3*3./ ' MAXIMUM OF SELECTED ELEMENTS IN C = ', F8.3)
C=A+B WRITE(6,2003) C(2:9)
CSUM=SUM(C) ; CMIN=MINVAL(C) ; CMAX=MAXVAL(C) 2003 FORMAT(' C = ',/,(1P,8E10.2))
AVERAGE=CSUM/10
A(4)=-1.0
WRITE(*,*) ' RESULTS FOR FULL C ARRAY' WHERE (A.GT.0)
WRITE(6,2000)AVERAGE,CMIN,CMAX C=LOG(A)
2000 FORMAT(' AVERAGE OF ALL ELEMENTS IN C = ', ELSE WHERE
F8.3,/,' MINIMUM OF ALL ELEMENTS IN C = ', F8.3,/, & C=0.
' MAXIMUM OF ALL ELEMENTS IN C = ', F8.3) END WHERE
WRITE(6,2001) C
PRINT *
2001 FORMAT(' C = ',/,(8E10.2)) WRITE(6,*) ' RESULTS OF LOG(A)'
C(1)=0. ; C(10)=0. WRITE(6,2004) C
C(2:9)=A(2:9)+B(2:9) 2004 FORMAT(' C = ',/,(1P,8E10.2))
CSUM=SUM(C(2:9)) STOP
CMIN=MINVAL(C(2:9)) END
gfortran -o arr_op.x arr_op.f90

./arr_op.x

07. Subprogram
Subprogram
2014-04-14
Subprogram (1/3)
Subprogram
– 반복되는 동일한 명령문들의 집단
– 별개의 프로그램 단위로 작성하여 호출
• 전체 프로그램의 간소화
• 다른 프로그램에서 공동으로 사용 가능
• 독립적 컴파일에 따른 에러의 수정이 쉽다
• 대규모 프로젝트에 적합(여러 사람의 참여 가능)
• 무리한 subprogram의 사용은 코드의 성능저하를 가져올 수 있다.

subroutine
subprogram library function
function statement function

User defined function
function

Subprogram (2/3)
Subroutine & Function
Subroutine Function
호출 호출문(call) Function명에 의해 호출
인수 필요한 경우 사용 한개 이상의 인수 반드시 필요
function명에 실어 단 한 개만을
처리된 결과 여러 인수에 실어 return
return
서브루틴명은 수식에 사용 불가 프로그램의 수식에서 변수처럼 사

기타
변수와 같이 이용할 수 없음 용가능

Subprogram (3/3)
Subroutine & function
Subroutine Function
INTEGER :: m = 1, n = 2 INTEGER :: m = 1, n = 2, total, myadd
CALL SWAP(m, n)
total = myadd(m, n)
SUBROUTINE SWAP(a, b)
INTEGER FUNCTION myadd (a, b)
INTEGER a, b
INTEGER a, b
INTEGER c
myadd = a + b
c=a
a=b
RETURN
b=c
END
RETURN
END

Intrinsic Function (1/2)
Math Function
Mathematical
Name Meaning e.g.
expression
Sine,cosine,
SIN, COS, TAN
tangent
Y=SIN(X) y = sin x
SQRT 제곱근 Y=SQRT(X) y= x
MOD 나머지 X=MOD(A,B)
EXP 지수 Y=EXP(X) y= x
ABS,IABS 절대값 Y=ABS(X)
ALOG 자연대수 Y=ALOG(X) y = ln x

ALOG10 상용대수 Y=ALOG10(X) y = log x

Intrinsic Function (2/2)
Transform Function
Name Meaning e.g. 비고
INT 실수 -> 정수 K=INT(X) 실수 X를 정수로 변환
REAL 정수 -> 실수 Y=REAL(J) 정수 J를 실수로 변환
FLOAT 정수 -> 실수 Y=FLOAT(J) 정수 J를 실수로 변환
DBLE 정수 -> 실수 Y=DLBE(J) 정수 J를 실수로 변환
ICHAR 문자 -> 정수 K=ICHAR(C) 문자 C를 정수로 변환
CHAR 정수 -> 문자 C=CHAR(K) 정수 K를 문자로 변환
MOD 나머지 Y=MOD(X,Y) X를 Y로 나눈 나머지
MAX (MIN) 최대(최소) j=MAX(i1,i2,i3) i1,i2,i3 중 최대값( 최소값)
FLOOR 가까운정수 FLOOR(x) X에 가장 가까운 정수

Common 문
전역변수(Global) 자료전달
– 함수의 인자가 많은 경우 사용, 메모리 낭비를 방지 (메모리 공유)
– 최초의 실행문 보다 앞에 위치해야 함
– 같은 변수 이름을 사용 하는 것이 편리하고, 같은 타입을 사용해야 함
PROGRAM ex6a_f77_common
INTEGER bufsize, n
PARAMETER (bufsize=10)
REAL a(bufsize, bufsize)
COMMON /apple/ a, n, bufsize
…
END
SUBROUTINE sub(…)
INTEGER bufsize, n
PARAMETER (bufsize=10)
REAL a(bufsize, bufsize)
COMMON /apple/ a, n, bufsize
..
END SUBROUTINE

Example Code – (1/2)
Fortran90
PROGRAM ex6a_subroutine tmp = c
c=d
IMPLICIT NONE d = tmp
INTEGER a, b END SUBROUTINE

COMMON a, b
a=1
b=2
WRITE(*, 100) 'Before swap: ', a, b

100 FORMAT(A, I2, I2)
CALL swap
WRITE(*, 100) 'After swap: ', a, b

END
SUBROUTINE swap
INTEGER c, d
INTEGER tmp
COMMON c, d
$ gfortran -o ex6a_subroutine.x ex6a_subroutine.f90

$ ./ex6a_subroutine.x

Fortran90
PROGRAM ex6b_function
IMPLICIT NONE
INTEGER :: a = 1, b = 2, myadd
INTEGER total
total = myadd(a, b)
WRITE (*, *) 'a + b = ', total
END
INTEGER FUNCTION myadd (c, d)

INTEGER c, d
myadd = c + d
RETURN
END
$ gfortran –o ex6b_function.x ex6b_function.f90

$ ./ex6b_function.x

Example Code 2
Fortran90
PROGRAM ex6c_function
IMPLICIT NONE
INTEGER :: a = 1, b = 2, myadd, added_op

INTEGER total,total2
total = myadd(a, b)
WRITE (*, *) 'a + b = ', total
total2 = added_op(myadd, b)
write (*,*) 'a + b + b = ', total2
END
FUNCTION myadd(c, d)
INTEGER c, d
integer myadd
myadd = c + d
END function
function added_op(a,b)
integer a,b,added_op
added_op = a(1,2)+b
end function
$ gfortran –o ex6b_function.x ex6b_function.f90
$ ./ex6b_function.x

Modules
관련된 Subprograms을 함께 묶어서 사용
– 형 선언, Subprogram, 새로운 데이터 형의 정의를 함께 묶음
– USE 문으로 Module을 선언부의 시작에 추가해서 사용
– 다른 프로그램에서 모듈을 재사용
– 모듈을 수정하지 않았을 경우 기존에 컴파일된 파일를 재사용

! MODULE EXAM - SUBPROGRAM !USING MODULE
MODULE ModuleName
USE ModuleName
CONTAINS
Subprogram 1 USE ModuleName, ONLY : List
Subprogram 2
…
Subprogram n
END MODULE ModuleName

Modules
INTENT Attribute
프로시저 내의 인수들에 대한 이용 계획 명시
– 효율적인 컴파일, 프로그램 안전성 증가
– in, out, inout
• INTENT(in) : 들어와서 나갈 때까지 값의 변화가 없는 인수
• INTENT(out) : 값을 새로 할당 받을 때까지 사용되지 않는 인수
• INTENT(inout) : 프로시저에 들어와 사용되고 값을 새로 할당 받아

그 결과를 호출한 프로그램에 되돌려 주는 인수

temp_conversion_1.f90
PROGRAM Temp_Conversion_1 "More temperature to convert(Y or N)?:"
READ *, Response
IMPLICIT NONE IF (Response /="Y") EXIT
REAL :: F_Temp, C_Temp END DO
CHARACTER(1) :: Response
CONTAINS
DO FUNCTION Fahr_to_Celsius(Temp)
! Get a Fahrenheit temperature REAL :: Fahr_to_Celsius
WRITE (*, '(1X, A) ', ADVANCE = "NO") & REAL, INTENT(IN) :: Temp
"Enter a Fahrenheit temperature:"
READ *, F_Temp Fahr_to_Celsius = (Temp - 32.0) / 1.8
END FUNCTION Fahr_to_Celsius
!Use the function Fahr_to_Celsius to convert it to Celsius
C_Temp = Fahr_to_Celsius(F_Temp) END PROGRAM Temp_Conversion_1
! Output the result

PRINT '(1X, 2(F6.2, A))', F_Temp, &
" in Fahrenheit is equivalent to ", C_Temp, " in Celsius"
WRITE (*, '(1X, A) ', ADVANCE = "NO") &
gfortran -o temp_conversion_1.x temp_conversion_1.f90

./temp_conversion_1.x

temp_conversion_2.f90 Temperature_Library.f90
PROGRAM Temp_Conversion_2 MODULE Temperature_Library
USE Temperature_Library IMPLICIT NONE
IMPLICIT NONE CONTAINS

REAL :: F_Temp, C_Temp ! Function to convert a Fahrenheit temperature to Celsius.
CHARACTER(1) :: Response FUNCTION Fahr_to_Celsius(Temp)
REAL::Fahr_to_Celsius
! Get a Fahrenheit temperature REAL, INTENT(IN) :: Temp
"Enter a Fahrenheit temperature:" Fahr_to_Celsius = (Temp - 32.0) / 1.8
READ *, F_Temp END FUNCTION Fahr_to_Celsius
!Use the function Fahr_to_Celsius to convert it to Celsius ! Function to convert a Celsius temperature to Fahrenheit.
C_Temp = Fahr_to_Celsius(F_Temp) Function Celsius_to_Fahr(Temp)
REAL::Celsius_to_Fahr
! Output the result REAL, INTENT(IN) :: Temp
PRINT '(1X, 2(F6.2, A))', F_Temp, &
" in Fahrenheit is equivalent to ", C_Temp, " in Celsius" Celsius_to_Fahr = 1.8 * Temp + 32.0
END FUNCTION Celsius_to_Fahr
END PROGRAM Temp_Conversion_2 END MODULE Temperature_Library
gfortran -c Temperature_Library.f90 ( Temperature_Library.mod , Temperature_Library.o )

gfortran -o temp_conversion_2.x temp_conversion_2.f90 Temperature_Library.o
./temp_conversion_2.x

Module [Compile & Link Process]
Program Program
Source Fortran 90 Object
File Compiler File
Program
Executable
Linker
File
Module Module
Source Fortran 90 Object
File Compiler File

Recursion
재귀 호출
– 프로시저가 직간접적으로 자기 자신 호출
– Fortran90에서 명시적으로 지원
– 재귀 호출 프로시저는 RECURSIVE로 선언
• recursion 함수는 RESULT로 선언된 변수를 통해 반환
I N T E G E R R E C U R S I V E F U N C T I O N f a c t ( n ) R E S U LT ( n _ f a c t )
R E C U R S I V E I N T E G E R F U N C T I O N f a c t ( n ) R E S U LT ( n _ f a c t )
R E C U R S I V E F U N C T I O N f a c t ( n ) R E S U LT ( n _ f a c t )
INTEGER :: n_fact

Recursion
재귀 호출
– Subprogram에서 자기 자신을 호출하는 Subprogram
Factorial(5) n Fact
5 120
= n * Factorial(n - 1) 120
Factorial(4) n Fact
= n * Factorial(n - 1)
4 24
n Fact
Factorial(3) = n * Factorial(n - 1)
3 6
n Fact
2 2
n Fact
1 1
Factorial(0) n Fact
=1
0 1

Example Code
factorial_recursive.f90
PROGRAM Factorial_recursive READ *, Response
IF (Response /="Y") EXIT
IMPLICIT NONE END DO
INTEGER :: Fact, Res
CHARACTER(1) :: Response CONTAINS
RECURSIVE FUNCTION Factorial(n) RESULT(Fact)
DO INTEGER :: Fact
WRITE (*,'(1X, A)',ADVANCE = "NO") & INTEGER, INTENT(IN) :: n
"Enter the Factorial Number : "
READ *, Fact IF (n==0) THEN
Fact = 1
Res = Factorial(Fact) ELSE
Fact = n * Factorial(n-1)
PRINT *, "Factorial Number(", Fact, ") : ",Res END IF
END FUNCTION Factorial
"More temperature to convert(Y or N)?:" END PROGRAM Factorial_recursive
gfortran -o factorial_recursive.x factorial_recursive.f90

./factorial_recursive.x

08. File I/O
File I/O
2014-04-14
Input / Output (1/4)
I/O statements
– Line단위의 입출력
READ(UNIT=n,FMT=f,END=label,ERR=label) input data-list

WRITE(UNIT=n,FMT=f,END=label,ERR=label) output data-list
• UNIT = 정수형 : 특정 장치에 의한 입/출력

– * : 컴파일러 지정 표준장치(키보드/모니터)
– 5 표준입력(Standard Input), 6 표준출력(Standard Output)
• FMT = Format부호(생략가능)
– * : 자유형식에 의한 입/출력, 데이터 사이 구분을 위해 ,나 빈칸
• Error및 파일끝부호(생략가능)
– ERR : 실행중 오류발생시 지정된 문 번호로 실행 이동
– END : 입력파일의 마지막까지 다 읽은 경우 지정된 문 번호로 이동

파일 입출력 (File I/O)
– Line단위의 입출력
OPEN(UNIT=12,FILE=“MY.TXT”,STATUS=“OLD”,ACTION=“READ”,
POSITION=“REWIND”,IOSTAT=status)
• UNIT : 정수형 (9 ~ 99), 중복되지 않은 숫자

• FILE : 파일이름
• STATUS : NEW(신규생성), OLD(기존파일사용),
REPLACE(NEW+OLD)
• ACTION : READ, WRITE, READWRITE(일반적)
• POSITION : REWIND(시작점), APPEND(끝점), ASIS(원래의 위치)
• IOSTAT : 0 – Successful Open, Not 0 - Error

CLOSE(UNIT=12)

Example
Input/Output
READ(*,*) A,B,C
READ(UNIT=5,FMT=*,ERR=50,END=70) A,B,C
READ *, A,B,C
READ(5,10) A,B,C
10 FORMAT(1X,3I4)
READ(5,’(1X,3I4)’) A,B,C
WRITE(*,*) A,B,C
WRITE(6,30) A+X,B+Y,C+Z
WRITE(6,*) ‘THE VALUE OF THE OUTPUT’, A,B,C

Example Code (3/4)
Fortran90
PROGRAM ex7a_read
IMPLICIT NONE
REAL A, B, C
WRITE(*, *) 'Please input A, B, C : ex) 1.1 2.2 3.3'
READ(*, *) A, B, C
WRITE(*, 10) A, B, C
10 FORMAT(F4.1, F5.2, F6.3)
STOP
END
$ gfortran –o ex7a_read.x ex7a_read.f90

$ ./ex7a_read.x

Example Code (4/4)
Fortran90
PROGRAM ex7b_fileio 100 FORMAT(3(F10.4))
IMPLICIT NONE
DO i=1, n
INTEGER, PARAMETER :: nmax = 1000 WRITE(*, 200) x(i), y(i), z(i)
INTEGER n, i WRITE(20, 200) x(i), y(i), z(i)
REAL x(nmax), y(nmax), z(nmax) END DO
200 FORMAT(3(F10.4))
! Open the data file
OPEN(10, FILE='points.dat', STATUS='OLD', POSITION='REWIND') WRITE(*,*) '------------------------------'
OPEN(20, FILE='result.dat', STATUS=‘REPLACE') WRITE(20, *) '------------------------------'
READ(10, *) n CLOSE(10)
CLOSE(20)
WRITE(*, *) n 9999 STOP
WRITE(20, *) n END
IF (n > nmax) THEN

WRITE(*, *) 'Error: n = ', 'is larger than nmax =', nmax
GOTO 9999 points.dat
ENDIF
3
DO i=1, n 1.0, 2.0, 3.0
read(10, 100) x(i), y(i), z(i) 4.0, 5.0, 6.0
ENDDO 7.0, 8.0, 9.0
$ vim points.dat $ ./ex7b_fileio.x

$ gfortran -o ex7b_fileio.x ex7b_fileio.f90 $ cat result.dat

09. Advanced Lab & Summary
Advanced Lab & Summary
2014-04-14
Advanced Lab #1 (1/2)
<Problem>
– Monte carlo simulation
– Random number use
– PI = 4 ⅹAc/As

Advanced Lab #1 (2/2)
PROGRAM PI_MC SUBROUTINE INIT_RANDOM_SEED()
IMPLICIT NONE
IMPLICIT NONE
INTEGER :: i, scope = 10000000
REAL :: x, y, z, pi, z1, in_count = 0.0, out_count = 0.0 INTEGER :: i, n, clock
INTEGER, DIMENSION(:), ALLOCATABLE :: seed
! Get Random
CALL INIT_RANDOM_SEED() CALL RANDOM_SEED(size = n)
ALLOCATE(seed(n))
DO i=0, scope-1
CALL RANDOM_NUMBER(x)
CALL RANDOM_NUMBER(y) CALL SYSTEM_CLOCK(COUNT=clock)
z=x*x+ y*y seed = clock + 37 * (/ (i - 1, i = 1, n) /)

z1 = SQRT(z)
CALL RANDOM_SEED(PUT = seed)
IF (z1 <= 1) THEN
in_count = in_count + 1
ELSE DEALLOCATE(seed)
out_count = out_count + 1 END SUBROUTINE
ENDIF
ENDDO
pi = (4 * in_count) / (in_count + out_count)

WRITE (*, '(A, F15.10)') 'PI = ', pi
END

Advanced Lab #2 (1/3) - Array
PROGRAM SCORE DO i=1, nTotal
IMPLICIT NONE DO j=1, nTotal
IF (total(i) .EQ. total(rank(j))) THEN
INTEGER kor(10), eng(10), matt(10), total(10), & trank(i) = j
END IF
rank(10), trank(10)
ENDDO
REAL ave(10)
INTEGER :: i, j, getTotal, nTotal IF (ave(i) .GE. 90) THEN
CHARACTER grade(10) grade(i) = 'A'
ELSE IF (ave(i) .GE. 80) THEN
grade(i) = 'B'
OPEN(20, FILE='score.dat', STATUS='OLD')
ELSE IF (ave(i) .GE. 70) THEN
grade(i) = 'C'
READ(20, *) nTotal ELSE
grade(i) = 'F'
DO i=1, nTotal ENDIF
READ(20, *) kor(i), eng(i), matt(i) ENDDO
!total(i) = kor(i) + eng(i) + matt(i)
WRITE(*, *) ' KOR ENG MAT Total Ave Rank Grade'
total(i) = getTotal(kor(i), eng(i), matt(i)) WRITE(*, *) '-------------------------------------------'
ave(i) = total(i) / 3.0 DO i=1, 5
rank(i) = i WRITE(*, 100) kor(i), eng(i), matt(i), total(i), ave(i), &
ENDDO trank(i), grade(i)
ENDDO
100 FORMAT(I5, I5, I5, I5, F6.1, I5, A4);
CALL BubbleSort(total, rank, nTotal)
WRITE(*, *) '-------------------------------------------‘
뒷장에 계속

Advanced Lab #2 (2/3) - Array
CLOSE(20)
END
INTEGER FUNCTION getTotal(k, e, m)

INTEGER k, e, m
Input Data
$ cat score.dat
getTotal = k + e+ m
5
END FUNCTION
70 50 65
89 70 99
SUBROUTINE BubbleSort(t, r, ns)
99 100 85
INTEGER t(*), r(*) ! INTEGER t(10), r(10) 도 같음
91 67 64
INTEGER i, j, c
76 96 60
DO i=1, ns-1
DO j=1, ns-i
IF (t(r(j)) < t(r(j+1))) THEN
c = r(j)
r(j) = r(j+1)
r(j+1) = c
ENDIF
ENDDO
ENDDO
END SUBROUTINE

Advanced Lab #2 (3/3) - Result

Advanced Lab #3 (1/2) – Dynamic Allocation
PROGRAM SCORE_DYNA
DO i=1, nTotal
IMPLICIT NONE READ(20, *) kor(i), eng(i), matt(i)
!total(i) = kor(i) + eng(i) + matt(i)
INTEGER, ALLOCATABLE, DIMENSION (:) :: kor, eng, & total(i) = getTotal(kor(i), eng(i), matt(i))
ave(i) = total(i) / 3.0
matt, total, rank, trank rank(i) = i
CHARACTER, ALLOCATABLE, DIMENSION (:) :: grade ENDDO
REAL, ALLOCATABLE, DIMENSION (:) :: ave
CALL BubbleSort(total, rank, nTotal)
INTEGER :: i, j, getTotal, nTotal
DO i=1, nTotal
OPEN(20, FILE='score.dat', STATUS='OLD') DO j=1, nTotal
READ(20, *) nTotal IF (total(i) .EQ. total(rank(j))) THEN
trank(i) = j
END IF
ALLOCATE(kor(nTotal))
ENDDO
ALLOCATE(eng(nTotal))
ALLOCATE(matt(nTotal)) IF (ave(i) .GE. 90) THEN
ALLOCATE(total(nTotal)) grade(i) = 'A'
ALLOCATE(rank(nTotal)) ELSE IF (ave(i) .GE. 80) THEN
ALLOCATE(trank(nTotal)) grade(i) = 'B'
ALLOCATE(ave(nTotal)) ELSE IF (ave(i) .GE. 70) THEN
grade(i) = 'C'
ALLOCATE (grade(nTotal))
ELSE
grade(i) = 'F'
ENDIF
ENDDO

Advanced Lab #3 (2/2) – Dynamic Allocation
WRITE(*, *) ' KOR ENG MAT Total Ave Rank Grade' INTEGER FUNCTION getTotal(k, e, m)
WRITE(*, *) '-------------------------------------------' INTEGER k, e, m
DO i=1, nTotal
WRITE(*, 100) kor(i), eng(i), matt(i), total(i), ave(i), & getTotal = k + e+ m
trank(i), grade(i) END FUNCTION
ENDDO
SUBROUTINE BubbleSort(t, r, ns)
INTEGER t(*), r(*) ! INTEGER t(10), r(10) 도 같음
100 FORMAT(I5, I5, I5, I5, F6.1, I5, A4);
INTEGER i, j, c
WRITE(*, *) '-------------------------------------------'
DO i=1, ns-1
DEALLOCATE(kor)
DO j=1, ns-i
DEALLOCATE(eng)
IF (t(r(j)) < t(r(j+1))) THEN
DEALLOCATE(matt)
c = r(j)
DEALLOCATE(total)
r(j) = r(j+1)
DEALLOCATE(rank)
r(j+1) = c Input Data
DEALLOCATE(trank)
ENDIF
DEALLOCATE(ave)
ENDDO $ cat score.dat
DEALLOCATE(grade)
ENDDO 5
END SUBROUTINE 70 50 65
CLOSE(20)
89 70 99
END
99 100 85
91 67 64
76 96 60

Advanced Lab #4 (1/4) Array Function - Norm
PROGRAM array_func_norm
IMPLICIT NONE
INTEGER, PARAMETER :: NumItems = 5
REAL, DIMENSION(NumItems) :: A
A = (/1,2,3,4,5/)
!A = (/I,I=1,5/)
PRINT '(1X, "Array A = (", 5F6.2 ,")")' , A(:)

PRINT '(1X, "Norm of the array A is", F6.2)', Norm(A,NumItems)
CONTAINS
FUNCTION Norm(A, N)
INTEGER, INTENT(IN) :: N
REAL, DIMENSION(N), INTENT(IN) :: A
REAL :: Norm
Norm = SQRT(SUM(A*A))
Using Array Intrinsic
END FUNCTION Norm functions
1 + 2 + ⋯ +
END PROGRAM array_func_norm

Advanced Lab #4 (2/4) Array Function - Dot Product
PROGRAM array_func_dot
IMPLICIT NONE
REAL, DIMENSION(NumItems) :: A, B
A = (/1,2,3,4,5/)
B = (/1,2,3,4,5/)
PRINT '(1X, "Dot Product define function : ", F6.2)', DOT(A,B,NumItems)
PRINT '(1X, "Dot Product array function : ", F6.2)', DOT_PRODUCT(A,B)
CONTAINS
FUNCTION DOT(A,B,N)
INTEGER i
INTEGER, INTENT(IN) :: N
REAL, DIMENSION(N), INTENT(IN) :: A, B
REAL :: DOT = 0
DO i = 1, N
DOT = DOT + A(i) * B(i)
END DO
END FUNCTION DOT
END PROGRAM array_func_dot

Advanced Lab #4 (3/4) Array Function - Mean 1
PROGRAM array_func_mean1
IMPLICIT NONE
REAL, DIMENSION(NumItems) :: A
A = (/1,2,3,4,5/)
!A = (/I,I=1,5/)
PRINT '(1X, "Array A = (", 5F6.2 ,")")' , A(:)

PRINT '(1X, "Mean of the array A is", F6.2)',Mean(A)
CONTAINS
FUNCTION Mean(X)
INTEGER, PARAMETER :: NumElements = 5

REAL, DIMENSION(NumElements), INTENT(IN) :: X
REAL :: Mean
Mean = SUM(X) / REAL(NumElements)
END FUNCTION Mean
END PROGRAM array_func_mean1

Advanced Lab #4 (4/4) Array Function - Mean 2
PROGRAM array_func_mean2
IMPLICIT NONE
REAL, DIMENSION(:), ALLOCATABLE :: Item
INTEGER :: NumItems
WRITE (*, '(1X, A)', ADVANCE = 'NO') "How many numbers are in the data set?"
READ *, NumItems
ALLOCATE(Item(NumItems))
PRINT *, "Enter the", NumItems, "real numbers:"

READ *, Item
PRINT '(1X, "Mean of the ", I3, " Numbers is ", F6.2)', NumItems, Mean(Item)
DEALLOCATE(Item)
CONTAINS
FUNCTION Mean(X)
REAL :: Mean
REAL, DIMENSION(:), INTENT(IN) :: X
Mean = SUM(X) / REAL(SIZE(X))
END FUNCTION Mean
END PROGRAM array_func_mean2

How does beginner make a good program?
1. 수많은 다른 좋은 코드를 이해하고, 가능하면 암기한다

– 눈으로 코딩 하지 말고, 손가락으로 코딩 한다
– 바둑의 시작은 정석을 많이 암기하는 것이다
2. 잘 구현된 코드(함수)는 직접 만들려고 하지 말고 가져다가 쓴다
3. Syntax에 너무 치우치지 말고, 프로그램을 만드는 것 에 중점을 둔다
4. 많은 코드를 작성해본 경험이 증가할수록 실력이 는다

– 다른 사람이 개발한 공개된 소스코드를 분석해서 자기 것으로 만든다
5. 랭귀지 바이블이라고 하는 책 1권 정도는 옆에 둔다
6. 프로그래밍에도 유행이 있다 시대의 흐름을 탄다

– 일반적인 방법론을 따른다 독불장군이 되지 말라

Fortran Training Course - V20140411 - 2day

Uploaded by

Copyright:

Available Formats

Fortran Training Course - V20140411 - 2day

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Fortran Training Course - V20140411 - 2day

Uploaded by

Copyright:

Available Formats

KISTI Supercomputing Center

SUPERCOMPUTING EDUCATION CENTER 1

09:30 - 10:30 Environment Setup

10:30 - 10:40 Break

10:40 - 12:00 Fortran Introduction

12:00 - 13:30 Lunch

13:30 - 14:50 Derived Data Type

14:50 - 15:00 Break

15:00 - 16:30 Array

SUPERCOMPUTING EDUCATION CENTER 2

10:30 - 10:40 Break

10:40 - 12:00 Module

12:00 - 13:30 Lunch

13:30 - 14:40 Recursive

14:40 - 14:50 Break

14:50 - 16:30 Advanced Lab

Summary & Closing

SUPERCOMPUTING EDUCATION CENTER 3

SUPERCOMPUTING EDUCATION CENTER 6

SUPERCOMPUTING EDUCATION CENTER 7

SUPERCOMPUTING EDUCATION CENTER 8

SUPERCOMPUTING EDUCATION CENTER 9

SUPERCOMPUTING EDUCATION CENTER 10

SUPERCOMPUTING EDUCATION CENTER 11

Fortran 90 (1991년도 표준제정, 가장 널리 사용됨)

SUPERCOMPUTING EDUCATION CENTER 13

쉽고 간단한 문법과 명령어

다양한 프로그램 라이브러리 지원

SUPERCOMPUTING EDUCATION CENTER 14

WRITE (*, *) ‘Hello, World’

STOP ! [STOP] is optional

END PROGRAM HELLO ! [PROGRAM] [hello] is optional

$ gfortran –o hello.x hello.f90

SUPERCOMPUTING EDUCATION CENTER 15

Basic Fortran Grammar

1 2~5 6 7~72 73~80

9 9999 FORMAT(‘Answer =‘,I4)

SUPERCOMPUTING EDUCATION CENTER 18

동적 메모리 기능 없음 (Fortran90 에서 가능)

사용자 정의 자료구조 불가능

함수(루틴)의 재귀적 호출(Recursive) 불가능 (Factorial)

COMMON 블록, EQUIVALENCE 문 등의 불안정성

SUPERCOMPUTING EDUCATION CENTER 19

SUPERCOMPUTING EDUCATION CENTER 20

C This is a Fortran 77 Style 컬럼표시 PROGRAM ex2_f90

$ gfortran –o ex2_f77.x ex2_f77.f $ gfortran –o ex2_f90.x ex2_f90.f90

SUPERCOMPUTING EDUCATION CENTER 21

SUPERCOMPUTING EDUCATION CENTER 22

SUPERCOMPUTING EDUCATION CENTER 23

SUPERCOMPUTING EDUCATION CENTER 24

REAL :: tx, ty, tz ! Trailing statements

tx=1.0 ; ty=2.0 ; tz=tx*ty ! Multiple statements

tx,ty,tz ! Continuation symbol on line to be continued

END PROGRAM free_source_form

SUPERCOMPUTING EDUCATION CENTER 25

Integer 정수형 4 Byte 0, 120, -235, +32856

1Byte (문자) ‘A’

Logical 논리형 4 Byte .TRUE. , .FALSE.

WRITE (, ) ‘Hello, World’

WRITE(, ) 'i = ', i

WRITE(, ) 'str = ', str