Учебники

Фортран – Краткое руководство

Фортран – Обзор

Фортран, как это происходит от Formula Translating System, является универсальным императивным языком программирования. Он используется для числовых и научных вычислений.

Fortran был изначально разработан IBM в 1950-х годах для научных и инженерных приложений. Фортран долгое время управлял этой областью программирования и стал очень популярен для высокопроизводительных вычислений.

Поддерживает –

  • Численный анализ и научные вычисления
  • Структурированное программирование
  • Программирование массива
  • Модульное программирование
  • Общее программирование
  • Высокопроизводительные вычисления на суперкомпьютерах
  • Объектно-ориентированное программирование
  • Параллельное программирование
  • Разумная степень переносимости между компьютерными системами

Факты о Фортране

  • Fortran был создан командой во главе с Джоном Бэкусом в IBM в 1957 году.

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

  • Фортран расшифровывается как ФОРМУЛА ТРАНСКЛАТОР.

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

  • Более поздние расширения и разработки превратили его в язык программирования высокого уровня с хорошей степенью переносимости.

  • Оригинальные версии, Fortran I, II и III, считаются устаревшими.

  • Самая старая версия, которая еще используется, это Fortran IV и Fortran 66.

  • Наиболее часто используемые версии сегодня: Fortran 77, Fortran 90 и Fortran 95.

  • Fortran 77 добавил строки как отдельный тип.

  • В Fortran 90 добавлены различные виды многопоточности и прямой обработки массивов.

Fortran был создан командой во главе с Джоном Бэкусом в IBM в 1957 году.

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

Фортран расшифровывается как ФОРМУЛА ТРАНСКЛАТОР.

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

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

Оригинальные версии, Fortran I, II и III, считаются устаревшими.

Самая старая версия, которая еще используется, это Fortran IV и Fortran 66.

Наиболее часто используемые версии сегодня: Fortran 77, Fortran 90 и Fortran 95.

Fortran 77 добавил строки как отдельный тип.

В Fortran 90 добавлены различные виды многопоточности и прямой обработки массивов.

Fortran – Настройка среды

Настройка Фортрана в Windows

G95 – это мультиархитектурный компилятор GNU Fortran, используемый для настройки Fortran в Windows. Версия для Windows эмулирует среду Unix, используя MingW под Windows. Инсталлятор позаботится об этом и автоматически добавит g95 в переменную PATH Windows.

Вы можете получить стабильную версию G95 здесь

установка установщика

настройка мини-установщика

Как использовать G95

Во время установки g95 автоматически добавляется в переменную PATH, если вы выбираете опцию «РЕКОМЕНДУЕТСЯ». Это означает, что вы можете просто открыть новое окно командной строки и набрать «g95», чтобы вызвать компилятор. Ниже приведены основные команды, с которых можно начать.

Sr.No Команда и описание
1

g95 –c hello.f90

Компилирует hello.f90 в объектный файл с именем hello.o

2

g95 hello.f90

Компилирует hello.f90 и связывает его для создания исполняемого файла a.out

3

g95 -c h1.f90 h2.f90 h3.f90

Компилирует несколько исходных файлов. Если все идет хорошо, создаются объектные файлы h1.o, h2.o и h3.o

4

g95 -o привет h1.f90 h2.f90 h3.f90

Компилирует несколько исходных файлов и связывает их вместе с исполняемым файлом с именем ‘hello’

g95 –c hello.f90

Компилирует hello.f90 в объектный файл с именем hello.o

g95 hello.f90

Компилирует hello.f90 и связывает его для создания исполняемого файла a.out

g95 -c h1.f90 h2.f90 h3.f90

Компилирует несколько исходных файлов. Если все идет хорошо, создаются объектные файлы h1.o, h2.o и h3.o

g95 -o привет h1.f90 h2.f90 h3.f90

Компилирует несколько исходных файлов и связывает их вместе с исполняемым файлом с именем ‘hello’

Параметры командной строки для G95

-c Compile only, do not run the linker.
-o Specify the name of the output file, either an object file or the executable.

Несколько исходных и объектных файлов могут быть указаны одновременно. Файлы Fortran обозначаются именами, заканчивающимися на “.f”, “.F”, “.for”, “.FOR”, “.f90”, “.F90”, “.f95”, “.F95”, “. f03 “и” .F03 “. Можно указать несколько исходных файлов. Объектные файлы также могут быть указаны и будут связаны для формирования исполняемого файла.

Фортран – основной синтаксис

Программа на Фортране состоит из набора программных модулей, таких как основная программа, модули и внешние подпрограммы или процедуры.

Каждая программа содержит одну основную программу и может содержать или не содержать другие программные блоки. Синтаксис основной программы следующий:

program program_name
implicit none      

! type declaration statements      
! executable statements  

end program program_name

Простая программа на фортране

Давайте напишем программу, которая добавляет два числа и печатает результат –

Live Demo

program addNumbers

! This simple program adds two numbers
   implicit none

! Type declarations
   real :: a, b, result

! Executable statements
   a = 12.0
   b = 15.0
   result = a + b
   print *, 'The total is ', result

end program addNumbers

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

The total is 27.0000000    

Пожалуйста, обратите внимание, что –

  • Все программы на Фортране начинаются с ключевого слова program и заканчиваются ключевым словом end program, за которым следует название программы.

  • Неявный оператор none позволяет компилятору проверить, что все ваши типы переменных объявлены правильно. Вы должны всегда использовать неявное none в начале каждой программы.

  • Комментарии в Фортране начинаются с восклицательного знака (!), Так как все символы после этого (кроме строки символов) игнорируются компилятором.

  • Команда print * отображает данные на экране.

  • Отступы строк кода – хорошая практика для сохранения читабельности программы.

  • Фортран допускает как прописные, так и строчные буквы. Фортран нечувствителен к регистру, за исключением строковых литералов.

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

Неявный оператор none позволяет компилятору проверить, что все ваши типы переменных объявлены правильно. Вы должны всегда использовать неявное none в начале каждой программы.

Комментарии в Фортране начинаются с восклицательного знака (!), Так как все символы после этого (кроме строки символов) игнорируются компилятором.

Команда print * отображает данные на экране.

Отступы строк кода – хорошая практика для сохранения читабельности программы.

Фортран допускает как прописные, так и строчные буквы. Фортран нечувствителен к регистру, за исключением строковых литералов.

основы

Базовый набор символов Фортрана содержит –

  • буквы А … Я и А … Я
  • цифры 0 … 9
  • символ подчеркивания (_)
  • специальные символы =: + пробел – * / () [],. $ ‘! “% &; <>?

Жетоны состоят из символов в базовом наборе символов. Токен может быть ключевым словом, идентификатором, константой, строковым литералом или символом.

Заявления программы состоят из токенов.

Идентификатор

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

  • Он не может быть длиннее 31 символа.

  • Он должен состоять из буквенно-цифровых символов (все буквы алфавита и цифры от 0 до 9) и подчеркивания (_).

  • Первым символом имени должна быть буква.

  • Имена нечувствительны к регистру

Он не может быть длиннее 31 символа.

Он должен состоять из буквенно-цифровых символов (все буквы алфавита и цифры от 0 до 9) и подчеркивания (_).

Первым символом имени должна быть буква.

Имена нечувствительны к регистру

Ключевые слова

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

В следующей таблице перечислены ключевые слова Fortran –

Ключевые слова не I / O
размещаемый выделять назначать назначение блокировать данные
вызов дело персонаж общий сложный
содержит Продолжить цикл данные DEALLOCATE
дефолт делать двойная точность еще иначе если
в другом месте данные конца блока конец делать конечная функция конец, если
конечный интерфейс конечный модуль конец программы выбор конца конец подпрограммы
тип конца конец где запись эквивалентность выход
внешний функция идти к если неявный
в INOUT целое число намерение интерфейс
свойственный Добрый Len логический модуль
список имен сводить на нет только оператор необязательный
из параметр Пауза указатель частный
программа общественности реальный рекурсивный результат
вернуть спасти выберите случай стоп подпрограмма
цель затем тип тип() использование
куда В то время как
Ключевые слова, связанные с вводом / выводом
возврат на одну позицию близко ENDFILE формат спрашивать
открыть Распечатать читать перемотка Написать

Фортран – Типы данных

Fortran предоставляет пять внутренних типов данных, однако вы также можете получить свои собственные типы данных. Пять внутренних типов –

  • Целочисленный тип
  • Реальный тип
  • Сложный тип
  • Логический тип
  • Тип персонажа

Целочисленный тип

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

Live Demo

program testingInt
implicit none

   integer :: largeval
   print *, huge(largeval)
   
end program testingInt

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

2147483647

Обратите внимание, что функция large () выдает наибольшее число, которое может содержаться конкретным целочисленным типом данных. Вы также можете указать количество байтов, используя спецификатор вида . Следующий пример демонстрирует это –

Live Demo

program testingInt
implicit none

   !two byte integer
   integer(kind = 2) :: shortval
   
   !four byte integer
   integer(kind = 4) :: longval
   
   !eight byte integer
   integer(kind = 8) :: verylongval
   
   !sixteen byte integer
   integer(kind = 16) :: veryverylongval
   
   !default integer 
   integer :: defval
        
   print *, huge(shortval)
   print *, huge(longval)
   print *, huge(verylongval)
   print *, huge(veryverylongval)
   print *, huge(defval)
   
end program testingInt

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

32767
2147483647
9223372036854775807
170141183460469231731687303715884105727
2147483647

Реальный тип

Он хранит числа с плавающей запятой, такие как 2.0, 3.1415, -100.876 и т. Д.

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

Однако Fortran 90/95 обеспечивает больший контроль над точностью реальных и целочисленных типов данных с помощью спецификатора вида , который мы изучим в главе о числах.

В следующем примере показано использование реального типа данных –

Live Demo

program division   
implicit none  

   ! Define real variables   
   real :: p, q, realRes 
   
   ! Define integer variables  
   integer :: i, j, intRes  
   
   ! Assigning  values   
   p = 2.0 
   q = 3.0    
   i = 2 
   j = 3  
   
   ! floating point division
   realRes = p/q  
   intRes = i/j
   
   print *, realRes
   print *, intRes
   
end program division  

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

0.666666687    
0

Комплексный тип

Это используется для хранения комплексных чисел. Комплексное число состоит из двух частей: действительной части и мнимой части. Два последовательных цифровых запоминающих устройства хранят эти две части.

Например, комплексное число (3,0, -5,0) равно 3,0 – 5,0i

Мы обсудим сложные типы более подробно в главе Numbers.

Логический тип

Есть только два логических значения: .true. и .false.

Тип персонажа

Тип символа хранит символы и строки. Длина строки может быть указана спецификатором len. Если длина не указана, это 1.

Например,

character (len = 40) :: name  
name = Zara Ali

Выражение name (1: 4) даст подстроку «Zara».

Неявная печать

В старых версиях Fortran допускалась функция, называемая неявной типизацией, т. Е. Вам не нужно объявлять переменные перед использованием. Если переменная не объявлена, то первая буква ее имени будет определять ее тип.

Имена переменных, начинающиеся с i, j, k, l, m или n, считаются целочисленными, а другие – действительными переменными. Однако вы должны объявить все переменные, так как это хорошая практика программирования. Для этого вы начинаете свою программу с заявления –

implicit none

Это утверждение отключает неявную типизацию.

Фортран – Переменные

Переменная – это не что иное, как имя, данное области памяти, которой могут манипулировать наши программы. Каждая переменная должна иметь определенный тип, который определяет размер и расположение памяти переменной; диапазон значений, которые могут быть сохранены в этой памяти; и набор операций, которые могут быть применены к переменной.

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

  • Он не может быть длиннее 31 символа.

  • Он должен состоять из буквенно-цифровых символов (все буквы алфавита и цифры от 0 до 9) и подчеркивания (_).

  • Первым символом имени должна быть буква.

  • Имена чувствительны к регистру.

Он не может быть длиннее 31 символа.

Он должен состоять из буквенно-цифровых символов (все буквы алфавита и цифры от 0 до 9) и подчеркивания (_).

Первым символом имени должна быть буква.

Имена чувствительны к регистру.

Основываясь на базовых типах, описанных в предыдущей главе, ниже приведены типы переменных:

Sr.No Тип и описание
1

целое число

Может содержать только целые значения.

2

реальный

Он хранит числа с плавающей запятой.

3

Сложный

Используется для хранения комплексных чисел.

4

логический

Он хранит логические логические значения.

5

символ

Он хранит символы или строки.

целое число

Может содержать только целые значения.

реальный

Он хранит числа с плавающей запятой.

Сложный

Используется для хранения комплексных чисел.

логический

Он хранит логические логические значения.

символ

Он хранит символы или строки.

Объявление переменной

Переменные объявляются в начале программы (или подпрограммы) в операторе объявления типа.

Синтаксис для объявления переменных выглядит следующим образом:

type-specifier :: variable_name

Например

integer :: total  	
real :: average 
complex :: cx  
logical :: done 
character(len = 80) :: message ! a string of 80 characters

Позже вы можете присвоить значения этим переменным, например,

total = 20000  
average = 1666.67   
done = .true.   
message = “A big Hello from Tutorials Point” 
cx = (3.0, 5.0) ! cx = 3.0 + 5.0i

Вы также можете использовать встроенную функцию cmplx, чтобы присвоить значения сложной переменной –

cx = cmplx (1.0/2.0, -7.0) ! cx = 0.5 – 7.0i 
cx = cmplx (x, y) ! cx = x + yi

пример

В следующем примере демонстрируется объявление, назначение и отображение переменной на экране –

Live Demo

program variableTesting
implicit none

   ! declaring variables
   integer :: total      
   real :: average 
   complex :: cx  
   logical :: done 
   character(len=80) :: message ! a string of 80 characters
   
   !assigning values
   total = 20000  
   average = 1666.67   
   done = .true.   
   message = "A big Hello from Tutorials Point" 
   cx = (3.0, 5.0) ! cx = 3.0 + 5.0i

   Print *, total
   Print *, average
   Print *, cx
   Print *, done
   Print *, message
   
