Вы здесь

Встроенные функции Fortran 90

 

Встроенные функции Fortran 90

Введение

Здесь большое число встроенных функций Fortran 90 и 5 встроенных подпрограмм. Численные и математические подпрограммы рассмотрены очень кратко, поскольку они не заменены по сравнению с Fortran 77 и они могут быть известны.

Раздел базируется на секции 13 стандарта ISO (1991), который содержит более формальное рассмотрение. Мы следуем представлению различных функций и подпрограмм стандарта, но более подробное рассмотрение мы увидим у Metcalf и Reid (1990, 1993).

Необязательные параметры даны малыми буквами. Когда список параметров содержит более одного параметра, функции могут быть вызваны позиционным перечислением параметров или с ключевыми словами. Ключевые слова дожны быть использованы обязательно, если предыдущие аргументы не включены. Ключевые слова обычно это имена, которые даны ниже. Мы не можем снова давать все естественные ограничения на переменные, например, что ранг не может быть отрицательным.

1. Функции, которые определяют, есть ли некий аргумент в списке фактических параметров:

Функция PRESENT(A) возвращает .TRUE. если аргумент A есть в вызывающем списке, .FALSE. в противном случае. Использование иллюстрируется в примере программы в главе 8 основного текста.

2. Числовые функции:

Следующие доступные из Fortran 77: ABS, AIMAG, AINT, ANINT, CMPLX, CONJG, DBLE, DIM, DPROD, INT, MAX, MIN, MOD, NINT, REAL и SIGN.

Дополнительно, CEILING, FLOOR и MODULO добавлены к Fortran 90. Только последняя трудна для объяснения, которое облегчается примером из ISO (1991)

    MOD (8,5)    дает  3     MODULO (8,5)    дает  3
    MOD (-8,5)   дает -3     MODULO (-8,5)   дает  2
    MOD (8,-5)   дает  3     MODULO (8,-5)   дает -2
    MOD (-8,-5)  дает -3     MODULO (-8,-5)  дает v3

Следующие функции из Fortran 77 могут иметь параметры вида (kind-parameter) подобно AINT(A, kind), именно AINT, ANINT, CMPLX, INT, NINT и REAL.

Исторический факт, что численные функции в Fortran 66 могли иметь специальные (различные) имена для различных точностей, и эти явные имена являются единственными, которые можно использовать, когда имя функции используется как аргумент.

Полная таблица всех числовых функций следует ниже. Те имена, которые помечены символом звездочка *, не разрешены для использования в качестве аргумента. Некоторые функции, подобно INT и IFIX имеют два специальных имени, из которых оба могут быть использованы. С другой стороны некоторые функции могут не иметь никаких специальных имен. Ниже я использую C для значений комплексных с плавающей точкой, D для значений двойной точности с плавающей точкой, I для целых, и R для значений одинарной точности с плавающей точкой.

Функци        Generic  Specific Data type
                name     name     Arg   Res
 
Преобразование  INT      -        I     I
 в  integer            * INT      R     I
                       * IFIX     R     I
                       * IDINT    D     I
 (вещественной части)    -        C     I
 
Преобразование  REAL   * REAL     I     R
 в real                * FLOAT    I     R
                         -        R     R
                       * SNGL     D     R
 (вещественная часть)    -        C     R
 
Преобразование  DBLE     -        I     D
 в  double               -        R     D
 precision               -        D     D
 (вещественная часть)    -        C     D
 
Преобразование  CMPLX    -     I (2I)   C
 в  complex              -     R (2R)   C
                         -     D (2D)   C
                         -        C     C
 
Усечение                 AINT     AINT     R     R
                         DINT     D     D
 
Округление               ANINT    ANINT    R     R
                         DNINT    D     D
                NINT     NINT     R     I
                         IDNINT   D     I
 
Абсолютное               ABS      IABS     I     I
 значение                ABS      R     R
                         DABS     D     D
                         CABS     C     R
 
Остаток                  MOD      MOD     2I     I
                         AMOD    2R     R
                         DMOD    2D     D
                MODULO   -       2I     I
                         -       2R     R
                         -       2D     D
 
Floor(дно)      FLOOR    -        I     I
                         -        R     R
                         -        D     D
 
Ceiling(потолок)CEILING  -        I     I
                         -        R     R
                         -        D     D
 
Передача        SIGN     ISIGN   2I     I
 Знака                   SIGN    2R     R
                         DSIGN   2D     D
 
Положительная            DIM      IDIM    2I     I
 Разность                DIM     2R     R
                         DDIM    2D     D
 
Внутреннее      -        DPROD    R     D
Произведение (Inner product)
Maximum         MAX    * MAX0     I     I
                       * AMAX1    R     R
                       * DMAX1    D     D
                -      * AMAX0    I     R
                -      * MAX1     R     I
 
Minimum         MIN    * MIN0     I     I
                       * AMIN1    R     R
                       * DMIN1    D     D
                -      * AMIN0    I     R
                -      * MIN1     R     I
 
Мнимая часть    -        AIMAG    C     R
 
Сопряженное     -        CONJG    C     C

