Справочное руководство по языку Fortran 95

Глава 2.Алфавитный справочник

• Конструкт CASE
• Оператор CASE
• Функция CEILING
• Функция CHAR
• Оператор CHARACTER
• Оператор CLOSE
• Функция CMPLX
• Оператор COMMON
• Оператор COMPLEX
• Оператор Computed GOTO
• Функция CONJG
• Оператор CONTAINS
• Оператор CONTINUE
• Функция COS

Конструкт CASE

Результат
Результат есть значение item. Его тип данных C определяется так:

Таблица 8: Ответные типы CARG

[ construct-name : ] SELECT CASE (case-expr)
CASE (case-selector [, case-selector ] ...  ) [ construct-name ]
                          block
                          ...
CASE DEFAULT [ construct-name ]]
                         block
                          ...
END SELECT [construct-name]

Здесь:
construct-name есть  необязательное имя для конструкта CASE.
case-expr есть скалярное выражение типа INTEGER, LOGICAL или CHARACTER.
case-selector is case-value  или  : case-value  или case-value :  или
case-value : case-value.
case-value есть постоянное скалярное LOGICAL, INTEGER

или CHARACTER выражение.
block есть последовательность из 0 или более операторов или исполнимых
консруктов.

Выполнение оператора SELECT CASE сводится к вычислению значения case-expr (см. SELECT CASE). Вычисленное значение называется case-индекс. Если индекс лежит в пределах, указанных в case-selector оператора CASE, выполняется блок, следующий за оператором CASE, если он есть.
case-selector вычисляется следующим образом:

case-value означает равенство с case-value;
: case-value означает меньше чем или равно case-value;
case-value : означает больше чем или равно case-value; и
case-value : case-value означает больше чем или равно левому case-value, и меньше чем или равно правому case-value.
Блок, следующий за CASE DEFAULT, если такой есть, выполняется, если индекс не соответствует ни одному из case-value в конструкте. CASE DEFAULT может стоять перед, в середине или после других операторов CASE, или может отсутствовать.

Каждое case-value должно быть той же разновидности, что и case-индекс. Области case-values в конструкте не должны перекрываться. Только один CASE DEFAULT допустим в конструкте.

Если оператор SELECT CASE имеет construct-name, то соответствующий оператор END SELECT должен быть идентифицирован тем же именем. Если SELECT CASE не имеет construct-name, то соответствующий оператор END SELECT не должен иметь имени. Если какой-нибудь оператор CASE идентифицирован посредством construct-name, то соответствующий оператор SELECT CASE должен иметь то же самое имя.

   select case (i)
            case (:-2)
               print*, "i is less than or equal to -2"
            case (0)
               print*, "i is equal to 0"
            case (1:97)
               print*, "i is in the range 1 to 97, inclusive"
            case default
               print*, "i is either -1 or greater than 97"
            end select
       

Оператор CASE

Описание
Выполнение оператора SELECT CASE требует вычисления case expression (см.SELECT CASE). Полученное значение называется case-индекс. Если этот индекс находится в области, указанной в операторе CASE посредством case-selector, то блок, следующий за оператором CASE, выполняется (если такой блок имеется).

           CASE (case-selector [, case-selector ] ...  ) [ construct-name ]
             или
           CASE DEFAULT [ construct-name ]
             Здесь:
            case-selector есть case-value
            или : case-value
            или case-value :
            или case-value : case-value.
            case-value есть постоянное скалярное выражение  типа LOGICAL,
            INTEGER или  CHARACTER.
            construct-name есть необязательное имя, присвоенное конструкту.

Пример

                     select case (i)
                     case (:-2)
                        print*, "i есть меньше или равно -2"
                     case (0)
                        print*, "i равно  0"
                     case (1:97)
                        print*, "i лежит в области от 1 до 97 включительно"
                     case default
                        print*, "i есть или -1 или больше чем 97"
                     end select

Функция CEILING

Описание
Наименьшее INTEGER, которое больше или равно значению аргумента.

Функция CHAR

Syntax
CEILING (a, kind)
Обязательный аргумент
a должно иметь тип REAL.
Необязательный аргумент
kind должен быть скалярным выражением типа INTEGER, которое можно вычислить во время компиляции.
Результат
Результат есть INTEGER со значением наименьшего целого, равного или большего чем a. Если присутствует kind, он определяет разновидность результата. Если kind отсутствует, используется параметр разновидности по умолчанию для типа REAL.
Пример

                 i = ceiling (-4.7) ! i получает значение  -4
                 i = ceiling (4.7)            ! i получает значение  5

        c = char(65) ! char получает значение 'A'
            ! с разновидностью, принятой по умолчанию для символов  ASCII