end program variableTesting

Когда приведенный выше код компилируется и выполняется, он дает следующий результат –

20000
1666.67004    
(3.00000000, 5.00000000 )
T
A big Hello from Tutorials Point         

Фортран – Константы

Константы ссылаются на фиксированные значения, которые программа не может изменить во время выполнения. Эти фиксированные значения также называются литералами .

Константы могут быть любого из основных типов данных, таких как целочисленная константа, плавающая константа, символьная константа, комплексная константа или строковый литерал. Есть только две логические константы: .true. и .false.

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

Именованные константы и литералы

Есть два типа констант –

  • Литеральные константы
  • Именованные константы

Литеральная константа имеет значение, но не имеет имени.

Например, следующие буквальные константы –

Тип пример
Целочисленные константы 0 1 -1 300 123456789
Реальные константы 0,0 1,0 -1,0 123,456 7,1E + 10 -52,715E-30
Комплексные константы (0,0, 0,0) (-123,456E + 30, 987,654E-29)
Логические константы .правда. .ложный.
Символьные константы

“PQR” “a” “123’abc $% # @!”

” цитата “” “

‘PQR’ ‘a’ ‘123 “abc $% # @!’

«апостроф»

“PQR” “a” “123’abc $% # @!”

” цитата “” “

‘PQR’ ‘a’ ‘123 “abc $% # @!’

«апостроф»

Именованная константа имеет значение, а также имя.

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

real, parameter :: pi = 3.1415927

пример

Следующая программа рассчитывает смещение из-за вертикального движения под действием силы тяжести.

Live Demo

program gravitationalDisp

! this program calculates vertical motion under gravity 
implicit none  

   ! gravitational acceleration
   real, parameter :: g = 9.81   
   
   ! variable declaration
   real :: s ! displacement   
   real :: t ! time  
   real :: u ! initial speed  
   
   ! assigning values 
   t = 5.0   
   u = 50  
   
   ! displacement   
   s = u * t - g * (t**2) / 2  
   
   ! output 
   print *, "Time = ", t
   print *, 'Displacement = ',s  
   
end program gravitationalDisp

Когда приведенный выше код компилируется и выполняется, он дает следующий результат –

Time = 5.00000000    
Displacement = 127.374992    

Фортран – Операторы

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

  • Арифметические Операторы
  • Операторы отношений
  • Логические Операторы

Давайте посмотрим на все эти типы операторов один за другим.

Арифметические Операторы

Следующая таблица показывает все арифметические операторы, поддерживаемые Fortran. Предположим, что переменная A содержит 5, а переменная B содержит 3, тогда –

Показать примеры

оператор Описание пример
+ Оператор сложения, добавляет два операнда. А + Б даст 8
Оператор вычитания, вычитает второй операнд из первого. А – Б даст 2
* Оператор умножения, умножает оба операнда. А * Б даст 15
/ Оператор деления, делитель числителя на числитель. А / Б даст 1
** Оператор возведения в степень, возводит один операнд в степень другого. А ** Б даст 125

Операторы отношений

Следующая таблица показывает все реляционные операторы, поддерживаемые Fortran. Предположим, что переменная A содержит 10, а переменная B содержит 20, тогда –

Показать примеры

оператор эквивалент Описание пример
== .eq. Проверяет, равны ли значения двух операндов или нет, если да, тогда условие становится истинным. (A == B) не соответствует действительности.
знак равно .На. Проверяет, равны ли значения двух операндов или нет, если значения не равны, тогда условие становится истинным. (A! = B) верно.
> .gt. Проверяет, больше ли значение левого операнда, чем значение правого операнда, если да, тогда условие становится истинным. (A> B) не соответствует действительности.
< .lt. Проверяет, меньше ли значение левого операнда, чем значение правого операнда, если да, тогда условие становится истинным. (A <B) верно.
> = .ge. Проверяет, больше ли значение левого операнда или равно значению правого операнда, если да, тогда условие становится истинным. (A> = B) не соответствует действительности.
<= .LE. Проверяет, меньше ли значение левого операнда или равно значению правого операнда, если да, тогда условие становится истинным. (A <= B) верно.

Логические Операторы

Логические операторы в Фортране работают только с логическими значениями .true. и .false.

В следующей таблице показаны все логические операторы, поддерживаемые Fortran. Предположим, переменная A содержит .true. и переменная B содержит .false. тогда –

Показать примеры

оператор Описание пример
.а также. Называется логический оператор И. Если оба операнда отличны от нуля, условие становится истинным. (A. И. B) является ложным.
.или же. Вызывается логическим оператором ИЛИ. Если любой из двух операндов отличен от нуля, условие становится истинным. (A. Или. B) это правда.
.не. Вызывается логическим оператором НЕ. Используйте для изменения логического состояния своего операнда. Если условие истинно, то оператор Логический НЕ будет делать ложь. ! (A. И. B) это правда.
.eqv. Называется логический EQUIVALENT Operator. Используется для проверки эквивалентности двух логических значений. (A .eqv. B) является ложным.
.neqv. Называется логическим неэквивалентным оператором. Используется для проверки неэквивалентности двух логических значений. (A. Neqv. B) верно.

Приоритет операторов в Фортране

Приоритет оператора определяет группировку терминов в выражении. Это влияет на то, как оценивается выражение. Некоторые операторы имеют более высокий приоритет, чем другие; например, оператор умножения имеет более высокий приоритет, чем оператор сложения.

Например, х = 7 + 3 * 2; здесь x назначено 13, а не 20, потому что оператор * имеет более высокий приоритет, чем +, поэтому он сначала умножается на 3 * 2, а затем прибавляется к 7.

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

Показать примеры

категория оператор Ассоциативность
Логическое НЕ и отрицательный знак .не. (-) Слева направо
Возведение ** Слева направо
Multiplicative * / Слева направо
присадка + – Слева направо
реляционный <<=>> = Слева направо
равенство == / = Слева направо
Логическое И .а также. Слева направо
Логическое ИЛИ .или же. Слева направо
присваивание знак равно Справа налево

Фортран – Решения

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

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

Принятие решения

Fortran предоставляет следующие типы конструкций для принятия решений.

Sr.No Заявление и описание
1 Если … то построить

Оператор if… then… end if состоит из логического выражения, за которым следует одно или несколько операторов.

2 Если … тогда … еще построить

За оператором if… then может следовать необязательный оператор else, который выполняется, когда логическое выражение ложно.

3 if … else if … else Заявление

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

4 вложенный, если построить

Вы можете использовать один оператор if или else if внутри другого оператора if или else if .

5 выберите случай конструкции

Оператор select case позволяет проверять переменную на соответствие списку значений.

6 вложенная конструкция выбора случая

Вы можете использовать один оператор выбора case внутри другого оператора (ов) выбора case .

Оператор if… then… end if состоит из логического выражения, за которым следует одно или несколько операторов.

За оператором if… then может следовать необязательный оператор else, который выполняется, когда логическое выражение ложно.

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

Вы можете использовать один оператор if или else if внутри другого оператора if или else if .

Оператор select case позволяет проверять переменную на соответствие списку значений.

Вы можете использовать один оператор выбора case внутри другого оператора (ов) выбора case .

Фортран – Петли

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

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

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

Если Условно

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

Sr.No Тип и описание петли
1 сделать цикл

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

2 сделать пока цикл

Повторяет оператор или группу операторов, пока данное условие выполняется. Он проверяет условие перед выполнением тела цикла.

3 вложенные циклы

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

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

Повторяет оператор или группу операторов, пока данное условие выполняется. Он проверяет условие перед выполнением тела цикла.

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

Заявления о контроле цикла

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

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

Sr.No Контрольное заявление и описание
1 выход

Если оператор выхода выполнен, цикл завершается, и выполнение программы продолжается с первого исполняемого оператора после оператора конца do.

2 цикл

Если выполняется цикл, программа продолжается в начале следующей итерации.

3 стоп

Если вы хотите, чтобы выполнение вашей программы остановилось, вы можете вставить оператор остановки

Если оператор выхода выполнен, цикл завершается, и выполнение программы продолжается с первого исполняемого оператора после оператора конца do.

Если выполняется цикл, программа продолжается в начале следующей итерации.

Если вы хотите, чтобы выполнение вашей программы остановилось, вы можете вставить оператор остановки

Фортран – Номера

Числа в Фортране представлены тремя внутренними типами данных –

  • Целочисленный тип
  • Реальный тип
  • Сложный тип

Целочисленный тип

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

Live Demo

program testingInt
implicit none

   integer :: largeval
   print *, huge(largeval)
   
end program testingInt

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

2147483647

Обратите внимание, что функция large () дает наибольшее число, которое может содержаться конкретным целочисленным типом данных. Вы также можете указать количество байтов, используя спецификатор вида . Следующий пример демонстрирует это –

Live Demo

program testingInt
implicit none

   !two byte integer
   integer(kind = 2) :: shortval
   
   !four byte integer
   integer(kind = 4) :: longval
   
   !eight byte integer
   integer(kind = 8) :: verylongval
   
   !sixteen byte integer
   integer(kind = 16) :: veryverylongval
   
   !default integer 
   integer :: defval
        
   print *, huge(shortval)
   print *, huge(longval)
   print *, huge(verylongval)
   print *, huge(veryverylongval)
   print *, huge(defval)
   
end program testingInt

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

32767
2147483647
9223372036854775807
170141183460469231731687303715884105727
2147483647

Реальный тип

Он хранит числа с плавающей запятой, такие как 2.0, 3.1415, -100.876 и т. Д.

Традиционно существовало два разных реальных типа: реальный тип по умолчанию и тип двойной точности .

Однако Fortran 90/95 обеспечивает больший контроль над точностью реальных и целочисленных типов данных с помощью спецификатора вида , который мы вскоре рассмотрим.

В следующем примере показано использование реального типа данных –

Live Demo

program division   
implicit none

   ! Define real variables   
   real :: p, q, realRes 
   
   ! Define integer variables  
   integer :: i, j, intRes  
   
   ! Assigning  values   
   p = 2.0 
   q = 3.0    
   i = 2 
   j = 3  
   
   ! floating point division
   realRes = p/q  
   intRes = i/j
   
   print *, realRes
   print *, intRes
   
end program division  

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

0.666666687    
0

Комплексный тип

Это используется для хранения комплексных чисел. Комплексное число состоит из двух частей: действительной части и мнимой части. Два последовательных цифровых запоминающих устройства хранят эти две части.

Например, комплексное число (3,0, -5,0) равно 3,0 – 5,0i

Универсальная функция cmplx () создает комплексное число. Это приводит к тому, что действительная и мнимая части имеют одинаковую точность, независимо от типа входных аргументов.

Live Demo

program createComplex
implicit none

   integer :: i = 10
   real :: x = 5.17
   print *, cmplx(i, x)
   
end program createComplex

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

(10.0000000, 5.17000008)

Следующая программа демонстрирует арифметику комплексных чисел –

Live Demo

program ComplexArithmatic
implicit none

   complex, parameter :: i = (0, 1)   ! sqrt(-1)   
   complex :: x, y, z 
   
   x = (7, 8); 
   y = (5, -7)   
   write(*,*) i * x * y
   
   z = x + y
   print *, "z = x + y = ", z
   
   z = x - y
   print *, "z = x - y = ", z 
   
   z = x * y
   print *, "z = x * y = ", z 
   
   z = x / y
   print *, "z = x / y = ", z 
   
end program ComplexArithmatic

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

(9.00000000, 91.0000000)
z = x + y = (12.0000000, 1.00000000)
z = x - y = (2.00000000, 15.0000000)
z = x * y = (91.0000000, -9.00000000)
z = x / y = (-0.283783793, 1.20270276)

Диапазон, точность и размер чисел

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

В следующей таблице показано количество битов и диапазон целых чисел –

Количество бит Максимальное значение причина
64 9.223.372.036.854.774.807 (2 ** 63) -1
32 2147483647 (2 ** 31) -1

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

Количество бит Наибольшее значение Наименьшее значение точность
64 0.8E + 308 0.5E-308 15-18
32 1.7E + 38 0.3e-38 6-9

Следующие примеры демонстрируют это –

Live Demo

program rangePrecision
implicit none

   real:: x, y, z
   x = 1.5e+40
   y = 3.73e+40
   z = x * y 
   print *, z
   
end program rangePrecision

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

x = 1.5e+40
          1
Error : Real constant overflows its kind at (1)
main.f95:5.12:

y = 3.73e+40
           1
Error : Real constant overflows its kind at (1)

Теперь давайте использовать меньшее число –

Live Demo

program rangePrecision
implicit none

   real:: x, y, z
   x = 1.5e+20
   y = 3.73e+20
   z = x * y 
   print *, z
   
   z = x/y
   print *, z
   
end program rangePrecision

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

Infinity
0.402144760   

Теперь давайте посмотрим, как опустится

Live Demo

program rangePrecision
implicit none

   real:: x, y, z
   x = 1.5e-30
   y = 3.73e-60
   z = x * y 
   print *, z
   
   z = x/y
   print *, z

end program rangePrecision

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

y = 3.73e-60
           1
Warning : Real constant underflows its kind at (1)

Executing the program....
$demo 

0.00000000E+00
Infinity

Добрый Спецификатор

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

Встроенная функция kind () позволяет вам запрашивать детали представления данных оборудования перед запуском программы.

Live Demo

program kindCheck
implicit none
   
   integer :: i 
   real :: r 
   complex :: cp 
   print *,' Integer ', kind(i) 
   print *,' Real ', kind(r) 
   print *,' Complex ', kind(cp) 
   
end program kindCheck

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

Integer 4
Real 4
Complex 4

Вы также можете проверить вид всех типов данных –

Live Demo

program checkKind
implicit none

   integer :: i 
   real :: r 
   character :: c 
   logical :: lg 
   complex :: cp 
   
   print *,' Integer ', kind(i) 
   print *,' Real ', kind(r) 
   print *,' Complex ', kind(cp)
   print *,' Character ', kind(c) 
   print *,' Logical ', kind(lg)
   