Усечение v это в сторону нуля, INT(-3.7) получает -3, но округление v это корректировка, NINT(-3.7) получает -4. Новые функции FLOOR и CEILING усекают бесконечно в сторону минуса и плюса, соответственно.

 

Функция CMPLX может иметь один или два аргумента, если имеются два аргумента, они должны быть одного и того же типа, но не COMPLEX.

Функция MOD(X,Y) вычисляет X - INT(X/Y)*Y.

Функция переноса знака SIGN(X,Y) берет знак второго аргумента и устанавливат его первому аргументу, ABS(X) если Y >= 0 и -ABS(X) если Y < 0.

Положительная разница DIM это функция. Я не могу никогда использовать, но (X,Y) дает X-Y, если разница положительна, и 0 в другом случае.

Внутреннеее произведение DPROD с другой стороны это очень нужная функция, которая дает произведение двух чисел в одинарной точности как двойной точности. Оба выстрые и точные.

Две функции MAX и MIN уникальны в том, что они могут иметь произвольное число аргументов, но не менее двух. Аргументы могут быть любого типа, но не разрешен тип COMPLEX.

3. Математические функции:

Так же как в Fortran 77. Все тригонометрические функции работают в радианах. Следующие известны: ACOS, ASIN, ATAN, ATAN2, COS, COSH, EXP, LOG, LOG10, SIN, SINH, SQRT, TAN и TANH.

Исторический факт, что математические функции в Fortran 66 могли иметь специальные (различные) имена в различных диапазонах точности, и эти явные имена до сих пор только и могут быть использованы, когда имена функций используются как аргумент.

Ниже дается полная таблица математических функций. Ниже я использую C для комплексных переменных с плавающей точкой, D для переменных двойной точности с плавающей точкой, I для целых, и R для переменных одинарной точности с плавающей точкой.

Функци        Generic  Specific Data type
                name     name     Arg   Res
 
Квадратный      SQRT     SQRT     R     R
корень                   DSQRT    D     D
                         CSQRT    C     C
 
Экспонента      EXP      EXP      R     R
                         DEXP     D     D
                         CEXP     C     C
 
Натуральный              LOG      ALOG     R     R
 Логарифм                DLOG     D     D
                         CLOG     C     C
 
Десятичный               LOG10    ALOG10   R     R
 Логарифм                DLOG10   D     D
 
Синус           SIN      SIN      R     R
                         DSIN     D     D
                         CSIN     C     C
 
Косинус         COS      COS      R     R
                         DCOS     D     D
                         CCOS     C     C
 
Тангенс         TAN      TAN      R     R
                         DTAN     D     D
 
Арксинус        ASIN     ASIN     R     R
                         DASIN    D     D
 
Арккосинус      ACOS     ACOS     R     R
                         DCOS     D     D
 
Арктангенс      ATAN     ATAN     R     R
                         DATAN    D     D
                ATAN2    ATAN2   2R     R
                         DATAN2  2D     D
 
Гиперболический SINH     SINH     R     R
 синус                   DSINH    D     D
 
Гиперболический COSH     COSH     R     R
 косинус        DCOSH    D     D
 
Гиперболический TANH    TANH     R     R
 тангенс                DTANH    D     D

 

Назначение большинства этих функций очевидно. Заметим, что они все определены только для чисел с плавающей точкой, а не для целых. Поэтому Вы не можете вычислять квадратный корень для 4 как SQRT(4), но взамен Вы можете использовать NINT(SQRT(REAL(4))). Заметим также, что все комплексные функции возвращают главное значение.

Квадратный корень дает результат типа real для аргументов типа real двойной или одинарной точности, и результат типа complex для аргумента типа complex. Так SQRT(-1.0) дает сообщение об ошибке (обычно во время компиляции), тогда как вы можете получить комплексный квадратный корень с помощью следующих операторов.

COMPLEX, PARAMETER    :: MINUS_ONE = -1.0
COMPLEX               :: Z
Z = SQRT(MINUS_ONE)

Аргумент для обычного логарифма может быть положительным, тогда как аргумент для CLOG должен быть отличен от нуля.

Модуль для аргумента функций ASIN и ACOS могут быть более 1. Результат будет на отрезке [-pi/2, pi/2] и [0, pi], соответственно.

Функция ATAN возвратит значение в [-pi/2, pi/2].

Функция ATAN2(Y,X) = arctan(y,x) возвратит значение в (-pi, pi]. Если Y положительно, результат будет положителен. Если Y нуль, результат будет нулевым, если X положительно , и pi, если X отрицательно. Если Y отрицательно, результат будет отрицательным. Если X нулевой, результат будет + или - pi/2. Оба X и Y позволяется быть нулевыми одновременно. Назначение функции избежать деления на ноль.

Естественным ограничением для математических функций является ограничение точности и диапазона, которые означают, например, что EXP может вызвать исчезновение или переполнение верхней границы значений аргумента. Тригонометрические функции получат малую точность для больших аргументов. Эти ограничения зависят от реализации и будут даны в руководстве поставщика.

4. Функции символьных строк:

Ниже представлены функции над символьными строками. Заметьте, что ACHAR работает с множеством символов стандврта ASCII, тогда как CHAR работает с представлением компьютера, который Вы используете.

