포트란 95(프로그램언어 1)

작 성 : 신병춘(전남대 병렬계산연구실)

주교재 : 포트란 95 (SaeRon Publishing Co. 임성순 저)

1. 프로그램의 기본사항	2. 상수와 변수	3. 표현식과 할당문
4. 변수의 속성	5. 선택문과 선택구조	6. 순환문과 순환구조
7. 분기문과 실행제어문	8. 입출력문	9. 배열
10. 프로시져	11. 외부파일 연결사용법	12. 여러 가지 예제

0. Fortran 컴파일

1.1 Intel compiler

ifc 소스파일이름
ifc -FR 소스파일이름
ifc -FR -o 실행파일이름 소스파일이름
In .bashrc, add " alias f90='ifc -FR' "
f90 소스파일이름
f90 -o 실행파일이름 소스파일이름

Chapter 1. 프로그램의 기본사항

1.1 사용문자

1) 영문자(26개)

a b c ... z A B C ... Z
대문자 소문자 구분이 없음

2) 아라비아 숫자(10개)

0 1 2 3 4 ... 9

3) 특수문자(22개)

공백(blank) = + - * / ( ) . , ' " ! $ : ; % & < > ? \
' => 문자형 변수값 지정이나 입출력의 서식문에 사용
" => 특정 문자자료값들을 인용하는 입출력의 서식문에서 사용
! => 감탄부호이후의 문자들은 설명문
: => 배열의 베이스 및 증분량 표시
     REAL :: a(-1:3:2, 1:2)
; => 한 줄에 여러 개의 명령어나 표현식을 작성할 때
     a=3; b=4; c=5;
% => 사용자 정의의 변수형 선언구조 즉, 파생형에서 변수속의 자료값에 접근할 때
& => 연속 기호로써 표현식이나 서식문 등을 한 줄에 작성하기에 너무 길 떄
     Print *, 'Department of Mathematics,&
                 &Chonnam National University'
     Print *, 'Department of Mathematics,&
                 & Chonnam National University'

(혼용 사용문자)

== just equal to 좌우변 자료값이 같음
/= not equal to 좌우변 자료값이 서로 정확히 틀림
>= greater than or equal to
<= less than or equa to
** double asterisk 거듭제곱
// concatennation 연속된 문자자료값을 덧붙여 합성함

예) 문자형 변수 a='Fortran', b='Language'
d=a//' '//b// => d='Fortran Language'

:: double colon 변수속성과 변수목록을 구별
REAL, DIMENSION(3,2) :: a, b, c
4) 기타(1개)

_ (underscore)

1.2 프로그램 구성

모듈 선언부분 (Module)

주 프로그램 (Program)

내부 부 프로그램(Subroutine)

외부 부 프로그램(Subroutine)

예제) See ch1_1.f

1.4 프로그램 형식

1) 자유형식(Free Form) : Fortran 90/95

고정형식 : Fortran 77 ( See ch1_fixed.f )
F77 => 7~72 칼럼사이에 명령문 작성
자유형식 : Fortran 90 / 95 ( See ch1_free.f )

2) 구조화 프로그래밍 : 독립된 프로시져로 확실히 구분

구조의 종류	구조의 시작	구조의 끝
프로시져 구조	Program username	End [Program [username]]
	Subroutine username	End [Subroutine [username]]
	Function username	End [Function [username]]
	Module username	End [Module [username]]
	Block Data username	End [Block Data [username]]
변수선언구조	Type username	End Type username
선택구조	If-Then-Elseif-Then-Else-Endif	End If
순환구조	Do Loop, Do While, Forall	End Do

Username 은 31개 이내의 글자를 이용, [ ]은 생략가능

변수형 선언구조 :

정수형(Integer), 실수형(Real), 복소수형(Complex),
문자형(Character), 논리형(Logical)

모듈 프로시저 주조 : 프로그램에서 사용할 변수, 배열 및 프로서저의 형식을 선언

파생형 변수군 선언구조

여러 개의 기본적인 변수형 선언문을 이용하여 변수 속에 변수를 가진 다층화된
새로운 변수, 즉 기본적인 변수형으로 부를 수 없는 복합적인 변수를 구성
See Ch1_type.f

Program MainProcedure
Implicit None
선언문

   Type Usertype
      Implicit None
      기본적인 변수형 선언
       ...
  End Type usertype

  Type(usertype) :: 변수명 ...
  기타 선언문 ...
  실행문 ...

End Program MainProcedure

선택구조

간단한 IF 문	블록 IF 문	Select Case 문
If (Cond) Statement	If (Cond1) Then Statement1 Else If (Cond2) Then Statement2 Else Statement3 Endif	Select Case (Selector) Case (Expression1) Statement1 Case (Expression2) Statement2 ..... End Select
Condition 이 참이면 Statement 실행		Selector 의 자료값이 Expression이면 Statement 실행
Program Main ! ( Ch1_if.f ) Implicit None Integer :: month, days 10 Print , 'Type a month ? ' Read , month If (month == 0) go to 10 ! 간단한 if문 If (month==1) Then ; days=31 Else If (month==2) Then ; days=29 Else If (month==3) Then ; days=31 Else If (month==4) Then ; days=30 Else ; Stop ! program STOP Endif Print *, 'Month : Days ', month, days Go To 10 End Program Main		Program MainProcedure ! (Ch1_select.f) Implicit None Intrinsic Modulo ! Intrinsic 내장함수나 내장프로시져 선언 Integer :: year, month, days 10 Print , ' Type year and month ? ' Read , year, month If (year <= 0) Stop ! Program Stop Select Case (month) Case (4,6,9,11) days=30 Case (2) If (Modulo(year,4)==0) Then days=29 Else days=28 Endif Case Default days=31 End Select Print *, "The number of days in month :",& &month, ' is ', days Go To 10 End Program MainProcedure

순환구조

Do 순환문	Do While 순환문
[Username :] Do [var = init, limit, incrm] Statement End Do [Username]	[Username :] Do While (Condition) Statement End Do [Username]
Username : 순환구조 이름 + 특수문자 : (필수) var 정수형 변수 init 초기값, limit 최종값, incrm 증분값	Condition 이 참이면 Statement 실행
Ch1_do.f ( Bisection Method 의 예)	Ch1_dowhile.f

Ch1_do.f ( Bisection Method 의 예)

! Bisection Method for f(x)=x^3+4*x^2-10 = 0

Program MainProcedure
   Implicit None
   Integer :: i, maxit
   Real(kind=16) :: a,b,x,p,fa,fb,fp,tol,f
   f(x)=(x+4)*x*x -10    ! 문함수 정의

10 Print *, ' Type a and b : ' ; Read *, a,b
   If (a>b) Then ; x=a ; a=b ; b=x ; End If
      ! 여러문장 한 줄에, a 와 b 를 바꿈
   fa=f(a) ; fb=f(b)
   If (fa*fb>0.0) Then
     Print *, 'f(a) and f(b) have same signs !'
     Go To 10 ! 서로 다른 sign 의 a and b 대입
   Else
     Print *, 'Input tolerance '
     Read *, tol
     Print *, 'Input maximum number of iterations '
     Read *, maxit
   End If

Loop : Do i=1,maxit ! Loop 명의 Do 문 시작
         p=a+(b-a)/2 ; fp=f(p)
Outer : If (Abs(fp)<= 1.0E-20 .OR. (b-a)/2 < tol) Then
               Print *, 'Final Results'
               Print *, ' p, i, tol ', p,i,tol
               Exit Loop ! 순환구조명 Loop 밖으로 분기
            Else
               Print *, ' p, i, tol ', p, i, tol ! 계산 중간값 출력
Inner :     If (fa*fp>0) Then
                   a=p ; fa=fp
               Else
                   b=p ; fb=p
               End If Inner   ! 구조명 inner 인 선택구조 끝
           End If Outer     ! 구조명 outer 인 선택구조 끝
      End Do Loop        ! 구조명 Loop 인 선택구조 끝

End Program MainProcedure

Ch1_dowhile.f

! Bisection Method for f(x)=x^3+4*x^2-10 = 0

Program MainProcedure
   Implicit None
   Integer :: i, maxit
   Real(kind=16) :: a,b,x,p,fa,fb,fp,tol,f
   f(x)=(x+4)*x*x -10    ! 문함수 정의