end program checkKind

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

Integer 4
Real 4
Complex 4
Character 1
Logical 4

Фортран – Персонажи

Язык Фортрана может обрабатывать символы как отдельные символы или смежные строки.

Символами могут быть любые символы, взятые из базового набора символов, т. Е. Из букв, десятичных цифр, подчеркивания и 21 специального символа.

Символьная константа – это символьная строка с фиксированным значением.

Внутренний символ типа данных хранит символы и строки. Длина строки может быть указана спецификатором len . Если длина не указана, она равна 1. Вы можете ссылаться на отдельные символы в строке, ссылаясь на позицию; самый левый символ находится в позиции 1.

Декларация персонажа

Объявление данных символьного типа аналогично другим переменным –

type-specifier :: variable_name

Например,

character :: reply, sex

Вы можете назначить значение, как,

reply = N 
sex = F

В следующем примере демонстрируется объявление и использование символьного типа данных –

Live Demo

program hello
implicit none

   character(len = 15) :: surname, firstname 
   character(len = 6) :: title 
   character(len = 25)::greetings
   
   title = 'Mr. ' 
   firstname = 'Rowan ' 
   surname = 'Atkinson'
   greetings = 'A big hello from Mr. Bean'
   
   print *, 'Here is ', title, firstname, surname
   print *, greetings
   
end program hello

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

Here is Mr. Rowan Atkinson       
A big hello from Mr. Bean

Конкатенация персонажей

Оператор конкатенации //, объединяет символы.

Следующий пример демонстрирует это –

Live Demo

program hello
implicit none

   character(len = 15) :: surname, firstname 
   character(len = 6) :: title 
   character(len = 40):: name
   character(len = 25)::greetings
   
   title = 'Mr. ' 
   firstname = 'Rowan ' 
   surname = 'Atkinson'
   
   name = title//firstname//surname
   greetings = 'A big hello from Mr. Bean'
   
   print *, 'Here is ', name
   print *, greetings
   
end program hello

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

Here is Mr.Rowan Atkinson       
A big hello from Mr.Bean

Некоторые функции персонажа

В следующей таблице приведены некоторые часто используемые символьные функции вместе с описанием –

Sr.No Описание функции
1

Len (строка)

Возвращает длину строки символов

2

Индекс (строка, sustring)

Он находит расположение подстроки в другой строке, возвращает 0, если не найден.

3

Ахар (целое)

Преобразует целое число в символ

4

iachar (с)

Преобразует символ в целое число

5

подрезать (строка)

Возвращает строку с удаленными конечными пробелами.

6

сканирование (строка, символы)

Он ищет «строку» слева направо (если только не = = .true.) Для первого вхождения любого символа, содержащегося в «символах». Возвращает целое число, указывающее позицию этого символа, или ноль, если ни один из символов в «символах» не был найден.

7

проверить (строка, символы)

Он сканирует «строку» слева направо (если только не задано = .true.) Для первого вхождения любого символа, не содержащегося в «символах». Возвращает целое число, указывающее позицию этого символа, или ноль, если были найдены только символы в “символах”

8

adjustl (строка)

Выравнивает по левому краю символы, содержащиеся в «строке»

9

adjustr (строка)

Правильно оправдывает символы, содержащиеся в «строке»

10

len_trim (строка)

Возвращает целое число, равное длине строки (len (string)) минус количество конечных пробелов

11

повтор (строка, ncopy)

Он возвращает строку с длиной, равной «ncopy», умноженной на длину «строки», и содержащей «ncopy» сцепленные копии «строки»

Len (строка)

Возвращает длину строки символов

Индекс (строка, sustring)

Он находит расположение подстроки в другой строке, возвращает 0, если не найден.

Ахар (целое)

Преобразует целое число в символ

iachar (с)

Преобразует символ в целое число

подрезать (строка)

Возвращает строку с удаленными конечными пробелами.

сканирование (строка, символы)

Он ищет «строку» слева направо (если только не = = .true.) Для первого вхождения любого символа, содержащегося в «символах». Возвращает целое число, указывающее позицию этого символа, или ноль, если ни один из символов в «символах» не был найден.

проверить (строка, символы)

Он сканирует «строку» слева направо (если только не задано = .true.) Для первого вхождения любого символа, не содержащегося в «символах». Возвращает целое число, указывающее позицию этого символа, или ноль, если были найдены только символы в “символах”

adjustl (строка)

Выравнивает по левому краю символы, содержащиеся в «строке»

adjustr (строка)

Правильно оправдывает символы, содержащиеся в «строке»

len_trim (строка)

Возвращает целое число, равное длине строки (len (string)) минус количество конечных пробелов

повтор (строка, ncopy)

Он возвращает строку с длиной, равной «ncopy», умноженной на длину «строки», и содержащей «ncopy» сцепленные копии «строки»

Пример 1

В этом примере показано использование функции индекса

Live Demo

program testingChars
implicit none

   character (80) :: text 
   integer :: i 
   
   text = 'The intrinsic data type character stores characters and   strings.'
   i=index(text,'character') 
   
   if (i /= 0) then
      print *, ' The word character found at position ',i 
      print *, ' in text: ', text 
   end if
   
end program testingChars

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

The word character found at position 25
in text : The intrinsic data type character stores characters and strings.  

Пример 2

Этот пример демонстрирует использование функции обрезки

Live Demo

program hello
implicit none

   character(len = 15) :: surname, firstname 
   character(len = 6) :: title 
   character(len = 25)::greetings
   
   title = 'Mr.' 
   firstname = 'Rowan' 
   surname = 'Atkinson'
   
   print *, 'Here is', title, firstname, surname
   print *, 'Here is', trim(title),' ',trim(firstname),' ', trim(surname)
   
end program hello

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

 Here isMr.   Rowan          Atkinson       
 Here isMr. Rowan Atkinson

Пример 3

Этот пример демонстрирует использование функции ачар

Live Demo

program testingChars
implicit none

   character:: ch
   integer:: i
   
   do i = 65, 90
      ch = achar(i)
      print*, i, ' ', ch
   end do
   
end program testingChars

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

65  A
66  B
67  C
68  D
69  E
70  F
71  G
72  H
73  I
74  J
75  K
76  L
77  M
78  N
79  O
80  P
81  Q
82  R
83  S
84  T
85  U
86  V
87  W
88  X
89  Y
90  Z

Проверка лексического порядка символов

Следующие функции определяют лексическую последовательность символов –

Sr.No Описание функции
1

lle (char, char)

Сравнивает, является ли первый символ лексически меньше или равен второму

2

lge (char, char)

Сравнивает, является ли первый символ лексически большим или равным второму

3

ЛГТ (символ, символ)

Сравнивает, является ли первый символ лексически большим, чем второй

4

llt (char, char)

Сравнивает, является ли первый символ лексически меньше, чем второй

lle (char, char)

Сравнивает, является ли первый символ лексически меньше или равен второму

lge (char, char)

Сравнивает, является ли первый символ лексически большим или равным второму

ЛГТ (символ, символ)

Сравнивает, является ли первый символ лексически большим, чем второй

llt (char, char)

Сравнивает, является ли первый символ лексически меньше, чем второй

Пример 4

Следующая функция демонстрирует использование –

Live Demo

program testingChars
implicit none

   character:: a, b, c
   a = 'A'
   b = 'a'
   c = 'B'
   
   if(lgt(a,b)) then
      print *, 'A is lexically greater than a'
   else
      print *, 'a is lexically greater than A'
   end if
   
   if(lgt(a,c)) then
      print *, 'A is lexically greater than B'
   else
      print *, 'B is lexically greater than A'
   end if  
   
   if(llt(a,b)) then
      print *, 'A is lexically less than a'
   end if
   
   if(llt(a,c)) then
      print *, 'A is lexically less than B'
   end if
   
end program testingChars

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

a is lexically greater than A
B is lexically greater than A
A is lexically less than a
A is lexically less than B

Фортран – Струны

Язык Фортрана может обрабатывать символы как отдельные символы или смежные строки.

Строка символов может иметь длину только один символ или даже нулевую длину. В Фортране символьные константы задаются между парой двойных или одинарных кавычек.

Внутренний символ типа данных хранит символы и строки. Длина строки может быть указана спецификатором len . Если длина не указана, она равна 1. Вы можете ссылаться на отдельные символы в строке, ссылаясь на позицию; самый левый символ находится в позиции 1.

Строковая декларация

Объявление строки совпадает с другими переменными –

type-specifier :: variable_name

Например,

Character(len = 20) :: firstname, surname

Вы можете назначить значение, как,

character (len = 40) :: name  
name = Zara Ali

В следующем примере демонстрируется объявление и использование символьного типа данных –

Live Demo

program hello
implicit none

   character(len = 15) :: surname, firstname 
   character(len = 6) :: title 
   character(len = 25)::greetings
   
   title = 'Mr.' 
   firstname = 'Rowan' 
   surname = 'Atkinson'
   greetings = 'A big hello from Mr. Beans'
   
   print *, 'Here is', title, firstname, surname
   print *, greetings
   
end program hello

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

Here is Mr. Rowan Atkinson       
A big hello from Mr. Bean

Конкатенация строк

Оператор конкатенации //, объединяет строки.

Следующий пример демонстрирует это –

Live Demo

program hello
implicit none

   character(len = 15) :: surname, firstname 
   character(len = 6) :: title 
   character(len = 40):: name
   character(len = 25)::greetings
   
   title = 'Mr.' 
   firstname = 'Rowan' 
   surname = 'Atkinson'
   
   name = title//firstname//surname
   greetings = 'A big hello from Mr. Beans'
   
   print *, 'Here is', name
   print *, greetings
   
end program hello

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

Here is Mr. Rowan Atkinson       
A big hello from Mr. Bean

Извлечение подстрок

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

В следующем примере показано, как извлечь подстроку «world» из строки «hello world» –

Live Demo

program subString

   character(len = 11)::hello
   hello = "Hello World"
   print*, hello(7:11)
   
end program subString 

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

World

пример

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

Live Demo

program  datetime
implicit none

   character(len = 8) :: dateinfo ! ccyymmdd
   character(len = 4) :: year, month*2, day*2

   character(len = 10) :: timeinfo ! hhmmss.sss
   character(len = 2)  :: hour, minute, second*6

   call  date_and_time(dateinfo, timeinfo)

   !  lets break dateinfo into year, month and day.
   !  dateinfo has a form of ccyymmdd, where cc = century, yy = year
   !  mm = month and dd = day

   year  = dateinfo(1:4)
   month = dateinfo(5:6)
   day   = dateinfo(7:8)

   print*, 'Date String:', dateinfo
   print*, 'Year:', year
   print *,'Month:', month
   print *,'Day:', day

   !  lets break timeinfo into hour, minute and second.
   !  timeinfo has a form of hhmmss.sss, where h = hour, m = minute
   !  and s = second

   hour   = timeinfo(1:2)
   minute = timeinfo(3:4)
   second = timeinfo(5:10)

   print*, 'Time String:', timeinfo
   print*, 'Hour:', hour
   print*, 'Minute:', minute
   print*, 'Second:', second   
   
end program  datetime

Когда вы компилируете и запускаете вышеуказанную программу, она дает подробную информацию о дате и времени –

Date String: 20140803
Year: 2014
Month: 08
Day: 03
Time String: 075835.466
Hour: 07
Minute: 58
Second: 35.466

Обрезка струн

Функция trim принимает строку и возвращает входную строку после удаления всех завершающих пробелов.

пример

Live Demo

program trimString
implicit none

   character (len = *), parameter :: fname="Susanne", sname="Rizwan"
   character (len = 20) :: fullname 
   
   fullname = fname//" "//sname !concatenating the strings
   
   print*,fullname,", the beautiful dancer from the east!"
   print*,trim(fullname),", the beautiful dancer from the east!"
   
end program trimString

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

Susanne Rizwan      , the beautiful dancer from the east!
 Susanne Rizwan, the beautiful dancer from the east!

Левая и правая настройка строк

Функция Adjustl берет строку и возвращает ее, удаляя начальные пробелы и добавляя их в качестве конечных пробелов.

Функция регулятор берет строку и возвращает ее, удаляя конечные пробелы и добавляя их в качестве ведущих пробелов.

пример

Live Demo

program hello
implicit none

   character(len = 15) :: surname, firstname 
   character(len = 6) :: title 
   character(len = 40):: name
   character(len = 25):: greetings
   
   title = 'Mr. ' 
   firstname = 'Rowan' 
   surname = 'Atkinson'
   greetings = 'A big hello from Mr. Beans'
   
   name = adjustl(title)//adjustl(firstname)//adjustl(surname)
   print *, 'Here is', name
   print *, greetings
   
   name = adjustr(title)//adjustr(firstname)//adjustr(surname)
   print *, 'Here is', name
   print *, greetings
   
   name = trim(title)//trim(firstname)//trim(surname)
   print *, 'Here is', name
   print *, greetings
   
end program hello

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

Here is Mr. Rowan  Atkinson           
A big hello from Mr. Bean
Here is Mr. Rowan Atkinson    
A big hello from Mr. Bean
Here is Mr.RowanAtkinson                        
A big hello from Mr. Bean

Поиск подстроки в строке

Функция index берет две строки и проверяет, является ли вторая строка подстрокой первой строки. Если второй аргумент является подстрокой первого аргумента, он возвращает целое число, которое является начальным индексом второй строки в первой строке, иначе он возвращает ноль.

пример

Live Demo

program hello
implicit none

   character(len=30) :: myString
   character(len=10) :: testString
   
   myString = 'This is a test'
   testString = 'test'
   
   if(index(myString, testString) == 0)then
      print *, 'test is not found'
   else
      print *, 'test is found at index: ', index(myString, testString)
   end if
   
end program hello

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

test is found at index: 11

Фортран – Массивы

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

Все массивы состоят из смежных областей памяти. Самый низкий адрес соответствует первому элементу, а самый высокий адрес – последнему.