ACHAR(I)          Возвращает символ ASCII, который имеет номер I
ADJUSTL(STRING)   пердвигает влево
ADJUSTR(STRING)   пердвигает вправо
CHAR(I, kind)     возвращает символ, который имеет номер I
IACHAR(C)         Возвращает номер  ASCII-символа для символа C
ICHAR(C)          Возвращает номер символа C
 
INDEX(STRING, SUBSTRING, back)  Возвращает начальную позицию 
                  подстроки SUBSTRING в строке STRING.  Если BACK  
                  есть "true", то Вы получаете последнюю начальную 
                  позицию, в противном случае одну первую.
 
LEN_TRIM(STRING)  Возвращает длину строки возможно без завершающих пробелов.
 
       LGE(STRING_A, STRING_B)
       LGT(STRING-A, STRING_B)
       LLE(STRING_A, STRING_B)
       LLT(STRING_A, STRING_B)

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

REPEAT(STRING, NCOPIES)    Присоединяет к себе самой символьную 
                           строку NCOPIES раз.
SCAN(STRING, SET, back)    Возвращает позицию первого вхождения 
                           любого символа  строки SET в стороку. 
                           Если BACK = "true", Вы получите самый
                                   правый такой символ.
TRIM(STRING)               Возвращает символьную строку STRING без          
                           конечных пробелов.
VERIFY(STRING, SET, back)  Возвращает позицию первого символа в 
                                                                        STRING, который не входит в множество SET.
                           Если BACK есть TRUE, вы получаете самый
                           последний!
                           Результат нулевой,  если все символы 
                                                                     включены!

5. Функции символьной строки для запроса:

LEN(STRING) возвращает длину символьной строки. Не может иметь

присваивания значения переменной STRING.

6. Функции Kind:

KIND(X)
SELECTED_INT_KIND(R)
SELECTED_REAL_KIND(p, r)

Первая возвращает тип (вид) вактического параметра, который может быть типа INTEGER, REAL, COMPLEX, LOGICAL или CHARACTER. Аргумент X не можкт быть присвоен никакого значения..Вторая возвращает вид целоес запрашиваемым числом цифр, и третья возвращает вид для чисел с плавающей точкой с точностью, меньшей чем P цифр и диапазоном десятичной степени между -R и +R. Параметры P и R должны быть скалярными целыми. Один из последних P и R должен быть задан.

Результат функции SELECTED_INT_KIND есть целое из диапазона между 0 и более, если требуемый тип не нужен, вы получите -1. Если некоторые выполненные типы удовлетворяют условию, единственный (one) использован с нименьшим диапазоном. Если здесь тем не менее некоторые типы или виды, которые удовлетворяют условию, единственный с нименьшим числом видов будт использован.

Результат функции SELECTED_REAL_KIND также целое 0 или более; если требуемый тип отсутствует, то возвращается -1, если точность не та, возвращается -2, если диапазон степени не тот, и возвращается -3, если ни одно из требований не выполнено. Если некоторые выполненные типы соответствуют условию, возвращается один с наименьшей десятичной точностью, и если он один из тех, возвращается вид с наименьшим номером.

7. Логические функции:

LOGICAL(L, kind) конвертирует различные виды логических переменных. Логические переменные могут быть выполнены различным способом, например, физическим представлением одним битом (не рекомендуется), одним байтом, одним словом или возможно даже одним двойным словом. Это различие важно, если COMMON и EQUIVALENCE с логическими переменными неправильно использованы в программе при традиционном способе программировании на языке Fortran.

8. Численные функции запроса, наведения справки:

Эти функции работают с определенной моделью арифметики целой и с плавающей точкой, смотри ISO (1991), раздел 13.7.1. Функции возвращают свойства чисел таких видов как переменная X, которая может быть real и в то же время integer. Функции, которые возвращают свойства фактического аргумента X, показаны ниже, функции манипуляции с плавающей точокй.

DIGITS(X)       число значащих цифр
EPSILON(X)      наименьшее положительное число, которое добавлено к 1,
                возвращает число, большее 1
HUGE(X)         наибольшее положительное число
MAXEXPONENT(X)  наибольшая экспонента
MINEXPONENT     наименльшая экспонента
PRECISION(X)    десятичная точность
RADIX(X)        база в модели
RANGE(X)        десятичная экспонента
TINY(X)         наименьшее положительное число

9. Битовая функция запроса, наведения справки:

BIT_SIZE(I) возвращает число битов согласно модели представления в стандарте ISO (1991), секция 13.5.7. Нормально мы получаем число битов в слове (во всем).

10. Функции для манипуляций над битовыми:

Модель для битового представления в стандарте ISO (1991), раздел 13.5.7 использована.

BTEST(I, POS)         .TRUE. , если номер позиции POS для I есть 1
IAND(I, J)            логическое добавление битовых символов в  
                      переменные I и J
 
IBCLR(I, POS)         установить нуль в бит в позиции POS
IBITS(I, POS, LEN)    использует LEN битов слова I , начиная с 
                      позиции POS,  дополнительные биты являются 
                      установкой в нуль. Требуется, чтобы     
                      POS + LEN <= BIT_SIZE(I)