10 Print *, ' Type a and b : ' ; Read *, a,b
   If (a>b) Then ; x=a ; a=b ; b=x ; End If
      ! 여러문장 한 줄에, a 와 b 를 바꿈
   fa=f(a) ; fb=f(b) ; i=1
   p=a+(b-a)/2 ; fp=f(p)
   If (fa*fb>0.0) Then
     Print *, 'f(a) and f(b) have same signs !'
     Go To 10 ! 서로 다른 sign 의 a and b 대입
   Else
     Print *, 'Input tolerance '
     Read *, tol   ! 오차의 한계
     Print *, 'Input maximum number of iterations '
     Read *, maxit
   End If

Loop : Do While (Abs(fp)>1.0E-20 .AND. (b-a)/2>tol .AND i<=maxit) ! 참이면 실행
         i=i+1
         Print *, ' ** p, i, f(p) ', p,i,f(p)
Inner : If (fa*fp>0) Then
            a=p ; fa=fp
         Else
           b=p ; fb=p
         End If Inner   ! 구조명 inner 인 선택구조 끝
           p=a+(b-a)/2 ; fp=f(p)
      End Do Loop        ! 구조명 Loop 인 선택구조 끝

End Program MainProcedure

3) 변수 특성(Properties) 및 속성(attributes)

구분	명령어	의미
특성	Kind	변수의 기억장소 크기를 byte 단위로 지정
특성	Len	문자형 변수의 문자수를 지정(영문 한 문자=1byte)
속성	Dimension	배열인 변수 정의
	Parameter	변수가 불변인 상수인 변수 정의
	Allocatable	실행 도중에 크기가 지정되는 배열변수 정의
	Intrinsic	내장함수난 내장 프로시져인 변수 정의
	Intent	프로시져 내에서 자료값의 변화를 지정하는 변수 정의
	Pointer	포인터인 변수 정의
	Target	타켓인 변수 정의
	External	외부에서 전달하는 변수 정의

예제)

Program DeclareVariables
  Implicit None

!---- 실체중심의 변수선언
  Integer :: i, j
  Integer, Parameter :: number=4, code=2
  Integer, Dimension(number) :: a, b
  Real(kind=16), Dimension(number, code) :: c, d
  Character(Len=code) :: seoul

! ---- 속성중심의 변수선언
  Integer size, length
  Parameter (size=3, length=5)
  Integer list
  Character(Len=length) chart
  Real(Kind=8) loop
  Dimension list(size), chart(size), loop(size, length)

............

End Program DeclareVariables

Chapter 2. 상수(Constant) 와 변수(Variable) (위로)

2.1 자료값 처리방법

컴퓨터 내부의 자료값은 2진법의 수 체계로 이루어 진다.
2개의 디지트(bit) 0 과 1

1) 메모리의 단위

비트는 컴퓨터 기종이나 종류마다 다르다
메모리의 크기를 표현하는 단위는 바이트(byte)이다

1 byte = 8 bits
1 Kb = 2¹⁰ byte = 1024 byte = 2¹⁰*2³ bits
1 Mb = 2¹⁰Kb = 1024 Kb = 2¹⁰*2¹⁰byte = 1,048,576 byte
1 Gb = 2¹⁰Mb = 2²⁰Mb = 2³⁰byte

몇 개의 바이트를 묶어 1워드(word)를 구성하며 그의 비트수는
CPU 레지스트 안에 있는 비트수와 동일하다.
최근의 PC 기종들은 32비트이며 곧 64비트 기종이 보급될 전망
워드나 바이트는 각각의 어드레서(adress)를 가지고 있으며
어드레스는 제어장치를 통해 특정위치의 메모리에 정보를 저장하거나
호출할 때 사용하는 주소지이다.

2) 자료의 처리방법

자료를 처리하는 프로그램 처리방법(program instruments)은 메모리 또는
주기억장치에 저장되어 있다.
처리도구는 컴퓨터가 이해할 수 있는 기계어로 작성하며 2진법을 사용
프로그램 처리방법은 2가지 부분으로 구분

수치조작부호(Numeric opcode) :
메모리로 호출(loading), 곱하기, 더하기, 저장하기 등의 기본 기계작동
연산대상자(Operand)의 주소지

[Example] 주소자가 1024, 1025, 1026인 메모리 위치에 저장된 자료값이 있다하자.
처음 두 곳의 자료값을 곱하여 세 번째 자료값에 더한 계산결과를 주소지
1027의 메로리 위치에 저장하는 연산

주소지 1024인 메모리 위체에 있는 자료값 호출한 후 ALU안의 레지스터 안에
이를 로딩한다.
주소지 1025인 메모리 위체에 있는 자료값 호출한 후 이 값과 레지스터 안의
값을 곱한다.
주소지 1026인 메모리 위체에 있는 자료값 호출한 후 이 값을 레지스터 안에의
값과 더한다.
레지스터의 값을 주소지 1027인 메모리 위치에 저장한다.
% ALU = Arithmetic Logic Unit 산술논리연산장치
수치조작부호의 로딩(16), 저장(17), 덧셈(35), 곱셈(36)를 가질 때, 기계어의 예
16/1024 => 36/1025 => 35/1026 => 17/1027

단계	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	25	26	27	28	29	30	31	32
1				1																		1
2			1			1																1										1
3			1				1	1														1									1
4				1			1															1									1	1
구분	조작부호								연산대상자

어셈블리어 : 수치조작부호에 명령어, 주소지 위치에 변수명을 사용하는 언어

어셈블리어로 작성한 프로그램을 기계어로 번역한 후 컴퓨터가 실행

현재 일반적인 사용자는 거의 고급언어, C, Fortran, ..., 등를 사용하여 기계어로 번역한 후 실행

3) 수치 자료 체계

1 byte = 8 bits, 1 word = 4 byte = 32 bits : 바이트나 워드는 각각 주소(address)를 가지고 있다.
자료의 접근은 주소지를 찾는 일부터 시작한다.

사용하는 수 체계

2진법(BNS : binary number system) : 0,1
10진법(DNS : decimal) : 0,1, ... , 9
8진법(ONS : octal) : 0,1, ..., 7
16진법(HNS : hexadecimal) : 0, 1, ..., 9, A, B, C, D, E, F
5E4₁₆ = 5*16²+ 14*16¹ + 4*16⁰=1508

4) 진법바꾸기(10진법=>2진법)

십진법의 자연수 N을 2진법의 수로 표현해보라.

N = a_j*2^j+ a_j-1*2^j-1+ ... + a₁*2¹+ a₀*2⁰

N/2 = a_j*2^j-1+ a_j-1*2^j-2+ ... + a₁*2⁰+ a₀/2 => mod(N, 2) = a₀

Set Q₀ = a_j*2^j-1+ a_j-1*2^j-2+ ... + a₁*2⁰

Q₀/2 = a_j*2^j-2+ a_j-1*2^j-3+ ... + a₂*2⁰+ a₁/2 => mod(Q₀ , 2) = a₁

Set Q₁ = a_j*2^j-2+ a_j-1*2^j-3+ ... + a₂*2⁰

Q₁/2 = a_j*2^j-3+ a_j-1*2^j-4+ ... + a₃*2⁰+ a₂/2 => mod(Q₁ , 2) = a₂

_.....

_{계속
반복하면}a_{0 ,}a_{1 , ... ,}a_j 를 찾을 수 있다.

  예] 24 = 2*12     ... 0,
        12 = 2*6       ... 0,
          6 = 2*3       ... 0,
          3 = 2*1+1    ... 1,
           1 = 2*0+1   ... 1

=> 24 = 11000₂

   예] 십진법인 소수 R = 7/10 을 2진법의 소수로
       2 R = 1.4     d₁ = int(1.4) = 1,   F₁= frac(1.4) = 0.4
      2 F₁ = 0.8     d₂ = int(2 F₁) = 0, F₂= frac(2 F₁) = 0.8
      2 F₂ = 1.6     d₃ = int(2 F₂) = 1, F₃= frac(2 F₂) = 0.6
      2 F₃ = 1.2     d₄ = int(2 F₃) = 1, F₄= frac(2 F₃) = 0.2
      2 F₄ = 0.4     d₅ = int(2 F₄) = 0, F₅= frac(2 F₄) = 0.4
      2 F₅ = 0.8     d₆ = int(2 F₅) = 0, F₆= frac(2 F₅) = 0.8
      2 F₆ = 1.6     d₇ = int(2 F₅) = 1, F₇= frac(2 F₆) = 0.6

    => 2 F₁= 1.6 = 2 F_{5

     =>}d₂= d₆ = d₁₀ .... d₃= d₇ = d_{11

     =>}d_k= d_k+4  for k=2,3,4, ...

