Fortran
데이터 유형

내장 유형

다음은 Fortran에 내장 된 데이터 유형입니다.

integer
real
character
complex
logical

integer , real 및 complex 는 숫자 유형입니다.

character 는 문자열을 저장하는 데 사용되는 유형입니다.

logical 는 이진 값을 저장하는 데 사용됩니다 .true. 또는 .false. .

모든 숫자 및 논리 내장 유형은 종류를 사용하여 매개 변수화됩니다.

integer(kind=specific_kind)

또는 단지

integer(specific_kind)

여기서 specific_kind 는 정수라는 정수입니다.

kind 매개 변수를 갖는 것뿐만 아니라 문자 변수에도 length 매개 변수가 있습니다.

character char

char 를 기본 종류의 길이 1 문자 변수로 선언하는 반면,

character(len=len) name

name 을 기본 종류 및 길이 len 의 문자 변수로 선언합니다. 종류도 지정할 수 있습니다.

character(len=len, kind=specific_kind) name
character(kind=specific_kind) char

name 을 kind kind 및 length len 의 문자로 선언합니다. char 종류의 길이 1 문자 kind .

또는 문자 선언을위한 쓸모없는 양식

character*len  name

선언 이전의 코드에서 볼 수있는 name 길이의 수 len 과 기본 문자 종류.

intrinsic 타입의 변수 선언은 위의 형식 일 수 있지만 또한 type(...) 형식을 사용할 수도 있습니다.

integer i
real x
double precision y

(그러나 매우 선호된다)

type(integer) i
type(real) x
type(double precision) y

파생 된 데이터 형식

새로운 유형 인 mytype 정의하십시오.

type :: mytype
  integer :: int
  real    :: float
end type mytype

mytype 유형의 변수를 선언하십시오.

type(mytype) :: foo

파생 형식의 구성 요소는 % 연산자 ^1을 사용하여 액세스 할 수 있습니다.

foo%int = 4
foo%float = 3.142

Fortran 2003 기능 (아직 모든 컴파일러에서 구현되지 않음)은 매개 변수화 된 데이터 유형을 정의 할 수 있습니다.

type, public :: matrix(rows, cols, k)
  integer, len :: rows, cols
  integer, kind :: k = kind(0.0)
  real(kind = k), dimension(rows, cols) :: values
end type matrix

파생 형식 matrix 에는 형식 이름 뒤에 오는 괄호 안에 나열된 세 개의 형식 매개 변수가 있습니다 ( rows , cols 및 k ). 각 유형 매개 변수의 선언에서 유형 ( kind ) 또는 길이 ( len ) 유형 매개 변수인지 여부를 표시해야합니다.

내장 유형과 같은 종류 유형 매개 변수는 상수 표현식이어야하며 고유 유형 변수의 길이와 같은 길이 유형 매개 변수는 실행 중에 변경 될 수 있습니다.

매개 변수 k 는 기본값을 가지므로 다음과 같이 matrix 유형의 변수가 선언 될 때 제공되거나 생략 될 수 있습니다