IBSET(I, POS)         кладет бит в позицию POS в 1
IEOR(I, J)            реализует логическое исключающее или OR
IOR(I, J)             реализует логическое OR
ISHIFT(I, SHIFT)      реализует логический сдвиг (вправо, если число 
                      шагов сдвига SHIFT < 0, и влево, если число 
                      шагов сдвига SHIFT > 0).
                      Позиции, которые освобождаются, устанавливаются 
                      в нуль.
ISHIFTC(I, SHIFT, size) реализует логический сдвиг числа шагов 
                      циклически вправо, если SHIFT  <  0,
                      циклически вправо, если SHIFT > 0.  Если SIZE 
                      задан, то требуется чтобы 0 < SIZE <=
                      BIT_SIZE(I). Сдвиг дается только для битов, 
                      которые занимают  в SIZE самую правую позицию , 
                      но для всех позиций в SIZE не дан.
NOT(I)                возвращает логическое дополнение

11. Функции передачи:

TRANSFER(SOURCE, MOULD, size) устанавливает, что физическое представление первого параметра SOURCE будет выступать так, как если бы он имел тип и параметры как второй параметр MOULD, но без его преобразования. Имеет целью дать возможность улучшить качество определенного типа с помощью подпрограммы, которое не может иметь яввно этот тип данных.

 

12. Функции для манипуляций над числами с плавающей точкой:

Эти функции работают в некоторой модели арифметики целых и с плавающей точкой, см. стандарт ISO(1991), раздел 13.7.1. Функции возвращают число, относительное к фактической переменной X типа REAL.

EXPONENT(X)         порядок (экспонента) для числа
FRACTION(X)         дробная часть числа
NEAREST(X, S)       возвращает следующее представимое число в     
                    направлении знака числа S
RRSPACING(X)        возвращает инвертированное значение расстояния 
                    между двумя ближайшими числами 
SCALE(X, I)         умножает  X на основание степени I
SET_EXPONENT(X, I)  возвращает число, которое имеет дробную часть
                    (мантиссу) для X и порядок I
SPACING(X)          расстояние между двумя ближайшими возможными 
                    числами 

13. Функции для манипуляций над векторами и матрицами:

DOT_PRODUCT(VECTOR_A, VECTOR_B) получает скалярное произведение двух векторов, которые должны иметь одинаковую длину (одно и то же число элементов).

Заметьте, что если VECTOR_A имет тип COMPLEX, результатом будет SUM(CONJG(VECTOR_A)*VECTOR_B).

MATMUL(MATRIX_A, MATRIX_B) производит умножение двух матриц, которые должны быть согласованными, то есть имеют размерности, похожие на (M, K) и (K, N).

14. Функции для массива:

ALL(MASK, dim) возвращает логическое значение, которое говорит о том, все ли отношения в MASK имеют значение .TRUE., только по требуемому измерению, если дан второй параметр.

ANY(MASK, dim) возвращает логическое значение, которое говорит о том, есть какое-либо отношение в MASK, имеющее значение .TRUE., только по требуемому измерению, если дан второй параметр.

COUNT(MASK, dim) возвращает числовое значение, которое является числом отношений в MASK, которые равны .TRUE., ., только по требуемому измерению, если дан второй параметр.

MAXVAL(ARRAY, dim, mask) возвращает наибольшее значение в массиве ARRAY из тех, которые подчиняются отношениям в третьем параметре MASK, если отношение дано, только по требуемому измерению, если дан второй параметр DIM.

MINVAL(ARRAY, dim, mask) возвращает наименьшее значение в массиве ARRAY из тех, которые подчиняются отношениям в третьем параметре MASK, если отношение дано, только по требуемому измерению, если дан второй параметр DIM.

PRODUCT(ARRAY, dim, mask) возвращает произведение всех элементов массива ARRAY, которые подчиняются отношениям в третьем параметре MASK, если отношение дано, только по требуемому измерению, если дан второй параметр DIM.

SUM (ARRAY, dim, mask) возвращает сумму всех элементов массива ARRAY, которые подчиняются отношениям в третьем параметре MASK, если отношение дано, только по требуемому измерению, если дан второй параметр DIM.

15. Функции запросов о массивах:

ALLOCATED(ARRAY) - логическая функция, которая сообщает, произошло ли выделение месста для массива.

LBOUND(ARRAY, dim) - функция, возвращающая меньшую границу по измерению для ARRAY. Если DIM (размерность) не задана в качестве аргумента, вы получите целый вектор, если DIM включен, Вы получите значение явно, которое означает меньшую границу того измерения, которое вы спрашивали.

SHAPE(SOURCE) - функция, которая возвращает образ массива SOURCE в виде целого вектора.

SIZE(ARRAY, dim) - функция, возвращающая число элементов массива ARRAY, если DIM не задано, и число элементов в измерении, заданном с помощью DIM, если он задан.

UBOUND(ARRAY, dim) - функция, подобная LBOUND, возвращающая верхнюю границу по измерению.

16. Функции конструирования массива:

MERGE(TSOURCE, FSOURCE, MASK) - функция, которая связывает два массива. Она дает элементы TSOURCE, если условие в MASK равно .TRUE. и элементы FSOURCE, если условие в MASK равно .FALSE.Два поля TSOURCE и FSOURCE имеют одинаковый тип и образ. Результат этого типа и этого образа. А также MASK должен иметь тот же образ.