R = 7/10 = 0.1[0110]₂= 0.101100110011001100110 .....₂무한소수

2.2 상수(Constant)

컴퓨터가 수치연산을 수행할 때 자료값을 기억장소에 저장하고 그 값을 다시 읽어
사용할 수 있는 모든 종류의 자료값들을 상수라 한다.

1) 상수의 종류

정수형, 실수형, 복소수형, 문자형, 논리형

2) 32비트 컴퓨터의 사용 자료값의 범위

형(Type)	바이트	사용범위	유효자리수
Integer	1	-127 - 127	3
	2	-32,768 - 32,767	5
	4	-2,147,483,647 - 2,147,483,647	10
	8	-9,223,372,036,854,775,808 - 9,223,372,036,854,775,808	19
Real	4	-1.18 E-38 ~ 3.40 E+38	7~8
	8	2.23 E-308 ~ 1.79 E+308	15~16
	16	1.0 E-4931 ~ 1.79 E-4932	약 33
Complex	4	-1.18 E-38 ~ 3.40 E+38	7~8
	8	2.23 E-308 ~ 1.79 E+308	15~16
	16	1.0 E-4931 ~ 1.79 E-4932	약 33
Logical	1	.True. 와 .False.
Logical	4	.True. 와 .False.
Character	1	Ascii 문자자료
비고		Default kinds(기본적인 바이트수)

자료값보다 적으면 => Underflow
자료값보다 크면 => Overflow
선언문을 사용하지 않고 특수문자를 사용하여 상수 및 변수의 기억장소크기 정의 ( _ Underscore)
3.0_4 3.0_8 a_4 a_16

3) 정수형 자료값 표현 방법

예] 16비트 : 111010₂

비트	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16
2진법표현	0	0	0	0	0	0	0	0	0	0	1	1	1	0	1	0
		유효숫자
	부호 0 => + 1 => -

n 비트 컴퓨터의 정수형 자료값의 사용범위
가장 큰 양의 정수 : 2¹⁵-1
가장 작은 음의 정수 : -2¹⁵

4) 실수형 자료값 표현 방법

고정형 표기법(Fixed Form) == 3.14159 == Fw.d == w 는 전체 필드

지수형 표기법(Exponential Form) == 0.314159*10¹ == Ew.d == d 는 유효숫자 필드
예] 6.625₁₀= 0.110101₂*2³

비트	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	25	26	27	28	29	30	31	32
값	0	1	1	0	1	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	1
2		유효숫자 부분(mantissa)																								지수(exponent)
3	부호 0 => + 1 => -																								부호

사사오입 오류 (Roundoff Error)

5) 논리형과 문자형 자료값

논리형 자료값

True => 1
False => 0
자료저장을 위해서는 1바이트가 요구되나 저장장소의 크기가 달라서 발생하는
오류를 사전에 막기 위하여 4바이트를 기본 저장장소 크기로 채택

문자형 자료값

영문자 하나 => 1바이트
한글자 하나 => 2바이트

5) 상수 선언방법

선언문 이용 변수형, Parameter :: 상수변수=자료값 ! Parameter 는 고정상수값 지정

초기값 지정 변수형 :: 변수=자료값

표현식 이용 변수=자료값

6) 변수 사용방법

변수 작성 기준

첫 글자는 반드시 영문자로 시작
변수명은 반드시 31개 이내의 문자로 구성
변수명은 영문자, 숫자, 공백, _(Underscore)를 사용
영문자의 대소문자를 구별하지 않는다.
공백과 _(Underscore)를 제외한 모든 특수문자는 사용할 수 없다.
예]
AbcdEf Tom_and_Jerry Tom and Jerry (OK)
2th war bcshin@chonnam (NO)

Implicit None

사용자 위주의 변수형 선언을 위해 미리 정의하는 명령문
프로시져 시작문 바로 다음 줄에 작성
Implicit None 문보다 먼저 작성할 수 있는 명령문은 USE 문 뿐이다.

사용예]

실체중심의 변수선언

Integer, Parameter :: ar_size=5, ss=10

Character(Len=ss) :: elem_name

Integer, Dimension(ar_size) :: arlist, chart

속성중심의 변수 선언

Integer ar_size, ss

Parameter (ar_size=5, ss=10)

Character(Len=ss) elem_name

Integer arlist, chart

Dimension arlist(ar_size), chart(ar_size)

3. 표현식(Expression)과 할당문(Assignment) (위로)

3.1 표현식

표현식은 2개 이상의 변수를 이용하여 자료값들의 관계를 포트란 식으로 표현한 것.
우선순위 : 산술연산자 => 관계연산자 => 논리연산자

1) 산술식(Arithmetic Expression)

우선순위 : ( ) => ** => * , / => + , -
산술식은 원칙적으로 같은 수형을 갖는 피연산자만의 계산식이나 다른 경우 계산결과의
수형은 피연산자간의 우선순위에 따른다.
피연산자 우선순위 :

기억장소크기(바이트)가 큰 것이 우선
복소수 => 실수 => 정수
a : 4바이트 실수, b : 8바이트 실수, c : 4바이트 정수

d=a+c => 4바이트 실수
e=a*b => 8바이트 실수
f=a*c+b => 8바이트 실수

지수표현 : 6.25*10³

4바이트 실수(실수형 변수) : 6.25E3

8바이트 실수(배정도 실수형 변수) : 6.25D3

16바이트 실수(네배정도실수형 변수) : 6.25Q3

2) 관계식(Relational Expression)

a == b 또는 a .EQ. b
a /= b 또는 a .NE. b
a < b 또는 a .LT. b
a <= b 또는 a .LE. b
a > b 또는 a .GT. b
a >= b 또는 a .GE. b
관계식의 출력결과는 T(True) 또는 F(False) 이다
기호 관계연산자를 권장
문자자료의 크기비교는 각 문자의 ASCII 코드번호를 비교

A (65) , a (97) : Ascii 코드
A >= a 의 출력결과는 F(False)

3) 논리식(Logical Expression)

.NOT. a : 부정
a .AND. b : 논리곱
a .OR. b : 논리합
a .EQV. b : 동치(Equivalence)
a .NEQV. b : 부동치(Not Equivalence)
관계식의 출력결과는 T(True) 또는 F(False) 이다

4) 문자식(Literal Expression)

문자연산자는 문자결합기호(Concatenation) : // (Double Slash)

'University'//' of '//'Chonnam' => University of Chonnam

TRIM : 문자 자료값의 뒷부분 공백을 모두 삭제

TRIM('_ _ University_ _ _')//'Chonnam' => _ _ UniversityChonnam

ADJUSTL : 앞부분 공백을 삭제하고 공백이 아닌 모든 글자들을 왼쪽으로 정렬

ADJUSTL(' University ')//'Chonnam' => University _ _ _Chonnam

ADJUSTR : 뒷부분 공백을 삭제하고 공백이 아닌 모든 글자들을 오른쪽으로 정렬

ADJUSTR(' University ')//'Chonnam' => _ _ UniversityChonnam

INDEX : 문자 자료값에서 특정 글자가 처음로 나타나는 위치를 찾는 함수

INDEX('_ _University','s') => 9

3.2 할당문

variable = expression

1) 형 변환함수

종류	인수	결과
Real(a)	정수, 복소수	실수
Float(a)	정수	실수
Dble(a)	정수, 실수	배정도 실수
Int(r)	실수, 복소수	정수
Cmplx(r)	하나의 실수	복소수
cmplx(r1,r2)	두 개의 실수	복소수

2) 혼돈하기 쉬운 형변환 내장함수