Оператор CHARACTER

Описание
Оператор CHARACTER объявляет примитив типа CHARACTER.
Syntax

  CHARACTER [char-selector] [, attribute-list :: ] entity [, entity ] ...

        Здесь:

       char-selector есть length-selector
       или  (LEN = type-param, KIND = kind-param)
       или  (type-param, KIND = kind-param)
       или (KIND = kind-param, LEN = type-param, ).
       length-selector есть ( [ LEN = ] type-param)
       или  * char-length.
       char-length есть  ( type-param)
       или scalar-int-literal-constant.
       type-param есть specification-expr
       или * .
 

specification-expr есть скалярное выражение типа INTEGER, которое можно вычислить при входе в программную единицу. kind-param есть скалярное выражение типа INTEGER, которое можно вычислить при компиляции.

entity есть entity-name [(array-spec)] [* char-length] [= initialization-expr] или function-name [(array-spec)] [* char-length]. array-spec есть спецификация массива.

1. Если примитив есть фиктивный аргумент. Фиктивный аргумент подразумевает длину соответствующего фактического аргумента.
2. Если объявляется именованная постоянная. Длина есть длина ее значения.
3. Во внешней функции как длину ее результата. В этом случае имя функции должно быть объявлено в вызывающей единице видимости с длиной, отличной от * доступно для определения по ассоциации с host или use. Длина полученной переменной предполагается согласно этому определению.

char-length для операторных функций со значением типа CHARACTER и фиктивных аргументов операторных функций должна быть постоянным выражением типа INTEGER.
Необязательная запятая, следующая за * char-length в char-selector, допустима только если в операторе нет двойных двоеточий.
Значение разновидности должно указывать множество символов, доступных в используемом компиляторе.
char-length должна включать параметр разновидности.
* char-length в примитиве указывает длину одного примитива и подавляет длину, указанную в char-selector.
Тот же самый атрибут не должен появляться более одного раза в операторе CHARACTER.

function-name должно быть именем внешней, встроенной или операторной функции или фиктивной процедуры функции
= initialization-expr должно появляться, если оператор содержит атрибут PARAMETER. Если = initialization-expr присутствует, удвоенное двоеточие должно появиться перед списком примитивов.

Каждый примитив имеет атрибут SAVE,если он не находится в именованном блоке common.
= initialization-expr не должно употребляться, если entity-name есть фиктивный аргумент, результат функции, объект в именованном блоке common за исключением случаев объявления типа в программной единице блок данных, объекта в безымянном блоке common, размещаемого массива, указателя, внешнего имени, встроенного имени или автоматического объекта.

Массив, объявленный с атрибутом POINTER или ALLOCATABLE, должен быть специфицирован с отложенной формой.
array-spec для имени функции, которая не имеет атрибута POINTER или ALLOCATABLE, должен быть специфицирован в явной форме.
array-spec для имени функции, которая имеет атрибут POINTER или ALLOCATABLE, должен специфицироваться с отложенной формой.
Если указан атрибут POINTER, атрибуты TARGET, INTENT, EXTERNAL или INTRINSIC указываться не должны.
Если указан атрибут TARGET, то атрибуты POINTER, EXTERNAL, INTRINSIC или PARAMETER не должны указываться.
Атрибут PARAMETER не должен указываться для фиктивных аргументов, указателей, размещаемых массивов, функций или объектов в блоках common.

Атрибуты INTENT и OPTIONAL могут указываться только для фиктивных аргументов.
Примитив не должен иметь атрибут PUBLIC, если его тип имеет атрибут PRIVATE.
Атрибут SAVE не должен указываться для объектов, которые находятся в в блоке common, для фиктивных аргументов, процедур, результатов функций или автоматических объектов данных.
Примитив не должен иметь атрибут EXTERNAL,если он имеет атрибут INTRINSIC.
Примитив в операторе CHARACTER не должен специфицироваться с атрибутом EXTERNAL или INTRINSIC, если это не функция.
Массив не может иметь одновременно атрибуты ALLOCATABLE и POINTER. Примитив не должен получать явно атрибут более одного раза в единице видимости.
Если char-length не есть постоянное выражение, длина объявляется при входе в процедуру и не подвержена никаким переопределениям переменных в выражениях спецификации во время исполнения процедуры.

                     character (len=2) :: x,y,z   ! x,y,z длины 2
                          character(len = *) :: d   ! длина фиктивного  d
                                                    ! определяется при
                                                    ! вызове процедуры

Оператор CLOSE