Я здесь дам полный пример использования MERGE, который использует также RESHAPE из следующего раздела с целью построения подходящего тестовой матрицы.

Заметим, что две подпрограммы WRITE_ARRAY и WRITE_L_ARRAY тестируют подпрограмму записи матриц, которые в первом случае имеют тип REAL, во втором случае - тип LOGICAL.

IMPLICIT NONE
INTERFACE
      SUBROUTINE WRITE_ARRAY (A)
             REAL :: A(:,:)
      END SUBROUTINE WRITE_ARRAY
      SUBROUTINE WRITE_L_ARRAY (A)
             LOGICAL :: A(:,:)
      END SUBROUTINE WRITE_L_ARRAY
END INTERFACE
 
REAL, DIMENSION(2,3)      :: TSOURCE, FSOURCE, RESULT
LOGICAL, DIMENSION(2,3)   :: MASK
TSOURCE = RESHAPE( (/ 11, 21, 12, 22, 13, 23 /), &
                   (/ 2, 3 /) )
FSOURCE = RESHAPE( (/ -11, -21, -12, -22, -13, -23 /), &
                   (/ 2,3 /) )
MASK = RESHAPE( (/ .TRUE., .FALSE., .FALSE., .TRUE., &
                   .FALSE., .FALSE. /), (/ 2,3 /) )
 
RESULT = MERGE(TSOURCE, FSOURCE, MASK)
CALL WRITE_ARRAY(TSOURCE)
CALL WRITE_ARRAY(FSOURCE)
CALL WRITE_L_ARRAY(MASK)
CALL WRITE_ARRAY(RESULT)
END
 
SUBROUTINE WRITE_ARRAY (A)
REAL :: A(:,:)
DO I = LBOUND(A,1), UBOUND(A,1)
   WRITE(*,*) (A(I, J), J = LBOUND(A,2), UBOUND(A,2) )
END DO
RETURN
END SUBROUTINE WRITE_ARRAY
 
SUBROUTINE WRITE_L_ARRAY (A)
LOGICAL :: A(:,:)
DO I = LBOUND(A,1), UBOUND(A,1)
   WRITE(*,"(8L12)") (A(I, J), J= LBOUND(A,2), UBOUND(A,2))
END DO
RETURN
END SUBROUTINE WRITE_L_ARRAY

Следующий вывод будет получен

       11.0000000   12.0000000   13.0000000
       21.0000000   22.0000000   23.0000000
 
       -11.0000000 -12.0000000  -13.0000000
       -21.0000000 -22.0000000  -23.0000000
 
                 T           F            F
                 F           T            F
 
       11.0000000  -12.0000000  -13.0000000
      -21.0000000   22.0000000  -23.0000000

PACK(ARRAY, MASK, vector) упаковывает массив в вектор с управлением с помощью MASK. Образ логического массива MASK может согласовываться с образом из ARRAY или MASK, один из которых должен быть скаляром. Если включен VECTOR, может быть массив ранга 1 (то есть вектор) с наименьшим числом элементов, для которых верен MASK и которые имеют тот же тип, что и ARRAY. Если MASK скаляр со значением .TRUE., то VECTOR взамен должен иметь то же число элементов, что и ARRAY.

Рещультатом является вектор с числом элементов, таким же как число элементов массива ARRAY, удовлетворяющих условиям, если вектор VECTOR не включен (то есть все элементы, когда MASK скаляр, со значением .TRUE.). В другом случае число элементов результата будет равно числу элементов в VECTOR. Значения будут отобраны и помещены в вектор, то есть значения, которые полностью удовлетворяют условию, и будет размещены в порядке обычного Фортрана . Если VECTOR включен и число его элементов превышает число отобранных значений, недостающие значения, требуемые для результата, берутся из соответствующих позиций в VECTOR.

Следующий пример основан на модификации примера для MERGE , но I дает теперь только результат (итог).

   ARRAY
         11.0000000   12.0000000   13.0000000
         21.0000000   22.0000000   23.0000000
 
   VECTOR
        -11.0000000
        -21.0000000
        -12.0000000
        -22.0000000
        -13.0000000
        -23.0000000
 
 
   MASK
          T               F              F
          F               T              F
 
   PACK(ARRAY, MASK)
         11.0000000
         22.0000000
 
   PACK(ARRAY, MASK, VECTOR)
         11.0000000
         22.0000000
        -12.0000000
        -22.0000000
        -13.0000000
        -23.0000000

SPREAD(SOURCE, DIM, NCOPIES) возвращает массив того же типа что и параметр SOURCE с рангом, большим на 1. Параметры DIM и NCOPIES целые. Если NCOPIES отрицательно, используется значение 0 вместо него. SOURCE скаляр, то SPREAD становится вектором с NCOPIES элементами, которые все имеют те же значения, что и SOURCE. Параметр DIM обозначает, что индекс может быть расширен. Он имеет внутри ранг 1 и 1+(ранг для SOURCE), если SOURCE скаляр, то DIM может иметь тот же ранг. Параметр NCOPIES это число элементов в новом измерении. Дополнительное обсуждение дано в решении упражнения (11.1).