함수	결과	용어	내용
Real(a)	실수	형 변환
Float(a)	실수	형 변환
Int(r)	정수	0으로 절삭	정수부분
Floor(r)	정수	-00으로 절삭	인수보다 작은 값 중 가장 큰 정수
Ceiling(r)	정수	00으로 절삭	인수보다 큰 값 중 가장 작은 정수
Nint(r)	정수	소수점이하 반올림 정수	인수에 가장 가까운 정수
Anint(r)	실수	소수점이하 반올림 실수	인수에 가장 가까운 정수를 실수로 변환
Aint(r)	실수	소수점이하 절삭	인수의 소수점이하를 삭제한 실수

3) 형 변환함수의 사용법

자료값	-1.00	-0.99	-0.50	-0.49	0.00	0.49	0.50	0.99	1.00
Aint(r)	-1.0	0.0	0.0	0.0	0.0	0.0	0.0	0.0	1.0
Int(r)	-1	0	0	0	0	0	0	0	1
Anint(r)	-1.0	-1.0	-1.0	0.0	0.0	0.0	1.0	1.0	1.0
Nint(r)	-1	-1	-1	0	0	0	1	1	1
Floor(r)	-1	-1	-1	-1	0	0	0	0	1
Ceiling(r)	-1	0	0	0	0	1	1	1	1

4) 수치연산 내장함수

ABS(a) : 절대값
MAX(a, ...) : 최대값
MIN(a, ...) : 최소값
SIGN(a,b) : 부호변환

SIGN(a,b) = |a| if b >= 0
-|a| if b < 0 .

DIM(a,b) : 잉여값

DIM(a,b) = a-b if a>b
0 o.w

MOD(a,p) : INT 로 계산한 나머지

MOD(a,p) = a - Int(a/p)*p

MODULO(a,p) : Floor 로 계산한 나머지

MODULO(a,p) = a - Floor(a/p)*p if a = real
r in a=q*p+r if a = integer

Acos(r) : Asin(r) : Atan(r) : Atan2(r) : inverse cosine, sine, tangent, tangent
Cos(rc), Cosh(r) : Cosine, Hyperbolic Cosine
Dprod(rc1,rc2) : 배정도 실수형 곱
Exp(r) : Exponential
Log(rc) : Natural Logarithm
Log10(rc) : Common Logarithm
Sin(rc), Sinh(r) : Sine, Hyperbolic Sine
Sqrt(r) : Squrar root
Tan(rc), Tanh(r) : Tangent, Hyperbolic Tangent

4. 변수의 속성(attribute) (위로)

4.1 표현식

속 성		설 명
Parameter		상수변수임을 선언
Allocatable		배열변수가 할당배열임을 알림
Dimension[(Shape)]		크기 및 형상 Shape를 가진 배열변수임을 알림
Intent(spec)		Intent(IN)	해당프로시져로 자료값을 전달만 하는 가인수 속성
spec	In, Out	Intent(Out)	상위르로시져로 자료값을 전달만 하는 가인수
	InOut	Intent(InOut)	상하위 프로시져로 자료값을 전달하는 가인수
Intrinsic		내장함수임을 알림
External		상위프로시져에서 전달되는 내장함수임을 알림
Public		전역변수임을 나타냄
Private		지역변수임을 나타냄
Optional		조건적 가인수임을 나타냄
Pointer		포인터 변수임을 알림
Target		타켓 변수임을 알림
Save		부프로시져에서 자료값을 저장한 후 리턴되는 변수
Sequence		자료값을 순차적인 저장 지시하는 변수 속성

1) Parameter ; 해당 프로시져에서 변수들의 자료값이 늘 일정한 상수로 취급하는 상수변수

2) Allocatable ; 배열이 할당배열임을 나타내는 명령어

선언] Allocatable [::] name[shape]
Shape => (:) , (:,: ) , ...
할당] Allocate ( name(a(2), b(3,4) )
해제] Deallocate ( a, b )
포트란95에서 프로그램을 실행하면 주기억장치의 많은 부분을 자유 메모리로 설정하고
자유메모리를 필요한 크기만큼씩 지정함으로서 배열을 선언할 수 있다.
이러한 배열을 할당배열이라고 하며 기억장소를 효과적으로 관리할 수 있는 방법이므로
널리 사용할 것을 권장
할당배열은 선언문에서 배열 이름만을 정의하고 배열의 형상과 크기는 프로그램이
실행될 때 확정되므로 이를 실행배열이라고도 한다.
예제] exa_alloc.f

3) Dimension ; 변수가 배열임을 나타내는 명령

4) Intent ; 가인수가 자료값을 하위 프로시져로 전달하거나 상위 프로시져로
전달하는 특성을 정의

Intent 선언을 하지 않으면 기본적으로 Intent(InOut) 선언으로 받아준다.
Intent(In) :: x ! 변수 x는 상위 프로시져로부터 자료값을 전달만 받음
해당 부 프로시져에서 계산되거나 변경되어서는 안됨

Intent(Out) :: y ! 변수 y는 부 프로시져에서 할당, 계산하여 상위 프로시져로 자료값을 전달

Intent(InOut) :: z ! 변수 z는 상위 프로시져로부터 자료값을 전달받아 하위 프로시져에서
연산을 하여 상위 프로시져로 전달함.
예제] exa_intent.f

5) Intrinsic ; 사용변수가 내장 함수명임을 나타내는 명령

Intrinsic :: Abs
사용할 변수가 내장함수임을 분명히 밝히고자 할 때
내장함수를 마치 일반 변수처럼 사용하고자 할 때
내장함수명을 호출문에서 실인수로 사용하고자 할 때
예제] exa_intrinsic.f

6) External ; 상위 프로시져에서 정의한 함수를 하위프로시져에서 사용하기 위하여
가인수로 전달 할 때 해당 프로시져 밖에서 정의한 함수임을 나타내는 명령

External :: Sin
정의한 변수가 External 이면 Intrinsic 속성을 동시에 가질 수 없다.
정의한 변수가 함수가 아니면 External 속성을 사용할 수 없다.
반드시 호출받는 하위 프로시져의 가인수에 대해서만 적용
External 문으로 선언한 프로시져명은 실인수로 사용할 수 없다.
예제] exa_external.f

7) Public ; 정의하는 변수가 해당 프로시져가 아닌 다른 전체 프로시져에서도 똑 같은 의미로
사용되는 전역변수임을 나타내는 명령

Public :: a, b
Public 문은 반드시 하나의 모듈 안에서만 적용
Module 프로시져에서 묵시적인 변수 속성은 PUBLIC 이다
Public문뒤에 객체목록이 없으면 모듈에서 정의하는 모든 항목이 전역변수
Public문뒤에 객체목록이 있으면 지정한 객체만이 전역변수
예제] exa_public.f

8) Private ; 정의하는 변수가 해당 프로시져 안에서만 적용되는 지역변수임을 나타내는 명령

Private :: a, b
Private 문은 반드시 하나의 모듈 안에서만 적용
Private 문뒤에 객체목록이 없으면 모듈에서 정의하는 모든 항목이 지역변수
예제] exa_private.f

9) Optional ; 호출하는 상위프로시져에서 실인수가 표현되면 하위 프로시져에서 자료값을
전달받는 특성을 가진 가인수 속성을 나타내는 명령

Real, Intent(In), Optional :: b, c
If (Present(b)) x=b*b
반드시 호출받는 하위 프로시져에서 사용하는 변수 속성
호출하는 상위프로시져에 실인수가 있는 지를 확인하는 명령문 Present와 함께 사용
예제] exa_optional.f

10) Pointer ; 포인터 변수나 배열의 특성을 나타내는 명령

Integer, Pointer :: a, b
Allocate(a) ; a=1
Allocate(b) ; b=3
a=b+3
a => b ; b=7 ! 포인터 할당문 pointer1 => pointer 2
b => a ; a=9 ! pointer1 에 pointer2 와 동일한 상태를 할당
포인터를 인용하거나 정의할 때는 반드시 포인터 할당문이나 Allocate 문으로 포인터를
처음 타켓과 연결한 후 이용
Pointer 속성 배열은 반드시 형상가정배열로 선언
예제] exa_pointer.f

11) Target ; 포인터와 연관된 타겟 속성을 가진 객체명 목록을 정의

Character(4), Target :: myname='SHIN'
Character(4), Pointer :: yourname
yourname => myname
Print *, Associated(yourname, myname)
Associated 문은 포인터와 타겟이 연관되어 있는지 확인
예제] exa_target.f