type (matrix (55, 65, kind=double)) :: b, c ! default parameter provided
type (matrix (rows=40, cols=50)     :: m    ! default parameter omitted

파생 된 형식의 이름은 doubleprecision 또는 내장 형식과 동일하지 않을 수 있습니다.

1. 많은 사람들이 Fortran이보다 일반적인 것 대신에 컴포넌트 액세스 연산자로 % 를 사용하는 이유를 궁금해 . . 이 때문입니다 . 연산자 구문에 의해 이미 취해진 다 .not. , .and. , .my_own_operator. .

부동 소수점 숫자의 정밀도

real 유형의 부동 소수점 수는 실제 값을 가질 수 없습니다. 그들은 10 진수의 특정 양까지 실수를 나타낼 수 있습니다.

FORTRAN 77은 2 개의 부동 소수점 유형을 보장하며 최근의 표준은 최소한 두 개의 실제 유형을 보장합니다. 실제 변수는 다음과 같이 선언 될 수 있습니다.

real x
double precision y

여기서 x 는 기본 종류의 실수이고 y 는 x 보다 십진 정밀도가 큰 종류의 실수입니다. Fortran 2008에서 y 의 십진수 정밀도는 10 이상이고 십진 지수는 37 이상입니다.

 real, parameter             :: single = 1.12345678901234567890
 double precision, parameter :: double = 1.12345678901234567890d0
 
 print *, single
 print *, double

인쇄물

   1.12345684    
   1.1234567890123457

기본 구성을 사용하는 공통 컴파일러에서.

double precision 상수의 d0 에 주목하십시오. 지수를 나타 내기 위해 e 대신 d 포함 된 실제 리터럴은 배정 밀도를 나타내는 데 사용됩니다.

! Default single precision constant
1.23e45
! Double precision constant
1.23d45

Fortran 90은 종류를 사용하여 매개 변수화 된 real 유형을 도입했습니다. 실제 유형의 종류는 상수 또는 리터럴 상수라는 정수입니다.

real(kind=real_kind) :: x

또는 단지

real(real_kind) :: x

이 문은 x 가 real_kind 의 값에 따라 특정 정밀도를 갖는 real 유형으로 선언합니다.

부동 소수점 리터럴은 접미사를 사용하여 특정 종류로 선언 될 수 있습니다.

1.23456e78_real_kind

real_kind 의 정확한 값은 표준화되지 않았으며 컴파일러마다 다릅니다. 실제 변수 또는 상수의 종류를 문의하려면 kind() 함수를 사용할 수 있습니다.

print *, kind(1.0), kind(1.d0)

일반적으로 인쇄 할 것이다.

4 8

또는

1 2

컴파일러에 따라 다릅니다.

종류 번호는 여러 가지 방법으로 설정할 수 있습니다.

1. 단일 (기본값) 및 배정 밀도 :

   integer, parameter :: single_kind = kind(1.)
   integer, parameter :: double_kind = kind(1.d0)
   

2. 내장 함수 인 selected_real_kind([p, r]) 를 사용하여 필요한 소수 정밀도를 지정합니다. 리턴 된 종류는 적어도 p 자리의 정밀도를 가지며 적어도 r 지수를 허용합니다.

   integer, parameter :: single_kind = selected_real_kind( p=6, r=37 )
   integer, parameter :: double_kind = selected_real_kind( p=15, r=200 )
   

3. Fortran 2003부터 내장 모듈 ISO_C_Binding 을 통해 미리 정의 된 상수를 사용하여 실제 종류가 동봉 된 C 컴파일러의 float , double 또는 long_double 유형과 상호 작동 할 수 있도록합니다.

   use ISO_C_Binding
   
   integer, parameter :: single_kind = c_float
   integer, parameter :: double_kind = c_double
   integer, parameter :: long_kind = c_long_double
   

4. Fortran 2008부터 미리 정의 된 상수는 내장 모듈 ISO_Fortran_env 통해 사용할 수 있습니다. 이러한 상수는 비트 단위로 특정 저장 크기를 가진 실제 종류를 제공합니다.

   use ISO_Fortran_env
   
   integer, parameter :: single_kind = real32
   integer, parameter :: double_kind = real64
   integer, parameter :: quadruple_kind = real128
   

컴파일러에서 특정 종류를 사용할 수없는 경우 selected_real_kind() 또는 정수 상수 값에 의해 반환 된 값은 -1 입니다.

추정 및 지연 길이 유형 매개 변수

문자 유형 또는 길이 매개 변수가있는 파생 유형의 변수에는 길이 매개 변수가 가정 또는 지연 될 수 있습니다. 문자 변수 name

character(len=len) name

실행 중에 길이가 len 입니다. 반대로 길이 지정자는

character(len=*) ...  ! Assumed length

또는

character(len=:) ...  ! Deferred length

가정 된 길이 변수는 다른 엔티티의 길이를 가정합니다.

함수에서

function f(dummy_name)
  character(len=*) dummy_name
end function f

dummy 인수 dummy_name 은 실제 인수의 길이 dummy_name 집니다.

명명 된 상수 const_name in

character(len=*), parameter :: const_name = 'Name from which length is assumed'

오른쪽의 상수 표현에 의해 주어진 길이를가집니다.

지연 길이 유형 매개 변수는 실행 중에 달라질 수 있습니다. 지연 길이가있는 변수에는 allocatable 또는 pointer 속성이 있어야합니다.

character(len=:), allocatable :: alloc_name
character(len=:), pointer :: ptr_name

이러한 변수의 길이는 다음과 같은 방법으로 설정할 수 있습니다.

allocate(character(len=5) :: alloc_name, ptr_name)
alloc_name = 'Name'         ! Using allocation on intrinsic assignment
ptr_name => another_name    ! For given target

길이 매개 변수화가있는 파생 유형의 경우 구문이 비슷합니다.

  type t(len)
    integer, len :: len
    integer i(len)
  end type t

  type(t(:)), allocatable :: t1
  type(t(5)) t2

  call sub(t2)
  allocate(type(t(5)) :: t1)

contains

  subroutine sub(t2)
    type(t(*)), intent(out) :: t2
  end subroutine sub

end  

리터럴 상수

프로그램 단위는 종종 리터럴 상수를 사용합니다. 이것들은 명백한 경우를 포함합니다.

print *, "Hello", 1, 1.0

한 가지 경우를 제외하고는, 각각의 리터럴 상수는 유형, 유형 매개 변수 및 구문에 의해 주어진 값을 갖는 스칼라입니다.

정수 리터럴 상수는 형태를가집니다.

1
-1
-1_1   ! For valid kind parameter 1
1_ik   ! For the named constant ik being a valid kind paramter

실제 리터럴 상수는 형식입니다.

1.0    ! Default real
1e0    ! Default real using exponent format
1._1   ! Real with kind parameter 1 (if valid)
1.0_sp ! Real with kind paramter named constant sp
1d0    ! Double precision real using exponent format
1e0_dp ! Real with kind named constant dp using exponent format

복잡한 리터럴 상수는 형태를가집니다.

(1, 1.)       ! Complex with integer and real components, literal constants
(real, imag)  ! Complex with named constants as components

실수 및 허수 성분이 모두 정수 인 경우 복합 리터럴 상수는 기본 복소수이며 정수 구성 요소는 기본 실수로 변환됩니다. 하나의 구성 요소가 실수 인 경우 복합 리터럴 상수의 종류 매개 변수는 실수의 정수 매개 변수이며 정수 구성 요소는 실제 매개 변수로 변환됩니다. 두 구성 요소가 모두 실제 인 경우 복잡한 상수 상수는 가장 정밀도가 높은 실수 유형입니다.

논리 리터럴 상수는

.TRUE.     ! Default kind, with true value
.FALSE.    ! Default kind, with false value
.TRUE._1   ! Of kind 1 (if valid), with true value
.TRUE._lk  ! Of kind named constant lk (if valid), with true value

문자 리터럴 값은 종류 지정자가 값 앞에 오는 점에서 약간 개념이 다릅니다.

"Hello"       ! Character value of default kind
'Hello'       ! Character value of default kind
ck_"Hello"    ! Character value of kind ck
"'Bye"        ! Default kind character with a '
'''Bye'       ! Default kind character with a '
""            ! A zero-length character of default kind

위에서 제안한 것처럼. 자 리터럴 상수는 어포 스트로피 또는 따옴표로 구분되어야하며 시작 및 종료 표시자가 일치해야합니다. 리터럴 아포스트로피는 따옴표 구분 기호 안에 있거나 두 번 나타나면 포함될 수 있습니다. 따옴표와 동일합니다.

BOZ 상수는 오직 값만 지정한다는 점에서 위와는 다르다. 유형이나 유형 매개 변수가 없다. BOZ 상수는 비트 패턴이며 다음과 같이 지정됩니다.

B'00000'    ! A binary bit pattern
B"01010001" ! A binary bit pattern
O'012517'   ! An octal bit pattern
O"1267671"  ! An octal bit pattern
Z'0A4F'     ! A hexadecimal bit pattern
Z"FFFFFF"   ! A hexadecimal bit pattern

BOZ 리터럴 상수는 data 문의 상수 및 내장 프로 시저의 선택과 같이 나타날 수있는 위치가 제한됩니다.

문자 하위 문자열 액세스

문자 엔티티의 경우

character(len=5), parameter :: greeting = "Hello"

구문과 함께 부분 문자열을 참조 할 수 있습니다.

greeting(2:4)  ! "ell"

한 글자에 액세스하는 것은 쓰기에 충분하지 않습니다.

greeting(1)    ! This isn't the letter "H"

그러나

greeting(1:1)  ! This is "H"

문자 배열의 경우

character(len=5), parameter :: greeting(2) = ["Hello", "Yo!  "]

우리는 다음과 같은 하위 문자열 액세스 권한을가집니다.

greeting(1)(2:4)  ! "ell"

그러나 연속되지 않는 문자는 참조 할 수 없습니다.

greeting(:)(2:4)  ! The parent string here is an array

리터럴 상수의 부분 문자열에도 액세스 할 수 있습니다.

"Hello"(2:4)

문자 변수의 일부는 하위 문자열을 변수로 사용하여 정의 할 수도 있습니다. 예를 들어

integer :: i=1
character :: filename = 'file000.txt'

filename(9:11) = 'dat'
write(filename(5:7), '(I3.3)') i

복잡한 구성 요소에 액세스하기

복잡한 엔티티

complex, parameter :: x = (1., 4.)

진짜 부분 1. 과 복잡한 부분 4. 있습니다. 우리는 이러한 개별 구성 요소에 액세스 할 수 있습니다.

real(x)  ! The real component
aimag(x) ! The complex component
x%re     ! The real component
y%im     ! The complex component

x%.. 형태는 Fortran 2008에 새로 추가되었으며 컴파일러에서 널리 지원되지 않습니다. 그러나이 형식은 복잡한 변수의 개별 구성 요소를 직접 설정하는 데 사용될 수 있습니다

complex y
y%re = 0.
y%im = 1.

선언과 속성

여기서 주제와 예제를 통해 변수, 함수 등의 많은 선언을 볼 수 있습니다.

이름뿐만 아니라 데이터 객체도 속성을 가질 수 있습니다. 이 주제에는 다음과 같은 선언문이 포함됩니다.

integer, parameter :: single_kind = kind(1.)

이것은 single_kind 객체에 parameter 속성을 부여합니다 (명명 된 상수로 지정).

다른 많은 속성이 있습니다.

• target
• pointer
• optional
• save

속성은 소위 속성 지정 문 으로 지정 될 수 있습니다

integer i    ! i is an integer (of default kind)...
pointer i    ! ... with the POINTER attribute...
optional i   ! ... and the OPTIONAL attribute

그러나 일반적으로 이러한 속성 지정 문을 사용하지 않는 것이 좋습니다. 명확성을 위해 속성은 단일 선언의 일부로 지정 될 수 있습니다

integer, pointer, optional :: i

이것은 암시 적 타이핑을 사용하려는 유혹을 줄여줍니다.

이 포트란 문서의 대부분의 경우이 단일 선언문을 사용하는 것이 좋습니다.