Пример

INTEGER AR(2,3), AR(3,2)

AR1=SPREAD(/1,2,3/),DIM=1,NCOPIES=2)! Возвращает

! 1 2 3

! 1 2 3

AR2= SPREAD(/1,2,3/),2,2) ! Возвращает 1 1

! 2 2

! 3 3

 

 

UNPACK(VECTOR, MASK, ARRAY) распаковывает вектор в массив под управлением MASK. MASK устанавливает образ результата и управляет размещением элементов из массива VECTOR . Элементы из VECTOR устанавливаются в те позиции, которым соответствуют позиции со значением .TRUE. в массиве MASK. ARRAY того же типа, что и VECTOR. ARRAY показывает значения, которые устанавливаются в позиции результата, для которых нет элемента в массиве VECTOR . Образ логического массива MASK может согласовываться с образом для ARRAY. Массив VECTOR имеет ранг 1 (то есть это вектор) с наименьшим числом тех элементов, которые имеют true в MASK. Если ARRAY дан как скаляр, то он рассмотрен в массиве с тем же образом что и MASK и такими же скалярными элементами всюду. Результат будет массивом с тем же образом, что и MASK, и тем же типом, что и VECTOR.

Пример

LOGICAL mask (2, 3)

INTEGER vector (3) /1,2,3/, AR1 (2, 3)

Mask = RESHAPE((/.TRUE.,.FALSE.,.FALSE.,.TRUE.,&

.TRUE.,.FALSE./),(/2,3/))

! vector = [1 2 3] и mask = T F T

! F T F

AR1 = UNPACK(vector, mask, 8) ! возвращает 1 8 3

! 8 2 8

END

 

17. Функция преобразования массива.

RESHAPE(SOURCE, SHAPE, pad, order) конструирует массив с указанным образом SHAPЕ, начиная с элементов из массива SOURCE. Если PAD не включен, то общий размер результата, определенный с помощью SHAPE , должен быть меньше или равен размеру SOURCE. Если PAD включен, он имеет тот же тип, что и тип SOURCE, он должен быть массивом. Если ORDER включен, он является одномерным массивом INTEGER с тем же образом, что и у SHAPE и значения должны быть выстроены по размерностям, пронумерованым (1,2,3,...,N), где N число элементов в SHAPE , оно должно быть меньше или равно 7.

Результат имеет образ SHAPE и те элементы из SOURCE, возможно дополненные из PAD. Различным размерностям могут быть установлены присваиванием элементов, если включен ORDER, но без влияния образа результата.

Несколько простых примеров было дано прежде и будет далее в следующем разделе. Более полный пример, иллюстрирующий необязательные параметры приведен ниже.

! Программа для тестирования необязательных параметров к RESHAPE
  INTERFACE
     SUBROUTINE WRITE_MATRIX(A)
         REAL, DIMENSION(:,:) :: A
     END SUBROUTINE  WRITE_MATRIX
  END INTERFACE
 
  REAL, DIMENSION (1:9) :: B = (/ 11, 12, 13, 14, 15, 16, 17, 18, 19 /)
  REAL, DIMENSION (1:3, 1:3) :: C, D, E
  REAL, DIMENSION (1:4, 1:4) :: F, G, H
  INTEGER, DIMENSION (1:2) :: ORDER1 = (/ 1, 2 /)
  INTEGER, DIMENSION (1:2) :: ORDER2 = (/ 2, 1 /)
  REAL, DIMENSION (1:16)   :: PAD1 = (/ -1, -2, -3, -4, -5, -6, -7, -8, &
                                 &   -9, -10, -11, -12, -13, -14, -15, -16 /)
  C = RESHAPE( B, (/ 3, 3 /) )
  CALL WRITE_MATRIX(C)
  D = RESHAPE( B, (/ 3, 3 /), ORDER = ORDER1)
  CALL WRITE_MATRIX(D)
  E = RESHAPE( B, (/ 3, 3 /), ORDER = ORDER2)
  CALL WRITE_MATRIX(E)
  F = RESHAPE( B, (/ 4, 4 /), PAD = PAD1)
  CALL WRITE_MATRIX(F)
  G = RESHAPE( B, (/ 4, 4 /), PAD = PAD1, ORDER = ORDER1)
  CALL WRITE_MATRIX(G)
  H = RESHAPE( B, (/ 4, 4 /), PAD = PAD1, ORDER = ORDER2)
  CALL WRITE_MATRIX(H)
  END
  SUBROUTINE WRITE_MATRIX(A)
  REAL, DIMENSION(:,:) :: A
  WRITE(*,*)
  DO I = LBOUND(A,1), UBOUND(A,1)
     WRITE(*,*) (A(I,J), J = LBOUND(A,2), UBOUND(A,2))
  END DO
  END SUBROUTINE WRITE_MATRIX

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

  11.0000000  14.0000000  17.0000000
  12.0000000  15.0000000  18.0000000
  13.0000000  16.0000000  19.0000000
  11.0000000  14.0000000  17.0000000
  12.0000000  15.0000000  18.0000000
  13.0000000  16.0000000  19.0000000
  11.0000000  12.0000000  13.0000000
  14.0000000  15.0000000  16.0000000
  17.0000000  18.0000000  19.0000000
  11.0000000  15.0000000  19.0000000  -4.0000000
  12.0000000  16.0000000  -1.0000000  -5.0000000
  13.0000000  17.0000000  -2.0000000  -6.0000000
  14.0000000  18.0000000  -3.0000000  -7.0000000
  11.0000000  15.0000000  19.0000000  -4.0000000
  12.0000000  16.0000000  -1.0000000  -5.0000000
  13.0000000  17.0000000  -2.0000000  -6.0000000
  14.0000000  18.0000000  -3.0000000  -7.0000000
  11.0000000  12.0000000  13.0000000  14.0000000
  15.0000000  16.0000000  17.0000000  18.0000000
  19.0000000  -1.0000000  -2.0000000  -3.0000000
  -4.0000000  -5.0000000  -6.0000000  -7.0000000