Описание
Оператор CLOSE прерывает связь указанного устройства с внешним файлом.
Syntax

                          CLOSE ( close-spec-list )
                Здесь:
                close-spec-list есть разделенный запятыми список  close-specs.
                close-spec есть [ UNIT = ] external-file-unit
                или  IOSTAT = iostat
                или  ERR = label
                или  STATUS = статус
                external-file-unit есть номер устройства ввода/вывода для
                внешних файлов.

iostat есть скалярная по умолчанию INTEGER переменная.
Если присутствует, она получает номер сообщения об ошибке, генерируемого при исполнении программы, если ошибка произошла при выполнении CLOSE и программа не прерывается; если ошибок нет, она получает значение 0.
label есть метка оператора, который получает управление, если при выполнении CLOSE обнаружена ошибка.
status есть выражение типа CHARACTER со значением 'KEEP' или 'DELETE'.

          close (8, status = 'keep') ! устройство  8 закрывается с keep
                close (err = 200, unit = 9) ! устройство 9 закрывается;
                          ! при ошибке переход по метке  200

Функция CMPLX

    y = cmplx (3.2, 4.7) ! y получает значение (3.2, 4.7)
          z = cmplx (3.2)   ! z получает значение (3.2, 0.0)

Оператор COMMON

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

               
COMMON [ / [ common-name ] / ] common-object-list [[,] / [ common-name ] /
                          common-object-list ] ...
                Здесь:
common-name есть имя объявляемого блока common
common-object-list есть список через запятую объектов данных, которые
объявляются в блоке common.

Если common-name присутствует, все объекты данных в соответствующем common-object-list объявляются именно в блоке с именем common-name. Если common-name опущено, все объекты данных в первом common-object-list относятся к безымянному блоку common.

Для каждого блока common последовательность в памяти формируется из последовательностей в памяти всех объектов common-блока, в том порядке, в каком они фигурируют в common-object-lists в единице видимости.

Если последовательность в памяти ассоциируется с эквивалентностью, связанной с блоком, последовательность может быть расширена только добавлением единиц памяти после самой последней единицы.

В пределах исполняемой программы, последовательности в памяти всех блоков common с тем же именем (или всех безымянных блоков) имеют одну и ту же первую единицу памяти. Это приводит к ассоциированию объектов в разных областях видимости.
Безымянный блок имеет те же самые свойства, как и именованный блок, за исключением:

1. Выполнение операторов RETURN или END может привести к тому, что объекты данных в именованном блоке станут неопределенными в именованном блоке, если его имя не было объявлено в операторе SAVE.
2. Именованные блоки common с тем же именем должны иметь один и тот же размер во всех единицах видимости программы, в которой они появились, а безымянные блоки могут иметь различные размеры.
3. Объекты данных в именованном common могут быть изначально определены в операторе DATA или объявлениях типа в программной единице блок данных, а объекты данных в безымянном common не должны быть изначально определенными.

Имя блока common или безымянный common могут появляться многократно в одном или более операторах COMMON в единице видимости. В таком случае common-object-list трактуется как продолжение common-object-list для текущего блока common.

Конкретный объект данных может появиться только один раз во всех common-object-lists в единице видимости.

Объект данных в common-object-list не может быть фиктивным аргументом, размещаемым массивом, автоматическим объектом, именем функции, именем входа или именем результата.

Каждая граница в объекте данных со значением массива в common-object-list должна быть постоянным специфицирующим выражением.

Если объект данных в common-object-list имеет производный тип, производный тип должен имиеть атрибут sequence.

Указатель может ассоциироваться только с указателем того же типа, Разновидностью, длины и ранга.

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

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

Объекты данных, по умолчанию имеющие тип CHARACTER, не должны становиться ассоциированными с объектами, получившими по умолчанию типы REAL, DOUBLE PRECISION, INTEGER, COMPLEX, DOUBLE COMPLEX или LOGICAL.

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

Объекты производного типа, в которых все компоненты имеют по умолчанию тип CHARACTER, могут ассоциироваться с объектами типа CHARACTER.

Оператор EQUIVALENCE не может разрешать последовательностям памяти двух разных блоков стать ассоциируемыми.

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

            
        common /first/ a,b,c                  ! a, b и c есть в именованном
                                                       ! common first
        common d,e,f, /second/, g        ! d, e и f лежат в безымянном
                                                 ! common, g в именованном  in named
                                                   ! common second
        common /first/ h                      ! h тоже в first

Оператор COMPLEX

COMPLEX [ kind-selector ] [ [, attribute-list ] :: ] entity [, entity ] ...
                где:
kind-selector есть ( [ KIND = ] scalar-int-initialization-expr )
scalar-int-initialization-expr есть скалярное выражение типа INTEGER, которое
можно вычислить при компиляции.
attribute-list есть список через запятую из следующих атрибутов: PARAMETER,
ALLOCATABLE, DIMENSION (array-spec), EXTERNAL, INTENT (IN) или INTENT (OUT) или
INTENT (IN OUT), PUBLIC или PRIVATE, INTRINSIC, OPTIONAL, POINTER, SAVE,
                TARGET.
entity is имя примитива [ ( array-spec ) ] [ = initialization-expr ]
или function-name [ ( array-spec ) ].
array-spec есть спецификация массива.
initialization-expr есть выражение, которое можно вычислить при компиляции.
entity-name есть имя объявляемого объекта данных.
function-name есть имя объявляемой функции.

Один и тот же атрибут не может появиться более одного раза в операторе COMPLEX. statement.function-name должно быть именем внешней, встроенной или операторной функции или фиктивной процедуры функции. = initialization-expr может появиться, если оператор содержит атрибут PARAMETER.

Если появится = initialization-expr, то двойное двоеточие должно стоять перед списком примитивов list of entities. Каждый примитив имеет атрибут SAVE, если не стоит в именованном блоке common.

= initialization-expr не может появиться, если entity-name есть фиктивный аргумент, результат функции, объект в именованном блоке common за исключением случая, когда объявление типа стоит в программной единице блок данных, объект в безымянном common, размещаемый массив, указатель, внешнее имя, встроенное имя или автоматический объект.

Массив, объявленный с атрибутом POINTER или ALLOCATABLE, должен специфицироваться с отложенной формой.

array-spec для function-name, которая не имеет атрибута POINTER или ALLOCATABLE, должен специфицироваться с явной формой.

array-spec для function-name, которая имеет атрибут POINTER или ALLOCATABLE, должен специфицироваться с отложенной формой.

Если указан атрибут POINTER, то не должны указываться атрибуты TARGET, INTENT, EXTERNAL или INTRINSIC.

Если указан атрибут TARGET, атрибуты POINTER, EXTERNAL, INTRINSIC или PARAMETER указываться не должны.

Атрибут PARAMETER не должен указываться для фиктивных аргументов, указателей, размещаемых массивов или объектов в блоке common.

Атрибуты INTENT и OPTIONAL могут указываться только для фиктивных аргументов.

Примитив не может иметь атрибут PUBLIC, если его тип имеет атрибут PRIVATE.

Атрибут SAVE не должен специфицировать объект, который находится в блоке common, фиктивный аргумент, процедуру, результат функции или автоматический объект данных.

Примитив не должен иметь атрибута EXTERNAL, если он имеет атрибут INTRINSIC.

Примитив в операторе COMPLEX не может иметь атрибуты EXTERNAL или INTRINSIC, если он не функция.

Массив не может иметь одновременно атрибуты ALLOCATABLE и POINTER.

Примитив не может получать явно любой атрибут более одного раза в области видимости.

         complex :: a, b, c            ! a, b, и c имеют тип  complex
         complex, dimension (2, 4) :: d
                                       ! d есть  2 x 4 комплексный массив
         complex :: e = (2.0, 3.14159)
                                       ! инициализируется complex e

Оператор Computed GOTO

                          GO TO ( labels ) [ , ] scalar-int-expr

                Здесь:
                labels есть разделенный запятыми список меток.

                scalar-int-expr есть скалярное выражение типа INTEGER.

                                  goto (10,20,30) i
                          10      a = a+1 ! if i=1, управление передается сюда
                          20      a = a+1 ! if i=2, управление передается сюда

                          30      a = a+1 ! if i=3, управление передается сюда

Функция CONJG

                x = conjg (2.1, -3.2) ! x получает
                                              ! значение (2.1, 3.2)

Оператор CONTAINS

                subroutine outside (a)
                  implicit none
                  real, intent(in) :: a
                  integer :: i, j
                  real :: x
                  ...
                  call inside (i)
                  x = sin (3.89)               ! не встроенный sin()
                  ...

                  contains

                  subroutine inside (k) ! недоступна вне outside()
                    implicit none
                    integer, intent(in) :: k
                    ...
                  end subroutine inside



                   function sin (m) ! недоступна вне outside()
                     implicit none
                     real :: sin
                     real, intent(in) :: m
                                 ...
                    end function sin
                 end subroutine outside

Оператор CONTINUE

                                  do 10 i=1,100
                                  ...
                           10     continue

Функция COS