10) Save ; 하위 프로시져에서 계산을 종료한 후 선언한 모든 객체의 연결상태, 할당위치,
정의, 자료값의 저장을 지시하는 명령

Common /mycommon/ a, b, c
Save :: /mycommon/, objectname
예제] exa_common.f

11) Sequence ; 변수들이 순차접근 속성을 가지고 있음을 정의하는 선언문
파생형 선언구조에서 변수특성 정의에서만 사용하며 Default이다

Sequence
예제] exa_sequence.f

5. 선택문과 선택구조 (위로)

5.1 선택문과 선택구조

어떤 자료값에 따라 프로그램 내용이나 명령이 달리 사용되는 포트란 명령문을 선택문
어떤 자료값을 조건식
조건식에 따라 실행문을 선택하므로 이를 조건문
조건식 결과에 따라 여러 가지 명령문을 실행하여야 하므로 분기문
이를 합쳐 조건분기문

5.2 선택문 : If, Merge, Where, Forall

1) 논리형 If 문

선언] If (Expression) Statement
예제] If (x-a < 0) b=1-x

2) 블록 If 문

선언] If (Expression 1) Then
             Statement 1
       Elseif (Expression 2) Then
             Statement 2
       ...
       Else
             Statement Default
       EndIf
예제] If (x < 0) Then      ; a = 'negative'
        Elseif (x==0) Then ; a = 'zero '
        Else                    ; a = 'positive'
        EndIf

3) Merge 문 : 논리형 조건식에 따라 실행문을 선택하여 실행을 제어하는 선택문

선언] Merge (Expression1, Expression2, Condition)

Expression1, Expression2 는 실행문
Condition은 논리형 조건식
만일 조건식 Condition이 참이면 실행문 Expression1을 실행
만일 조건실 Condition이 거짓이면 실행문 Expression2를 실행

예제] a = Merge(a/b, a, b/=0 )
b=0 이 아니면 a=a/b, b=0 이면 a = b
예제] Merge.f

4) Where 문 : 논리형 조건식에 따라 배열자료값을 할당하는 선택문

선언] Where (mask) [assignment]

mask는 논리형 표현식이며 반드시 배열자료값을 이용한 표현식
assignment는 할당문으로 반드시 배열할당문
Where문 뒤에 assignment가 없으면 Where 구조의 시작을 나타냄
assignment의 좌변 변수는 반드시 mask와 동일한 형상을 가진 배열
mask가 침이면 assignment의 우변의 계산결과를 좌변의 해당요소에 할당
assignment의 우변에서 기본함수가 아닌 특정함수를 인용하면 mask와 관계없이 계산
IF문의 논리형 조건식이 변수이데 비해 Where문의 논리형 조건식이 배열자료값

예제] Real, Dimension(3) :: a=(/1,2,3/), b=(/1,3,2/)
Where(a>b) a=-1
Write(*,*) ' a = ', a
예제] Where.f

5) Forall 문 : 표현식 mask의 논리값과 표현식 triplets에 따라 해당 명령문 assignment를 실행

선언] Forall ( triplets [,mask] ) assignment

triplets은 다음과 같은 형식을 가진다
index=하한치 : 상한치 [: 증분] 예] i = 1:10:2
index는 정수형 지정변수
mask는 논리형 표현식으로 요소자료값에 대한 연산식이나 배열첨자에 대한 관계식
mask를 사용하지 않으면 mask의 자료값을 참으로 가정한다.
assignment는 할당문 또는 포인터 할당문을 사용하며 반드시 배열에 대한 연산

예제] Real, Dimension(2:2) :: a=Reshape((/1,2,3,4/),(/2,2/)), b=Reshape((/1,3,2,5/),(/2,2/))
Forall (i=1:2, j=1:2, j>i) a(i,j)=b(i,j)
예제] Forall.f

5.3 선택구조문 : If, Select Case, Where, Forall

1) (Select) Case 구조문 :

선언] Select Case ( Expression )
          Case (selector [, selector] ... )
               Executive Block
          ...
          [Case Default]
               Executive Block
        End Select

selector의 형식 : value, : value (이하), value : (이상) , lvalue : uvalue (사이)
논리형, 정수형 상수, 문자형 표현식
Case Default 문 뒤의 block은 경우의 수가 없는 경우 실행, 생략가능

예제] Case.f

2) Where 구조문

선언] Where (mask)
            assignment
        Else Where (mask)
            assignment
        Else Where
            assignment
        End Where
예제] Where.f

3) Forall 문 : 표현식 mask의 논리값과 표현식 triplets에 따라 해당 명령문 assignment를 실행

선언] Forall ( triplets [,mask] )
statement
End Forall
예제] Real, Dimension(2:2) :: a=Reshape((/1,2,3,4/),(/2,2/)), b=Reshape((/1,3,2,5/),(/2,2/))
          Forall (i=1:2, j=1:2, j>i)
                  a(i,j)=b(i,j)
          End Forall
예제] Forall.f

6. 순환문과 순환구조 (위로)

변수값을 일정량씩 증가 또는 감소시키거나 반복연산 횟수를 증가 도는 감소시키면서
반복연산을 실행시키는 일련의 명령문을 순환구조 도는 반복구조 또는 Do 순환구조라고 한다.

6.1. 횟수제어 순환구조

1) 구조명이 있는 순환구조

선언]               pi=4.0*Atan(1.0) ; limit=360; delta=10
        AngDo : Do n=0,limit,delta
                      angle=Real(n); radian=angle/180*pi ; sinx=Sin(radian)
                      Write(*,*) n, radian, sinx
                   EndDo AngDo

2) 제어변수가 없는 순환구조

예제]               pi=4.0*Atan(1.0) ; limit=360; delta=10
                   n = 0
        AngDo : Do
                      angle=Real(n); radian=angle/180*pi ; sinx=Sin(radian)
                      n = n+delta
                      If (n>limit) Exit [AngDo]
                      Write(*,*) n, radian, sinx
                   EndDo AngDo

6.2. 일반 순환구조

1) Do Exit 순환구조 ; Do Exit 순환구조에서 완전히 벗어나서 연이어 작성한 명령문 실행을 지시

예제]               pi=4.0*Atan(1.0) ; limit=360; delta=10
        AngDo : Do
                      angle=Real(n); radian=angle/180*pi ; sinx=Sin(radian)
                      n = n+delta
==>                 If (n>limit) Exit [AngDo]
                      Write(*,*) n, radian, sinx
                   EndDo AngDo
조건식이 참이면 해당 Do Loop 인 AngDo 밖으로 나가기

2) Do Cycle 순환구조 ; 제어변수를 변화시켜 다음 단계의 반복 연산과정으로 명령 분기

선언] [MyName : ] Do
                                Statement 1
                                If (Condition) Cycle [MyName]
                                Statement 2
                             EndDo [Myname]
조건식이 참이면 해당 Do Loop 인 MyName의 처음으로 돌아가기
예제]               delta=10 ; x=-10
         AngDo : Do
                      x=x+delta
                      If (x>10) Exit [AngDo]
                      If (Abs(x) < 1.0E-4) Cycle [AngDo]
                      y = 1/x
                      Write(*,*) x,y
                   EndDo AngDo

3) Do While 순환구조 ; 조건식이 참일 때만 반복연산 실행

선언] [MyName : ] Do While (Condition)
Statement 1
EndDo [Myname]
조건식이 참이면 해당 Do Loop을 실행
예제]               delta=10 ; x=-10
         AngDo : Do While (x<10)
                      x=x+delta
                      If (Abs(x) < 1.0E-4) Cycle [AngDo]
                      y = 1/x
                      Write(*,*) x,y
                   EndDo AngDo

4) 내부순환구조 ; 입출력문에서 배열자료값을 입력하거나 출력할 때 사용

예제]   Integer :: x(5)=(/1,2,3,4,5/), y(2,2)=(/1,2,3,4/)
         Write(*,*) (x(i), i=1,5,2)
         Write(*,*) x(1:5:2)
         Write(*,*) ( (y(i,j), j=1,2), i=1,2)

5) 재귀 순환구조 ; 재귀 프로시져를 연속 호출하여 반복계산을 수행하는 구조