18. Функции манипуляции с массивом.

Функция сдвига возвращают образ массива неизмененным, перемещают элементы. Они до некоторой степени трудны для объснения, то я рекомендую изучать стандарт ISO (1991).

 CSHIFT(ARRAY, SHIFT, dim) осуществляет циклический сдвиг на SHIFT позиций влево, если SHIFT положительно и вправо, если SHIFT отрицательно. Если ARRAY есть вектор, сдвиг производится естественным путем, если это массив более высокой размерности, то производится сдвиг по размерности DIM. Если DIM опУщено, то он берется равным 1, в другом случае он будет скалярным целым числом между 1 и n (где n равно рангу массива ARRAY ). Параметр SHIFT это целый скаляр или целый массив ранга n-1 и с тем же образом, что и массив ARRAY, исключая измеение DIM (которое удалено поскольку меньшего ранга). Различные секции поэтому могут быть сдвинуты в различных направлениях и на различное число позиций

.

EOSHIFT(ARRAY, SHIFT, boundary, dim) производит сдвиг влево, если SHIFT положительно и направо, если сдвиг отрицателен. Вместо выдвинутых элементов берутся новые элементы из BOUNDARY. Если ARRAY это вектор, сдвиг присходит естестивенным путем, если ARRAY явяляется массивом более высокого ранга, сдвиг по всем секциям вдоль измерения DIM. Если DIM отсутствует, то DIM принимается равным 1, в других случаях он должен иметь скалярное целое значение между 1 и n (где n равно рангу массива ARRAY). Параметр SHIFT есть скалярное целое, если ARRAY имеет ранг 1, в ином случае он может быть скалярным целым или целым массивом ранга n-1 и с тем же образом, что и массив ARRAY, исключая размерность DIM (которая удаляется, потому что меньшего ранга).

Связь показывает на BOUNDARY, который должен иметь тот же тип, что и ARRAY. Если параметр BOUNDARY отсутствует, вы имеете выбранные значения нулевые, .FALSE. или пробелы,в зависимости от типа данных. Различные секции быть сдвинуты в различных направлениях и на различное число позиций. Простой пример выше приведенных функций для выбора векторов показывает две программы и вывод.

REAL, DIMENSION(1:6)  :: A = (/ 11.0, 12.0, 13.0, 14.0, &
                                15.0, 16.0 /)
REAL, DIMENSION(1:6)  :: X, Y
WRITE(*,10) A
X = CSHIFT ( A, SHIFT = 2)
WRITE(*,10) X
Y = CSHIFT (A, SHIFT = -2)
WRITE(*,10) Y
X = EOSHIFT ( A, SHIFT = 2)
WRITE(*,10) X
Y = EOSHIFT ( A, SHIFT = -2)
WRITE(*,10) Y
10  FORMAT(1X,6F6.1)
END
       11.0  12.0  13.0   14.0  15.0  16.0
       13.0  14.0  15.0   16.0  11.0  12.0
       15.0  16.0  11.0   12.0  13.0  14.0
       13.0  14.0  15.0   16.0   0.0   0.0
        0.0   0.0  11.0   12.0  13.0  14.0

Простой пример вышеприведенных двух функций для выбора матриц следующий. Я здесь использовал RESHAPE, чтобы создать подходящую матрицу для начала работы. Программа здесь не приводится, только основные операторы.

B = (/ 11.0, 12.0, 13.0, 14.0, 15.0, 16.0 /)
  11.0  12.0  13.0   Z = RESHAPE( B, (/3,3/) )
  14.0  15.0  16.0
  17.0  18.0  19.0
  17.0  18.0  19.0   X = CSHIFT (Z, SHIFT = 2)
  11.0  12.0  13.0
  14.0  15.0  16.0
  13.0  11.0  12.0   X = CSHIFT ( Z, SHIFT = 2, DIM = 2)
  16.0  14.0  15.0
  19.0  17.0  18.0
  14.0  15.0  16.0   X = CSHIFT (Z, SHIFT = -2)
  17.0  18.0  19.0
  11.0  12.0  13.0
  17.0  18.0  19.0   X = EOSHIFT ( Z, SHIFT = 2)
   0.0   0.0   0.0
   0.0   0.0   0.0
  13.0   0.0   0.0   X = EOSHIFT ( Z, SHIFT = 2, DIM = 2)
  16.0   0.0   0.0
  19.0   0.0   0.0
   0.0   0.0   0.0   X = EOSHIFT ( Z, SHIFT = -2)
   0.0   0.0   0.0
  11.0  12.0  13.0

