Fortran
Типы данных

algorithm C Language C# Language C++ Java Language GNU/Linux MATLAB Language Python Language R Language vim
Поиск…


Внутренние типы

Ниже перечислены типы данных, присущие Fortran: 

integer
real
character
complex
logical

integer , real и complex - числовые типы.

character - это тип, используемый для хранения символьных строк.

logical используется для хранения двоичных значений .true. или .false. ,

Все числовые и логические внутренние типы параметризуются с использованием видов. 

integer(kind=specific_kind)

или просто 

integer(specific_kind)

где specific_kind - целое число с константой.

Символьные переменные, а также имеющие параметр вида, также имеют параметр длины: 

character char

объявляет char как переменную символа length-1 типа по умолчанию, тогда как 

character(len=len) name

объявляет name символьной переменной по умолчанию и длиной len . Можно также указать вид 

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

объявляет name символом доброго kind и длины len . char является длиной 1 символ доброго kind .

Альтернативно, устаревшая форма для объявления символа 

character*len  name

может быть замечен в более старом коде, объявляя, что name имеет длину len и тип символа по умолчанию.

Объявление переменной внутреннего типа может иметь форму выше, но также может использовать форму 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 ) или length ( 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. е .not. , .and. , .my_own_operator. ,

Точность чисел с плавающей запятой

Числа с плавающей точкой типа real не могут иметь никакого реального значения. Они могут представлять действительные числа до определенного количества десятичных цифр.

FORTRAN 77 гарантирует два типа с плавающей точкой, а более поздние стандарты гарантируют по меньшей мере два реальных типа. Реальные переменные могут быть объявлены как 

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

в обычных компиляторах, использующих конфигурацию по умолчанию.

Обратите внимание на d0 в константе двойной точности. Для обозначения двойной точности используется реальный литерал, содержащий d вместо e для обозначения экспоненты. 

! 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 с определенной точностью в зависимости от значения real_kind .

Литералы с плавающей запятой могут быть объявлены в определенном виде с использованием суффикса 

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 чтобы гарантировать, что реальные виды взаимодействуют с типами float , double или long_double сопроводительного компилятора C: 

    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_name имеет длину фактического аргумента.

Именованная константа const_name в 

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

Это также уменьшает соблазн использовать неявное типирование.

В большинстве случаев в этой документации по Фортрану это утверждение является предпочтительным.



Modified text is an extract of the original Stack Overflow Documentation
Лицензировано согласно CC BY-SA 3.0
Не связан с Stack Overflow