선언] Recursive SubProcedureName
예제] Recursive Integer Function Fctorial(n) Result(fac)
          Integer :: n
          If (n==0) Then
             fac=1
          Else
             fac=n*Factorial(n-1)
          Endif
        End Function Factorial
Example ] Factor.f

6) 다중 순환구조

Example ] mul_do.f

7. 분기문과 실행제어문 (위로)

7.1 GoTo문 (되도록이면 사용하지 말 것을 권장)

프로그램 실행을 다른 위치로 이동시키는 문장

선언] Condition GoTo label ! 조건 GoTo 문
GoTo label ! 무조건 GoTo 문
GoTo (labels) expression ! 계산형 GoTo 문
예제] If (n==1) GoTo 40
GoTo 40
GoTo (10,20,30) n

n=1 => GoTo 10
n=2 => GoTo 20
n=3 => GoTo 30
n<1 or n>3 => GoTo 문 바로 아래 실행문

예제] GoTo.f

7.2 실행제어문 (되도록이면 사용하지 말 것을 권장)

프로그램이 연이어 실행되도록 지시하거나 실행을 잠시 중지시키거너 계산결과값을
상위 프로시져로 되돌려 주거나 프로그램 실행을 종료시키는 명령문

1) Continue 문 : 특별한 의미없이 연산과정을 나타내거나 명령문의 분기를 위해 작성

2) Pause 문 : 프로그램 실행을 잠시 중지시키는 명령문

선언] Pause
Pause ' Any String '

3) Return 문 : 부프로시져를 실행한 후 계산결과값을 상위 프로시져에 되돌려 주는 명령

선언] If (a>b) Return

4) Stop 문 : 실행종료를 지시하는 명령

선언] Stop
Stop ' Any String '

8. 입출력문 (위로)

8.1 Read 문(입력문)

Read(*,*) Input_lists

Read (spec) [Input_lists]

Read formatspec [, Input_lists]
Spec

[UNIT = ] unitnumber

* : 컴파일러에서 기본적으로 정의한 입력장치번호 ( 보통 5,6 또는 10, 11)

외부파일의 입력장치번호 ( 되도록 위의 번호를 피할 것)

[FMT = ] format

서식문 번호를 나타내는 정수형 상수나 변수
또는 서식문을 바로 입력할 수도 있음
Fmt = "(F10.5)"

[NML = ] groupname

사용자가 정의하는 변수그룹명
예제] NameList
Integer :: hours, minutes, seconds
Namelist /CurrentTime/ hours, minutes, sconds
     ! 여기서 CurrentTime 이 Groupname ( 31개 이내의 글자)
Read(*, NML=CurrentTime)
     ! 이 때, 입력 자료값은 아래와 같이 작성하여야 한다.
     ! &CurrentTime hours=12, minutes=30, seconds=10 /
Write(*, NML=CurrentTime)
     ! 이 때, 출력 자료값은 아래와 같이 작성하여야 한다.
     ! &CurrentTime hours=12, minutes=30, seconds=10 /

Advance = advance

Advance="Yes" : (Default) 레코드 진행하며 읽든지 또는 출력할 때 사용
Advance="No" : 레코드 진행없이 읽든지 또는 출력할 때 사용
예제]
Character(*) :: S="ABCDEFG"
Write(*,*) " Start "
Write(*,"(A)", Advance="No") " ### "
Write(*,"(A)", Advance="No") S(1:3)
Write(*,"(A)", Advance="No") " ### "
Write(*,"(A)", Advance="No") S(4:7)
Write(*,"(A)", Advance="No") " ### "
Write(*,*) " END "
결과]
Start
### ABC ### DEFG ###
END

Rec = record

직접접근파일의 읽힐 레코드번호

Iostat = stat

오류 발생하면 stat=양

파일끝 또는 레코드 끝이면 stat=음

그 이외의 경우는 stat=영

Err = errlabel

실행중 파일 끝이나 레코드 끝이 아닌 상태에서 오류가 발생하면 명령을 분기시킬 문번호

End = endlabel

실행중 오류발생 없이 파일 끝을 만나면 분기시킬 문번호

Eor = eorlabel

실행중 파일 끝이 아닌 상태에서 오류발생 없이 레코드 끝을 만나면 분기시킬 문번호

Size = size

정수형 변수로서 현재 하나의 레코드에 자료값을 연이어 입출력하는 동안 자료편집기호에
의해 변환되는 문자의 수

Input_Lists

Variables : 변수명
(Inputs, docontrol)

docontrol
dovariable = strat, end [, increment]
docontrol의 예
i = 1,9,2

Formatspec

FormatNumber : 서식문 번호를 나타내는 정수형 상수나 변수
Format Description : 서식문에서 사용하는 서식표현식
* : 컴파일러에서 기본적으로 제공하는 서식

8.2 Print 문과 Write 문 (출력문)

Print *, [Outputs]

Print format [,Outputs]

Write(*,*) [Outputs]

Write (spec) [Outputs]
Spec : Read문과 동일
Outputs : Read문의 Input_lists와 동일
format

*
label : 정수형상수로서 Format 문번호
assignedlabel : Format문번호를 할당한 정수형 변수
Expression : 문자형 표현식
[" ( [r]Editdescrptor, [r]Datadescriptor, Stringdescriptor )" ]

r 은 반복회수를 나태내는 정수형 상수
Editdescriptot : 변수형에 따른 서식제어기호

Tn : n 번째 칼럼 위치 지정
TLn : 왼쪽으로 n 컬럼 이동
TRn : 오른쪽으로 n 컬럼 이동
nX : 현재 위치에서 앞으로 n 컬럼 이동
S : 양의 부호를 무시하고 출력 ( Default )
SP : 양의 부호를 출력
SS :양의 부호를 무시하고 출력
BN : 입력시 공백을 빈 문자로 취급
BZ : 공백을 0으로 취급
[r]/ : 현재 레코드의 끝으로 다음 레코드로 진행
: : 해당 레코드의 서식제어를 끝내는 서식제어기호
kP : 부동소수점 위치를 지정

pi = 3.14159
Write(*, "(E10.3, 1p, E10.3, 1pE10.3, 2p,E10.3, -2p, E10.3) pi, pi, pi, pi, pi
0.314E+01 3.141E+00 3.141E+00 31.415E-01 0.003E+03

Datadescriptot : 자료 편집기호

w = 전체필드 길이, m = 자릿수, d = 소수점이하의 자릿수, e = 지수 자릿수
Iw[.m] : 10진법의 정수형 자료
Fw.d : 고정수수점 형식의 실수, 복소수
Ew.d[e] : 지수형식으로 실수, 복소수
A[w] : 문자형 자료값
Dw.d : 지수형식 배정도 실수, 복소수
Qw.d : 지수형식 네배정도 실수, 복소수
Bw[.m] : 2진법의 정수형 자료
Ow[.m] : 8진법의 정수형 자료
Zw[.m] : 16진법의 정수형 자료
ENw.d[e] :공학적 표시
ESw.d[e] : 과학적 표시
Gw.d[e] : 일반화 서식, 자료값의 특성에 따라 서식이 변화
Lw : 논리형 자료값
예제]

자료값이 다음과 같이 주어져 있다.
123_ _ 6789_ _ 3.14
입력문
Read "(T6, I3, TL8, F3.1, TL3, F3.2, TR3, F3.1, 2X, F5.2)", a, b, c, d, e

a = 678 : 6번째 칼럼부터 정수형 3자리수
b = 12.3 : 왼쪽으로 8칸이동하여 F3.1
c = 1.23 : 왼족으로 3칸이동하여 F3.2
d = 78.9 : 오른쪽으로 이동하여 F3.1
e = 3.14 : 오른쪽으로 2칸 무시하고 F5.2

입출력문의 예] Read_write.f

9. 배열(Array or Matrix or Vector) (위로)

9.1 배열의 종류

1차원, 2차원, ... , 7차원 배열
Real :: a(5), b(-1:3), c(3,4), d(0:4,0:5)
지정배열, 할당배열, 형상가정배열, 크기가정배열

지정배열
Integer, Dimension(3,2) :: a

할당배열(Allocatable)
Real, Allocatable, Dimension(:,:) :: a, b

Allocate(a(3,2), b(0:5, 1:9:2))
Deallocate(a, b)