Числа (1) Числа (2) Числа (3) Числа (4)

Массивы могут быть одномерными (как векторы), двумерными (как матрицы) и Fortran позволяет создавать до 7-мерных массивов.

Объявление массивов

Массивы объявляются с атрибутом измерения .

Например, чтобы объявить одномерный массив с именем number из действительных чисел, содержащий 5 элементов, вы пишете:

real, dimension(5) :: numbers

На отдельные элементы массивов ссылаются путем указания их индексов. Первый элемент массива имеет нижний индекс один. Числа массива содержат пять действительных переменных – числа (1), числа (2), числа (3), числа (4) и числа (5).

Чтобы создать двумерный массив целых чисел 5 x 5 с именем matrix, вы пишете:

integer, dimension (5,5) :: matrix  

Вы также можете объявить массив с некоторой явной нижней границей, например –

real, dimension(2:6) :: numbers
integer, dimension (-3:2,0:4) :: matrix  

Присвоение значений

Вы можете назначить значения отдельным членам, например,

numbers(1) = 2.0

или вы можете использовать цикл,

do i  =1,5
   numbers(i) = i * 2.0
end do

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

numbers = (/1.5, 3.2,4.5,0.9,7.2 /)

обратите внимание, что между скобками не должно быть пробелов ‘(‘ и обратной косой черты ‘/’

пример

Следующий пример демонстрирует концепции, обсужденные выше.

Live Demo

program arrayProg

   real :: numbers(5) !one dimensional integer array
   integer :: matrix(3,3), i , j !two dimensional real array
   
   !assigning some values to the array numbers
   do i=1,5
      numbers(i) = i * 2.0
   end do
   
   !display the values
   do i = 1, 5
      Print *, numbers(i)
   end do
   
   !assigning some values to the array matrix
   do i=1,3
      do j = 1, 3
         matrix(i, j) = i+j
      end do
   end do
   
   !display the values
   do i=1,3
      do j = 1, 3
         Print *, matrix(i,j)
      end do
   end do
   
   !short hand assignment
   numbers = (/1.5, 3.2,4.5,0.9,7.2 /)
   
   !display the values
   do i = 1, 5
      Print *, numbers(i)
   end do
   
end program arrayProg

Когда приведенный выше код компилируется и выполняется, он дает следующий результат –

 2.00000000    
 4.00000000    
 6.00000000    
 8.00000000    
 10.0000000    
         2
         3
         4
         3
         4
         5
         4
         5
         6
 1.50000000    
 3.20000005    
 4.50000000    
0.899999976    
 7.19999981    

Некоторые термины, связанные с массивом

В следующей таблице приведены некоторые термины, связанные с массивом:

Срок Имея в виду
Ранг Это количество измерений в массиве. Например, для массива с именем matrix ранг равен 2, а для массива с именем numbers ранг равен 1.
степень Это количество элементов в измерении. Например, номера массивов имеют экстент 5, а массив с именем matrix имеет экстент 3 в обоих измерениях.
форма Форма массива представляет собой одномерный целочисленный массив, содержащий количество элементов (экстент) в каждом измерении. Например, для матрицы массива shape равен (3, 3), а для номеров массива – (5).
Размер Это количество элементов в массиве. Для матрицы массива это 9, а для номеров массива это 5.

Передача массивов в процедуры

Вы можете передать массив процедуре в качестве аргумента. Следующий пример демонстрирует концепцию –

Live Demo

program arrayToProcedure      
implicit none      

   integer, dimension (5) :: myArray  
   integer :: i
   
   call fillArray (myArray)      
   call printArray(myArray)
   
end program arrayToProcedure


subroutine fillArray (a)      
implicit none      

   integer, dimension (5), intent (out) :: a
   
   ! local variables     
   integer :: i     
   do i = 1, 5         
      a(i) = i      
   end do  
   
end subroutine fillArray 


subroutine printArray(a)

   integer, dimension (5) :: a  
   integer::i
   
   do i = 1, 5
      Print *, a(i)
   end do
   
end subroutine printArray

Когда приведенный выше код компилируется и выполняется, он дает следующий результат –

1
2
3
4
5

В приведенном выше примере подпрограммы fillArray и printArray могут вызываться только для массивов с измерением 5. Однако для записи подпрограмм, которые можно использовать для массивов любого размера, вы можете переписать их, используя следующую технику:

Live Demo

program arrayToProcedure      
implicit  none    

   integer, dimension (10) :: myArray  
   integer :: i
   
   interface 
      subroutine fillArray (a)
         integer, dimension(:), intent (out) :: a 
         integer :: i         
      end subroutine fillArray      

      subroutine printArray (a)
         integer, dimension(:) :: a 
         integer :: i         
      end subroutine printArray   
   end interface 
   
   call fillArray (myArray)      
   call printArray(myArray)
   
end program arrayToProcedure


subroutine fillArray (a)      
implicit none      
   integer,dimension (:), intent (out) :: a      
   
   ! local variables     
   integer :: i, arraySize  
   arraySize = size(a)
   
   do i = 1, arraySize         
      a(i) = i      
   end do  
   
end subroutine fillArray 


subroutine printArray(a)
implicit none

   integer,dimension (:) :: a  
   integer::i, arraySize
   arraySize = size(a)
   
   do i = 1, arraySize
     Print *, a(i)
   end do
   
end subroutine printArray

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

Когда приведенный выше код компилируется и выполняется, он дает следующий результат –

1
2
3
4
5
6
7
8
9
10

Разделы массива

Пока мы ссылались на весь массив, Fortran предоставляет простой способ ссылаться на несколько элементов или часть массива, используя один оператор.

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

array ([lower]:[upper][:stride], ...)

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

Следующий пример демонстрирует концепцию –

Live Demo

program arraySubsection

   real, dimension(10) :: a, b
   integer:: i, asize, bsize
   
   a(1:7) = 5.0 ! a(1) to a(7) assigned 5.0
   a(8🙂 = 0.0  ! rest are 0.0 
   b(2:10:2) = 3.9
   b(1:9:2) = 2.5
   
   !display
   asize = size(a)
   bsize = size(b)
   
   do i = 1, asize
      Print *, a(i)
   end do
   
   do i = 1, bsize
      Print *, b(i)
   end do
   
end program arraySubsection

Когда приведенный выше код компилируется и выполняется, он дает следующий результат –

5.00000000    
5.00000000    
5.00000000    
5.00000000    
5.00000000    
5.00000000    
5.00000000    
0.00000000E+00
0.00000000E+00
0.00000000E+00
2.50000000    
3.90000010    
2.50000000    
3.90000010    
2.50000000    
3.90000010    
2.50000000    
3.90000010    
2.50000000    
3.90000010 

Встроенные функции массива

Fortran 90/95 предоставляет несколько внутренних процедур. Их можно разделить на 7 категорий.

Векторное и матричное умножение

снижение

запрос

строительство

Переформуйте

манипуляция

Место нахождения

Фортран – динамические массивы

Динамический массив – это массив, размер которого неизвестен во время компиляции, но будет известен во время выполнения.

Динамические массивы объявляются с атрибутом.

Например,

real, dimension (:,:), allocatable :: darray    

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

allocate ( darray(s1,s2) )      

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

deallocate (darray)  

пример

Следующий пример демонстрирует концепции, обсужденные выше.

program dynamic_array 
implicit none 

   !rank is 2, but size not known   
   real, dimension (:,:), allocatable :: darray    
   integer :: s1, s2     
   integer :: i, j     
   
   print*, "Enter the size of the array:"     
   read*, s1, s2      
   
   ! allocate memory      
   allocate ( darray(s1,s2) )      
   
   do i = 1, s1           
      do j = 1, s2                
         darray(i,j) = i*j               
         print*, "darray(",i,",",j,") = ", darray(i,j)           
      end do      
   end do      
   
   deallocate (darray)  
end program dynamic_array

Когда приведенный выше код компилируется и выполняется, он дает следующий результат –

Enter the size of the array: 3,4
darray( 1 , 1 ) = 1.00000000    
darray( 1 , 2 ) = 2.00000000    
darray( 1 , 3 ) = 3.00000000    
darray( 1 , 4 ) = 4.00000000    
darray( 2 , 1 ) = 2.00000000    
darray( 2 , 2 ) = 4.00000000    
darray( 2 , 3 ) = 6.00000000    
darray( 2 , 4 ) = 8.00000000    
darray( 3 , 1 ) = 3.00000000    
darray( 3 , 2 ) = 6.00000000    
darray( 3 , 3 ) = 9.00000000    
darray( 3 , 4 ) = 12.0000000   

Использование заявления данных

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

Синтаксис заявления данных –

data variable / list / ...

пример

Следующий пример демонстрирует концепцию –

Live Demo

program dataStatement
implicit none

   integer :: a(5), b(3,3), c(10),i, j
   data a /7,8,9,10,11/ 
   
   data b(1,:) /1,1,1/ 
   data b(2,:)/2,2,2/ 
   data b(3,:)/3,3,3/ 
   data (c(i),i = 1,10,2) /4,5,6,7,8/ 
   data (c(i),i = 2,10,2)/5*2/
   
   Print *, 'The A array:'
   do j = 1, 5                
      print*, a(j)           
   end do 
   
   Print *, 'The B array:'
   do i = lbound(b,1), ubound(b,1)
      write(*,*) (b(i,j), j = lbound(b,2), ubound(b,2))
   end do

   Print *, 'The C array:' 
   do j = 1, 10                
      print*, c(j)           
   end do      
   
end program dataStatement

Когда приведенный выше код компилируется и выполняется, он дает следующий результат –

 The A array:
           7
           8
           9
          10
          11
 The B array:
           1           1           1
           2           2           2
           3           3           3
 The C array:
           4
           2
           5
           2
           6
           2
           7
           2
           8
           2

Использование оператора Where

Оператор where позволяет использовать некоторые элементы массива в выражении в зависимости от результата какого-либо логического условия. Это позволяет выполнять выражение элемента, если данное условие истинно.

пример

Следующий пример демонстрирует концепцию –

Live Demo

program whereStatement
implicit none

   integer :: a(3,5), i , j
   
   do i = 1,3
      do j = 1, 5                
         a(i,j) = j-i          
      end do 
   end do
   
   Print *, 'The A array:'
   
   do i = lbound(a,1), ubound(a,1)
      write(*,*) (a(i,j), j = lbound(a,2), ubound(a,2))
   end do
   
   where( a<0 ) 
      a = 1 
   elsewhere
      a = 5
   end where
  
   Print *, 'The A array:'
   do i = lbound(a,1), ubound(a,1)
      write(*,*) (a(i,j), j = lbound(a,2), ubound(a,2))
   end do   
   
end program whereStatement

Когда приведенный выше код компилируется и выполняется, он дает следующий результат –

 The A array:
           0           1           2           3           4
          -1           0           1           2           3
          -2          -1           0           1           2
 The A array:
           5           5           5           5           5
           1           5           5           5           5
           1           1           5           5           5

Fortran – производные типы данных

Fortran позволяет вам определять производные типы данных. Производный тип данных также называется структурой и может состоять из объектов данных разных типов.

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

  • заглавие
  • автор
  • Предмет
  • ID книги

Определение производного типа данных

Чтобы определить производный тип данных, используются операторы типа и конечного типа . , Оператор type определяет новый тип данных с более чем одним членом для вашей программы. Формат оператора типа такой:

type type_name      
   declarations
end type 

Вот как вы бы объявили структуру Книги –

type Books
   character(len = 50) :: title
   character(len = 50) :: author
   character(len = 150) :: subject
   integer :: book_id
end type Books

Доступ к членам структуры

Объект производного типа данных называется структурой.

Структура типа Книги может быть создана в операторе объявления типа как –

type(Books) :: book1 

Доступ к компонентам структуры можно получить с помощью символа селектора компонента (%) –

book1%title = "C Programming"
book1%author = "Nuha Ali"
book1%subject = "C Programming Tutorial"
book1%book_id = 6495407

Обратите внимание, что до и после символа% нет пробелов.

пример

Следующая программа иллюстрирует вышеуказанные понятия –

Live Demo

program deriveDataType

   !type declaration
   type Books
      character(len = 50) :: title
      character(len = 50) :: author
      character(len = 150) :: subject
      integer :: book_id
   end type Books
   
   !declaring type variables
   type(Books) :: book1 
   type(Books) :: book2 
   
   !accessing the components of the structure
   
   book1%title = "C Programming"
   book1%author = "Nuha Ali"
   book1%subject = "C Programming Tutorial"
   book1%book_id = 6495407 
   
   book2%title = "Telecom Billing"
   book2%author = "Zara Ali"
   book2%subject = "Telecom Billing Tutorial"
   book2%book_id = 6495700
  
   !display book info
   
   Print *, book1%title 
   Print *, book1%author 
   Print *, book1%subject 
   Print *, book1%book_id  
   
   Print *, book2%title 
   Print *, book2%author 
   Print *, book2%subject 
   Print *, book2%book_id  

end program deriveDataType

Когда приведенный выше код компилируется и выполняется, он дает следующий результат –

 C Programming                                     
 Nuha Ali                                          
 C Programming Tutorial            
   6495407
 Telecom Billing                                   
 Zara Ali                                          
 Telecom Billing Tutorial            
   6495700

Массив структур

Вы также можете создавать массивы производного типа –

type(Books), dimension(2) :: list

Отдельные элементы массива могут быть доступны как –

list(1)%title = "C Programming"
list(1)%author = "Nuha Ali"
list(1)%subject = "C Programming Tutorial"
list(1)%book_id = 6495407

Следующая программа иллюстрирует концепцию –

Live Demo

program deriveDataType

   !type declaration
   type Books
      character(len = 50) :: title
      character(len = 50) :: author
      character(len = 150) :: subject
      integer :: book_id
   end type Books
   
   !declaring array of books
   type(Books), dimension(2) :: list 
    
   !accessing the components of the structure
   
   list(1)%title = "C Programming"
   list(1)%author = "Nuha Ali"
   list(1)%subject = "C Programming Tutorial"
   list(1)%book_id = 6495407 
   
   list(2)%title = "Telecom Billing"
   list(2)%author = "Zara Ali"
   list(2)%subject = "Telecom Billing Tutorial"
   list(2)%book_id = 6495700
  
   !display book info
   
   Print *, list(1)%title 
   Print *, list(1)%author 
   Print *, list(1)%subject 
   Print *, list(1)%book_id  
   
   Print *, list(1)%title 
   Print *, list(2)%author 
   Print *, list(2)%subject 
   Print *, list(2)%book_id  

end program deriveDataType

Когда приведенный выше код компилируется и выполняется, он дает следующий результат –

C Programming                                     
Nuha Ali                                          
C Programming Tutorial               
   6495407
C Programming                                     
Zara Ali                                          
Telecom Billing Tutorial                                      
   6495700

Фортран – Указатели

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

Указатель связан с целью путем выделения или назначения указателя.

Объявление переменной-указателя

Переменная указателя объявляется с атрибутом указателя.

В следующих примерах показано объявление переменных-указателей –

integer, pointer :: p1 ! pointer to integer  
real, pointer, dimension (:) :: pra ! pointer to 1-dim real array  
real, pointer, dimension (:,:) :: pra2 ! pointer to 2-dim real array

Указатель может указывать на –

  • Область динамически выделяемой памяти.

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

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

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

Выделение пространства для указателя

Оператор allocate позволяет вам выделить место для объекта указателя. Например –

Live Demo

program pointerExample
implicit none

   integer, pointer :: p1
   allocate(p1)
   
   p1 = 1
   Print *, p1
   
   p1 = p1 + 4
   Print *, p1
   
end program pointerExample

Когда приведенный выше код компилируется и выполняется, он дает следующий результат –

1
5

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

Цели и Ассоциация

Цель – это еще одна нормальная переменная, для которой выделено пространство. Целевая переменная должна быть объявлена ​​с целевым атрибутом.

Вы связываете переменную-указатель с целевой переменной, используя оператор связи (=>).

Давайте перепишем предыдущий пример, чтобы продемонстрировать концепцию –

Live Demo

program pointerExample
implicit none

   integer, pointer :: p1
   integer, target :: t1 
   
   p1=>t1
   p1 = 1
   
   Print *, p1
   Print *, t1
   
   p1 = p1 + 4
   
   Print *, p1
   Print *, t1
   
   t1 = 8
   
   Print *, p1
   Print *, t1
   
end program pointerExample

Когда приведенный выше код компилируется и выполняется, он дает следующий результат –

1
1
5
5
8
8

Указатель может быть –

  • Неопределенный
  • ассоциированный
  • диссоциированного

В приведенной выше программе мы связали указатель p1 с целью t1, используя оператор =>. Функция, связанная, проверяет статус ассоциации указателя.

Оператор nullify разъединяет указатель от цели.

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

Пример 1

Следующий пример демонстрирует понятия –

Live Demo

program pointerExample
implicit none

   integer, pointer :: p1
   integer, target :: t1 
   integer, target :: t2
   
   p1=>t1
   p1 = 1
   
   Print *, p1
   Print *, t1
   
   p1 = p1 + 4
   Print *, p1
   Print *, t1
   
   t1 = 8
   Print *, p1
   Print *, t1
   
   nullify(p1)
   Print *, t1
   
   p1=>t2
   Print *, associated(p1)
   Print*, associated(p1, t1)
   Print*, associated(p1, t2)
   
   !what is the value of p1 at present
   Print *, p1
   Print *, t2
   
   p1 = 10
   Print *, p1
   Print *, t2
   
end program pointerExample

Когда приведенный выше код компилируется и выполняется, он дает следующий результат –

1
1
5
5
8
8
8
T
F
T
952754640
952754640
10
10

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

Пример 2

Live Demo

program pointerExample
implicit none

   integer, pointer :: a, b
   integer, target :: t
   integer :: n
   
   t = 1
   a => t
   t = 2
   b => t
   n = a + b
   
   Print *, a, b, t, n 
   
end program pointerExample

Когда приведенный выше код компилируется и выполняется, он дает следующий результат –

2  2  2  4

Фортран – Базовый ввод-вывод

До сих пор мы видели, что мы можем читать данные с клавиатуры, используя оператор read * , и отображать вывод на экран, используя оператор print * , соответственно. Эта форма ввода-вывода является вводом-выводом произвольного формата и называется направленным на ввод-вывод списком .

Свободный формат простого ввода / вывода имеет вид –

read(*,*) item1, item2, item3...
print *, item1, item2, item3
write(*,*) item1, item2, item3...

Однако форматированный ввод / вывод дает вам больше гибкости по сравнению с передачей данных.

Форматированный ввод-вывод

Форматированный ввод-вывод имеет следующий синтаксис:

read fmt, variable_list 
print fmt, variable_list 
write fmt, variable_list 

Куда,

  • fmt – спецификация формата

  • переменная-список представляет собой список переменных, которые будут считаны с клавиатуры или записаны на экране

fmt – спецификация формата

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

Спецификация формата определяет способ отображения форматированных данных. Он состоит из строки, содержащей список дескрипторов редактирования в скобках.

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

Например

Print "(f6.3)", pi

Следующая таблица описывает дескрипторы –

дескриптор Описание пример
я

Это используется для целочисленного вывода. Это принимает форму «rIw.m», где значения r, w и m приведены в таблице ниже. Целочисленные значения правильно выровнены в своих полях. Если ширина поля не достаточно велика, чтобы вместить целое число, то поле заполняется звездочками.

печать “(3i5)”, i, j, k
F

Это используется для вывода действительного числа. Это принимает форму ‘rFw.d’, где значения r, w и d приведены в таблице ниже. Реальные ценности оправданы в своих областях. Если ширина поля недостаточно велика, чтобы вместить действительное число, то поле заполняется звездочками.

печать “(f12.3)”, пи
Е

Это используется для реального вывода в экспоненциальной записи. Оператор дескриптора ‘E’ принимает форму ‘rEw.d’, где значения r, w и d приведены в таблице ниже. Реальные ценности оправданы в своих областях. Если ширина поля недостаточно велика, чтобы вместить действительное число, то поле заполняется звездочками.

Обратите внимание, что для распечатывания действительного числа с тремя десятичными знаками необходима ширина поля не менее десяти. Один для знака мантиссы, два для нуля, четыре для мантиссы и два для самого показателя. В общем, w ≥ d + 7.

выведите «(e10.3)», 123456.0 дает «0.123e + 06»
ES

Это используется для реального результата (научная запись). Это принимает форму ‘rESw.d’, где значения r, w и d приведены в таблице ниже. Описанный выше «E» дескриптор несколько отличается от традиционного общеизвестного «научного обозначения». Научная нотация имеет мантиссу в диапазоне от 1,0 до 10,0 в отличие от дескриптора E, который имеет мантиссу в диапазоне от 0,1 до 1,0. Реальные ценности оправданы в своих областях. Если ширина поля недостаточно велика, чтобы вместить действительное число, то поле заполняется звездочками. Здесь также поле ширины должно удовлетворять выражению w ≥ d + 7

выведите «(es10.3)», 123456.0 дает «1.235e + 05»

Это используется для вывода символов. Это принимает форму ‘rAw’, где значения r и w приведены в таблице ниже. Типы символов правильны в своих полях. Если ширина поля недостаточно велика, чтобы вместить строку символов, то поле заполняется первыми символами ‘w’ строки.

печать “(а10)”, ул
Икс

Это используется для вывода пространства. Это принимает форму ‘nX’, где ‘n’ – количество желаемых пробелов.

печать “(5х, а10)”, ул
/

Дескриптор косой черты – используется для вставки пустых строк. Это принимает форму ‘/’ и заставляет следующий вывод данных быть в новой строке.

печать “(/, 5х, а10)”, стр

Это используется для целочисленного вывода. Это принимает форму «rIw.m», где значения r, w и m приведены в таблице ниже. Целочисленные значения правильно выровнены в своих полях. Если ширина поля не достаточно велика, чтобы вместить целое число, то поле заполняется звездочками.

Это используется для вывода действительного числа. Это принимает форму ‘rFw.d’, где значения r, w и d приведены в таблице ниже. Реальные ценности оправданы в своих областях. Если ширина поля недостаточно велика, чтобы вместить действительное число, то поле заполняется звездочками.

Это используется для реального вывода в экспоненциальной записи. Оператор дескриптора ‘E’ принимает форму ‘rEw.d’, где значения r, w и d приведены в таблице ниже. Реальные ценности оправданы в своих областях. Если ширина поля недостаточно велика, чтобы вместить действительное число, то поле заполняется звездочками.

Обратите внимание, что для распечатывания действительного числа с тремя десятичными знаками необходима ширина поля не менее десяти. Один для знака мантиссы, два для нуля, четыре для мантиссы и два для самого показателя. В общем, w ≥ d + 7.

Это используется для реального результата (научная запись). Это принимает форму ‘rESw.d’, где значения r, w и d приведены в таблице ниже. Описанный выше «E» дескриптор несколько отличается от традиционного общеизвестного «научного обозначения». Научная нотация имеет мантиссу в диапазоне от 1,0 до 10,0 в отличие от дескриптора E, который имеет мантиссу в диапазоне от 0,1 до 1,0. Реальные ценности оправданы в своих областях. Если ширина поля недостаточно велика, чтобы вместить действительное число, то поле заполняется звездочками. Здесь также поле ширины должно удовлетворять выражению w ≥ d + 7

Это используется для вывода символов. Это принимает форму ‘rAw’, где значения r и w приведены в таблице ниже. Типы символов правильны в своих полях. Если ширина поля недостаточно велика, чтобы вместить строку символов, то поле заполняется первыми символами ‘w’ строки.

Это используется для вывода пространства. Это принимает форму ‘nX’, где ‘n’ – количество желаемых пробелов.

Дескриптор косой черты – используется для вставки пустых строк. Это принимает форму ‘/’ и заставляет следующий вывод данных быть в новой строке.

Следующие символы используются с дескрипторами формата –

Sr.No Символ и описание
1

с

Номер колонки

2

d

Количество цифр справа от десятичного разряда для реального ввода или вывода

3

м

Минимальное количество отображаемых цифр

4

N

Количество пропущенных пробелов

5

р

Количество повторов – количество раз, чтобы использовать дескриптор или группу дескрипторов

6

вес

Ширина поля – количество символов, используемых для ввода или вывода

с

Номер колонки

d

Количество цифр справа от десятичного разряда для реального ввода или вывода

м

Минимальное количество отображаемых цифр

N

Количество пропущенных пробелов

р

Количество повторов – количество раз, чтобы использовать дескриптор или группу дескрипторов

вес

Ширина поля – количество символов, используемых для ввода или вывода

Пример 1

Live Demo

program printPi

   pi = 3.141592653589793238 
   
   Print "(f6.3)", pi 
   Print "(f10.7)", pi
   Print "(f20.15)", pi 
   Print "(e16.4)", pi/100 
   
end program printPi

Когда приведенный выше код компилируется и выполняется, он дает следующий результат –

3.142
3.1415927
3.141592741012573
0.3142E-01

Пример 2

program printName
implicit none

   character (len = 15) :: first_name
   print *,' Enter your first name.' 
   print *,' Up to 20 characters, please'
   
   read *,first_name 
   print "(1x,a)",first_name
   
end program printName

Когда приведенный выше код компилируется и выполняется, он дает следующий результат: (предположим, что пользователь вводит имя Zara)

Enter your first name.
Up to 20 characters, please
Zara 

Пример 3

Live Demo

program formattedPrint
implicit none

   real :: c = 1.2786456e-9, d = 0.1234567e3 
   integer :: n = 300789, k = 45, i = 2
   character (len=15) :: str="Tutorials Point"
   
   print "(i6)", k 
   print "(i6.3)", k 
   print "(3i10)", n, k, i 
   print "(i10,i3,i5)", n, k, i 
   print "(a15)",str 
   print "(f12.3)", d
   print "(e12.4)", c 
   print '(/,3x,"n = ",i6, 3x, "d = ",f7.4)', n, d
   
end program formattedPrint

Когда приведенный выше код компилируется и выполняется, он дает следующий результат –

45
045
300789 45  2
300789 45  2
Tutorials Point
123.457
0.1279E-08

n = 300789 d = *******

Заявление о формате

Оператор формата позволяет смешивать и сопоставлять символьные, целые и реальные выходные данные в одном операторе. Следующий пример демонстрирует это –

Live Demo

program productDetails 
implicit none 

   character (len = 15) :: name
   integer :: id 
   real :: weight
   name = 'Ardupilot'
   id = 1
   weight = 0.08
   
   print *,' The product details are' 
   
   print 100
   100 format (7x,'Name:', 7x, 'Id:', 1x, 'Weight:')
   
   print 200, name, id, weight 
   200 format(1x, a, 2x, i3, 2x, f5.2) 
   
end program productDetails

Когда приведенный выше код компилируется и выполняется, он дает следующий результат –

The product details are
Name:       Id:    Weight:
Ardupilot   1       0.08

Фортран – Файл ввода-вывода

Fortran позволяет вам читать данные и записывать данные в файлы.

В последней главе вы увидели, как читать данные и записывать данные в терминал. В этой главе вы изучите функции ввода и вывода файлов, предоставляемые Fortran.

Вы можете читать и писать в один или несколько файлов. Операторы OPEN, WRITE, READ и CLOSE позволяют вам достичь этого.

Открытие и закрытие файлов

Перед использованием файла вы должны открыть файл. Команда open используется для открытия файлов для чтения или записи. Самая простая форма команды –

open (unit = number, file = "name").

Тем не менее, открытое заявление может иметь общую форму –

open (list-of-specifiers)

В следующей таблице описаны наиболее часто используемые спецификаторы.

Sr.No Спецификатор и описание
1

[UNIT =] U

Номер устройства u может быть любым числом в диапазоне 9-99, и это указывает на файл, вы можете выбрать любое число, но каждый открытый файл в программе должен иметь уникальный номер

2

IOSTAT = IOS

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

3

ERR = ошибка

Это метка, к которой переходит элемент управления в случае любой ошибки.

4

ФАЙЛ = имя

Имя файла, строка символов.

5

STATUS = STA

Показывает предыдущий статус файла. Символьная строка и может иметь одно из трех значений NEW, OLD или SCRATCH. Скретч-файл создается и удаляется при закрытии или завершении программы.

6

ДОСТУП = акк

Это режим доступа к файлу. Может иметь одно из двух значений, SEQUENTIAL или DIRECT. По умолчанию установлено значение SEQUENTIAL.

7

ФОРМА = ФРМ

Это дает статус форматирования файла. Может иметь одно из двух значений: FORMATTED или UNFORMATTED. По умолчанию установлено значение UNFORMATTED

8

RECL = RL

Он определяет длину каждой записи в файле прямого доступа.

[UNIT =] U

Номер устройства u может быть любым числом в диапазоне 9-99, и это указывает на файл, вы можете выбрать любое число, но каждый открытый файл в программе должен иметь уникальный номер

IOSTAT = IOS

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

ERR = ошибка

Это метка, к которой переходит элемент управления в случае любой ошибки.

ФАЙЛ = имя

Имя файла, строка символов.

STATUS = STA

Показывает предыдущий статус файла. Символьная строка и может иметь одно из трех значений NEW, OLD или SCRATCH. Скретч-файл создается и удаляется при закрытии или завершении программы.

ДОСТУП = акк

Это режим доступа к файлу. Может иметь одно из двух значений, SEQUENTIAL или DIRECT. По умолчанию установлено значение SEQUENTIAL.

ФОРМА = ФРМ

Это дает статус форматирования файла. Может иметь одно из двух значений: FORMATTED или UNFORMATTED. По умолчанию установлено значение UNFORMATTED

RECL = RL

Он определяет длину каждой записи в файле прямого доступа.

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

Оператор close имеет следующий синтаксис:

close ([UNIT = ]u[,IOSTAT = ios,ERR = err,STATUS = sta])

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

пример

Этот пример демонстрирует открытие нового файла для записи некоторых данных в файл.

program outputdata   
implicit none

   real, dimension(100) :: x, y  
   real, dimension(100) :: p, q
   integer :: i  
   
   ! data  
   do i=1,100  
      x(i) = i * 0.1 
      y(i) = sin(x(i)) * (1-cos(x(i)/3.0))  
   end do  
   
   ! output data into a file 
   open(1, file = 'data1.dat', status = 'new')  
   do i=1,100  
      write(1,*) x(i), y(i)   
   end do  
   
   close(1) 
   
end program outputdata

Когда приведенный выше код компилируется и выполняется, он создает файл data1.dat и записывает в него значения массива x и y. И затем закрывает файл.

Чтение и запись в файл

Операции чтения и записи соответственно используются для чтения и записи в файл соответственно.

У них есть следующий синтаксис –

read ([UNIT = ]u, [FMT = ]fmt, IOSTAT = ios, ERR = err, END = s)
write([UNIT = ]u, [FMT = ]fmt, IOSTAT = ios, ERR = err, END = s)

Большинство спецификаторов уже обсуждались в приведенной выше таблице.

Спецификатор END = s – это метка оператора, куда программа переходит, когда она достигает конца файла.

пример

Этот пример демонстрирует чтение и запись в файл.

В этой программе мы читаем из файла, который мы создали в последнем примере, data1.dat, и отображаем его на экране.

Live Demo

program outputdata   
implicit none   

   real, dimension(100) :: x, y  
   real, dimension(100) :: p, q
   integer :: i  
   
   ! data  
   do i = 1,100  
      x(i) = i * 0.1 
      y(i) = sin(x(i)) * (1-cos(x(i)/3.0))  
   end do  
   
   ! output data into a file 
   open(1, file = 'data1.dat', status='new')  
   do i = 1,100  
      write(1,*) x(i), y(i)   
   end do  
   close(1) 

   ! opening the file for reading
   open (2, file = 'data1.dat', status = 'old')

   do i = 1,100  
      read(2,*) p(i), q(i)
   end do 
   
   close(2)
   
   do i = 1,100  
      write(*,*) p(i), q(i)
   end do 
   
end program outputdata

Когда приведенный выше код компилируется и выполняется, он дает следующий результат –

0.100000001  5.54589933E-05
0.200000003  4.41325130E-04
0.300000012  1.47636665E-03
0.400000006  3.45637114E-03
0.500000000  6.64328877E-03
0.600000024  1.12552457E-02
0.699999988  1.74576249E-02
0.800000012  2.53552198E-02
0.900000036  3.49861123E-02
1.00000000   4.63171229E-02
1.10000002   5.92407547E-02
1.20000005   7.35742599E-02
1.30000007   8.90605897E-02
1.39999998   0.105371222    
1.50000000   0.122110792    
1.60000002   0.138823599    
1.70000005   0.155002072    
1.80000007   0.170096487    
1.89999998   0.183526158    
2.00000000   0.194692180    
2.10000014   0.202990443    
2.20000005   0.207826138    
2.29999995   0.208628103    
2.40000010   0.204863414    
2.50000000   0.196052119    
2.60000014   0.181780845    
2.70000005   0.161716297    
2.79999995   0.135617107    
2.90000010   0.103344671    
3.00000000   6.48725405E-02
3.10000014   2.02930309E-02
3.20000005  -3.01767997E-02
3.29999995  -8.61928314E-02
3.40000010  -0.147283033    
3.50000000  -0.212848678    
3.60000014  -0.282169819    
3.70000005  -0.354410470    
3.79999995  -0.428629100    
3.90000010  -0.503789663    
4.00000000  -0.578774154    
4.09999990  -0.652400017    
4.20000029  -0.723436713    
4.30000019  -0.790623367    
4.40000010  -0.852691114    
4.50000000  -0.908382416    
4.59999990  -0.956472993    
4.70000029  -0.995793998    
4.80000019  -1.02525222    
4.90000010  -1.04385209    
5.00000000  -1.05071592    
5.09999990  -1.04510069    
5.20000029  -1.02641726    
5.30000019  -0.994243503    
5.40000010  -0.948338211    
5.50000000  -0.888650239    
5.59999990  -0.815326691    
5.70000029  -0.728716135    
5.80000019  -0.629372001    
5.90000010  -0.518047631    
6.00000000  -0.395693362    
6.09999990  -0.263447165    
6.20000029  -0.122622721    
6.30000019   2.53026206E-02
6.40000010   0.178709000    
6.50000000   0.335851669    
6.59999990   0.494883657    
6.70000029   0.653881252    
6.80000019   0.810866773    
6.90000010   0.963840425    
7.00000000   1.11080539    
7.09999990   1.24979746    
7.20000029   1.37891412    
7.30000019   1.49633956    
7.40000010   1.60037732    
7.50000000   1.68947268    
7.59999990   1.76223695    
7.70000029   1.81747139    
7.80000019   1.85418403    
7.90000010   1.87160957    
8.00000000   1.86922085    
8.10000038   1.84674001    
8.19999981   1.80414569    
8.30000019   1.74167395    
8.40000057   1.65982044    
8.50000000   1.55933595    
8.60000038   1.44121361    
8.69999981   1.30668485    
8.80000019   1.15719533    
8.90000057   0.994394958    
9.00000000   0.820112705    
9.10000038   0.636327863    
9.19999981   0.445154816    
9.30000019   0.248800844    
9.40000057   4.95488606E-02
9.50000000  -0.150278628    
9.60000038  -0.348357052    
9.69999981  -0.542378068    
9.80000019  -0.730095863    
9.90000057  -0.909344316    
10.0000000  -1.07807255    

Фортран – Процедуры

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

Есть два типа процедур –

  • функции
  • подпрограммы

функция

Функция – это процедура, которая возвращает единственное количество. Функция не должна изменять свои аргументы.

Возвращаемое количество называется значением функции и обозначается именем функции.

Синтаксис

Синтаксис для функции выглядит следующим образом –

function name(arg1, arg2, ....)  
   [declarations, including those for the arguments]   
   [executable statements] 
end function [name]

В следующем примере демонстрируется функция с именем area_of_circle. Вычисляет площадь круга с радиусом r.

Live Demo

program calling_func

   real :: a
   a = area_of_circle(2.0) 
   
   Print *, "The area of a circle with radius 2.0 is"
   Print *, a
   
end program calling_func


! this function computes the area of a circle with radius r  
function area_of_circle (r)  

! function result     
implicit none      

   ! dummy arguments        
   real :: area_of_circle   
   
   ! local variables 
   real :: r     
   real :: pi
   
   pi = 4 * atan (1.0)     
   area_of_circle = pi * r**2  
   
end function area_of_circle

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

The area of a circle with radius 2.0 is
   12.5663710   

Пожалуйста, обратите внимание, что –

  • Вы должны указать неявное none как в основной программе, так и в процедуре.

  • Аргумент r в вызываемой функции называется фиктивным аргументом .

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

Аргумент r в вызываемой функции называется фиктивным аргументом .

Вариант результата

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

Вы можете указать имя возвращаемой переменной как –

function name(arg1, arg2, ....) result (return_var_name)  
   [declarations, including those for the arguments]   
   [executable statements] 
end function [name]

подпрограмма

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

Синтаксис

subroutine name(arg1, arg2, ....)    
   [declarations, including those for the arguments]    
   [executable statements]  
end subroutine [name]

Вызов подпрограммы

Вам необходимо вызвать подпрограмму, используя оператор вызова .

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

Live Demo

program calling_func
implicit none

   real :: a, b
   a = 2.0
   b = 3.0
   
   Print *, "Before calling swap"
   Print *, "a = ", a
   Print *, "b = ", b
   
   call swap(a, b)
   
   Print *, "After calling swap"
   Print *, "a = ", a
   Print *, "b = ", b
   
end program calling_func


subroutine swap(x, y) 
implicit none

   real :: x, y, temp   
   
   temp = x  
   x = y 
   y = temp  
   
end subroutine swap

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

Before calling swap
a = 2.00000000    
b = 3.00000000    
After calling swap
a = 3.00000000    
b = 2.00000000   

Указание намерений аргументов

Атрибут intent позволяет указать намерение, с которым аргументы используются в процедуре. В следующей таблице приведены значения атрибута intent –

Значение Используется в качестве объяснение
в Намерение (в) Используется как входные значения, не изменяется в функции
из Намерение (уходит) Используется как выходное значение, они перезаписываются
INOUT Намерение (INOUT) Аргументы используются и перезаписываются

Следующий пример демонстрирует концепцию –

Live Demo

program calling_func
implicit none

   real :: x, y, z, disc
   
   x = 1.0
   y = 5.0
   z = 2.0
   
   call intent_example(x, y, z, disc)
   
   Print *, "The value of the discriminant is"
   Print *, disc
   
end program calling_func


subroutine intent_example (a, b, c, d)     
implicit none     

   ! dummy arguments      
   real, intent (in) :: a     
   real, intent (in) :: b      
   real, intent (in) :: c    
   real, intent (out) :: d   
   
   d = b * b - 4.0 * a * c 
   
end subroutine intent_example

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

The value of the discriminant is
   17.0000000    

Рекурсивные процедуры

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

Когда процедура вызывает себя, прямо или косвенно, называется рекурсивной процедурой. Вы должны объявить этот тип процедур, предшествуя слову recursive перед его объявлением.

Когда функция используется рекурсивно, должна использоваться опция результата .

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

program calling_func
implicit none

   integer :: i, f
   i = 15
   
   Print *, "The value of factorial 15 is"
   f = myfactorial(15)
   Print *, f
   
end program calling_func

! computes the factorial of n (n!)      
recursive function myfactorial (n) result (fac)  
! function result     
implicit none     

   ! dummy arguments     
   integer :: fac     
   integer, intent (in) :: n     
   
   select case (n)         
      case (0:1)         
         fac = 1         
      case default    
         fac = n * myfactorial (n-1)  
   end select 
   
end function myfactorial

Внутренние процедуры

Когда процедура содержится в программе, она называется внутренней процедурой программы. Синтаксис для содержания внутренней процедуры выглядит следующим образом:

program program_name     
   implicit none         
   ! type declaration statements         
   ! executable statements    
   . . .     
   contains         
   ! internal procedures      
   . . .  
end program program_name

Следующий пример демонстрирует концепцию –

Live Demo

program mainprog  
implicit none 

   real :: a, b 
   a = 2.0
   b = 3.0
   
   Print *, "Before calling swap"
   Print *, "a = ", a
   Print *, "b = ", b
   
   call swap(a, b)
   
   Print *, "After calling swap"
   Print *, "a = ", a
   Print *, "b = ", b
 
contains   
   subroutine swap(x, y)     
      real :: x, y, temp      
      temp = x 
      x = y  
      y = temp   
   end subroutine swap 
   
end program mainprog   

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

Before calling swap
a = 2.00000000    
b = 3.00000000    
After calling swap
a = 3.00000000    
b = 2.00000000   

Фортран – Модули

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

Модули предоставляют вам способ разделения ваших программ между несколькими файлами.

Модули используются для –

  • Упаковка подпрограмм, блоков данных и интерфейса.

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

  • Объявление переменных, которые можно сделать доступными в любых подпрограммах по вашему выбору.

  • Полностью импортировать модуль для использования в другую программу или подпрограмму.

Упаковка подпрограмм, блоков данных и интерфейса.

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

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

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

Синтаксис модуля

Модуль состоит из двух частей –

  • часть спецификации для декларации операторов
  • a содержит часть для определения подпрограммы и функции

Общая форма модуля –

module name     
   [statement declarations]  
   [contains [subroutine and function definitions] ] 
end module [name]

Использование модуля в вашей программе

Вы можете включить модуль в программу или подпрограмму с помощью оператора use –

use name  

Обратите внимание, что

  • Вы можете добавить столько модулей, сколько нужно, каждый будет в отдельных файлах и скомпилирован отдельно.

  • Модуль может использоваться в различных программах.

  • Модуль может использоваться много раз в одной и той же программе.

  • Переменные, объявленные в части спецификации модуля, являются глобальными для модуля.

  • Переменные, объявленные в модуле, становятся глобальными переменными в любой программе или подпрограмме, где используется модуль.

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

Вы можете добавить столько модулей, сколько нужно, каждый будет в отдельных файлах и скомпилирован отдельно.

Модуль может использоваться в различных программах.

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

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

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

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

пример

Следующий пример демонстрирует концепцию –

Live Demo

module constants  
implicit none 

   real, parameter :: pi = 3.1415926536  
   real, parameter :: e = 2.7182818285 
   
contains      
   subroutine show_consts()          
      print*, "Pi = ", pi          
      print*,  "e = ", e     
   end subroutine show_consts 
   
end module constants 


program module_example     
use constants      
implicit none     

   real :: x, ePowerx, area, radius 
   x = 2.0
   radius = 7.0
   ePowerx = e ** x
   area = pi * radius**2     
   
   call show_consts() 
   
   print*, "e raised to the power of 2.0 = ", ePowerx
   print*, "Area of a circle with radius 7.0 = ", area  
   
end program module_example

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

Pi = 3.14159274    
e =  2.71828175    
e raised to the power of 2.0 = 7.38905573    
Area of a circle with radius 7.0 = 153.938049   

Доступность переменных и подпрограмм в модуле

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

Однако вы можете контролировать доступность кода модуля, используя атрибуты private и public . Когда вы объявляете некоторую переменную или подпрограмму как приватную, она недоступна за пределами модуля.

пример

Следующий пример иллюстрирует концепцию –

В предыдущем примере у нас было две переменные модуля, e и pi. Давайте сделаем их приватными и посмотрим на результат –

Live Demo

module constants  
implicit none 

   real, parameter,private :: pi = 3.1415926536  
   real, parameter, private :: e = 2.7182818285 
   
contains      
   subroutine show_consts()          
      print*, "Pi = ", pi          
      print*, "e = ", e     
   end subroutine show_consts 
   
end module constants 


program module_example     
use constants      
implicit none     

   real :: x, ePowerx, area, radius 
   x = 2.0
   radius = 7.0
   ePowerx = e ** x
   area = pi * radius**2     
   
   call show_consts() 
   
   print*, "e raised to the power of 2.0 = ", ePowerx
   print*, "Area of a circle with radius 7.0 = ", area  
   
end program module_example

Когда вы компилируете и запускаете вышеуказанную программу, она выдает следующее сообщение об ошибке –

   ePowerx = e ** x
   1
Error: Symbol 'e' at (1) has no IMPLICIT type
main.f95:19.13:

   area = pi * radius**2     
   1
Error: Symbol 'pi' at (1) has no IMPLICIT type

Так как e и pi оба объявлены как private, программа module_example больше не может обращаться к этим переменным.

Однако другие подпрограммы модуля могут получить к ним доступ –

Live Demo

module constants  
implicit none 

   real, parameter,private :: pi = 3.1415926536  
   real, parameter, private :: e = 2.7182818285 
   
contains      
   subroutine show_consts()          
      print*, "Pi = ", pi          
      print*, "e = ", e     
   end subroutine show_consts 
   
   function ePowerx(x)result(ePx) 
   implicit none
      real::x
      real::ePx
      ePx = e ** x
   end function ePowerx
    
   function areaCircle(r)result(a)  
   implicit none
      real::r
      real::a
      a = pi * r**2  
   end function areaCircle
    
end module constants 


program module_example     
use constants      
implicit none     

   call show_consts() 
   
   Print*, "e raised to the power of 2.0 = ", ePowerx(2.0)
   print*, "Area of a circle with radius 7.0 = ", areaCircle(7.0)  
   
end program module_example

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

Pi = 3.14159274    
e = 2.71828175    
e raised to the power of 2.0 = 7.38905573    
Area of a circle with radius 7.0 = 153.938049   

Фортран – внутренние функции

Внутренние функции – это некоторые общие и важные функции, которые предоставляются как часть языка Фортран. Мы уже обсуждали некоторые из этих функций в главах «Массивы», «Символы» и «Строки».

Внутренние функции могут быть классифицированы как –

  • Числовые функции
  • Математические функции
  • Числовые функции запроса
  • Функции с плавающей запятой
  • Функции управления битами
  • Функции персонажа
  • Добрые функции
  • Логические функции
  • Функции массива.

Мы обсудили функции массива в главе «Массивы». В следующем разделе мы даем краткое описание всех этих функций из других категорий.

В столбце имени функции

  • A представляет любой тип числовой переменной
  • R представляет собой вещественную или целочисленную переменную
  • X и Y представляют собой реальные переменные
  • Z представляет комплексную переменную
  • W представляет действительную или комплексную переменную

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

Sr.No Описание функции
1

ABS (A)

Возвращает абсолютное значение A

2

AIMAG (Z)

Возвращает мнимую часть комплексного числа Z

3

AINT (A [, KIND])

Он усекает дробную часть A до нуля, возвращая действительное целое число.

4

ANINT (A [, KIND])

Возвращает реальное значение, ближайшее целое или целое число.

5

ПОТОЛОК (A [, KIND])

Возвращает наименьшее целое число, большее или равное числу А.

6

CMPLX (X [, Y, KIND])

Он преобразует действительные переменные X и Y в комплексное число X + iY; если Y отсутствует, используется 0.

7

CONJG (Z)

Возвращает комплексное сопряжение любого комплексного числа Z.

8

DBLE (A)

Он преобразует A в вещественное число двойной точности.

9

DIM (X, Y)

Возвращает положительную разницу X и Y.

10

DPROD (X, Y)

Возвращает реальное произведение двойной точности X и Y.

11

ЭТАЖ (A [, KIND])

Это обеспечивает наибольшее целое число, меньшее или равное числу А.

12

INT (A [, KIND])

Он преобразует число (действительное или целое) в целое число, обрезая действительную часть до нуля.

13

MAX (A1, A2 [, A3, …])

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

14

MIN (A1, A2 [, A3, …])

Возвращает минимальное значение из аргументов, все они одного типа.

15

MOD (A, P)

Возвращает остаток от A при делении на P, причем оба аргумента имеют одинаковый тип (A-INT (A / P) * P)

16

МОДУЛЬ (A, P)

Возвращает по модулю P: (A-FLOOR (A / P) * P)

17

NINT (A [, KIND])

Возвращает ближайшее целое число числа A

18

НАСТОЯЩИЙ (A [, KIND])

Преобразует в реальный тип

19

ЗНАК (A, B)

Возвращает абсолютное значение A, умноженное на знак P. В основном, оно передает знак B на A.

ABS (A)

Возвращает абсолютное значение A

AIMAG (Z)

Возвращает мнимую часть комплексного числа Z

AINT (A [, KIND])

Он усекает дробную часть A до нуля, возвращая действительное целое число.

ANINT (A [, KIND])

Возвращает реальное значение, ближайшее целое или целое число.

ПОТОЛОК (A [, KIND])

Возвращает наименьшее целое число, большее или равное числу А.

CMPLX (X [, Y, KIND])

Он преобразует действительные переменные X и Y в комплексное число X + iY; если Y отсутствует, используется 0.

CONJG (Z)

Возвращает комплексное сопряжение любого комплексного числа Z.

DBLE (A)

Он преобразует A в вещественное число двойной точности.

DIM (X, Y)

Возвращает положительную разницу X и Y.

DPROD (X, Y)

Возвращает реальное произведение двойной точности X и Y.

ЭТАЖ (A [, KIND])

Это обеспечивает наибольшее целое число, меньшее или равное числу А.

INT (A [, KIND])

Он преобразует число (действительное или целое) в целое число, обрезая действительную часть до нуля.

MAX (A1, A2 [, A3, …])

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

MIN (A1, A2 [, A3, …])

Возвращает минимальное значение из аргументов, все они одного типа.

MOD (A, P)

Возвращает остаток от A при делении на P, причем оба аргумента имеют одинаковый тип (A-INT (A / P) * P)

МОДУЛЬ (A, P)

Возвращает по модулю P: (A-FLOOR (A / P) * P)

NINT (A [, KIND])

Возвращает ближайшее целое число числа A

НАСТОЯЩИЙ (A [, KIND])

Преобразует в реальный тип

ЗНАК (A, B)

Возвращает абсолютное значение A, умноженное на знак P. В основном, оно передает знак B на A.

пример

Live Demo

program numericFunctions
implicit none  

   ! define constants  
   ! define variables
   real :: a, b 
   complex :: z
   
   ! values for a, b 
   a = 15.2345
   b = -20.7689
    
   write(*,*) 'abs(a): ',abs(a),' abs(b): ',abs(b)   
   write(*,*) 'aint(a): ',aint(a),' aint(b): ',aint(b) 
   write(*,*) 'ceiling(a): ',ceiling(a),' ceiling(b): ',ceiling(b)   
   write(*,*) 'floor(a): ',floor(a),' floor(b): ',floor(b)  
    
   z = cmplx(a, b)
   write(*,*) 'z: ',z   
   
end program numericFunctions

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

abs(a): 15.2344999   abs(b): 20.7688999    
aint(a): 15.0000000  aint(b): -20.0000000    
ceiling(a): 16  ceiling(b): -20
floor(a): 15  floor(b): -21
z: (15.2344999, -20.7688999)

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

Sr.No Описание функции
1

ACOS (X)

Возвращает обратный косинус в диапазоне (0, π) в радианах.

2

ASIN (X)

Возвращает обратный синус в диапазоне (-π / 2, π / 2) в радианах.

3

ATAN (X)

Возвращает тангенс в диапазоне (-π / 2, π / 2) в радианах.

4

ATAN2 (Y, X)

Возвращает обратную касательную в диапазоне (-π, π) в радианах.

5

COS (X)

Возвращает косинус аргумента в радианах.

6

КОШ (X)

Возвращает гиперболический косинус аргумента в радианах.

7

EXP (X)

Возвращает экспоненциальное значение X.

8

LOG (X)

Возвращает натуральное логарифмическое значение X.

9

LOG10 (X)

Возвращает общее логарифмическое (базовое 10) значение X.

10

ГРЕХ (X)

Он возвращает синус аргумента в радианах.

11

Синь (X)

Возвращает гиперболический синус аргумента в радианах.

12

SQRT (X)

Возвращает квадратный корень из X.

13

Тан (X)

Возвращает тангенс аргумента в радианах.

14

Тан (X)

Возвращает гиперболический тангенс аргумента в радианах.

ACOS (X)

Возвращает обратный косинус в диапазоне (0, π) в радианах.

ASIN (X)

Возвращает обратный синус в диапазоне (-π / 2, π / 2) в радианах.

ATAN (X)

Возвращает тангенс в диапазоне (-π / 2, π / 2) в радианах.

ATAN2 (Y, X)

Возвращает обратную касательную в диапазоне (-π, π) в радианах.

COS (X)

Возвращает косинус аргумента в радианах.

КОШ (X)

Возвращает гиперболический косинус аргумента в радианах.

EXP (X)

Возвращает экспоненциальное значение X.

LOG (X)

Возвращает натуральное логарифмическое значение X.

LOG10 (X)

Возвращает общее логарифмическое (базовое 10) значение X.

ГРЕХ (X)

Он возвращает синус аргумента в радианах.

Синь (X)

Возвращает гиперболический синус аргумента в радианах.

SQRT (X)

Возвращает квадратный корень из X.

Тан (X)

Возвращает тангенс аргумента в радианах.

Тан (X)

Возвращает гиперболический тангенс аргумента в радианах.

пример

Следующая программа вычисляет горизонтальное и вертикальное положение x и y снаряда через некоторое время, t –

Где x = ut cos a и y = ut sin a – g t2 / 2

Live Demo

program projectileMotion  
implicit none  

   ! define constants  
   real, parameter :: g = 9.8  
   real, parameter :: pi = 3.1415927  
   
   !define variables
   real :: a, t, u, x, y   
   
   !values for a, t, and u 
   a = 45.0
   t = 20.0
   u = 10.0
   
   ! convert angle to radians  
   a = a * pi / 180.0  
   x = u * cos(a) * t   
   y = u * sin(a) * t - 0.5 * g * t * t  
   
   write(*,*) 'x: ',x,'  y: ',y   
   
end program projectileMotion

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

x: 141.421356  y: -1818.57861  

Числовые функции запроса

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

Sr.No Описание функции
1

ЦИФРЫ (X)

Возвращает количество значащих цифр модели.

2

ЭПСИЛОН (X)

Возвращает число, которое практически ничтожно по сравнению с одним. Другими словами, он возвращает наименьшее значение, так что REAL (1.0, KIND (X)) + EPSILON (X) не равен REAL (1.0, KIND (X)).

3

ОГРОМНЫЙ (X)

Возвращает наибольшее количество модели

4

МАКСЭКСПОНЕНТ (X)

Возвращает максимальный показатель модели

5

MINEXPONENT (X)

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

6

ТОЧНОСТЬ (X)

Возвращает десятичную точность

7

RADIX (X)

Возвращает базу модели

8

ДИАПАЗОН (X)

Возвращает десятичный диапазон экспонент

9

Крошечный (X)

Возвращает наименьшее положительное число модели

ЦИФРЫ (X)

Возвращает количество значащих цифр модели.

ЭПСИЛОН (X)

Возвращает число, которое практически ничтожно по сравнению с одним. Другими словами, он возвращает наименьшее значение, так что REAL (1.0, KIND (X)) + EPSILON (X) не равен REAL (1.0, KIND (X)).

ОГРОМНЫЙ (X)

Возвращает наибольшее количество модели

МАКСЭКСПОНЕНТ (X)

Возвращает максимальный показатель модели

MINEXPONENT (X)

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

ТОЧНОСТЬ (X)

Возвращает десятичную точность

RADIX (X)

Возвращает базу модели

ДИАПАЗОН (X)

Возвращает десятичный диапазон экспонент

Крошечный (X)

Возвращает наименьшее положительное число модели

Функции с плавающей запятой

Sr.No Описание функции
1

Экспонент (X)

Возвращает экспонентную часть номера модели

2

ФРАКЦИЯ (X)

Возвращает дробную часть числа

3

БЛИЖАЙШИЙ (X, S)

Возвращает ближайший другой номер процессора в заданном направлении

4

RRSPACING (X)

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

5

МАСШТАБ (X, I)

Он умножает действительное на его основание до целочисленной степени

6

SET_EXPONENT (X, I)

возвращает экспонентную часть числа

7

ПРОСТРАНСТВО (X)

Возвращает абсолютный интервал номеров моделей рядом с данным номером.

Экспонент (X)

Возвращает экспонентную часть номера модели

ФРАКЦИЯ (X)

Возвращает дробную часть числа

БЛИЖАЙШИЙ (X, S)

Возвращает ближайший другой номер процессора в заданном направлении

RRSPACING (X)

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

МАСШТАБ (X, I)

Он умножает действительное на его основание до целочисленной степени

SET_EXPONENT (X, I)

возвращает экспонентную часть числа

ПРОСТРАНСТВО (X)

Возвращает абсолютный интервал номеров моделей рядом с данным номером.

Функции управления битами

Sr.No Описание функции
1

BIT_SIZE (I)

Возвращает количество бит модели

2

BTEST (I, POS)

Битовое тестирование

3

IAND (I, J)

Логическое И

4

IBCLR (I, POS)

Очистить бит

5

IBITS (I, POS, LEN)

Извлечение бит

6

IBSET (I, POS)

Установить бит

7

IEOR (I, J)

Эксклюзивный или

8

IOR (I, J)

Включая ИЛИ

9

ИШФТ (Я, СДВИГ)

Логический сдвиг

10

ISHFTC (I, SHIFT [, РАЗМЕР])

Круговой сдвиг

11

НЕ (я)

Логическое дополнение

BIT_SIZE (I)

Возвращает количество бит модели

BTEST (I, POS)

Битовое тестирование

IAND (I, J)

Логическое И

IBCLR (I, POS)

Очистить бит

IBITS (I, POS, LEN)

Извлечение бит

IBSET (I, POS)

Установить бит

IEOR (I, J)

Эксклюзивный или

IOR (I, J)

Включая ИЛИ

ИШФТ (Я, СДВИГ)

Логический сдвиг

ISHFTC (I, SHIFT [, РАЗМЕР])

Круговой сдвиг

НЕ (я)

Логическое дополнение

Функции персонажа

Sr.No Описание функции
1

АХАР (I)

Возвращает I-й символ в последовательности сортировки ASCII.

2

ADJUSTL (STRING)

Он корректирует строку слева, удаляя все ведущие пробелы и вставляя конечные пробелы

3

ADJUSTR (STRING)

Он корректирует строку, удаляя задние пробелы и вставляя ведущие пробелы.

4

ЧАР (Я [, ВИД]]

Возвращает I-й символ в определенной последовательности сортировки машины

5

ЯЧАР (С)

Возвращает позицию символа в последовательности сортировки ASCII.

6

ИЧАР (С)

Возвращает положение символа в определенной последовательности сортировки машины (процессора).

7

INDEX (STRING, SUBSTRING [, BACK])

Он возвращает крайнюю левую (самую правую, если BACK -. TRUE.) Начальную позицию SUBSTRING в пределах STRING.

8

ЛЕН (STRING)

Возвращает длину строки.

9

LEN_TRIM (STRING)

Возвращает длину строки без конечных пустых символов.

10

LGE (STRING_A, STRING_B)

Лексически больше или равно

11

LGT (STRING_A, STRING_B)

Лексически больше чем

12

LLE (STRING_A, STRING_B)

Лексически меньше или равно

13

LLT (STRING_A, STRING_B)

Лексически меньше чем

14

REPEAT (STRING, NCOPIES)

Повторная конкатенация

15

SCAN (STRING, SET [, BACK])

Он возвращает индекс самого левого (самого правого, если BACK равен .TRUE.) Символа STRING, принадлежащего SET, или 0, если ни один из них не принадлежит.

16

TRIM (STRING)

Удаляет завершающие пробелы

17

VERIFY (STRING, SET [, BACK])

Проверяет набор символов в строке

АХАР (I)

Возвращает I-й символ в последовательности сортировки ASCII.

ADJUSTL (STRING)

Он корректирует строку слева, удаляя все ведущие пробелы и вставляя конечные пробелы

ADJUSTR (STRING)

Он корректирует строку, удаляя задние пробелы и вставляя ведущие пробелы.

ЧАР (Я [, ВИД]]

Возвращает I-й символ в определенной последовательности сортировки машины

ЯЧАР (С)

Возвращает позицию символа в последовательности сортировки ASCII.

ИЧАР (С)

Возвращает положение символа в определенной последовательности сортировки машины (процессора).

INDEX (STRING, SUBSTRING [, BACK])

Он возвращает крайнюю левую (самую правую, если BACK -. TRUE.) Начальную позицию SUBSTRING в пределах STRING.

ЛЕН (STRING)

Возвращает длину строки.

LEN_TRIM (STRING)

Возвращает длину строки без конечных пустых символов.

LGE (STRING_A, STRING_B)

Лексически больше или равно

LGT (STRING_A, STRING_B)

Лексически больше чем

LLE (STRING_A, STRING_B)

Лексически меньше или равно

LLT (STRING_A, STRING_B)

Лексически меньше чем

REPEAT (STRING, NCOPIES)

Повторная конкатенация

SCAN (STRING, SET [, BACK])

Он возвращает индекс самого левого (самого правого, если BACK равен .TRUE.) Символа STRING, принадлежащего SET, или 0, если ни один из них не принадлежит.

TRIM (STRING)

Удаляет завершающие пробелы

VERIFY (STRING, SET [, BACK])

Проверяет набор символов в строке

Добрые функции

Sr.No Описание функции
1

ВИД (X)

Возвращает значение параметра типа type.

2

SELECTED_INT_KIND (R)

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

3

SELECTED_REAL_KIND ([P, R])

Реальное значение параметра типа типа с учетом точности и диапазона

ВИД (X)

Возвращает значение параметра типа type.

SELECTED_INT_KIND (R)

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

SELECTED_REAL_KIND ([P, R])

Реальное значение параметра типа типа с учетом точности и диапазона

Логическая функция

Sr.No Описание функции
1

ЛОГИЧЕСКИЙ (L [, KIND])

Преобразование между объектами логического типа с различными типами параметров

ЛОГИЧЕСКИЙ (L [, KIND])

Преобразование между объектами логического типа с различными типами параметров

Фортран – числовая точность

Мы уже обсуждали, что в старых версиях Fortran существовало два реальных типа: реальный тип по умолчанию и тип с двойной точностью .

Тем не менее, Fortran 90/95 обеспечивает больший контроль над точностью реальных и целочисленных типов данных через спецификацию вида .

Добрый атрибут

Различные виды чисел хранятся по-разному в компьютере. Атрибут kind позволяет указать, как число хранится внутри. Например,

real, kind = 2 :: a, b, c
real, kind = 4 :: e, f, g
integer, kind = 2 :: i, j, k
integer, kind = 3 :: l, m, n

В приведенном выше объявлении действительные переменные e, f и g имеют большую точность, чем действительные переменные a, b и c. Целочисленные переменные l, m и n могут хранить большие значения и иметь больше цифр для хранения, чем целочисленные переменные i, j и k. Хотя это зависит от машины.

пример

Live Demo

program kindSpecifier
implicit none

   real(kind = 4) :: a, b, c
   real(kind = 8) :: e, f, g
   integer(kind = 2) :: i, j, k
   integer(kind = 4) :: l, m, n
   integer :: kind_a, kind_i, kind_e, kind_l
   
   kind_a = kind(a)
   kind_i = kind(i)
   kind_e = kind(e)
   kind_l = kind(l)
   
   print *,'default kind for real is', kind_a
   print *,'default kind for int is', kind_i
   print *,'extended kind for real is', kind_e
   print *,'default kind for int is', kind_l
   
end program kindSpecifier

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

default kind for real is 4
default kind for int is 2
extended kind for real is 8
default kind for int is 4

Запрос размера переменных

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

Например, встроенная функция bit_size (i) определяет количество битов, используемых для хранения. Для действительных чисел встроенная функция precision (x) возвращает число десятичных цифр точности, а встроенная функция range (x) возвращает десятичный диапазон показателя степени.

пример

Live Demo

program getSize
implicit none

   real (kind = 4) :: a
   real (kind = 8) :: b
   integer (kind = 2) :: i
   integer (kind = 4) :: j

   print *,'precision of real(4) =', precision(a)
   print *,'precision of real(8) =', precision(b)
   
   print *,'range of real(4) =', range(a)
   print *,'range of real(8) =', range(b)
   

   print *,'maximum exponent of real(4) =' , maxexponent(a)
   print *,'maximum exponent of real(8) =' , maxexponent(b)
  
   print *,'minimum exponent of real(4) =' , minexponent(a)
   print *,'minimum exponent of real(8) =' , minexponent(b)
   
   print *,'bits in integer(2) =' , bit_size(i)
   print *,'bits in integer(4) =' , bit_size(j)
   
end program getSize

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

precision of real(4) = 6
precision of real(8) = 15
range of real(4) = 37
range of real(8) = 307
maximum exponent of real(4) = 128
maximum exponent of real(8) = 1024
minimum exponent of real(4) = -125
minimum exponent of real(8) = -1021
bits in integer(2) = 16
bits in integer(4) = 32

Получение Доброй Ценности

Fortran предоставляет еще две встроенные функции для получения значения типа для требуемой точности целых и вещественных чисел –

  • selected_int_kind (r)
  • selected_real_kind ([p, r])

Функция selected_real_kind возвращает целое число, которое является значением параметра типа вида, необходимым для заданной десятичной точности p и диапазона десятичных экспонент r. Точность десятичной дроби – это число значащих цифр, а диапазон десятичной экспоненты указывает наименьшее и наибольшее представимое число. Таким образом, диапазон составляет от 10-r до 10 + r.

Например, selected_real_kind (p = 10, r = 99) возвращает значение типа, необходимое для точности до 10 десятичных разрядов, и диапазон от 10-99 до 10 + 99.

пример

Live Demo

program getKind
implicit none

   integer:: i
   i = selected_real_kind (p = 10, r = 99) 
   print *,'selected_real_kind (p = 10, r = 99)', i
   
end program getKind

Когда вы компилируете и запускаете вышеуказанную программу, она дает следующий результат –

selected_real_kind (p = 10, r = 99) 8

Фортран – Программные библиотеки

Существуют различные инструменты и библиотеки Fortran. Некоторые из них бесплатные, а некоторые платные.

Ниже приведены некоторые бесплатные библиотеки –

  • RANDLIB, генераторы случайных чисел и статистических распределений
  • BLAS
  • EISPACK
  • Руководство GAMS – NIST по доступному математическому программному обеспечению
  • Некоторые статистические и другие процедуры из NIST
  • LAPACK
  • LINPACK
  • MINPACK
  • косметическая маска
  • Математическая библиотека НКАР
  • Коллекция математических программ, документов и баз данных Netlib.
  • ODEPACK
  • ODERPACK, набор процедур для ранжирования и упорядочения.
  • Экспокит для вычисления матричных экспонент
  • SLATEC
  • SPECFUN
  • StarPac
  • StatLib статистическая библиотека
  • TOMS
  • Сортировка и объединение строк

Следующие библиотеки не являются бесплатными –

  • Числовая библиотека NAG Fortran
  • Библиотека Visual Numerics IMSL
  • Численные Рецепты

Фортран – Стиль программирования

Стиль программирования заключается в соблюдении некоторых правил при разработке программ. Эти хорошие практики придают вашей программе такие ценности, как читабельность и однозначность.

Хорошая программа должна иметь следующие характеристики –

  • читабельность
  • Правильная логическая структура
  • Не требующие пояснений заметки и комментарии

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

! loop from 1 to 10 
do i = 1,10  

Однако, если вы вычисляете биномиальный коэффициент и вам нужен этот цикл для nCr, вам пригодится такой комментарий:

! loop to calculate nCr 
do i = 1,10
  • Блоки кода с отступом, чтобы сделать различные уровни кода понятными.

  • Коды самопроверки, чтобы гарантировать, что не будет никаких цифровых ошибок, таких как деление на ноль, квадратный корень из отрицательного действительного числа или логарифм отрицательного действительного числа.

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

  • Не ставить проверки там, где это было бы ненужным и замедляет выполнение. Например –

Блоки кода с отступом, чтобы сделать различные уровни кода понятными.

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

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

Не ставить проверки там, где это было бы ненужным и замедляет выполнение. Например –

real :: x 
x = sin(y) + 1.0

if (x >= 0.0) then
   z = sqrt(x)
end if
  • Четко написанный код с использованием соответствующих алгоритмов.
  • Разделение длинных выражений с помощью маркера продолжения ‘&’.
  • Создание значимых имен переменных.

Фортран – Программа отладки

Инструмент отладчика используется для поиска ошибок в программах.

Программа отладчика проходит по коду и позволяет вам проверять значения переменных и других объектов данных во время выполнения программы.

Он загружает исходный код, и вы должны запустить программу в отладчике. Отладчики отлаживают программу с помощью –

  • Установка точек останова,
  • Пошагово просматривая исходный код,
  • Установка часовых точек.

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

Программы отладчика также проверяют исходный код построчно.

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

Отладчик GDB

Отладчик gdb, отладчик GNU поставляется с операционной системой Linux. Для системы X Windows, GDB поставляется с графическим интерфейсом, и программа называется xxgdb.

В следующей таблице приведены некоторые команды в GDB –

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

Отладчик dbx

Существует еще один отладчик dbx для Linux.

В следующей таблице приведены некоторые команды в dbx –