TRANSPOSE (MATRIX) преобразует матрицу, которая является массивом ранга 2. Функция TRANSPOSE заменяет ряды и колонки в матрице.

19. Функции указания в массивах:

MAXLOC(ARRAY, mask) возвращает позицию наибольшего элемента в массиве ARRAY, если MASK включен, только для тех, которым соответсвуют условия в MASK. Результат это целый вектор! 

MINLOC(ARRAY, mask) возвращает позицию наименьшего элемента в массиве ARRAY, если MASK включен, только для тех, которым соответсвуют условия в MASK. Результат это целый вектор!

20. Функции запроса для указателей:

ASSOCIATED(POINTER, target) это логическая функция, которая сообщает, если указатель POINTER связан с некоторым адресатом, и если спецификация TARGET включена, указывает, если указатель связан именно с этим адресатом. Если оба параметра POINTER и TARGET являются указателями, результат есть .TRUE. только если оба связаны с одним и тем же адресатом.

21. Встроенные подпрограммы:

Подпрограммы времени:

DATE_AND_TIME(date, time, zone, values)

Подпрограмма, которая возвращает дату, время и часть дня. Хотя бы один параметр должен быть задан.

DATE должна быть скалярной переменной строк символов хотя бы с 8 символами и присваивает значение CCYYMMDD для столетия, года, месяца, дня. Все заданы числами, с пробелами, если система не включает дату.

TIME должна быть скалярной переменной как строка символов, содержащая не менее 10 символов и присвоено значение hhmmss.sss для времени в часах, минутах, секндах и миллисекундах. Все даны числами с пробелами, если система не включает часы.

ZONE должна быть скалярной переменной типа "строка символов", содержащая не менее 5 символов и присвоено значение +hhmm для знака, времени в часах и минутах для местного времени, отличного от мирового гринвичского UTC. Все даны численно с пробелами, если система не включает часы. В Швеции мы получим +0100 зимой и +0200 летом, в Новосибирске получим +0700 .

Переменная VALUES вместо целого вектора с числом элементов не менее 8, она дает ниболее простой путь использования результата из DATE_AND_TIME в вычилениях в программе. Если система не включает дату или время, вы получаете в качестве выходной величины значение -HUGE(0), которое есть наименьшее целое число в модели. Вектор будет включать следующие элементы: год, месяц, день, время в минутах, часах, секундах и миллисекундах.

SYSTEM_CLOCK(COUNT, COUNT_RATE, COUNT_MAX)

Подпрограмма, которая возвращает системное время. Не менее одного параметра должно быть задано. COUNT это скалярное целое, которое увеличивается на один прикаждом проходе через COUNT_MAX , где он начинается снова. Если нет системных часов, то возвращается HUGE(0).

COUNT_RATE это скалярное целое, которое дает число цикловпо секнде.. Если системных часов нет, возвращается значение нуль.

COUNT_MAX это скалярное целое, которое дает максимальное значение, которое COUNT может достичь. Если системных часов нет, возвращается значение нуль.

Программа копирования битов (Bit copy routine):

MVBITS(FROM, FROMPOS, LEN, TO, TOPOS)

Подпрограмма, которая копирует последовательность битов в позиции FROMPOS и имеет длину LEN в целевую величину TO с начальной позиции TOPOS. Перемещаемые биты не заменяются. Все количественные величины должны быть целыми и все, исключая TO, должны быть входными с INTENT(IN), тогда как TO должно быть выходным с INTENT(INOUT) и быть того же вида типа, что и FROM. FROM и TO могут быть одной и той же переменной. Некоторые естественные ограничения накладываются на значения LEN, FROMPOS и TOPOS и вы должны иметь в виду значение BIT_SIZE.

Программы случайных чисел:

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

RANDOM_NUMBER(HARVEST)

Эта подпрограмма возвращает в переменной HARVEST одно число с плавающей точкой (или несколько, если HARVEST является массивом), случайные числа между 0 и 1.

RANDOM_SEED(size, put, get)

Эта подпрограммe переустанавливает или дает информацию о генераторе случайных чисел. Без параметров не может быть выполнена. Выходная переменная SIZE должна быть скалярным целым и дает число целых (N), процессор использует для начальных значений. Входная переменная PUT это целый вектор, который кладет начальные числа, заданные пользователем, в генератор случайных чисел. Выходная переменная GET (также целый вектор ) читает представленные начальные значения. Пример:

CALL RANDOM_SEED                    ! Инициализация
CALL RANDOM SEED (SIZE=K)           ! Sets K = N
CALL RANDOM_SEED (PUT = SEED (1:K)) ! Использует начальное 
                                    ! значение,            
                                    ! заданное пользователем
CALL RANDOM_SEED (GET = OLD(1:K))   ! Возвращает  
                                    ! представленное 
                                    ! начальное значение

 

Последняя модификация от: 25 November 1999. Обращаться по адресу:
boein@nsc.liu.se

 

Яндекс.Метрика