형상가정배열
Program Main
   Implicit None
   Integer, Dimension(3,4) :: a

   Interface      ! Interface가 반드시 필요
      Subroutine Sub(x)    ! Subroutine 대신 Function을 사용할 수 있다.
          Integer, Dimension(-1:,:), Intent(Out) :: x
      End Subroutine Sub
   End Interface

   Call Sub(a)
   Write(*,*) ' a ', a
End Program Main

Subroutine Sub(x)
   Implicit None
   Integer :: i,j
   Integer, Dimension(-1:,:) :: x    ! 마지막 첨자는 생략할 수 있다
   Do i=-1,1 ; Do j=1,4
       x(i,j) = i*j
   EndDo ; EndDo
End Subroutine Sub

형상가정배열은 할당배열과는 달리 하한치를 재정의 할 수 있다.

크기가정배열
Program Main
   Implicit None
   Integer :: m=3, n=4
   Integer :: a(10),b(3,4)

   Call Sub(m,n,a,b)
   Write(*,*) ' a ', a
   Write(*,*) ' b ', b
End Program Main

Subroutine Sub(m,n,x,y)
   Implicit None
   Integer :: m, n, i, j
   Integer, Dimension(*) :: x     ! 마지막 첨자는 생략할 수 있다
   Integer, Dimension(m,n) :: y
   Do i=1,10 ; x(i)=i ; EndDo
   Do i=1,m ; Do j=1,n
       y(i,j) = i+(j-1)*m
   EndDo ; EndDo
End Subroutine Sub

크기가정배열은 반드시 부프로시져에서 정의

9.2 배열 함수

All(mask [,dim]) : 모두 같을 때 참

Integer, Dimension (2,3) :: a, b
Logical :: c, d(3), e(2)
a = Reshape((/1,2,3,4,5,6/),(/2,3/))
b = Reshape((/1,2,3,4,6,5/),(/2,3/))
    ! a = 1 3 5          b = 1 3 6
    !       2 4 6               2 4 5
c = All(a==b)      ! c = F
d = All(a==b, 1)   ! d = [T, F, F] 칼럼을 비교하여 행으로
e = All(a==b, 2)   ! e = [F, F]      행을 비교하여 칼럼으로

Any (mask [,dim]) : 하나라도 같으면 참

Integer, Dimension (2,3) :: a, b
Logical :: c, d(3), e(2)
a = Reshape((/1,2,3,4,5,6/),(/2,3/))
b = Reshape((/1,2,3,4,6,5/),(/2,3/))
c = Any(a==b)      ! c = T
d = Any(a==b, 1)   ! d = [T, T, F] 칼럼을 비교하여 행으로
e = Any(a==b, 2)   ! e = [T, T]      행을 비교하여 칼럼으로

Allocated (array) : 할당이 돼어 있으면 참

Allocated (a(2,3))
b = Allocated (a) ! b = T

Count(mask [,dim]) : 참인 요소들의 총수

Integer, Dimension (2,3) :: a, b
Integer :: c, d(2), e(3)
a = Reshape((/1,2,3,4,5,6/),(/2,3/))
b = Reshape((/1,2,3,4,6,5/),(/2,3/))
c = Count(a==b)      ! c = e
d = Count(a==b, 1)   ! d = [2, 1, 0] 칼럼을 비교하여 행으로
e = Count(a==b, 2)   ! e = [2, 1]      행을 비교하여 칼럼으로

Cshift(array, shift [,dim]) : 배열을 순환 이동

Integer, Dimension (2,3) :: a, b, c, d
Integer :: e(3), f(3)
a = Reshape((/1,2,3,4,5,6/),(2,3/))   ! 2*3 행렬
e = (/1,2,3/)            ! 3*1 벡터
b = Cshift(a, 1)        ! b = 각각의 열에서 하나씩 뒤로 밀어냄
c = Cshift(a, -1, 2)   ! c = 각각의 행에서 하나씩 앞으로 당김
d = Cshift(a, e, 1)    ! d = 각각의 열에서 1칸, 2칸, 3칸씩 뒤로 밀어냄
f = Cshift(e, 2)        ! f = 2칸 앞으로 당김

Dot_Product (vectora, vectorb): Function

Dot_Product( (/3,4,5/), (/6,7,8/) )

Eoshift(array, shift [,boundary] [,dim])
Lbound (array [,dim])
Matmul (matrixa,matrixb): Function

a = Reshape( (/1,2,3,4,5,6/), (/2,3/) )
b = (/1,2,3/)
c = Matmul(a,b)

Maxloc (array [,dim] [,mask]) : Function

array의 모든 요소중 최대값을 갖는 첫 요소위치
a = Maxloc( (/3,0,4,4/ ) ! a = 3

Maxval (array [,dim] [,mask]) : Function

array의 모든 요소중 최대값

Integer :: a(2,3), b(3), m
a = Reshape( (/1,2,3,4,5,6/), (/2,3/) )
m = Maxval(a)     ! m = 6
m = Maxval(a, Mask = a < 4)   ! m = 3
b = Maxval(a, dim=1)    ! b = [2 4 6]

Minloc (array [,dim] [,mask])
Minval (array [,dim] [,mask])
Merge (tsource, fsource, mask)

mask가 참이면 tsource, 거짓이면 fsource

Integer :: a(2,2), b(2,2), m(2,2)
a = Reshape( (/1,2,3,4/), (/2,2/) )
b = Reshape( (/3,3,3,3/), (/2,2/) )
m = Merge(a, b, a<b) ! m = Reshape( (/1,2,3,3/), (/2,2/) )

Pack (array, mask [,vector])

Product (array [,dim] [,mask]) : Function

mask가 참일 때, 주어진 차원으로 배열 요소를 곱하는 함수

Integer :: a(2,2), m(2), b
a = Reshape( (/1,2,3,4/), (/2,2/) )
b = Product(a)     ! b = 24
b = Product(a, Mask = a>2 )   ! b = 12
m = Product(a, Dim = 1)    ! m = [2 12]

Reshape (source, shape)

배열을 명시한 형상으로 재구성하는 함수

Integer :: a(2,2)
a = Reshape( (/1,2,3,4/), (/2,2/) ) ! a = [ 1 3; 2 4 ] 행렬

Shape (soruce)
Size (array [, dim])

배열의 크기 또는 차원을 계산하는 함수

Integer, Dimension(3, -1:3) :: a, b, c
b = Size(a) ! a = 3*5 = 15
c = Size(a, 2) ! c = 5

Spread (source, dim, ncopies)
Sum (array [,dim] [,mask])

배열의 합을 계산하는 함수

Integer :: a(2,2), m(2), b
a = Reshape( (/1,2,3,4/), (/2,2/) )
b = Sum(a)      ! a = 10
b = Sum(a, Mask = m>2)  ! b = 7
m = Sum(a, Dim = 1)  ! m = [3 7]

Transpose (matrix)
Ubound (array, dim)
Unpack (vector, mask, field)

10. 프로시져 (Procedure) (위로)

10.1 프로시져의 종류

종류 및 설명	프로시져의 시작	프로시져의 끝
주프로그램	Program UserName	End [Program UserName]
서브루틴	Subroutine UserName	End [Subroutine UserName]
함수	Function UserName	End [Function UserName]
모듈	Module UserName	End [Module UserName]
블록 테이터	Block Data [UserName]	End [Block Data [UserName]]

10.2 서브루틴의 종류

내부 서브루틴 프로시져
외부 서브루틴 프로시져
재귀 서브루틴 프로시져 ( Recursive Subroutine )
내장 서브루틴 프로시져 ( Intrinsic Subroutine )

표준 내장 서브루틴 : 포트란위원회에서 제정한 표준 내장 서브루틴

Cpu_Time(time) : 연산이나 계산 처리시간 산정

Cpu_time (start)
...
Cpu_time (End)
Print *, End-Start

Date_And_Time([date] [,time] [,zone] [,values]) : 날짜와 실시간 시계 자료
Mvbits(from, frompos, len, to, topos) : 하나의 정수형 자료객체를 다른 정수형 객체로 복사
Random_Number(harvest) : 범위 0<= x =< 1 내의 랜덤수
Random_Seed([size] [,put] [,get]) : Random_Number를 사용할 때 적용하는 랜덤수 생성기준
System_Clock(count, rate,max) : 정수형 자료로 실시를 구하는 서브루틴

비표준 내장 서브루틴 : 컴파일러 제조사에서 독자적으로 제공하는 서브루틴

함수 프로시져 ( Function )

[Type] Function FunctionName (인수들) [Result (전달인수)]
...
End Function FunctionName
내부 및 외부 함수 프로시져
문함수 ( Statement Functions )

Program Main
   Implicit None
   Real :: a, b=4.0, square, x
   Square(x) = x*x + x

   a = Square(4) + 5
   Print *, a
End Program

재귀 함수 프로시져 ( Recursive Function ) : 자기 자신을 다시 호출하는 함수 프로시져
내장 함수 ( Intrinsic Function ) : 컴파일러에서 제공하는 내장 함수

표준 내장함수 : 포트란위원회에서 제정한 표준 내장 함수

수치연산 기본함수
기본 수학함수
문자함수
배열함수
조회 및 바이트 조정함수
비트 처리 기본 프로시져
기타 내장 기본함수

비표준 내장함수 : 컴파일러 제조사에서 독자적으로 제공하는 함수

모듈 프로시져 : 프로시져에서 사용할 변수, 배열, 프로그램 전체에서 필요한 서브루틴이나
함수 프로시져의 사용형식을 정의

사용한 변수나 프로시져는 모두 전역 변수의 속성 Public 을 가진다.
모듈프로시져의 호출은 Use문을 사용한다.

모듈프로시져 호출법

Use ModuleName

모듈의 모든 정보 사용

Use ModuleName, Current_variable => Variable_of_module

변수명을 대체

Use ModuleName, Only : Variables_of_module

특정 변수만 사용

블록테이터 프로시져 ( Block Data )

한번 선언한 변수들의 기억장소를 공유시킴으로서 메모리를 절약하는 방법
Block Data MyData
   Implicit None
   Integer :: a, b
   Common /MyCom/ a, b(3)
   Data a/2/, b/3,4,5/
End Block Data MyData
Example ] blockdata.f

인터페이스 프로시져 ( Interface Procedure )

프로시져의 명과 형식을 정의하는 명령문
프로시져에서 사용할 변수나 배열을 선언문으로 정의하듯이 앞으로 사용될
프로시져나 사용자 정의의 연산자 등을 미리 정의하는 명령문
각종 오류를 최소화하기 위해 미리 정의
묵시적 인터페이스

프로시져의 모든 특성을 컴파일러에서 기본값으로 채택하고 있는 특성을 가진 프로시져
문함수, 외부프로시져와 같은 것은 묵시적 인터페이스

명시적 인터페이스 (권장)

프로시져의 모든 특성을 명확하게 정의하는 프로시져
주요인수(Keyword Argument), 정의할당(Defined Assignment)
정의연산자(Defined Operator)를 가진 인터페이스
일반이름(Generic Name)을 가진 명시적 인터페이스
Interface [Spec]
선언문들
End Interface [Spec]
Spec

GenericName

구조명이 있는 인터페이스 :: Interface2.f

Operator (operator)

내장연산자 중의 하나
.OperatorName.
정의 연산자를 가진 인터페이스 :: Interface3.f

Assignment (=)

+ , -, * , / , **
정의 할당문을 사용한 인터페이스 :: Interface4.f

구조명이 없는 인터페이스 :: Interface1.f

Example ]

Program Main
   Implicit None

   Interface
      Function F2c(t)
         Real :: f2c
         Real, Intent(IN) :: t
      End Function F2c
   End Interface

   Real : f, c
   Print *, " 화씨온도는 ? "
   Read *, f
   c = f2c(f)
   Print *, " 섭씨온도는 ? ", c

End Program Main

Function F2c(t)
   Implicit None
   Real :: f2c
   Real, Intent(IN) :: t
   f2c = (t-32)/1.8
End Function F2c

11. 외부파일 사용방법 (Open, Close) (위로)

11.1 Open 문 : 외부파일과 입출력장치번호를 연결 또는 재연결시키는 명령문

OPEN (Specs)

Default : Open(unitnumber, filename) == Open(unitnumber, filename, Access='Sequential', Form='Formatted')
Specs :

[Unit = ] unitnumber : 반드시 첫 항으로
[File = ] filename : 반드시 두 번째 항
Access = access

순차접근파일 : Sequential
직접접근파일 : Direct
2진법 파일 또는 투명접근파일 : Binary
기본정의(Default)는 순차접근 (Sequential)

Form = form

서식이 있는 경우 : Formatted : 순차접근의 기본

서식이 없는 경우 : UnFormatted : 직접접근의 기본

직접접근의 기본은 : UnFormatted

순차접근의 기본은 : Formatted

Status = status

외부파일 존재하고 새로운 외부파일 만들 때 : New
기존외부파일을 수정 또는 파일이 없는 경우 생성 : Replace
기존외부파일과 연결되었으나 수정모드 아닌 경우 : Old
프로그램 종료 또는 Close문 실행될 때 파일연결 해제 : Scratch (임시파일)
상기사항에 해당되지 않으면 : Unknown

Recl = recl

직접접근파일의 레코드 길이 ( 바이트 수 )
순차접근파일의 최대 레코드 길이 ( 바이트 수 )

Err = label

오류발생시 분기되는 문번호

Position = position

새로운 순차접근파일의 초기위치로 이동 : Rewind

기존파일의 마지막 레코드 전, 새로운 파일 끝 : Append (파일의 덧붙이기)

11.2 Close 문 : 외부파일과 연결해제

CLOSE(list)

Close(unitnumber, Status=status)

외부파일 보존 : Keep
외부파일 삭제 : Delete

11.3 대표적인 파일연결문과 입출력문의 사용법

순차접근 서식파일 : Text 문자파일

Open( unit, file, Access='Sequential', Form='Formatted')
Read( unit, format)
Write( unit, format)

순차접근 비서식파일 : 기계어나 2진법

Open( unit, file, Access='Sequential', Form='UnFormatted')
Read( unit )
Write( unit )

직접접근 서식파일 : Text 문자파일

Open( unit, file, Access='Direct', Form='Formatted', Recl=n )
Read( unit, Rec=n, format)
Write( unit, Rec=n, format)

직접접근 비서식파일 : 기계어나 2진법

Open( unit, file, Access='Direct', Form='UnFormatted', Recl=n )
Read( unit, Rec=n )
Write( unit, Rec=n )

11.4 Rewind 문 :

11.5 BackSpace 문 :

11.6 EndFile 문 :

11.7 Entry 문 :

12. 여러 가지 예제들 (위로)

십진법을 이진법으로 바꾸기 : fdecbin.f
근을 찾는 문제 :

아래의 포트란 파일을 Include 한 포트란 파일 : root.f

myft.f : 함수 f(x) 정의
bisect.f : 이분법
newton.f : 뉴톤법

Include를 사용하지 않고 컴파일 : root0.f

f90 -o root0 root0.f myft.f bisect.f newton.f

위의 파일을 함께 모아서 하나의 파일로 : root2.f
Makefile : root0.mak

ff        = ifc -FR (Tab키로 분리)
obj     = root0.o myft.o bisect.o newton.o (Tab키로 분리)
rootm : $(obj)
        $(ff) -o rootm $(obj)
root0.o : root0.f
        $(ff) root0.f -c -o root0.o
myft.o   : myft.f
        $(ff) myft.f -c -o root0.o
bisect.o : bisect.f
        $(ff) bisect.f -c -o root0.o
newton.o : newton.f
        $(ff) newton.f -c -o root0.o
make -f root0.mak

파생형 Type 명령을 사용한 주소록 프로그램(Module사용) : mylist.f
반복법 SOR Method : sor.f

Allocatable사용 및 여러 가지 함수 정의
Built in 함수 Dot_Product(a, b), Matmul(A, B) 사용
Built in 프로시져 Random_Number(a), Cpu_Time(t) 사용

실행파일에서 입력인자를 받아 들이는 프로그램 : argument.f
학점을 매기는 프로그램 : degree.f
Recursive를 이용한 Factorial값을 구하는 프로그램 : factor.f
Forall 예제(Reshape포함) 프로그램 : forall.f
Maxloc and Maxval : maxloc.f
유한 차분 등의 미분계수 구하기 : myder.f