Learn Fortran (Fortran Tutorial)

Machine Translated by Google
Fortran
i
Fortran
Despre Tutorial
Fortran a fost dezvoltat inițial de o echipă de la IBM în 1957 pentru calcule științifice.
Evoluțiile ulterioare au transformat-o într-un limbaj de programare de nivel înalt. În acest tutorial, vom învăța
conceptele de bază ale Fortran și codul său de programare.
Public
Acest tutorial este conceput pentru cititorii care doresc să învețe elementele de bază ale Fortran.
Cerințe preliminare
Acest tutorial este conceput pentru începători. O cunoaștere generală a limbajelor de programare pentru computer
este singura condiție prealabilă pentru a profita la maximum de acest tutorial.
Drepturi de autor și declinare a răspunderii
Copyright 2017 by Tutorials Point (I) Pvt. Ltd.
Tot conținutul și graficele publicate în această carte electronică sunt proprietatea Tutorials Point (I) Pvt. Ltd.
Utilizatorului acestei cărți electronice îi este interzis să refolosească, să rețină, să copieze, să distribuie sau să
republice orice conținut sau o parte din conținutul acestei cărți electronice în orice mod, fără acordul scris al
editorului.
Ne străduim să actualizăm conținutul site-ului și tutorialele noastre cât mai în timp util și cât mai precis posibil, cu
toate acestea, conținutul poate conține inexactități sau erori. Tutoriale Punctul (I)
Pvt. Ltd. nu oferă nicio garanție cu privire la acuratețea, actualitatea sau integralitatea site-ului nostru web sau a
conținutului acestuia, inclusiv acest tutorial. Dacă descoperiți erori pe site-ul nostru web sau în acest tutorial, vă
rugăm să ne anunțați la contact@tutorialspoint.com
i
Fortran
Cuprins
Despre tutorial ···················································· ····································i
Audiență ··················································· ···················································· ················································i
Cerințe preliminare·················································· ···················································· ···········································i
Drepturi de autor și declinare a responsabilității ···················································· ·····························i
Cuprins··············································· ···················································· ·····································ii
1. FORTRAN PREZENTARE GENERALĂ ············································ ···················································· ········· 1
Fapte despre Fortran ···················································· ·································1
2. FORTRAN CONFIGURARE MEDIU ············································· ············································ 2
Configurarea Fortran în Windows ···················································· ··················2
Cum se utilizează G95 ················································ ···················································· ·······································3
3. FORTRAN SINTAXA DE BAZĂ ············································· ···················································· ····· 4
Un program simplu în Fortran ······································ ···················································· ·····················4
Bazele ···················································· ···················································· ·5
Identificator ···················································· ···············································5
Cuvinte cheie················································· ···················································· ·············································6
4. FORTRAN TIPURI DE DATE ············································· ···················································· ········ 8
Tipul întregi ···················································· ············································8
Tip real ·················································· ···················································· ·············································9
Tipul complex ···················································· ······································10
Tip logic ·················································· ···················································· ·········································11
Tipul de caractere ···················································· ·····································11
Tastare implicită ···················································· ·····································11
ii
Fortran
5. FORTRAN VARIABILE ·············································· ···················································· ······· 12
Declarația variabilei ···················································· ····························12
6. FORTRAN CONSTANTE ·············································· ···················································· ····· 15
Constante numite și literale ···················································· ················15
7. FORTRAN OPERATORI ·············································· ···················································· ····· 17
Operatori aritmetici ···················································· ··························17
Operatori relaționali ···················································· ···························19
Operatori logici ···················································· ·································21
Prioritatea operatorilor în Fortran ······································ ···················································· ···········23
8. FORTRAN DECIZII ·············································· ···················································· ······· 26
Dacă... atunci Construiește ············································ ···················································· ··································27
Dacă... atunci... altfel Construiește···································· ···················································· ··························29
if...else if...else Declarație········································ ···················································· ·····························31
Imbricat dacă se construiește ············································ ···················································· ·······························33
Selectați construcția cazului ···················································· ···························34
Construcție de caz selectată imbricată ···················································· ················37
9. FORTRAN BUCLE········································ ···················································· ··············· 39
face Loop ·················································· ···················································· ···············································40
buclă do-while ················································ ···················································· ········································43
Bucle imbricate ·················································· ···················································· ·······································45
Declarații de control al buclei ···················································· ·······················46
Declarație de ieșire ·················································· ···················································· ·····································47
Declarație de ciclu ···················································· ···································48
Declarație de oprire ···················································· ····································50
iii
Fortran
10. FORTRAN NUMERE ·············································· ···················································· ········ 51
Tipul întregi ···················································· ·········································51
Tip real ·················································· ···················································· ·············································52
Tipul complex ···················································· ·······································53
Intervalul, precizia și dimensiunea numerelor ···················································· 55
Specificatorul de fel ················································· ···················································· ·································57
11. FORTRAN PERSONAJE ·············································· ···················································· ··· 59
Declarație de caracter ················································· ···················································· ··························59
Concatenare de caractere ···················································· ················60
Unele funcții de caractere ···················································· ····················61
Verificarea ordinii lexicale a caracterelor ···················································· ·····64
12. FORTRAN CORZI ·············································· ···················································· ············ 66
Declarație șir de caractere ·················································· ···················································· ································66
Concatenare șiruri de caractere ···················································· ···························67
Extragerea șirurilor secundare············································· ···················································· ···························68
Tăierea șirurilor················································· ···················································· ··································70
Reglarea în stânga și în dreapta a șirurilor de caractere ···················································· ·······70
Căutarea unui subșir într-un șir ············································ ···················································· ·········71
13. FORTRAN MATRII ·············································· ···················································· ············· 73
Declararea matricei ···················································· ···································73
Atribuirea de valori ···················································· ···································74
Unii termeni legați de matrice ···················································· ·····················76
Trecerea de matrice la proceduri ···················································· ·················76
Secțiuni matrice ···················································· ······································79
Funcții intrinseci ale matricei ··············································· ···················································· ······················81
iv
Fortran
14. FORTRAN MATRICE DINAMICE ············································· ··············································· 99
Utilizarea declarației de date ···················································· ························100
Declarația de utilizare a unde ···················································· ······················102
15. FORTRAN TIPURI DE DATE DERIVATE ············································ ········································· 104
Definirea unui tip de date derivate ···················································· ················104
Accesarea membrilor structurii ···················································· ·············104
Matrice de structuri ···················································· ······························106
16. FORTRAN POINTERS ·············································· ···················································· ······ 109
Declararea unei variabile pointer ···················································· ················109
Alocarea spațiului pentru un pointer ···················································· ···············109
Ținte și Asociere ················································ ···················································· ·····················110
17. FORTRAN INTRARE DE BAZĂ IEȘIRE ·········································· ········································· 114
Intrare formatată Ieșire ···················································· ······················114
Declarația de format ·················································· ···················································· ························119
18. FORTRAN IEȘIRE INTRARE FIȘIER ············································ ············································ 120
Deschiderea si inchiderea fisierelor ···················································· ····················120
19. FORTRAN PROCEDURI ·············································· ···················································· · 127
Func ie················································· ···················································· ············································127
Subrutina ·········································· ···················································· ·······································129
Proceduri recursive ···················································· ························131
Proceduri Interne ···················································· ···························133
20. FORTRAN MODULE ·············································· ···················································· ······ 135
Sintaxa unui modul ··············································· ···················································· ······························135
Utilizarea unui modul în programul dvs. ···················································· ········135
v
Fortran
Accesibilitatea variabilelor și subrutinelor dintr-un modul ······························137
21. FORTRAN FUNCȚII INTRINSECE ············································· ······································ 140
Funcții numerice ···················································· ·····························140
Funcții matematice ···················································· ·····················143
Funcții de interogare numerică ···················································· ·················145
Funcții de manipulare în virgulă mobilă ·········································· ···················································· 145
Funcții de manipulare a biților ···················································· ················146
Funcții de caractere ················································· ···················································· ··························147
Funcții amabile ···················································· ····································148
Funcție logică ·········································· ···················································· ·································148
22. FORTRAN PRECIZIE NUMERICĂ ············································· ········································· 149
Atributul amabil ···················································· ·······························149
Întrebarea mărimii variabilelor ···················································· ··············150
Obținerea valorii de amabilitate ···················································· ····················151
23. FORTRAN BIBLIOTECI DE PROGRAME ············································· ········································· 153
24. FORTRAN STIL DE PROGRAMARE ············································· ······································ 154
25. FORTRAN PROGRAM DE DEBUGARE ············································· ····································· 155
Debugger-ul gdb ···················································· ·······························155
Debuggerul dbx ··············································· ···················································· ·······························156
vi
1. Fortran Prezentare generală Fortran
Fortran, așa cum este derivat din Formula Translating System, este un limbaj de programare imperativ, de uz general. Este
folosit pentru calculul numeric și științific.
Fortran a fost dezvoltat inițial de IBM în anii 1950 pentru aplicații științifice și de inginerie. Fortran a condus mult timp
această zonă de programare și a devenit foarte popular pentru calculul de înaltă performanță, deoarece.
Acesta suportă:
• Analiză numerică și calcul științific
• Programare structurată
• Programarea matricei
• Programare modulară
• Programare generică
• Calcul de înaltă performanță pe supercalculatoare
• Programare orientată pe obiecte
• Programare concomitentă
• Gradul rezonabil de portabilitate între sisteme informatice
Fapte despre Fortran
• Fortran a fost creat de o echipă, condusă de John Backus la IBM în 1957.
• Inițial, numele era scris cu majuscule, dar standardele actuale și

implementările necesită doar ca prima literă să fie majusculă.
• Fortran reprezintă FORmula TRANslator.
• Dezvoltat inițial pentru calcule științifice, avea suport foarte limitat pentru șirurile de caractere și alte structuri necesare
pentru programarea de uz general.
• Extensiile și evoluțiile ulterioare au transformat-o într-o programare de nivel înalt

limbaj cu grad bun de portabilitate.
• Versiunile originale, Fortran I, II și III sunt considerate acum învechite.
• Cea mai veche versiune încă folosită este Fortran IV și Fortran 66.
• Cele mai frecvent utilizate versiuni astăzi sunt: Fortran 77, Fortran 90 și Fortran 95.
• Fortran 77 a adăugat șiruri ca tip distinct.
• Fortran 90 a adăugat diferite tipuri de threading și procesare directă a matricei.
1
2. Fortran Configurare mediu Fortran
Configurarea Fortran în Windows

G95 este compilatorul multi-arhitectural GNU Fortran, folosit pentru configurarea Fortran în
Windows. Versiunea Windows emulează un mediu Unix folosind MingW sub Windows. Programul
de instalare se ocupă de acest lucru și adaugă automat g95 la variabila PATH din Windows.
Puteți obține versiunea stabilă a G95 de aici:
2
Fortran
Cum se utilizează G95
În timpul instalării, g95 este adăugat automat la variabila PATH dacă selectați opțiunea „RECOMANDAT”. Aceasta
înseamnă că puteți pur și simplu deschide o nouă fereastră de linie de comandă și tastați „g95” pentru a afișa
compilatorul. Găsiți mai jos câteva comenzi de bază pentru a începe.
Comanda Descriere
g95 –c salut.f90 Compilează hello.f90 într-un fișier obiect numit hello.o
g95 salut.f90 Compilează hello.f90 și îl conectează pentru a produce un

executabil a.out
g95 -c h1.f90 h2.f90 h3.f90 Compilează mai multe fișiere sursă. Dacă totul merge bine,
fișierele obiect h1.o, h2.o și h3.o sunt create
g95 -o hello h1.f90 h2.f90 h3.f90 Compilează mai multe fișiere sursă și le conectează
împreună la un fișier executabil numit „hello”
Opțiuni pentru linia de comandă pentru G95:
-c Numai compilați, nu rulați linkerul.
-o Specificați numele fișierului de ieșire, fie un fișier obiect, fie executabil.
Mai multe fișiere sursă și obiect pot fi specificate simultan. Fișierele Fortran sunt indicate prin nume care se termină
în „.f”, „.F”, „.for”, „.FOR”, „.f90”, „.F90”, „.f95”, „.F95”, „. f03" și ".F03".
Pot fi specificate mai multe fișiere sursă. Fișierele obiect pot fi specificate, de asemenea, și vor fi legate pentru a
forma un fișier executabil.
3
3. Fortran Sintaxă de bază

Fortran
Un program Fortran este format dintr-o colecție de unități de program, cum ar fi un program principal, module și subprograme
sau proceduri externe.
Fiecare program conține un program principal și poate sau nu conține alte unități de program. Sintaxa programului principal
este următoarea:
program program_name
implicit nici unul
! declarații de tip
! instrucțiuni executabile
final program program_name
Un program simplu în Fortran

Să scriem un program care adună două numere și imprimă rezultatul:
program addNumbers
! Acest program simplu adaugă două numere
implicit nici unul
! Declarații de tip
real :: a, b, rezultat
! Declarații executabile
a = 12,0
b = 15,0
rezultat = a + b
print *, „Totalul este „, rezultat
termina programul addNumbers
Când compilați și executați programul de mai sus, acesta produce următorul rezultat:
Totalul este de 27.0000000
4
Fortran
Te rog noteaza asta:
• Toate programele Fortran încep cu programul de cuvinte cheie și se termină cu programul de încheiere a
cuvintelor , urmat de numele programului.
• Instrucțiunea implicită none permite compilatorului să verifice dacă toate tipurile de variabile sunt declarate
corect. Trebuie să utilizați întotdeauna implicit none la începutul fiecărui program.
• Comentariile în Fortran sunt începute cu semnul exclamării (!), deoarece toate caracterele de după acesta (cu
excepția unui șir de caractere) sunt ignorate de compilator.
• Comanda print * afișează date pe ecran.
• Indentarea liniilor de cod este o bună practică pentru a menține un program lizibil.
• Fortran permite atât litere mari, cât și litere mici. Fortran nu ține seama de majuscule, cu excepția literalelor șir.
Bazele
Setul de caractere de bază al Fortran conține:
• literele A ... Z și a ... z
• cifrele 0 ... 9
• caracterul de subliniere (_).

"
caracterele speciale = : + gol - */()[],.$'• ! %&;<>?
Jetoanele sunt formate din caractere din setul de caractere de bază. Un token poate fi un cuvânt cheie, un identificator, o
constantă, un literal șir sau un simbol.
Declarațiile de program sunt făcute din jetoane.
Identificator
Un identificator este un nume folosit pentru a identifica o variabilă, o procedură sau orice alt element definit de
utilizator. Un nume în Fortran trebuie să respecte următoarele reguli:
• Nu poate avea mai mult de 31 de caractere.
• Trebuie să fie compus din caractere alfanumerice (toate literele alfabetului,

iar cifrele de la 0 la 9) și litere de subliniere (_).
• Primul caracter al unui nume trebuie să fie o literă.
• Numele sunt insensibile la majuscule
5
Fortran
Cuvinte cheie
Cuvintele cheie sunt cuvinte speciale, rezervate limbii. Aceste cuvinte rezervate nu pot fi folosite ca identificatori sau
nume.
Următorul tabel listează cuvintele cheie Fortran:
Cuvinte cheie non-I/O
alocabil aloca atribui misiune blocarea datelor
apel caz caracter uzual complex
con ine continua ciclu date dezalocarea
Mod implicit do precizie dubla altfel altfel dacă
în altă parte end block data end do end function end if
modul final de interfață termina programul final select sfâr itul subrutinei
tipul de capăt sfâr itul unde intrare echivalen ă Ieșire
extern func ie mergi la dacă

implicit
în în afară întreg intentie interfata
intrinsec drăguț len logic modul
lista de nume anula numai operator opțional
afară parametru pauză indicator privat
program public real recursiv rezultat
întoarcere salva selectați cazul Stop subrutină
intă atunci tip tip() utilizare
Unde In timp ce
6
Fortran
Cuvinte cheie legate de I/O
backspace închide fi ierul final format întreba
pix imprimare citit derulează înapoi Scrie
7
4. Fortran Tipuri de date

Fortran
Fortran oferă cinci tipuri de date intrinseci, cu toate acestea, puteți obține și propriile tipuri de date. Cele
cinci tipuri intrinseci sunt:
• Tipul întreg
• Tip real
• Tip complex
• Tip logic
• Tipul de caracter
Tip întreg
Tipurile întregi pot conține numai valori întregi. Următorul exemplu extrage cea mai mare valoare care
poate fi păstrată într-un număr întreg obișnuit de patru octeți:
program testingInt
implicit nici unul
întreg :: largeval
imprimare *, uriaș(largeval)
sfârșitul programului testingInt
2147483647
Rețineți că funcția huge() oferă cel mai mare număr care poate fi deținut de tipul de date întreg specific.
De asemenea, puteți specifica numărul de octeți folosind specificatorul de tip . Următorul exemplu
demonstrează acest lucru:
program testingInt
implicit nici unul
!doi octeți întreg
integer(kind=2) :: shortval
!număr întreg de patru octeți
integer(kind=4) :: longval
8
Fortran
!un întreg de opt octeți
integer(kind=8) :: verylongval
!întreg de șaisprezece octeți
integer(kind=16) :: veryverylongval
!întreg implicit
întreg :: defval
imprimare *, imens(scurtval)
imprimare *, uriaș(val lung)
imprimare *, uriaș (valabil foarte lung)
imprimare *, imens (foarte foarte lungval)
imprimare *, imens (defval)
32767
2147483647
9223372036854775807
170141183460469231731687303715884105727
2147483647
Tip real
Stochează numerele în virgulă mobilă, cum ar fi 2.0, 3.1415, -100.876 etc.
În mod tradițional, există două tipuri reale diferite, tipul real implicit și tipul dublu de precizie.
Cu toate acestea, Fortran 90/95 oferă mai mult control asupra preciziei tipurilor de date reale și întregi prin
kindspecifier, pe care îl vom studia în capitolul despre Numere.
Următorul exemplu arată utilizarea tipului de date reale:
9
Fortran
diviziunea programului
implicit nici unul
! Definiți variabilele reale
real :: p, q, realRes
! Definiți variabile întregi
întreg :: i, j, intRes
! Atribuirea de valori
p = 2,0
q = 3,0
i=2
j=3
! diviziune în virgulă mobilă
realRes = p/q
intRes = i/j
print *, realRes
print *, intRes
sfârșitul diviziunii programului
0,666666687
Tip complex
Acesta este folosit pentru stocarea numerelor complexe. Un număr complex are două părți, partea reală și partea
imaginară. Două unități de stocare numerice consecutive stochează aceste două părți.
De exemplu, numărul complex (3,0, -5,0) este egal cu 3,0 – 5,0i
Vom discuta mai detaliat despre tipurile complexe, în capitolul Numere.
10
Fortran
Tip logic
Există doar două valori logice: .adevărat. iar .fals.
Tip de caracter
Tipul de caractere stochează caractere și șiruri. Lungimea șirului poate fi specificată prin specificatorul len. Dacă nu
este specificată lungimea, aceasta este 1.
De exemplu,
caracter (len=40) :: nume

nume = „Zara Ali”
Expresia nume (1:4) ar da subșirul „Zara”.
Tastare implicită
Versiunile mai vechi de Fortran permiteau o caracteristică numită tastare implicită, adică nu trebuie să declarați
variabilele înainte de utilizare. Dacă o variabilă nu este declarată, atunci prima literă a numelui ei va determina tipul
acesteia.
Numele de variabile care încep cu i, j, k, l, m sau n sunt considerate a fi pentru variabile întregi, iar altele sunt variabile
reale. Cu toate acestea, trebuie să declarați toate variabilele, deoarece este o bună practică de programare. Pentru
asta începeți programul cu declarația:
implicit nici unul
Această afirmație dezactivează tastarea implicită.
11
5. Fortran Variabile Fortran
O variabilă nu este altceva decât un nume dat unei zone de stocare pe care programele noastre o pot manipula. Fiecare
variabilă ar trebui să aibă un tip specific, care determină dimensiunea și aspectul memoriei variabilei; intervalul de
valori care poate fi stocat în acea memorie; și setul de operații care pot fi aplicate variabilei.
Numele unei variabile poate fi compus din litere, cifre și caracterul de subliniere.
Un nume în Fortran trebuie să respecte următoarele reguli:
• Nu poate avea mai mult de 31 de caractere.
• Trebuie să fie compus din caractere alfanumerice (toate literele alfabetului,

iar cifrele de la 0 la 9) și litere de subliniere (_).
• Primul caracter al unui nume trebuie să fie o literă.
• Numele sunt insensibile la majuscule.
Pe baza tipurilor de bază explicate în capitolul anterior, următoarele sunt tipurile de variabile:
Tip Descriere
Întreg Poate deține numai valori întregi.
Real Stochează numerele în virgulă mobilă.
Complex Este folosit pentru stocarea numerelor complexe.
Logic Stochează valori booleene logice.
Caracter Stochează caractere sau șiruri.
Declarație variabilă
Variabilele sunt declarate la începutul unui program (sau subprogram) într-o declarație de tip.
Sintaxa pentru declararea variabilelor este următoarea:
specificator de tip :: nume_variabilă
12
Fortran
De exemplu,
întreg :: total
real :: mediu
complex :: cx
logic :: gata
caracter(len=80) :: mesaj ! un șir de 80 de caractere
Mai târziu, puteți atribui valori acestor variabile, cum ar fi,
total = 20000
medie = 1666,67
făcut = .adevărat.
mesaj = „Un mare salut de la Tutorials Point”
cx = (3,0, 5,0) ! cx = 3,0 + 5,0i
De asemenea, puteți utiliza funcția intrinsecă cmplx, pentru a atribui valori unei variabile complexe:
cx = cmplx (1,0/2,0, -7,0) ! cx = 0,5 – 7,0i
cx = cmplx (x, y) ! cx = x + yi
Exemplu
Următorul exemplu demonstrează declararea, atribuirea și afișarea variabilelor activate

ecran:
Testarea variabilelor programului
implicit nici unul
! declararea variabilelor
întreg :: total
real :: mediu
complex :: cx
logic :: gata
caracter(len=80) :: mesaj ! un șir de 80 de caractere
!atribuirea de valori
total = 20000
medie = 1666,67
făcut = .adevărat.
13
Fortran
mesaj = „Un mare salut din partea Tutorials Point”
cx = (3,0, 5,0) ! cx = 3,0 + 5,0i
Tipărire *, total
Tipărire *, medie
Tipărire *, cx
Imprimare *, gata
Imprimare *, mesaj
Testarea variabilei programului final
Când codul de mai sus este compilat și executat, acesta produce următorul rezultat:
20000
1666.67004
(3,00000000, 5,00000000)
T
Un salut mare de la Tutorials Point
14
6. Fortran Constante Fortran
Constantele se referă la valorile fixe pe care programul nu le poate modifica în timpul execuției sale. Aceste
valori fixe sunt numite și literale.
Constantele pot fi din oricare dintre tipurile de date de bază, cum ar fi o constantă întreagă, o constantă
flotantă, o constantă de caractere, o constantă complexă sau un literal șir. Există doar două constante
logice: .adevărat. iar .fals.
Constantele sunt tratate la fel ca variabilele obișnuite, cu excepția faptului că valorile lor nu pot fi modificate
după definirea lor.
Constante și literale numite
Există două tipuri de constante:
• Constante literale
• Constante numite
O constantă literală are o valoare, dar fără nume.
De exemplu, următoarele sunt constantele literale:
Tip Exemplu
Constante întregi 0 1 -1 300 123456789
Constante reale 0,0 1,0 -1,0 123,456 7,1E+10 -52,715E-30
Constante complexe (0,0, 0,0) (-123,456E+30, 987,654E-29)
Constante logice .Adevărat. .fals.
Constante de caractere "PQR" "a" "123'abc$%#@!"

" "" "
un citat
'PQR' 'a' '123"abc$%#@!'

'
un apostrof '' '
O constantă numită are o valoare, precum și un nume.
Constantele numite trebuie declarate la începutul unui program sau al unei proceduri, la fel ca o declarație
de tip variabilă, indicând numele și tipul acesteia. Constantele numite sunt declarate cu atributul parametru.
De exemplu,
15
Fortran
real, parametru :: pi = 3,1415927
Exemplu
Următorul program calculează deplasarea datorată mișcării verticale sub gravitație.
program gravitationalDisp
! acest program calculează mișcarea verticală sub gravitație
implicit nici unul
! acceleratie gravitationala
real, parametru :: g = 9,81
! declarație variabilă
real :: s ! deplasare
real :: t ! timp
real :: tu ! viteza initiala
! atribuirea de valori
t = 5,0
u = 50
! deplasare
s=u * t - g * (t**2) / 2
! ieșire
tipărire *, "Timp = ", t
print *, 'Deplasare = ',s
programul final gravitationalDisp
Timp = 5,00000000
Deplasare = 127,374992
16
7. Fortran Operatori Fortran
Un operator este un simbol care îi spune compilatorului să efectueze anumite manipulări matematice sau
logice. Fortran oferă următoarele tipuri de operatori:
• Operatori aritmetici
• Operatori rela ionali
• Operatori logici
Să ne uităm la toate aceste tipuri de operatori unul câte unul.
Operatori aritmetici
Următorul tabel prezintă toți operatorii aritmetici acceptați de Fortran. Presupunem ca variabila A deține 5
și variabila B deține 3 atunci:
Operator Descriere Exemplu
+ Operator de adăugare, adaugă doi operanzi. A + B va da 8
-
Operator de scădere, scade al doilea operand din primul. A - B va da 2
*
Operator de multiplicare, înmulțește ambii operanzi. A * B va da 15
/ Operator de diviziune, împarte numărătorul cu A/B va da 1

denumărătorul.
**
Operator de exponențiere, ridică un operand la puterea celuilalt. A ** B va da 125
Exemplu
Încercați următorul exemplu pentru a înțelege toți operatorii aritmetici disponibili în Fortran:
program aritmeticOp
! acest program efectuează calcule aritmetice
implicit nici unul
17
Fortran
întreg :: a, b, c
a=5
b=3
! Exponentiatie
c=a ** b
! ieșire
tipăriți *, "c = ", c
! Multiplicare
c=a *b
! ieșire
! Divizia
c = a/b
! ieșire
! Plus
c=a+b
! ieșire
! Scădere
c=a-b
! ieșire
18
Fortran
termina programul aritmeticOp
c = 125
c = 15
c=1
c=8
c=2
Operatori Relaționali
Următorul tabel prezintă toți operatorii relaționali suportați de Fortran. Presupunem ca variabila A deține 10
și variabila B deține 20, atunci:
Echivalent operator Descriere Exemplu
== .echiv. Verifică dacă valorile a doi operanzi sunt egale sau nu, (A == B) nu este
dacă da atunci condiția devine adevărată. adevărat.
/= .ne. Verifică dacă valorile a doi operanzi sunt egale sau nu, (A != B) este
dacă valorile nu sunt egale atunci condiția devine adevărat.
adevărată.
> .gt. Verifică dacă valoarea operandului din stânga este mai (A > B) nu este
mare decât valoarea operandului din dreapta, dacă da adevărat.
atunci condiția devine adevărată.
< .lt. Verifică dacă valoarea operandului din stânga este mai (A < B) este
mică decât valoarea operandului din dreapta, dacă da adevărată.
atunci condiția devine adevărată.
>= .GE. Verifică dacă valoarea operandului din stânga este mai (A >= B) nu este
mare sau egală cu valoarea operandului din dreapta, adevărat.
dacă da atunci condiția devine adevărată.
<= .le. Verifică dacă valoarea operandului din stânga este mai (A <= B) este
mică sau egală cu valoarea operandului din dreapta, adevărată.
dacă da atunci condiția devine adevărată.
Exemplu
19
Fortran
Încercați următorul exemplu pentru a înțelege toți operatorii logici disponibili în Fortran:
program logicalOp
! acest program verifică operatorii logici
implicit nici unul
logic :: a, b
a = .adevărat.
b = .fals.
dacă (a .și. b) atunci
print *, "Linia 1 - Condiția este adevărată"

altfel
print *, "Linia 1 - Condiția este falsă"

sfâr itul dacă
dacă (a .sau. b) atunci

altfel

sfâr itul dacă
! modificarea valorilor
a = .fals.
b = .adevărat.
dacă (.nu.(a .și. b)) atunci

altfel

sfâr itul dacă
dacă (b .neqv. a) atunci
20
Fortran

altfel

sfâr itul dacă
dacă (b .echiv. a) atunci

altfel

sfâr itul dacă
termina programul logicOp
Linia 1 - Condiția este falsă
Linia 2 - Condiția este adevărată
Operatori logici
Operatorii logici din Fortran lucrează numai pe valori logice .true. iar .fals.
Următorul tabel prezintă toți operatorii logici suportați de Fortran. Să presupunem că variabila A este valabilă. iar
variabila B deține .fals. atunci: ,
Operator Descriere Exemplu
.și. Denumit operator logic AND. Dacă ambii operanzi sunt diferiti de (A și B) este fals.
zero, atunci condiția devine adevărată.
.sau. Numit Operator logic SAU. Dacă oricare dintre cei doi operanzi (A sau B) este adevărată.
este diferit de zero, atunci condiția devine adevărată.
.nu. Numit Operator logic NOT. Utilizați pentru a inversa starea logică !(A .și. B) este adevărat.
a operandului său. Dacă o condiție este adevărată, operatorul
logic NOT va deveni fals.
.echiv. Denumit Operator ECHIVALENT logic. Folosit pentru a verifica (A .echiv. B) este falsă.
echivalența a două valori logice.
21
Fortran
.neqv. Numit Operator logic NEECHIVALENT. Folosit pentru a verifica (A .neqv. B) este adevărată.
neechivalența a două valori logice.
Exemplu
Încercați următorul exemplu pentru a înțelege toți operatorii logici disponibili în Fortran:
program logicalOp
implicit nici unul

logic :: a, b
a = .adevărat.
b = .fals.
dacă (a .și. b) atunci

altfel

sfâr itul dacă
dacă (a .sau. b) atunci

altfel

sfâr itul dacă
! modificarea valorilor
a = .fals.
b = .adevărat.
dacă (.nu.(a .și. b)) atunci

altfel

sfâr itul dacă
22
Fortran
dacă (b .neqv. a) atunci

altfel

sfâr itul dacă
dacă (b .echiv. a) atunci

altfel

sfâr itul dacă
termina programul logicOp
Prioritatea operatorilor în Fortran

Prioritatea operatorului determină gruparea termenilor într-o expresie. Acest lucru afectează modul în care o
expresie este evaluată. Unii operatori au prioritate mai mare decât alții; de exemplu, operatorul de înmulțire are o
prioritate mai mare decât operatorul de adunare.
De exemplu, x = 7 + 3 * 2; aici, lui x i se atribuie 13, nu 20, deoarece operatorul * are o prioritate mai mare decât +, așa
că mai întâi se înmulțește cu 3*2 și apoi se adună în 7.
Aici, operatorii cu cea mai mare prioritate apar în partea de sus a tabelului, cei cu cea mai mică prioritate apar în
partea de jos. În cadrul unei expresii, operatorii cu prioritate mai mare vor fi evaluați mai întâi.
Categorie Operator Asociativitatea
NU logic și semn negativ .nu. (-) De la stânga la dreapta
23
Fortran
**
Exponentiatie De la stânga la dreapta
Multiplicativ */ De la stânga la dreapta
Aditiv +- De la stânga la dreapta
Relațional < <= > >= De la stânga la dreapta
Egalitatea == != De la stânga la dreapta
ȘI logic .și. De la stânga la dreapta
SAU logic .sau. De la stânga la dreapta
Misiune = De la dreapta la stanga
Exemplu
Încercați următorul exemplu pentru a înțelege prioritatea operatorului în Fortran:
prioritate programOp
implicit nici unul
întreg :: a, b, c, d, e
a = 20
b = 10
c = 15
d=5
e = (a + b) * c/d ! ( 30 * 15 ) / 5
print *, "Valoarea (a + b) * c/d este: ", e
24
Fortran
e = ((a + b) * c) / d ! (30 * 15 ) / 5
print *, "Valoarea lui ((a + b) * c) / d este : ", e
e = (a + b) * (c / d); ! (30) * (15/5)
print *, "Valoarea lui (a + b) * (c / d) este : ", e
e = a + (b * c) / d; ! 20 + (150/5)
"
print *, "Valoarea lui a + (b * c) / d este: , e
sfârșitul programului de prioritateOp
Valoarea lui (a + b) * c/d este: 90
Valoarea lui ((a + b) * c) / d este: 90
Valoarea lui (a + b) * (c / d) este: 90
Valoarea lui a + (b * c) / d este: 50
25
8. Fortran Decizii Fortran
Structurile de luare a deciziilor necesită ca programatorul să specifice una sau mai multe condiții care
urmează să fie evaluate sau testate de program, împreună cu o declarație sau instrucțiuni care
urmează să fie executate, dacă condiția este determinată a fi adevărată și, opțional, alte instrucțiuni
care urmează să fie executate dacă condiția este determinată a fi falsă.
Mai jos este forma generală a unei structuri tipice de luare a deciziilor găsită în majoritatea limbajelor
de programare:
Fortran oferă următoarele tipuri de constructe de luare a deciziilor.
Afirmație Descriere
Dacă... atunci construiește

O instrucțiune if... then... end if constă dintr-o expresie logică urmată
de una sau mai multe instrucțiuni.
Dacă... atunci... altfel construi O instrucțiune if... then poate fi urmată de o instrucțiune
opțională else, care se execută atunci când expresia logică este
falsă.
26
Fortran
imbricat if construct Puteți altul if sau else

utilizați
if. unul if sau else if declarație în interior
selectează construcția cazului O instrucțiune select case permite ca o variabilă să fie testată pentru
egalitate față de o listă de valori.
construct imbricat select Puteți utiliza o declarație select case în interiorul altei declarații select
case case.
Dacă... atunci Construiește
O instrucțiune if... then constă dintr-o expresie logică urmată de una sau mai multe instrucțiuni și
terminată cu o instrucțiune end if .
Sintaxă
Sintaxa de bază a unei instrucțiuni if... then este:
dacă (expresie logică) atunci

afirmație
sfâr itul dacă
Cu toate acestea, puteți da un nume blocului if , apoi sintaxa instrucțiunii named if ar fi, cum ar fi:
[nume:] if (expresie logică) atunci

! diverse afirmatii
. . .
se încheie dacă [nume]
Dacă expresia logică este evaluată la adevărat, atunci blocul de cod din interiorul instrucțiunii if...then
va fi executat. Dacă expresia logică se evaluează ca fals, atunci va fi executat primul set de cod după
încheierea instrucțiunii if .
27
Fortran
Diagrama fluxului
Exemplul 1
program ifProg
implicit nici unul

! declarația variabilelor locale
întreg :: a = 10
! verificați condiția logică folosind instrucțiunea if
dacă (a < 20 ) atunci
! dacă condiția este adevărată, imprimați următoarele
print*, „a este mai mic de 20”

sfâr itul dacă
print*, „valoarea lui a este”, a
termina programul ifProg
28
Fortran
a este mai mic de 20
valoarea lui a este 10
Exemplul 2
Acest exemplu demonstrează un bloc numit if :
program markGradeA
implicit nici unul

real :: mărci
! atribuie note
note = 90,4
! utilizați o declarație if pentru a acorda nota
gr: dacă (marcă > 90,0) atunci
tipăriți *, „Grad A”
termina daca gr
programul final markGradeA
Nota A
Dacă... atunci... altfel Construiți
O instrucțiune if... then poate fi urmată de o instrucțiune opțională else, care se execută atunci când expresia logică
este falsă.
Sintaxă
Sintaxa de bază a unei declarații if… then… else este:
dacă (expresie logică) atunci
declarație(e)
altfel
alte_declarații
sfâr itul dacă
29
Fortran
Cu toate acestea, dacă dați un nume blocului if , atunci sintaxa instrucțiunii denumite if-else ar fi, cum ar fi:
[nume:] if (expresie logică) atunci

! diverse afirmatii
. . .
altfel
!altă declarație(e)
. . .
Dacă expresia logică este evaluată la adevărat, atunci blocul de cod din interiorul instrucțiunii if...then va
fi executat, în caz contrar blocul de cod din blocul else va fi executat.
Diagrama fluxului
Exemplu
program ifElseProg
implicit nici unul
întreg :: a = 100
30
Fortran
dacă (a < 20 ) atunci
print*, „a este mai mic de 20”
altfel
print*, „a nu este mai mic de 20”
sfâr itul dacă
print*, „valoarea lui a este”, a
termina programul ifElseProg
a nu este mai mică de 20
valoarea lui a este 100
if...else if...else Declarație
Un construct de instrucțiune if poate avea unul sau mai multe constructe opționale else-if . Când condiția if eșuează, se
execută else-if imediat urmată . Când și ele -if eșuează, succesorul ei else-if (dacă există) este executată și așa mai departe.
Opțional else este plasat la sfârșit și este executat atunci când niciuna dintre condițiile de mai sus nu este adevărată.
• Toate instrucțiunile else (else-if și else) sunt opționale.
• else-if poate fi folosit una sau de mai multe ori
• else trebuie să fie întotdeauna plasat la sfârșitul construcției și ar trebui să apară o singură dată.
Sintaxă
Sintaxa unei instrucțiuni if...else if...else este:
[Nume:]
dacă (expresia logică 1) atunci
! blocul 1
else if (expresia logică 2) atunci
! blocul 2
else if (expresia logică 3) atunci
! blocul 3
altfel
31
Fortran
! blocul 4
Exemplu
programul ifElseIfElseProg
implicit nici unul
întreg :: a = 100
dacă( a == 10 ) atunci
print*, „Valoarea lui a este 10”
altfel if( a == 20 ) atunci
! dacă altfel, dacă condiția este adevărată
altfel if( a == 30 ) atunci
! dacă altfel, dacă condiția este adevărată

altfel
! dacă nici una dintre condi ii nu este adevărată
print*, „Niciuna dintre valori nu se potrivește”

sfâr itul dacă
print*, „valoarea exactă a lui a este”, a
termina programul ifElseIfElseProg
Niciuna dintre valori nu se potrivește

valoarea exactă a lui a este 100
32
Fortran
Imbricat If Construct
Puteți utiliza o declarație if sau else if în interiorul altei declarații if sau else if .
Sintaxă
Sintaxa pentru o instrucțiune if imbricată este următoarea:
dacă (expresie_logică 1) atunci
!Se execută când expresia booleană 1 este adevărată
if(expresie_logică 2)atunci
! Se execută atunci când expresia booleană 2 este adevărată
sfâr itul dacă
sfâr itul dacă
Exemplu
programul nestedIfProg
implicit nici unul
întreg :: a = 100, b= 200
dacă( a == 100 ) atunci
! dacă condiția este adevărată, verificați următoarele
dacă( b == 200 ) atunci
! dacă condiția internă dacă este adevărată
print*, „Valoarea lui a este 100 și b este 200”
sfâr itul dacă
sfâr itul dacă
print*, „valoarea exactă a lui a este”, a
print*, „valoarea exactă a lui b este”, b
termina programul nestedIfProg
33
Fortran
Valoarea lui a este 100 și b este 200
valoarea exactă a lui a is 100
valoarea exactă a lui b este 200
Selectați Case Construct

O instrucțiune select case permite ca o variabilă să fie testată pentru egalitate față de o listă de valori.
Fiecare valoare este numită caz, iar variabila pe care este selectată este bifată pentru fiecare caz selectat.
Sintaxă
Sintaxa pentru constructul select case este următoarea:
[nume:] selectați caz (expresie)
caz (selector1)
! niste afirmatii
... caz (selector2)

! alte afirmatii
...
caz implicit
! mai multe afirmatii
...
final selectați [nume]
Următoarele reguli se aplică unei declarații select :
• Expresia logică utilizată într-o instrucțiune select ar putea fi expresie logică, de caractere sau
întreagă (dar nu reală).
• Puteți avea orice număr de declarații de caz într-un select. Fiecare caz este urmat de valoarea cu care
trebuie comparat și poate fi expresie logică, de caractere sau întreagă (dar nu reală) și determină
ce instrucțiuni sunt executate.
• Expresia constantă pentru un caz trebuie să fie de același tip de date ca și variabila
în select și trebuie să fie o constantă sau un literal.
• Când variabila care este selectată pe, este egală cu un caz, următoarele afirmații
acel caz se va executa până când se ajunge la următoarea instrucțiune de caz.
• Blocul implicit caz este executat dacă expresia din select case (expresie) nu se potrivește cu niciunul
dintre selectori.
34
Fortran
Diagrama fluxului
Exemplul 1
program selectCaseProg
implicit nici unul

caracter :: nota = „B”
selectați cazul (clasa)
caz ('A')
print*, "Excelent!"
caz („B”)
35
Fortran
caz („C”)
print*, "Bravo"
caz ('D')
print*, „Ai trecut”
caz („F”)
print*, „Mai bine încercați din nou”
caz implicit
print*, „Notă nevalidă”

final select
print*, "Nota dvs. este ", nota
termina programul selectCaseProg
Nota ta este B
Specificarea unui interval pentru selector

Puteți specifica un interval pentru selector, specificând o limită inferioară și superioară, separate prin
două puncte:
caz (scăzut:înalt)
Următorul exemplu demonstrează acest lucru:
Exemplul 2
program selectCaseProg
implicit nici unul

întreg :: mărci = 78
selectați caz (semne)
caz (91:100)
print*, "Excelent!"
36
Fortran
caz (81:90)
print*, "Foarte bine!"
caz (71:80)
print*, "Bravo!"
caz (61:70)
print*, „Nu-i rău!”
caz (41:60)
print*, "Ai trecut!"
caz (:40)
print*, „Mai bine încercați din nou!”
caz implicit
print*, „Marcă nevalidă”

final select
print*, "Marcile dvs. sunt ", mărci
termina programul selectCaseProg
Foarte bine!
Semnele tale sunt 78
Imbricat Select Case Construct

Puteți utiliza o declarație select case în interiorul altei declarații select case .
Sintaxă
selectați cazul (a)
caz (100)
print*, „Acesta face parte din comutatorul exterior”, a
selectați cazul (b)
37
Fortran
caz (200)
print*, „Acesta face parte din comutatorul interior”, a

final select
final select
Exemplu
programul nestedSelectCase
! definirea variabilei locale
întreg :: a = 100
întreg :: b = 200
selectați cazul (a)
caz (100)
print*, „Acesta face parte din comutatorul exterior”, a
selectați cazul (b)
caz (200)
print*, „Acesta face parte din comutatorul interior”, a

final select
final select
print*, "Valoarea exactă a lui a este : ", a
print*, "Valoarea exactă a lui b este : ", b
termina programul nestedSelectCase
Aceasta face parte din comutatorul exterior 100
Aceasta face parte din comutatorul interior 100
Valoarea exactă a lui a este: 100
Valoarea exactă a lui b este: 200
38
9. Fortran Bucle
Fortran
Poate exista o situație în care trebuie să executați un bloc de cod de mai multe ori. În general, instrucțiunile sunt
executate secvențial: prima instrucțiune dintr-o funcție este executată prima, urmată de a doua și așa mai departe.
Limbajele de programare oferă diverse structuri de control care permit căi de execuție mai complicate.
O instrucțiune buclă ne permite să executăm o instrucțiune sau un grup de instrucțiuni de mai multe ori, iar
următoarea este forma generală a unei instrucțiuni buclă în majoritatea limbajelor de programare:
Fortran oferă următoarele tipuri de construcții de bucle pentru a gestiona cerințele de buclă.
Faceți clic pe următoarele link-uri pentru a verifica detaliile acestora.
Tip buclă Descriere
face bucla Acest construct permite ca o declarație sau o serie de declarații să fie efectuată în mod
iterativ, în timp ce o condiție dată este adevărată.
bucla do while Repetă o instrucțiune sau un grup de instrucțiuni în timp ce o anumită condiție este
Adevărat. Testează condiția înainte de a executa corpul buclei.
bucle imbricate Puteți utiliza una sau mai multe bucle în interiorul oricărei alte bucle
construi.
39
Fortran
face Loop
Construcția buclă do permite ca o declarație, sau o serie de instrucțiuni, să fie efectuată iterativ, în timp ce o condiție
dată este adevărată.
Sintaxă
Forma generală a buclei do este:
do var = start, stop [,step]
! declarație(e)
…
sfâr itul face
Unde,
• variabila buclă var ar trebui să fie un număr întreg
• start este valoarea ini ială
• stop este valoarea finală
• pasul este incrementul, dacă acesta este omis, atunci variabila var este mărită cu
unitate
De exemplu:
! calculează factoriali
face n = 1, 10
nfact = nfact * n
! imprimând valoarea lui n și factorialul său
imprimare*, n, " ", de fapt
sfâr itul face
Diagrama fluxului
Iată fluxul de control pentru construcția buclei do:
• Pasul inițial este executat mai întâi și o singură dată. Acest pas vă permite să declarați și să inițializați orice
variabile de control al buclei. În cazul nostru, variabila var este inițializată cu valoarea start.
• În continuare, se evaluează starea. Dacă este adevărat, corpul buclei este executat. Dacă este fals, corpul
buclei nu se execută și fluxul de control sare la următoarea instrucțiune imediat după buclă. În cazul
nostru, condiția este ca variabila var să atingă valoarea finală stop.
40
Fortran
• După ce corpul buclei se execută, fluxul de control sare înapoi la instrucțiunea de increment.
Această instrucțiune vă permite să actualizați variabila de control al buclei var.
• Starea este acum evaluată din nou. Dacă este adevărat, bucla se execută și procesul se repetă
(corpul buclei, apoi pasul de incrementare și apoi din nou condiția). După ce condiția devine falsă,
bucla se termină.
Exemplul 1
Acest exemplu tipărește numerele de la 11 la 20:
program printNum
implicit nici unul
! definiți variabile
întreg :: n
face n = 11, 20
! imprimarea valorii lui n
41
Fortran
tipar*, n
sfâr itul face
termina program printNum
11
12
13
14
15
16
17
18
19
20
Exemplul 2
Acest program calculează factorialii numerelor de la 1 la 10:
factorial de program
implicit nici unul
întreg :: nfact = 1
întreg :: n
face n = 1, 10
nfact = nfact * n
! imprima valorile

sfâr itul face
factorial de program final
42
Fortran
1 1
2 2
3 6
4 24
5 120
6 720
7 5040
8 40320
9 362880
10 3628800
do-while Loop
Repetă o declarație sau un grup de afirmații în timp ce o anumită condiție este adevărată. Testează condiția
înainte de a executa corpul buclei.
Sintaxă
face while (expr logic)

declarații
sfâr itul face
Diagrama fluxului
43
Fortran
Exemplu
factorial de program
implicit nici unul
întreg :: nfact = 1
întreg :: n = 1
face while (n <= 10)

nfact = nfact * n
n=n+1

sfâr itul face
factorial de program final
2 1
3 2
4 6
5 24
6 120
7 720
8 5040
9 40320
10 362880
11 3628800
44
Fortran
Bucle imbricate
Puteți folosi una sau mai multe bucle în interiorul oricărei alte bucle. De asemenea, puteți pune etichete pe
bucle.
Sintaxă
iloop: face i = 1, 3
print*, "i:", i
jloop: face j = 1, 3
print*, "j: ", j
kloop: face k = 1, 3
imprimare*, "k: ", k
sfâr itul face kloop
sfâr itul face jloop
sfâr itul face iloop
Exemplu
programul nestedLoop
implicit nici unul
întreg:: i, j, k
print*, "(i, j, k): ", i, j, k
termina programul nestedLoop
45
Fortran
(i, j, k): 1 1 1 (i, j, k): 1 1 2
(i, j, k): 1 1 3
(i, j, k): 1 2 1
(i, j, k): 1 2 2
(i, j, k): 1 2 3
(i, j, k): 1 3 1
(i, j, k): 1 3 2
(i, j, k): 1 3 3
(i, j, k): 2 1 1
(i, j, k): 2 1 2
(i, j, k): 2 1 3
(i, j, k): 2 2 1
(i, j, k): 2 2 2
(i, j, k): 2 2 3
(i, j, k): 2 3 1
(i, j, k): 2 3 2
(i, j, k): 2 3 3
(i, j, k): 3 1 1
(i, j, k): 3 1 2
(i, j, k): 3 1 3
(i, j, k): 3 2 1
(i, j, k): 3 2 2
Declarații de control al buclei

Instrucțiunile de control al buclei modifică execuția din secvența normală. Când execuția părăsește
un domeniu, toate obiectele automate care au fost create în acel domeniu sunt distruse.
Fortran acceptă următoarele declarații de control. Faceți clic pe următoarele link-uri pentru a verifica detaliile
acestora.
Control Descriere
Afirmație
Ieșire Dacă instrucțiunea de ieșire este executată, bucla este ieșită, iar execuția
programului continuă la prima instrucțiune executabilă
46
Fortran
după sfârșitul do declarație.
ciclu Dacă se execută o instrucțiune de ciclu, programul continuă la începutul următoarei iterații.
Stop Dacă doriți ca execuția programului dumneavoastră să se oprească, puteți introduce o

instrucțiune stop
Declarație de ieșire
Instrucțiunea Exit termină bucla sau instrucțiunea select case și transferă execuția instrucțiunii imediat după bucla sau
select.
Diagrama fluxului
Exemplu
programul nestedLoop
implicit nici unul
întreg:: i, j, k
print*, "(i, j, k): ", i, j, k
47
Fortran
dacă (k==2) atunci
ieșiți din jloop

sfâr itul dacă
termina programul nestedLoop
(i, j, k): 1 1 1
(i, j, k): 1 1 2
(i, j, k): 2 1 1
(i, j, k): 2 1 2
(i, j, k): 3 1 1
(i, j, k): 3 1 2
Declarație de ciclu
Declarația ciclului face ca bucla să săriască restul corpului său și să retesteze imediat starea acesteia
înainte de a reitera.
Diagrama fluxului
Exemplu
48
Fortran
ciclu de program_exemplu
implicit nici unul
întreg :: i
fac i = 1, 20
dacă (i == 5) atunci
ciclu
sfâr itul dacă
imprimare*, i
sfâr itul face
sfârșitul programului ciclu_exemplu
10
11
12
13
14
15
16
17
18
19
20
49
Fortran
Declarație Stop
Dacă doriți să înceteze execuția programului, puteți introduce o instrucțiune stop.
Exemplu
program stop_example
implicit nici unul
întreg :: i
fac i = 1, 20
dacă (i == 5) atunci
Stop
sfâr itul dacă
imprimare*, i
sfâr itul face
termina programul stop_example
50
10. Fortran Numere Fortran
Numerele din Fortran sunt reprezentate de trei tipuri de date intrinseci:
• Tipul întreg
• Tip real
• Tip complex
Tip întreg
Tipurile întregi pot conține numai valori întregi. Următorul exemplu extrage cea mai mare valoare care ar
putea fi păstrată într-un număr întreg obișnuit de patru octeți:
program testingInt
implicit nici unul
întreg :: largeval
imprimare *, uriaș(largeval)
2147483647
Vă rugăm să rețineți că funcția huge() oferă cel mai mare număr care poate fi deținut de tipul de date
întreg specific. De asemenea, puteți specifica numărul de octeți folosind specificatorul de tip . Următorul
exemplu demonstrează acest lucru:
program testingInt
implicit nici unul
!doi octeți întreg
integer(kind=2) :: shortval
!număr întreg de patru octeți
integer(kind=4) :: longval
!un întreg de opt octeți
integer(kind=8) :: verylongval
51
Fortran
!întreg de șaisprezece octeți
integer(kind=16) :: veryverylongval
!întreg implicit
întreg :: defval
imprimare *, imens(scurtval)
imprimare *, uriaș(val lung)
imprimare *, uriaș (valabil foarte lung)
imprimare *, imens (foarte foarte lungval)
imprimare *, imens (defval)
32767
2147483647
9223372036854775807
170141183460469231731687303715884105727
2147483647
Tip real
Stochează numerele în virgulă mobilă, cum ar fi 2.0, 3.1415, -100.876 etc.
În mod tradițional, existau două tipuri reale diferite: tipul real implicit și tipul cu precizie dublă .
Cu toate acestea, Fortran 90/95 oferă mai mult control asupra preciziei tipurilor de date reale și întregi prin
specificatorul de tip , pe care îl vom studia în scurt timp.
Următorul exemplu arată utilizarea tipului de date reale:
diviziunea programului
implicit nici unul
! Definiți variabilele reale
real :: p, q, realRes
52
Fortran
! Definiți variabile întregi
întreg :: i, j, intRes
! Atribuirea de valori
p = 2,0
q = 3,0
i=2
j=3
! diviziune în virgulă mobilă
realRes = p/q
intRes = i/j
print *, realRes
print *, intRes
sfârșitul diviziunii programului
0,666666687
Tip complex
Acesta este folosit pentru stocarea numerelor complexe. Un număr complex are două părți: partea reală și partea
imaginară. Două unități de stocare numerice consecutive stochează aceste două părți.
De exemplu, numărul complex (3,0, -5,0) este egal cu 3,0 – 5,0i
Funcția generică cmplx() creează un număr complex. Produce un rezultat care are părți reale și imaginare cu precizie unică,
indiferent de tipul argumentelor de intrare.
programul createComplex
implicit nici unul
întreg :: i = 10
real :: x = 5,17
print *, cmplx(i, x)
termina programul createComplex
53
Fortran
(10,0000000, 5,17000008)
Următorul program demonstrează aritmetica numerelor complexe:
programul ComplexArithmatic
implicit nici unul
complex, parametru :: i = (0, 1) ! sqrt(-1)
complex :: x, y, z
x = (7, 8);
y = (5, -7)
X *
scrie (*),*) i * y
z=x+y
tipăriți *, "z = x + y = ", z
z=x-y
imprimați *, "z = x - y = ", z
z=x *
y
*
tipăriți *, "z = x y = ", z
z=x/y
imprimați *, "z = x / y = ", z
programul final 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)
54
Fortran
Intervalul, precizia și dimensiunea numerelor

Intervalul numerelor întregi, precizia și dimensiunea numerelor în virgulă mobilă depind de numărul de biți alocați
tipului de date specific.
Următorul tabel afișează numărul de biți și intervalul pentru numere întregi:
Număr Valoare maximă Motiv

de biți
64 9.223.372.036.854.774.807 (2**63)–1
32 2.147.483.647 (2**31)–1
Următorul tabel afișează numărul de biți, cea mai mică și cea mai mare valoare și precizia pentru numerele reale.
Numărul Cea mai mare valoare Cea mai mică valoare Precizie
de biți
64 0,8E+308 0,5E–308 15–18
32 1,7E+38 0,3E–38 6-9
Următoarele exemple demonstrează acest lucru:
gama de programePrecizie
implicit nici unul
real:: x, y, z
x = 1,5e+40
y = 3,73e+40
z=x *
y
imprimare *, z
Gama finală a programului Precizie
55
Fortran
x = 1,5e+40
Eroare: constanta reală depășește tipul său la (1)
principal.f95:5.12:
y = 3,73e+40
Eroare: constanta reală depășește tipul său la (1)
Acum să folosim un număr mai mic:
implicit nici unul
real:: x, y, z
x = 1,5e+20
y = 3,73e+20
z=x *
y
imprimare *, z
z = x/y
imprimare *, z
Infinit
0,402144760
Acum să vedem underflow:
implicit nici unul
real:: x, y, z
x = 1,5e-30
y = 3,73e-60
56
Fortran
z=x *
y
imprimare *, z
z = x/y
imprimare *, z
y = 3,73e-60
Avertisment: constanta reală depășește tipul său la (1)
Se execută programul....
$demo
0,00000000E+00
Infinit
Specificatorul de tip
În programarea științifică, de multe ori trebuie să cunoaștem gama și precizia datelor platformei hardware pe care se
lucrează.
Funcția intrinsecă kind() vă permite să interogați detaliile reprezentărilor de date ale hardware-ului înainte de a rula un
program.
program kindCheck
implicit nici unul
întreg :: i
real :: r
complex :: cp
print *, 'Integer', kind(i)
print *, 'Real', kind(r)
print *, 'Complex', kind(cp)
termina programul kindCheck
57
Fortran
Numărul întreg 4
Real 4
Complexul 4
De asemenea, puteți verifica tipul tuturor tipurilor de date:
program checkKind
implicit nici unul
întreg :: i
real :: r
caracter*1 :: c
logic :: lg
complex :: cp
print *, 'Integer', kind(i)
print *, 'Real', kind(r)
print *, 'Complex', kind(cp)
tipărire *, 'Caracter', fel (c)
tipărire *, 'logic', fel (lg)
terminați programul checkKind
Numărul întreg 4
Real 4
Complexul 4
Personajul 1
logic 4
58
11. Fortran Personaje Fortran
Limba Fortran poate trata caracterele ca un singur caracter sau șiruri adiacente.
Caracterele pot fi orice simbol luat din setul de caractere de bază, adică din litere, cifre zecimale, liniuță și 21 de caractere
speciale.
O constantă de caractere este un șir de caractere cu valoare fixă.
Caracterul de tip de date intrinsec stochează caractere și șiruri. Lungimea șirului poate fi specificată prin specificatorul
len . Dacă nu este specificată lungimea, aceasta este 1. Puteți trimite caractere individuale într-un șir referindu-se după
poziție; caracterul cel mai din stânga este în poziția 1.
Declarație de caracter
Declararea datelor unui tip de caracter este aceeași ca și alte variabile:
De exemplu,
caracter :: replica, sex
puteți atribui o valoare cum ar fi,
raspuns = 'N'
sex = 'F'
Următorul exemplu demonstrează declararea și utilizarea tipului de date caracter:
program salut
implicit nici unul
caracter(len=15) :: prenume, prenume
caracter(len=6) :: titlu
caracter(len=25)::salutări
titlu = „Dl. '
prenume = 'Rowan'
nume = „Atkinson”
salutări = „Un salut mare de la Mr. Beans”
print *, 'Aici este', titlu, prenume, prenume
59
Fortran
print *, salutări
termina programul salut
Iată-l pe domnul Rowan Atkinson
Un salut mare din partea domnului Bean
Concatenarea personajelor
Operatorul de concatenare // concatenează caracterele.
program salut
implicit nici unul
caracter(len=40):: nume
titlu = „Dl. '
prenume = 'Rowan'
nume = titlu//prenume//prenume
print *, „Aici este”, nume
print *, salutări
Un salut mare de la Mr.Bean
60
Fortran
Unele funcții ale caracterului

Următorul tabel prezintă câteva funcții de caracter utilizate în mod obișnuit împreună cu descrierea:
Func ie Descriere
len(șir) Returnează lungimea unui șir de caractere
index(string,sustring) Găsește locația unui subșir într-un alt șir, returnează 0

dacă nu este găsit.
achar(int) Acesta transformă un număr întreg într-un caracter
iachar(c) Acesta transformă un caracter într-un număr întreg
trim(sir) Returnează șirul cu spațiile libere eliminate.
scanare (șir, caractere) Căută „șirul” de la stânga la dreapta (cu excepția cazului în care
back=.true.) pentru prima apariție a oricărui caracter conținut în „chars”.
Returnează un număr întreg care indică poziția acelui caracter sau
zero dacă niciunul dintre caracterele din „caractere” nu a fost găsit.
verifica (șir, caractere) Scanează „șirul” de la stânga la dreapta (cu excepția cazului în care
back=.true.) pentru prima apariție a oricărui caracter care nu este conținut în „chars”.
Returnează un număr întreg care indică poziția acelui caracter sau
zero dacă au fost găsite doar caracterele din „caractere”.
adjustl(șir) A stânga justifică caracterele conținute în „șir”
ajustator(șir) Justifică corect caracterele conținute în „șir”
len_trim(șir) Returnează un număr întreg egal cu lungimea „șirului” (len(șir)) minus

numărul de spații libere finale
repeat(string,ncopy) Returnează un șir cu lungime egală cu „ncopy” ori lungimea lui „string” și care
conține „ncopy” copii concatenate ale „string”
61
Fortran
Exemplul 1
Acest exemplu arată utilizarea funcției index :
program testingChars
implicit nici unul
caracter (80) :: text
întreg :: i
text = 'Caracterul de tipul de date intrinsec stochează caractere și șiruri de caractere.'
i=index(text,'caracter')
dacă (i /= 0) atunci
print *, ' Caracterul cuvânt găsit la poziția ',i
print *, ' în text: ', text
sfâr itul dacă
sfârșitul programului de testareChars
Caracterul cuvânt găsit la poziția 25
în text : caracterul de tip de date intrinsec stochează caractere și șiruri de caractere.
Exemplul 2
Acest exemplu demonstrează utilizarea funcției de tăiere :
program salut
implicit nici unul
title = „Domn.”
prenume = 'Rowan'
print *, 'Iată', titlu, prenume, prenume
62
Fortran
print *, 'Iată', trim(titlu),' ',trim(prenume),' ', trim(nume)
Exemplul 3
Acest exemplu demonstrează utilizarea funcției achar
implicit nici unul
personaj:: cap
întreg:: i
face i=65, 90
ch = achar(i)
print*, i, ' ', cap
sfâr itul face
65 A
66 B
67 C
68 D
69 E
70 F
71 G
72 H
73 eu
74 J
75 K
76 L
63
Fortran
77 M
78 N
79 O
80 p
81 Î
82 R
83 S
84 T
85 U
86 V
87 W
88 X
89 Y
90 Z
Verificarea ordinii lexicale a caracterelor

Următoarele funcții determină succesiunea lexicală a caracterelor:
Func ie Descriere
lle(char, char) Compară dacă primul caracter este lexical mai mic sau egal cu
al doilea
lge(char, char) Compară dacă primul caracter este mai mare sau egal lexical cu al doilea
lgt(char, char) Compară dacă primul caracter este mai mare din punct de vedere lexical decât al
doilea
llt(char, char) Compară dacă primul caracter este mai mic din punct de vedere lexical decât al doilea
Exemplul 4
Următoarea funcție demonstrează utilizarea:
64
Fortran
implicit nici unul
caracter:: a, b, c
a = 'A'
b = 'a'
c = 'B'
dacă(lgt(a,b)) atunci
print *, „A este mai mare din punct de vedere lexical decât a”
altfel
print *, 'a este lexical mai mare decât A'

sfâr itul dacă
dacă(lgt(a,c)) atunci
print *, „A este mai mare din punct de vedere lexical decât B”
altfel
print *, „B este mai mare din punct de vedere lexical decât A”
sfâr itul dacă
dacă(llt(a,b)) atunci
print *, „A este lexical mai mic decât a”

sfâr itul dacă
dacă(llt(a,c)) atunci
print *, „A este lexical mai mic decât B”

sfâr itul dacă
a este lexical mai mare decât A
B este mai mare din punct de vedere lexical decât A
A este lexical mai mic decât a
A este lexical mai mic decât B
65
12. Fortran Coarde

Fortran
Limba Fortran poate trata caracterele ca un singur caracter sau șiruri adiacente.
Un șir de caractere poate avea o lungime de doar un caracter sau chiar poate avea lungimea zero. În Fortran, constantele
de caractere sunt date între o pereche de ghilimele duble sau simple.
Caracterul de tip de date intrinsec stochează caractere și șiruri. Lungimea șirului poate fi specificată prin specificatorul
len. Dacă nu este specificată lungimea, aceasta este 1. Puteți trimite caractere individuale într-un șir referindu-se după
poziție; caracterul cel mai din stânga este în poziția 1.
Declarație șir
Declararea unui șir este aceeași ca și alte variabile:
De exemplu,
Personaj(len=20) :: prenume, prenume
puteți atribui o valoare cum ar fi,
nume = „Zara Ali”
Următorul exemplu demonstrează declararea și utilizarea tipului de date caracter:
program salut
implicit nici unul
title = „Domn.”
prenume = 'Rowan'
print *, 'Iată', titlu, prenume, prenume
66
Fortran
print *, salutări
Concatenarea șirurilor
Operatorul de concatenare // concatenează șiruri.
program salut
implicit nici unul
title = „Domn.”
prenume = 'Rowan'
nume = titlu//prenume//prenume
print *, „Iată”, nume
print *, salutări
67
Fortran
Extragerea subșirurilor
În Fortran, puteți extrage un subșir dintr-un șir prin indexarea șirului, dând începutul și sfârșitul subșirului într-o pereche
de paranteze. Acesta se numește specificator de extindere.
Următorul exemplu arată cum să extrageți subșirul „world” din șirul „hello world”:
program subString
caracter(len=11)::bună ziua
salut = "Bună ziua, lume"
imprimare*, salut (7:11)
final program subString
Lume
Exemplu
Următorul exemplu utilizează funcția date_and_time pentru a da șirul de dată și oră. Folosim specificatorii de extindere
pentru a extrage separat informațiile despre anul, data, luna, ora, minutele și secunda.
program datatime
implicit nici unul
caracter (len = 8) :: dateinfo ! ccyymmdd
caracter(len = 4) :: an, luna*2, zi*2
caracter (len = 10) :: timeinfo ! hhmmss.sss
caracter (len = 2) :: oră, minut, secundă*6
apelează date_and_time(dateinfo, timeinfo)
! hai să împărțim dateinfo în an, lună și zi.
! dateinfo are o formă de ccyymmdd, unde cc = secol, aa = an
! mm = lună și dd = zi
68
Fortran
an = dateinfo(1:4)
luna = dateinfo(5:6)
zi = dateinfo(7:8)
print*, „Șir de dată:”, dateinfo
print*, „Anul:”, anul
print *,'Lună:', lună
print *,'Day:', day
! hai să împărțim timeinfo în oră, minut și secundă.
! timeinfo are o formă de hhmmss.sss, unde h = oră, m = minut

! și s = secundă
oră = timp informații (1:2)
minut = timp informații (3:4)

secunda = timeinfo(5:10)
print*, „Șir de timp:”, timeinfo
print*, „Ora:”, oră
print*, „Minut:”, minut
print*, „Al doilea:”, al doilea
data de încheiere a programului
Când compilați și executați programul de mai sus, acesta oferă informații detaliate despre dată și oră:
Șirul de dată: 20140803

Anul: 2014
Luna: 08
Ziua: 03
Șir de timp: 075835.466

Ora: 07
Minutul: 58
Al doilea: 35.466
69
Fortran
Tăierea șirurilor
Funcția de tăiere preia un șir și returnează șirul de intrare după eliminarea tuturor spațiilor libere.
Exemplu
program trimString
implicit nici unul
caracter (len=*), parametru :: fname="Susanne", sname="Rizwan"
caracter (len=20) :: nume complet
fullname=fname//" "//sname !concatenarea șirurilor
print*,fullname,", frumoasa dansatoare din est!"
print*,trim(fullname),", frumoasa dansatoare din est!"
termina programul trimString
Susanne Rizwan, frumoasa dansatoare din est!
Susanne Rizwan, frumoasa dansatoare din est!
Reglarea șirurilor la stânga și la dreapta

Funcția adjustl preia un șir și îl returnează eliminând spațiile de început și adăugându-le ca spații finale.
Funcția de ajustare ia un șir și îl returnează prin eliminarea spațiilor de sfârșit și adăugându-le ca spații de
început.
Exemplu
program salut
implicit nici unul
caracter(len=25):: salutări
70
Fortran
titlu = „Dl. '
prenume = 'Rowan'
nume = adjustl(titlu)//adjustl(prenume)//adjustl(nume)
print *, salutări
nume = adjustr(titlu)//adjustr(prenume)//adjustr(nume)
print *, salutări
nume = trim(titlu)//trim(prenume)//trim(nume)
print *, salutări
Iată-l pe domnul RowanAtkinson
Căutarea unui subșir într-un șir

Funcția index preia două șiruri și verifică dacă al doilea șir este un subșir al primului șir. Dacă al doilea argument este un subșir
al primului argument, atunci returnează un număr întreg care este indexul de pornire al celui de-al doilea șir din primul șir, altfel
returnează zero.
Exemplu
71
Fortran
program salut
implicit nici unul
caracterul(len=30) :: myString
character(len=10) :: testString
myString = „Acesta este un test”
testString = 'test'
if(index(myString, testString) == 0) atunci
print *, „testul nu a fost găsit”

altfel
print *, 'testul este găsit la index: ', index(myString, testString)

sfâr itul dacă
testul se găsește la indexul: 11
72
13. Fortran Matrice

Fortran
Matricele pot stoca o colecție secvențială de dimensiuni fixe de elemente de același tip. O matrice este folosită pentru
a stoca o colecție de date, dar este adesea mai util să ne gândim la o matrice ca la o colecție de variabile de același tip.
Toate tablourile constau din locații de memorie contigue. Cea mai joasă adresă corespunde primului element și cea
mai înaltă adresă ultimului element.
numere(1) numere(2) numere(3) numere(4) …
Matricele pot fi unidimensionale (cum ar fi vectorii), bidimensionale (ca matricele) și Fortran vă permite să creați
tablouri de până la 7 dimensiuni.
Declararea Arrays
Matricele sunt declarate cu atributul dimension .
De exemplu, pentru a declara o matrice unidimensională numită număr, de numere reale care conțin 5 elemente,
scrieți,
real, dimensiune(5) :: numere
Elementele individuale ale tablourilor sunt referite prin specificarea subindicelor lor. Primul element al unui tablou are
un indice de unu. Matricea numere conține cinci variabile reale – numere (1), numere (2), numere (3), numere (4) și
numere (5).
Pentru a crea o matrice bidimensională de numere întregi de 5 x 5 numită matrice, scrieți:
întreg, dimensiunea (5,5) :: matrice
De asemenea, puteți declara o matrice cu o limită inferioară explicită, de exemplu:
real, dimensiune(2:6) :: numere
întreg, dimensiune (-3:2,0:4) :: matrice
73
Fortran
Atribuirea de Valori
Puteți fie să atribuiți valori membrilor individuali, cum ar fi,
numere(1) = 2,0
sau, puteți folosi o buclă,
face i=1,5
numere(i) = i * 2,0
sfâr itul face
Elementelor de matrice unidimensionale li se pot atribui direct valori folosind un simbol de mână scurtă,
numit constructor de matrice, cum ar fi,
numere = (/1.5, 3.2,4.5,0.9,7.2 /)
Vă rugăm să rețineți că nu sunt permise spații între paranteze „( „și bara oblică „/”
Exemplu
Următorul exemplu demonstrează conceptele discutate mai sus.
program arrayProg
real :: numere(5) !matrice de întregi unidimensionale
întreg :: matrix(3,3), i , j !matrice reală bidimensională
!atribuirea unor valori numerelor de matrice

face i=1,5
numere(i) = i * 2,0
sfâr itul face
!afiseaza valorile
fac i = 1, 5
Tipăriți *, numere (i)

sfâr itul face
!atribuirea unor valori matricei matrice

face i=1,3
face j = 1, 3
matricea(i, j) = i+j
74
Fortran
sfâr itul face
sfâr itul face
!afiseaza valorile
face i=1,3
face j = 1, 3
Imprimare *, matrice (i,j)
sfâr itul face
sfâr itul face
!alocarea mâinii scurte
numere = (/1.5, 3.2,4.5,0.9,7.2 /)
!afiseaza valorile
fac i = 1, 5
Tipăriți *, numere (i)
sfâr itul face
termina programul arrayProg
2,00000000
4,00000000
6,00000000
8,00000000
10,0000000
1,50000000
75
Fortran
3.20000005
4,50000000
0,899999976
7.19999981
Unii termeni legați de matrice

Următorul tabel oferă câțiva termeni legați de matrice:
Termen Sens
Rank Este numărul de dimensiuni pe care le are o matrice. De exemplu, pentru matricea numită matrice, rangul este 2, iar
pentru matricea numită numere, rangul este 1.
Extindere Este numărul de elemente de-a lungul unei dimensiuni. De exemplu, numerele matricei au extensia 5, iar matricea
numită matrice are extensia 3 în ambele dimensiuni.
Formă Forma unui tablou este o matrice întregă unidimensională, care conține numărul de elemente (întinderea) din
fiecare dimensiune. De exemplu, pentru matricea matrice, forma este (3, 3), iar numerele matricei este (5).
mărimea Este numărul de elemente pe care le conține o matrice. Pentru matricea matrice, este 9, iar pentru numerele
matrice, este 5.
Trecerea de matrice la proceduri

Puteți trece o matrice unei proceduri ca argument. Următorul exemplu demonstrează conceptul:
programul arrayToProcedure
implicit nici unul
întreg, dimensiunea (5) :: myArray
întreg :: i
apelați fillArray (myArray)
apelați printArray(myArray)
termina programul arrayToProcedure
76
Fortran
subrutine fillArray (a)
implicit nici unul
întreg, dimensiune (5), intenție (out) :: a
! variabile locale
întreg :: i
fac i = 1, 5
a(i) = i
sfâr itul face
sfârșitul subrutinei fillArray
subrutina printArray(a)
întreg, dimensiunea (5) :: a
întreg::i
fac i = 1, 5
Tipăriți *, a(i)
sfâr itul face
termina subrutinele printArray
În exemplul de mai sus, subrutinele fillArray și printArray pot fi apelate numai cu matrice cu dimensiunea 5. Cu toate
acestea, pentru a scrie subrutine care pot fi folosite pentru matrice de orice dimensiune, le puteți rescrie folosind
următoarea tehnică:
programul arrayToProcedure
77
Fortran
implicit nici unul
întreg, dimensiunea (10) :: myArray
întreg :: i
interfata
întreg, dimensiune(:), intenție (out) :: a
întreg :: i
subrutina printArray (a)
întreg, dimensiune(:) :: a
întreg :: i

interfață finală
apelează fillArray (myArray)
apelează printArray (myArray)
termina programul arrayToProcedure

implicit nici unul
întreg, dimensiune (:), intenție (out) :: a
! variabile locale
întreg :: i, arraySize
arraySize = dimensiune (a)
do i = 1, arraySize
a(i) = i
sfâr itul face
78
Fortran
subrutina printArray(a)
implicit nici unul
întreg, dimensiune (:) :: a
integer::i, arraySize
arraySize = dimensiune (a)
do i = 1, arraySize
Tipăriți *, a(i)
sfâr itul face
Vă rugăm să rețineți că programul folosește funcția size pentru a obține dimensiunea matricei.
10
Secțiuni de matrice
Până acum ne-am referit la întreaga matrice, Fortran oferă o modalitate ușoară de a trimite mai multe elemente,
sau o secțiune a unei matrice, folosind o singură instrucțiune.
Pentru a accesa o secțiune matrice, trebuie să furnizați limitele inferioare și superioare ale secțiunii, precum și un
pas (increment), pentru toate dimensiunile. Această notație se numește triplet asubscript:
79
Fortran
matrice ([jos]:[sus][:pas], ...)
Atunci când nu sunt menționate limite inferioare și superioare, acesta este implicit în limitele pe care le-ați declarat,
iar valoarea pasului este implicită la 1.
Următorul exemplu demonstrează conceptul:
program arraySubsection
real, dimensiune(10) :: a, b
întreg:: i, asize, bsize
a(1:7) = 5,0 ! a(1) la a(7) atribuit 5.0
a(8:) = 0,0 ! restul sunt 0,0
b(2:10:2) = 3,9
b(1:9:2) = 2,5
!afi a
mărime = mărime (a)
bsize = dimensiune (b)
do i = 1, asize
Tipăriți *, a(i)
sfâr itul face
do i = 1, bsize
Tipăriți *, b(i)
sfâr itul face
termina programul arraySubsection
5,00000000
5,00000000
5,00000000
5,00000000
5,00000000
80
Fortran
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
Funcții intrinseci ale matricei

Fortran 90/95 oferă mai multe proceduri intrinseci. Ele pot fi împărțite în 7 categorii:
• Înmulțirea vectorială și matriceală
• Reducere
• Anchetă
• Constructii
• Reforma
• Manipulare
• Localizare
Înmulțirea vectorială și matriceală

Următorul tabel descrie funcțiile de multiplicare vectorială și matrice:
Func ie Descriere
Această funcție returnează un produs scalar a doi vectori de intrare,

produs_punct(vector_a, vector_b)
care trebuie să aibă aceeași lungime.
81
Fortran
Returnează produsul matriceal a două matrice, care trebuie

matmul (matrice_a, matrice_b) să fie consecvent, adică să aibă dimensiuni precum (m, k)
și (k, n)
Exemplu
Următorul exemplu demonstrează produsul punctual:
programul arrayDotProduct
real, dimensiune(5) :: a, b
întreg:: i, asize, bsize
mărime = mărime (a)
bsize = dimensiune (b)
do i = 1, asize
a(i) = i
sfâr itul face
do i = 1, bsize
b(i) = i*2
sfâr itul face
do i = 1, asize
Tipăriți *, a(i)
sfâr itul face
do i = 1, bsize
Tipăriți *, b(i)
sfâr itul face
Tipăriți*, „Înmulțirea vectorială: Produs punct:”
Imprimare*, produs_punct(a, b)
programul final arrayDotProduct
82
Fortran
1,00000000
2,00000000
3,00000000
4,00000000
5,00000000
2,00000000
4,00000000
6,00000000
8,00000000
10,0000000
Înmulțire vectorială: Produs punct:
110,000000
Exemplu
Următorul exemplu demonstrează multiplicarea matricei:
programul matMulProduct
întreg, dimensiune(3,3) :: a, b, c
întreg :: i, j
fac i = 1, 3
face j = 1, 3
a(i, j) = i+j
sfâr itul face
sfâr itul face
print *, „Înmulțirea matricei: o matrice”
fac i = 1, 3
face j = 1, 3
imprimare*, a(i, j)
sfâr itul face
sfâr itul face
fac i = 1, 3
83
Fortran
face j = 1, 3
b(i, j) = i*j
sfâr itul face
sfâr itul face
Imprimare*, „Multiplicare matrice: matrice B”
fac i = 1, 3
face j = 1, 3
imprimare*, b(i, j)
sfâr itul face
sfâr itul face
c = matmul(a, b)
Imprimare*, „Multiplicarea matricei: Matricea rezultatelor”
fac i = 1, 3
face j = 1, 3
imprimare*, c(i, j)
sfâr itul face
sfâr itul face
programul final matMulProduct
Înmulțirea matricei: o matrice
84
Fortran
Înmulțirea matricei: Matricea B
Înmulțirea matricei: Matricea rezultatelor
20
40
60
26
52
78
32
64
96
Reducere
Următorul tabel descrie funcțiile de reducere:
Func ie Descriere
Returnează o valoare logică care indică dacă toate relațiile din mască
toate (mască, dim) sunt .adevărate., împreună cu doar dimensiunea dorită dacă este dat al doilea
argument.
Returnează o valoare logică care indică dacă orice relație din mască
orice (mască, dim) este .adevărată., împreună cu doar dimensiunea dorită dacă este dat al doilea
argument.
85
Fortran
Returnează o valoare numerică care este numărul de relații din mască

numără (mască, dim) care sunt .adevărate., împreună cu doar dimensiunea dorită dacă este
dat al doilea argument.
Returnează cea mai mare valoare din tabloul matrice, dintre cele care se
supun relației din masca al treilea argument, dacă este dată aceea,
maxval(matrice, dim, mască)
împreună cu doar dimensiunea dorită dacă este dat al doilea argument
dim.
Returnează cea mai mică valoare din tabloul matrice, dintre cele care se
supun relației din masca al treilea argument, dacă este dată aceea,
minval (matrice, dim, mască)
DIM.
Returnează produsul tuturor elementelor din tabloul matrice, al celor care

se supun relației din masca al treilea argument, dacă acesta este dat,
produs (matrice, dim, mască)
dim.
Returnează suma tuturor elementelor din tabloul matrice, a celor care se

supun relației din masca al treilea argument, dacă acesta este dat,
sumă (matrice, dim, mască)
dim.
Exemplu
program arrayReduction
real, dimensiune(3,2) :: a
a = remodelare( (/5,9,6,10,8,12/), (/3,2/) )
Tipăriți *, toate (a>5)
Tipăriți *, orice(a>5)
Tipăriți *, numărați (a>5)
Print *, all(a>=5 .and. a<10)
termina programul arrayReduction
86
Fortran
Exemplu
program arrayReduction
implicit nici unul
real, dimensiune(1:6) :: a = (/ 21,0, 12,0,33,0, 24,0, 15,0, 16,0 /)
Imprimare *, maxval(a)
Tipărire *, minval(a)
Tipăriți *, suma(a)
Imprimare *, produs(a)
termina programul arrayReduction
33,0000000
12,0000000
121,000000
47900160.0
Anchetă
Următorul tabel descrie funcțiile de interogare:
Func ie Descriere
alocat (matrice) Este o funcție logică care indică dacă matricea este alocată.
lbound(array, dim) Returnează limita inferioară a dimensiunii pentru matrice. Dacă dim (dimensiunea) nu este dat ca
argument, obțineți un vector întreg, dacă dim este inclus, obțineți valoarea întreagă cu
exact acea limită de dimensiune inferioară, pentru care ați cerut.
87
Fortran
forma (sursa) Returnează forma unei surse matrice ca un vector întreg.
dimensiune (matrice, dim) Returnează numărul de elemente dintr-o matrice. Dacă dim nu este specificat
și numărul de elemente din dimensiunea relevantă dacă dim este inclus.
ubound(array, dim) Returnează limitele dimensionale superioare.
Exemplu
program arrayInquiry
real, dimensiune(3,2) :: a
a = remodelare( (/5,9,6,10,8,12/), (/3,2/) )
Print *, lbound(a, dim=1)
Print *, ubound(a, dim=1)
Imprimare *, forma(a)
Imprimare *, dimensiune (a, dim=1)
termina programul arrayInquiry
32
Constructie
Următorul tabel descrie funcțiile de construcție:
88
Fortran
Func ie Descriere
Această funcție unește două matrice. Oferă elementele în tsource

dacă condiția din mască este .adevărată. și fsource dacă condiția
din mască este .false. Cei doi
merge (tsource, fsource, mask) câmpurile tsource și fsource trebuie să fie identice
tip și aceeași formă. Rezultatul este, de asemenea, de acest tip și
formă. De asemenea, masca trebuie să aibă aceeași formă.
Împachetează o matrice într-un vector cu controlul măștii. Forma

măștii matricei logice trebuie să fie de acord cu cea pentru matrice,
altfel masca trebuie să fie scalară. Dacă vectorul este inclus, acesta
trebuie să fie o matrice de rang 1 (adică un vector) cu cel puțin tot
pachet (matrice, mască, vector) atâtea elemente cât cele care sunt adevărate în mască și să aibă
același tip ca și matrice. Dacă masca este un scalar cu valoarea .true.
atunci vectorul trebuie să aibă același număr de elemente ca și
tabloul.
Returnează o matrice de același tip ca și sursa argumentului, cu

rangul crescut cu unu.
Parametrii dim și ncopies sunt întregi. dacă ncopies este negativ se
folosește în schimb valoarea zero. Dacă sursa este un scalar, atunci
spread devine un vector cu elemente ncopies care au toate aceeași
răspândire (sursă, dim, ncopii) valoare ca sursă. Parametrul dim indică ce index trebuie extins.
trebuie să fie în intervalul 1 și 1+ (rangul sursei), dacă sursa este un
scalar, atunci dim trebuie să fie unul. Parametrul ncopies este
numărul de elemente din noile dimensiuni.
Imprăștie un vector într-o matrice sub controlul măștii. Forma

măștii matricei logice trebuie să fie în acord cu cea pentru matrice.
Vectorul matrice trebuie să aibă rangul 1 (adică este un vector) cu
cel puțin la fel de multe elemente câte sunt adevărate în mască și, de
asemenea, trebuie să aibă același tip ca și matrice. Dacă matricea
este dată ca un scalar, atunci este considerată a fi o matrice cu
despachetați (vector, mască, matrice)
aceeași formă ca masca și aceleași elemente scalare peste tot.
Rezultatul va fi o matrice cu aceeași formă ca masca și de același tip

ca vector. Valorile vor fi cele din vector care sunt acceptate, în timp ce
în
89
Fortran
pozițiile rămase în matrice se păstrează valorile vechi.
Exemplu
program arrayConstruction
implicit nici unul

interfata
subrutine write_array (a)
real :: a(:,:)
sfârșitul subrutinei write_array
subrutina write_l_array (a)
logic :: a(:,:)
sfârșitul subrutinei write_l_array

interfață finală
real, dimensiune(2,3) :: tsource, fsource, result
logic, dimensiune(2,3) :: masca
tsource = remodelare( (/ 35, 23, 18, 28, 26, 39 /), &
(/ 2, 3 /) )
fsursă = remodelare( (/ -35, -23, -18, -28, -26, -39 /), &
(/ 2,3 /) )
masca = remodelare( (/ .true., .false., .false., .true., &
.fals., .fals. /), (/ 2,3 /) )
rezultat = merge(tsource, fsource, mask)
apelați write_array(tsource)
apelați write_array(fsource)
apelați write_l_array(mască)
apelează write_array (rezultat)

termina programul arrayConstruction
subrutine write_array (a)
real :: a(:,:)
fac i = lbound(a,1), ubound(a,1)
90
Fortran
scrie(*,*) (a(i, j), j = lbound(a,2), ubound(a,2) )
sfâr itul face
întoarcere
sfârșitul subrutinei write_array
subrutina write_l_array (a)
logic :: a(:,:)
scrie(*,*) (a(i, j), j= lbound(a,2), ubound(a,2))
sfâr itul face
întoarcere
sfârșitul subrutinei write_l_array
35,0000000 18,0000000 26,0000000
23,0000000 28,0000000 39,0000000
-35,0000000 -18,0000000 -26,0000000
-23,0000000 -28,0000000 -39,0000000
TFF
FTF
35,0000000 -18,0000000 -26,0000000
-23,0000000 28,0000000 -39,0000000
Reformează
Următorul tabel descrie funcția de remodelare:
Func ie Descriere
Acesta construiește o matrice cu o formă specificată pornind de la

elementele dintr-o sursă de matrice dată. Dacă pad-ul nu este
inclus, atunci dimensiunea sursei trebuie să fie cel puțin produs
remodelare (sursa, forma, pad, comanda)
(forma). Dacă pad-ul este inclus, acesta trebuie să aibă același tip
ca și sursa. Dacă este inclusă ordinea, aceasta trebuie să fie o
matrice întregă cu aceeași formă ca și forma și
91
Fortran
valorile trebuie să fie o permutare a lui (1,2,3,...,n), unde n

este numărul de elemente din formă, acesta trebuie să
fie mai mic sau egal cu 7.
Exemplu
programul arrayReshape
implicit nici unul
interfata
subrutina write_matrix(a)
real, dimensiune(:,:) :: a
sfârșitul subrutinei write_matrix
interfață finală
real, dimensiune (1:9) :: b = (/ 21, 22, 23, 24, 25, 26, 27, 28, 29 /)
real, dimensiune (1:3, 1:3) :: c, d, e real,
dimensiune (1:4, 1:4) :: f, g, h
întreg, dimensiune (1:2) :: ordine1 = (/ 1, 2 /)
întreg, dimensiune (1:2) :: ordine2 = (/ 2, 1 /)
real, dimensiune (1:16) :: pad1 = (/ -1, -2, -3, -4, -5, -6, -7, -8 și
& -9, -10, -11, -12, -13, -14, -15, -16 /)
c = remodelare( b, (/ 3, 3 /) )
apelați write_matrix(c)
d = remodelare( b, (/ 3, 3 /), ordine = ordine1)
apelează write_matrix(d)
e = remodelare( b, (/ 3, 3 /), ordine = ordine2)
apelați write_matrix(e)
f = remodelare( b, (/ 4, 4 /), pad = pad1)
apelează write_matrix(f)
92
Fortran
g = remodelare( b, (/ 4, 4 /), pad = pad1, ordine = ordine1)
apelați write_matrix(g)
h = remodelare( b, (/ 4, 4 /), pad = pad1, ordine = ordine2)
apelați write_matrix(h)
termina programul arrayReshape
real, dimensiune(:,:) :: a
scrie(*,*)
scrie(*,*) (a(i,j), j = lbound(a,2), ubound(a,2))
sfâr itul face
21,0000000 24,0000000 27,0000000
22,0000000 25,0000000 28,0000000
23,0000000 26,0000000 29,0000000
21,0000000 24,0000000 27,0000000
22,0000000 25,0000000 28,0000000
23,0000000 26,0000000 29,0000000
21,0000000 22,0000000 23,0000000
24,0000000 25,0000000 26,0000000
27,0000000 28,0000000 29,0000000
21,0000000 25,0000000 29,0000000 -4,00000000
22,0000000 26,0000000 -1,00000000 -5,00000000
23,0000000 27,0000000 -2,00000000 -6,00000000
24,0000000 28,0000000 -3,00000000 -7,00000000
93
Fortran
21,0000000 25,0000000 29,0000000 -4,00000000
22,0000000 26,0000000 -1,00000000 -5,00000000
23,0000000 27,0000000 -2,00000000 -6,00000000
24,0000000 28,0000000 -3,00000000 -7,00000000
21,0000000 22,0000000 23,0000000 24,0000000
25,0000000 26,0000000 27,0000000 28,0000000
29,0000000 -1,00000000 -2,00000000 -3,00000000
-4,00000000 -5,00000000 -6,00000000 -7,00000000
Manipulare
Funcțiile de manipulare sunt funcții de schimbare. Funcțiile de schimbare returnează neschimbată forma unui tablou, dar
mută elementele.
Func ie Descriere
Efectuează deplasare circulară cu poziții de schimbare la stânga,

dacă deplasarea este pozitivă și la dreapta dacă este negativă.
Dacă matricea este un vector, schimbarea se face într-un mod
natural, dacă este o matrice de rang superior, atunci deplasarea
este în toate secțiunile de-a lungul dimensiunii dim.
Dacă lipsește dim, acesta este considerat a fi 1, în alte cazuri
cshift(matrice, shift, dim) trebuie să fie un număr întreg scalar între 1 și n (unde n este egal
cu rangul matricei). Argumentul shift este un număr întreg scalar
sau o matrice întregă de rang n-1 și aceeași formă ca și tabloul, cu
excepția dimensiunii dim (care este eliminată din cauza rangului
inferior). Prin urmare, diferite secțiuni pot fi deplasate în diferite
direcții și cu un număr diferit de poziții.
Este tura de sfârșit. Efectuează deplasarea la stânga dacă deplasarea

este pozitivă și la dreapta dacă este negativă.
eoshift (matrice, deplasare, delimitare, dim) În loc de elementele mutate, noi elemente sunt luate de la graniță.
Dacă tabloul este un vector, deplasarea se face într-un
94
Fortran
mod natural, dacă este o matrice de rang superior, deplasarea

pe toate secțiunile este de-a lungul dimensiunii dim. dacă dim
lipsește, se consideră a fi 1, în alte cazuri trebuie să aibă o
valoare întreagă scalară între 1 și n (unde n este egal cu
rangul matricei).
Argumentul shift este un întreg scalar dacă matricea are rangul

1, în celălalt caz poate fi un întreg scalar sau o matrice
întregă de rang n-1 și cu aceeași formă ca și tabloul matricei,
cu excepția dimensiunii dim (care este eliminată din cauza
rangului inferior).
Transpune o matrice, care este o matrice de rang 2. Înlocuiește

transpune (matrice) rândurile și coloanele din matrice.
Exemplu
programul arrayShift
implicit nici unul
real, dimensiune(1:6) :: a = (/ 21,0, 22,0, 23,0, 24,0, 25,0, 26,0 /)
real, dimensiune(1:6) :: x, y
scrie(*,10) a
x = cshift ( a, shift = 2)
scrie(*,10) x
y = cshift (a, shift = -2)
scrie(*,10) y
x = eoshift ( a, deplasare = 2)
scrie(*,10) x
y = eoshift ( a, deplasare = -2)
scrie(*,10) y
95
Fortran
Format 10 (1x, 6f6.1)
termina programul arrayShift
21,0 22,0 23,0 24,0 25,0 26,0
23,0 24,0 25,0 26,0 21,0 22,0
25,0 26,0 21,0 22,0 23,0 24,0
23,0 24,0 25,0 26,0 0,0 0,0
0,0 0,0 21,0 22,0 23,0 24,0
Exemplu
Următorul exemplu demonstrează transpunerea unei matrice:
program matrixTranspose
implicit nici unul
interfata
întreg, dimensiune(:,:) :: a
interfață finală
întreg, dimensiune(3,3) :: a, b
întreg :: i, j
fac i = 1, 3
face j = 1, 3
a(i, j) = i
sfâr itul face
sfâr itul face
print *, „Matrix Transpose: A Matrix”
apelați write_matrix(a)
b = transpune(a)
96
Fortran
print *, „Matrice transpusă:”
apelați write_matrix(b)
programul final matrixTranspose
întreg, dimensiune(:,:) :: a
scrie(*,*)

sfâr itul face
Matrix Transpose: A Matrix

111
222
333
Matrice transpusă:
123
123
123
Locație
Următorul tabel descrie funcțiile de locație:
Func ie Descriere
Returnează poziția celui mai mare element din tabloul matrice, dacă masca
este inclusă numai pentru cei care îndeplinesc condițiile din masca, poziția
maxloc (matrice, mască)
este returnată și rezultatul este un vector întreg.
97
Fortran
Returnează poziția celui mai mic element din tabloul matrice, dacă masca este
inclusă numai pentru cei care îndeplinesc condițiile din masca, poziția este
minloc (matrice, mască)
returnată și rezultatul este un vector întreg.
Exemplu
program arrayLocation
implicit nici unul
real, dimensiune(1:6) :: a = (/ 21,0, 12,0,33,0, 24,0, 15,0, 16,0 /)
Imprimare *, maxloc(a)
Imprimare *, minloc(a)
sfârșitul programului arrayLocation
98
14. Fortran Dynamic Arrays Fortran
O matrice dinamică este o matrice a cărei dimensiune nu este cunoscută în momentul compilării, dar va fi
cunoscută în momentul execuției.
Matricele dinamice sunt declarate cu atributul alocabil.
De exemplu,
real, dimensiune (:,:), alocabil :: darray
Rangul matricei, adică dimensiunile trebuie menționat, totuși, pentru a aloca memorie unui astfel de tablou,
folosiți funcția de alocare .
aloca ( darray(s1,s2) )
După ce matricea este utilizată, în program, memoria creată trebuie eliberată folosind funcția deallocate
dealocare (darray)
Exemplu
Următorul exemplu demonstrează conceptele discutate mai sus.
program dynamic_array
implicit nici unul
!rank este 2, dar dimensiunea nu este cunoscută
real, dimensiune (:,:), alocabil :: darray
întreg :: s1, s2
întreg :: i, j
print*, "Introduceți dimensiunea matricei:"
citește*, s1, s2
! aloca memorie
aloca (darray(s1,s2))
face i = 1, s1
face j = 1, s2
darray(i,j) = i*j
99
Fortran
print*, "darray(",i,",",j,") = ", darray(i,j)

sfâr itul face
sfâr itul face
dealocare (darray)
sfârșitul programului dynamic_array
Introduceți dimensiunea matricei: 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
Declarația de utilizare a datelor
Declarația de date poate fi utilizată pentru inițializarea mai multor matrice sau pentru inițializarea
secțiunii de matrice.
Sintaxa declarației de date este:
variabilă de date / listă / ...
Exemplu
program dataStatement
implicit nici unul
întreg :: a(5), b(3,3), c(10),i, j
100
Fortran
date a /7,8,9,10,11/
date b(1,:) /1,1,1/
date b(2,:)/2,2,2/
date b(3,:)/3,3,3/
date (c(i),i=1,10,2) /4,5,6,7,8/
date (c(i),i=2,10,2)/5*2/
Print *, „Matricea A:”
face j = 1, 5
imprimare*, a(j)
sfâr itul face
Print *, „Matricea B:”
do i = lbound(b,1), ubound(b,1)
scrie(*,*) (b(i,j), j = lbound(b,2), ubound(b,2))

sfâr itul face
Print *, „Matricea C:”
face j = 1, 10
imprimare*, c(j)
sfâr itul face
sfârșitul programului dataStatement
Matricea A:
7
10
11
Matricea B:
111
222
333
101
Fortran
Matricea C:
4
Utilizarea declarației Where
Instrucțiunea where vă permite să utilizați unele elemente ale unui tablou într-o expresie, în funcție de
rezultatul unei anumite condiții logice. Permite executarea expresiei, pe un element, dacă condiția dată este
adevărată.
Exemplu
program whereStatement
implicit nici unul
întreg :: a(3,5), i ,j
fac i = 1,3
face j = 1, 5
a(i,j) = ji
sfâr itul face
sfâr itul face

sfâr itul face
102
Fortran
unde(a<0)
a=1
în altă parte
a=5
sfâr itul unde

sfâr itul face
termina programul whereStatement
Matricea A:
01234
-1 0 1 2 3
-2 -1 0 1 2
Matricea A:
5 5 555
15 555
11555
103
15. Fortran Tipuri de date derivate Fortran
Fortran vă permite să definiți tipuri de date derivate. Un tip de date derivat se mai numește și structură și
poate consta din obiecte de date de diferite tipuri.
Tipurile de date derivate sunt folosite pentru a reprezenta o înregistrare. De exemplu, dacă doriți să urmăriți
cărțile dvs. într-o bibliotecă, este posibil să doriți să urmăriți următoarele atribute despre fiecare carte:
• Titlu
• Autor
• Subiect
• ID carte
Definirea unui tip de date derivate

Pentru a defini un tip de date derivat , sunt utilizate instrucțiunile tip și tip final . . Declarația de tip definește un
nou tip de date, cu mai mult de un membru pentru programul dvs. Formatul declarației de tip este următorul:
tastați tip_nume
declarații
tipul de capăt
Iată modul în care ați declara structura Cărții:
tip Books
caracter(len=50) :: autor
caracter(len=150) :: subiect
întreg :: book_id
Cărți de tip final
Accesarea membrilor structurii

Un obiect de tip de date derivat se numește structură
O structură de tip Books poate fi creată într-o declarație de tip, cum ar fi:
tip(Carti) :: carte1
Componentele structurii pot fi accesate folosind caracterul selector de componente (%):
104
Fortran
book1%title = „Programare C”
carte1%autor = „Nuha Ali”
book1%subject = "Tutorial de programare C"
book1%book_id = 6495407
Rețineți că nu există spații înainte și după simbolul %.
Exemplu
Următorul program ilustrează conceptele de mai sus:
programul derivDataType
!declara ie de tip
tip Books
întreg :: book_id
!declarând variabile de tip
!accesarea componentelor structurii
book1%title = „Programare C”
carte1%autor = „Nuha Ali”
book1%subject = "Tutorial de programare C"
book2%title = „Facturare telecom”
carte2%autor = „Zara Ali”
book2%subject = "Tutorial Facturare Telecom"
!afișează informații despre carte
105
Fortran
Tipărire *, carte1%titlu
Tipărire *, carte1%autor
Tipărire *, carte1%subiect
Print *, book1%book_id
Tipărire *, carte2%titlu
Tipărire *, carte2%autor
Tipărire *, carte2%subiect
Print *, book2%book_id
programul final deriveDataType
Programare C
Nuha Ali
Tutorial de programare C
6495407
Facturare Telecom
Zara Ali
Tutorial Facturare Telecom

6495700
Matrice de structuri
De asemenea, puteți crea matrice de tip derivat:
tip(Carti), dimensiune(2) :: lista
Elementele individuale ale matricei pot fi accesate ca:
list(1)%title = "Programare C"
list(1)%author = "Nuha Ali"
list(1)%subject = "Tutorial de programare C"
list(1)%book_id = 6495407
106
Fortran
Următorul program ilustrează conceptul:
programul derivDataType
!declara ie de tip
tip Books
întreg :: book_id
!declaring array of books
tip(Carti), dimensiune(2) :: lista
!accesarea componentelor structurii
list(1)%title = "Programare C"
list(1)%author = "Nuha Ali"
list(1)%subject = "Tutorial de programare C"
list(2)%title = „Facturare telecom”
list(2)%author = "Zara Ali"
list(2)%subject = "Tutorial Facturare Telecom"
!afișează informații despre carte
Print *, list(1)%title
Print *, list(1)%author
Imprimare *, listă(1)%subiect
Print *, list(1)%book_id
Print *, list(1)%title
Print *, list(2)%author
Imprimare *, listă(2)%subiect
107
Fortran
Print *, list(2)%book_id
programul final deriveDataType
Programare C
Nuha Ali
Tutorial de programare C
6495407
Programare C
Zara Ali
Tutorial Facturare Telecom

6495700
108
16. Fortran Indicatori Fortran
În majoritatea limbajelor de programare, o variabilă pointer stochează adresa de memorie a unui obiect. Cu toate
acestea, în Fortran, un pointer este un obiect de date care are mai multe funcționalități decât doar stocarea adresei
de memorie. Conține mai multe informații despre un anumit obiect, cum ar fi tipul, rangul, extinderea și adresa de
memorie.
Un pointer este asociat cu o țintă prin alocare sau atribuire pointer.
Declararea unei variabile pointer
O variabilă pointer este declarată cu atributul pointer.
Următoarele exemple arată declararea variabilelor pointer:
întreg, indicator :: p1 ! pointer către număr întreg
real, indicator, dimensiune (:) :: pra ! pointer către o matrice reală 1-dim
real, indicator, dimensiune (:,:) :: pra2 ! pointer către o matrice reală cu 2 dim
Un indicator poate indica:
• o zonă de memorie alocată dinamic
• un obiect de date de același tip ca și pointerul, cu atributul target
Alocarea de spațiu pentru un pointer
Instrucțiunea allocate vă permite să alocați spațiu pentru un obiect pointer. De exemplu:
program pointerExample
implicit nici unul
întreg, indicator :: p1
aloca (p1)
p1 = 1
Tipărire *, p1
p1 = p1 + 4
Tipărire *, p1
sfâr itul programului pointerExample
109
Fortran
Ar trebui să goliți spațiul de stocare alocat prin instrucțiunea deallocate atunci când nu mai este necesar și să
evitați acumularea de spațiu de memorie neutilizat și inutilizabil.
Ținte și Asociere
O țintă este o altă variabilă normală, cu spațiu rezervat pentru ea. O variabilă țintă trebuie declarată cu
atributul țintă .
Asociați o variabilă pointer cu o variabilă țintă folosind operatorul de asociere (=>).
Să rescriem exemplul anterior, pentru a demonstra conceptul:
implicit nici unul
întreg, țintă :: t1
p1 => t1
p1 = 1
Tipărire *, p1
Tipărire *, t1
p1 = p1 + 4
Tipărire *, p1
Tipărire *, t1
t1 = 8
Tipărire *, p1
Tipărire *, t1
110
Fortran
Un indicator poate fi:
• Nedefinit
• Asociat
• disociat
În programul de mai sus, am asociat pointerul p1, cu ținta t1, folosind operatorul =>. Funcția asociată testează
starea de asociere a unui pointer.
Instrucțiunea nullify disociază un pointer de o țintă.
Nullify nu golește țintele, deoarece ar putea exista mai mult de un pointer care să indice aceeași țintă. Cu toate
acestea, golirea indicatorului implică și anularea.
Exemplul 1
Următorul exemplu demonstrează conceptele:
implicit nici unul
p1 => t1
p1 = 1
Tipărire *, p1
Tipărire *, t1
p1 = p1 + 4
Tipărire *, p1
Tipărire *, t1
111
Fortran
t1 = 8
Tipărire *, p1
Tipărire *, t1
anulează (p1)
Tipărire *, t1
p1 => t2
Imprimare *, asociat(p1)
Imprimare*, asociat(p1, t1)
Imprimare*, asociat(p1, t2)
!care este valoarea lui p1 în prezent
Tipărire *, p1
Tipărire *, t2
p1 = 10
Tipărire *, p1
Tipărire *, t2
952754640
952754640
112
Fortran
10
10
Vă rugăm să rețineți că de fiecare dată când rulați codul, adresele de memorie vor fi diferite.
Exemplul 2
implicit nici unul
întreg, indicator :: a, b
întreg, țintă :: t
întreg :: n
t= 1
a => t
t=2
b => t
n=a+b
Tipăriți *, a, b, t, n
2224
113
17. Fortran Intrare de bază Ieșire

Fortran
Am văzut până acum că putem citi date de la tastatură utilizând instrucțiunea read * și, respectiv, afișam
rezultatul pe ecran folosind instrucțiunea print* . Această formă de intrare-ieșire este I/O în format liber și
se numește intrare-ieșire direcționată pe listă .
I/O simplu format gratuit are forma:
citește(*,*) item1, item2, item3...
imprimare *, item1, item2, item3
scrie(*,*) item1, item2, item3...
Cu toate acestea, I/O formatat vă oferă mai multă flexibilitate în ceea ce privește transferul de date.
Formatat Intrare Ieșire

Ieșirea de intrare formatată are sintaxa după cum urmează:
citiți fmt, lista_variabile
print fmt, lista_variabile
scrieți fmt, listă_variabile
Unde,
• fmt este specificația formatului
• lista-variabile este o listă a variabilelor care trebuie citite de la tastatură sau pe care trebuie scrise
ecran
Specificația formatului definește modul în care sunt afișate datele formatate. Este format dintr-un șir, care
conține o listă de descriptori de editare între paranteze.
Un descriptor de editare specifică formatul exact, de exemplu, lățimea, cifrele după virgulă zecimală etc.,
în care sunt afișate caracterele și numerele.
De exemplu:
Tipăriți „(f6.3)”, pi
114
Fortran
Următorul tabel descrie descriptorii:
Descriptor Descriere Exemplu
Acesta este folosit pentru ieșirea întregului. Aceasta ia

forma „rIw.m” unde semnificațiile lui r, w și m sunt date
în tabelul de mai jos.
eu
Valorile întregi sunt justificate la dreapta în câmpurile tipăriți „(3i5)”, i, j, k
lor. Dacă lățimea câmpului nu este suficient de mare
pentru a găzdui un număr întreg, atunci câmpul este
umplut cu asteriscuri.
Acesta este folosit pentru ieșirea numerelor reale.

Aceasta ia forma „rFw.d” unde semnificațiile lui r, w și d
sunt date în tabelul de mai jos. Valorile reale sunt
corect justificate în domeniile lor. Dacă lățimea
F tipăriți „(f12.3)”,pi
câmpului nu este suficient de mare pentru a găzdui
numărul real, atunci câmpul este completat cu
asteriscuri.
Acesta este folosit pentru ieșirea reală în notație

exponențială. Declarația de descriptor „E” ia forma
„rEw.d”, unde semnificațiile lui r, w și d sunt date în
tabelul de mai jos. Valorile reale sunt corect justificate
în domeniile lor. Dacă lățimea câmpului nu este
suficient de mare pentru a găzdui numărul real, atunci
câmpul este umplut cu asteriscuri.
printează „(e10.3)”, 123456.0 dă
E
„0.123e+06”
Vă rugăm să rețineți că, pentru a tipări un număr

real cu trei zecimale, este necesară o lățime a câmpului
de cel puțin zece. Unul pentru semnul mantisei, doi
pentru zero, patru pentru mantise și două pentru
exponentul însuși. În general, w d + 7.
Acesta este utilizat pentru rezultate reale (notație

științifică). Aceasta ia forma „rESw.d” unde semnificațiile
lui r, w și d sunt date în tabelul de mai jos. Descriptorul
„E” descris mai sus diferă ușor de „notația științifică” printează „(es10.3)”, 123456.0 dă
ES
tradițională. „1.235e+05”
Notația științifică are mantisa în intervalul 1,0 până la

10,0 spre deosebire de descriptorul E
115
Fortran
care are mantisa în intervalul 0,1 până la 1,0.

Valorile reale sunt corect justificate în domeniile
lor. Dacă lățimea câmpului nu este suficient de
mare pentru a găzdui numărul real, atunci
câmpul este umplut cu asteriscuri. Aici
de asemenea, câmpul de lățime trebuie să
satisfacă expresia w d+7
Acesta este folosit pentru ieșirea caracterelor.

Aceasta ia forma „rAw” unde semnificațiile lui r și
w sunt date în tabelul de mai jos.
A Tipurile de caractere sunt justificate la dreapta în
tipăriți „(a10)”, str
câmpurile lor. Dacă lățimea câmpului nu este
suficient de mare pentru a găzdui șirul de
caractere, atunci câmpul este umplut cu primele
caractere „w” ale șirului.
Acesta este folosit pentru ieșirea spațiului. Aceasta

X ia forma „nX” unde „n” este numărul de tipăriți „(5x, a10)”, str
spatiile dorite.
Descriptor bară oblică – folosit pentru a insera

/ linii goale. Aceasta ia forma „/” și forțează tipăriți „(/,5x, a10)”, str
următoarea ieșire de date să fie pe o linie nouă.
Următoarele simboluri sunt utilizate cu descriptorii de format:
Simbol Descriere
c Numărul coloanei
d Numărul de cifre la dreapta zecimalei pentru intrare sau ieșire reală
m Numărul minim de cifre care trebuie afișate
n Numărul de spații de ignorat
r Repet count – numărul de ori pentru a utiliza un descriptor sau un grup de descriptori
w Lățimea câmpului – numărul de caractere de utilizat pentru intrare sau ieșire
116
Fortran
Exemplul 1
programul printPi
pi = 3,141592653589793238
Tipăriți „(e16.4)”, pi/100
termina programul printPi
3.142
3.1415927
3.141592741012573
0,3142E-01
Exemplul 2
program printName
implicit nici unul
caracter (len=15) :: prenume
print *,' Introduceți prenumele.'
print *, 'Până la 20 de caractere, vă rugăm'
citește *,prenume
tipăriți „(1x,a)”, prenume
termina programul printName
Când codul de mai sus este compilat și executat, acesta produce următorul rezultat: (presupunem că utilizatorul introduce
numele Zara)
Introduceți prenumele dvs.
Până la 20 de caractere, vă rog
Zara
117
Fortran
Exemplul 3
program formatedPrint
implicit nici unul
real :: c = 1,2786456e-9, d = 0,1234567e3
întreg :: n = 300789, k = 45, i = 2
caracter (len=15) :: str="Tutorials Point"
tipăriți „(i6)”, k
tipăriți „(i6.3)”, k
tipăriți „(3i10)”, n, k, i
tipăriți „(i10,i3,i5)”, n, k, i
tipăriți „(a15)”,str
tipăriți „(f12.3)”, d
tipăriți „(e12.4)”, c
tipăriți „(/,3x,"n = ",i6, 3x, "d = ",f7.4)', n, d
termina programul formatatPrint
45
045
300789 45 2
300789 45 2
Punct de tutoriale
123.457
0,1279E-08
n = 300789 d = ******
118
Fortran
Declarația de format
Instrucțiunea de format vă permite să amestecați și să potriviți caractere, întregi și rezultate reale într-o singură
instrucțiune. Următorul exemplu demonstrează acest lucru:
program produsDetalii
implicit nici unul
întreg :: id
real :: greutate
nume = 'Ardupilot'
id = 1
greutate = 0,08
print *,' Detaliile produsului sunt'
tipăriți 100
Format 100 (7x, „Nume:”, 7x, „Id:”, 1x, „Greutate:”)
tipăriți 200, nume, id, greutate
Format 200 (1x, a, 2x, i3, 2x, f5.2)
Programul final Detalii produs
Detaliile produsului sunt
Nume: Id: Greutate:
Ardupilot 1 0,08
119
18. Fortran File Input Output Fortran
Fortran vă permite să citiți și să scrieți date în fișiere.
În ultimul capitol, ați văzut cum să citiți și să scrieți date pe terminal. În acest capitol veți studia funcționalitățile de
intrare și ieșire ale fișierelor furnizate de Fortran.
Puteți citi și scrie în unul sau mai multe fișiere. Declarațiile OPEN, WRITE, READ și CLOSE vă permit să realizați acest
lucru.
Deschiderea și închiderea fișierelor
Înainte de a utiliza un fișier, trebuie să deschideți fișierul. Comanda de deschidere este folosită pentru a deschide
fișiere pentru citire sau scriere. Cea mai simplă formă a comenzii este:
deschis (unitate = număr, fișier = „nume”).
Cu toate acestea, declarația deschisă poate avea o formă generală:
deschis (lista de specificatori)
Următorul tabel descrie specificatorii cei mai des utilizați:
Specificator Descriere
Numărul unității u poate fi orice număr în intervalul 9-99 și indică fișierul, puteți alege
[UNITATE=] u orice număr, dar fiecare fișier deschis din program trebuie să aibă un număr unic
Este identificatorul de stare I/O și ar trebui să fie o variabilă întreagă. Dacă instrucțiunea
IOSTAT= ios open are succes, atunci valoarea ios returnată este zero, altfel o valoare diferită de zero.
ERR = greșeală Este o etichetă la care sare controlul în cazul oricărei erori.
FILE = fname Nume fișier, un șir de caractere.
Acesta arată starea anterioară a fișierului. Un șir de caractere și poate avea una dintre cele
STARE = sta trei valori NEW, OLD sau SCRATCH. Un fișier scratch este creat și șters atunci când este închis
sau programul se termină.
Este modul de acces la fișiere. Poate avea oricare dintre cele două valori, SECVENTIAL sau
ACCES = acc
DIRECT. Valoarea implicită este SECVENTIAL.
120
Fortran
FORM= frm Oferă starea de formatare a fișierului. Poate avea oricare dintre cele două valori
FORMATTED sau UNFORMATTED. Valoarea implicită este NEFORMATATE
RECL = rl Specifică lungimea fiecărei înregistrări într-un fișier cu acces direct.
După ce fișierul a fost deschis, acesta este accesat prin instrucțiuni de citire și scriere. Odată terminat, ar
trebui să fie închis folosind declarația close .
Instrucțiunea close are următoarea sintaxă:
închidere ([UNIT=]u[,IOSTAT=ios,ERR=err,STATUS=sta])
Vă rugăm să rețineți că parametrii dintre paranteze sunt opționali.
Exemplu
Acest exemplu demonstrează deschiderea unui fișier nou pentru scrierea unor date în fișier.
datele de ieșire ale programului
implicit nici unul
real, dimensiune(100) :: x, y
real, dimensiune(100) :: p, q
întreg :: i
! date
face i=1.100
x(i) = i * 0,1
y(i) = sin(x(i)) * (1-cos(x(i)/3.0))

sfâr itul face
! scoateți datele într-un fișier
open(1, file='data1.dat', status='new')

face i=1.100
scrie(1,*) x(i), y(i)

sfâr itul face
închide (1)
date de ieșire a programului final
121
Fortran
Când codul de mai sus este compilat și executat, acesta creează fișierul data1.dat și scrie valorile matricei x și y în el.
Și apoi închide fișierul.
Citirea și scrierea în fișier

Declarațiile de citire și, respectiv, de scriere sunt utilizate pentru citirea și, respectiv, scrierea într-un fișier.
Au următoarea sintaxă:
citiți ([UNIT=]u, [FMT=]fmt, IOSTAT=ios, ERR=err, END=s)
scrie([UNIT=]u, [FMT=]fmt, IOSTAT=ios, ERR=err, END=s)
Majoritatea specificatorilor au fost deja discutate în tabelul de mai sus.
Specificatorul END=s este o etichetă de instrucțiune în care programul sare când ajunge la sfârșitul fișierului.
Exemplu
Acest exemplu demonstrează citirea și scrierea într-un fișier.
În acest program citim din fișier, l-am creat în ultimul exemplu, data1.dat, și îl afișam pe ecran.
datele de ieșire ale programului
implicit nici unul
real, dimensiune(100) :: x, y
real, dimensiune(100) :: p, q
întreg :: i
! date
face i=1.100
x(i) = i * 0,1
y(i) = sin(x(i)) * (1-cos(x(i)/3.0))

sfâr itul face
! scoateți datele într-un fișier
open(1, file='data1.dat', status='new')
face i=1.100
scrie(1,*) x(i), y(i)

sfâr itul face
închide (1)
122
Fortran
! deschiderea fișierului pentru citire
deschis (2, fișier='data1.dat', stare='vechi')
face i=1.100
citiți(2,*) p(i), q(i)
sfâr itul face
inchidere(2)
face i=1.100
scrie (*),*) p(i), q(i)
sfâr itul face
date de ieșire a programului final
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
123
Fortran
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
124
Fortran
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
125
Fortran
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
126
19. Fortran Proceduri Fortran
O procedură este un grup de instrucțiuni care efectuează o sarcină bine definită și pot fi invocate din programul
dumneavoastră. Informațiile (sau datele) sunt transmise programului apelant, procedurii ca argumente.
Există două tipuri de proceduri:
• Func ii
• Subrutine
Func ie
O funcție este o procedură care returnează o singură cantitate. O funcție nu ar trebui să-și modifice argumentele.
Cantitatea returnată este cunoscută sub denumirea de valoare a funcției și este indicată de funcție
Nume.
Sintaxă:
Sintaxa unei funcții este următoarea:
numele funcției (arg1, arg2, ....)
[declarații, inclusiv cele pentru argumente]
[declarații executabile]
sfârșitul funcției [nume]
Următorul exemplu demonstrează o funcție numită area_of_circle. Calculează aria unui cerc cu raza r.
program calling_func
real :: a
a = zona_cercului(2.0)
Print *, "Aria unui cerc cu raza 2.0 este"
Imprimare *, a
termina programul calling_func
! această funcție calculează aria unui cerc cu raza r
127
Fortran
funcția area_of_circle (r)
! rezultatul funcției
implicit nici unul
! argumente false
real :: area_of_circle
! variabile locale
real :: r
real :: pi
pi = 4 * atan (1,0)
zona_cercului = pi * r**2
sfârșitul funcției area_of_circle
Aria unui cerc cu raza 2,0 este
12,5663710
Te rog noteaza asta:
• Trebuie să specificați niciunul implicit atât în programul principal, cât și în programul

procedură.
• Argumentul r din funcția apelată se numește argument dummy.
Opțiunea rezultatului
Dacă doriți ca valoarea returnată să fie stocată sub alt nume decât numele funcției, puteți utiliza opțiunea rezultat .
Puteți specifica numele variabilei de returnare ca:
numele funcției (arg1, arg2, ....) rezultat (return_var_name)
funcția finală [nume]
128
Fortran
Subrutină
O subrutină nu returnează o valoare, totuși își poate modifica argumentele.
Sintaxă
numele subrutinei (arg1, arg2, ....)
termina subrutinei [nume]
Apelarea unei subrutine Trebuie
să invocați o subrutină folosind instrucțiunea de apel .
Următorul exemplu demonstrează definirea și utilizarea unui schimb de subrutine, care modifică valorile argumentelor sale.
implicit nici unul
real :: a, b
a = 2,0
b = 3,0
Imprimați *, „Înainte de a apela schimbul”
Tipăriți *, "a = ", a
Tipăriți *, "b = ", b
schimb de apeluri (a, b)
Imprimați *, „După apelarea schimbului”
schimb de subrutine (x, y)
implicit nici unul
129
Fortran
real :: x, y, temp
temp = x
x=y
y = temp
terminați schimbul de subrutine
Înainte de a apela swap
a = 2,00000000
b = 3,00000000
După apelarea swap
a = 3,00000000
b = 2,00000000
Specificarea Intenției Argumentelor

Atributul intent vă permite să specificați intenția cu care argumentele sunt utilizate în procedură. Următorul tabel oferă
valorile atributului intent:
Valoare Utilizată ca Explica ie
în intentia(in) Folosit ca valori de intrare, nu a fost modificat în funcție
afară intentie Folosite ca valoare de ieșire, acestea sunt suprascrise
în afară intentie(inout) Argumentele sunt atât folosite, cât și suprascrise
implicit nici unul
real :: x, y, z, disc
x= 1,0
130
Fortran
y = 5,0
z = 2,0
apel intent_example(x, y, z, disc)
Print *, "Valoarea discriminantului este"
Imprimare *, disc
subrutină intent_example (a, b, c, d)
implicit nici unul
! argumente false
real, intenție (în) :: a
real, intenție (în) :: b
real, intentie (in) :: c real, intentie
(out) :: d
d = b * b - 4,0 * A * c
sfâr itul subrutinei intent_example
Valoarea discriminantului este
17,0000000
Proceduri recursive
Recursiunea apare atunci când un limbaj de programare vă permite să apelați o funcție în cadrul aceleiași funcții. Se numește
apel recursiv al funcției.
Când o procedură se autoapelează, direct sau indirect, se numește procedură recursivă. Ar trebui să declarați acest tip de
proceduri precedând cuvântul recursiv înainte de declararea acestuia.
Când o funcție este utilizată recursiv, trebuie utilizată opțiunea rezultat .
131
Fortran
Următorul este un exemplu, care calculează factorial pentru un număr dat folosind o procedură recursivă:
implicit nici unul
întreg :: i, f
i = 15
Print *, "Valoarea factorialului 15 este"
f = myfactorial(15)
Tipărire *, f
! calculează factorialul lui n (n!)
funcția recursivă myfactorial (n) rezultat (fac)

! rezultatul funcției
implicit nici unul
! argumente false
întreg :: fac
întreg, intenție (în) :: n
selectați cazul (n)
caz (0:1)
fac = 1
caz implicit
fac = n * myfactorial (n-1)

final select
funcția finală myfactorial
132
Fortran
Proceduri interne
Când o procedură este conținută într-un program, se numește procedură internă a programului. Sintaxa pentru care
conține o procedură internă este următoarea:
program program_name
implicit nici unul
! declarații de tip
! instrucțiuni executabile
. . .
con ine
! proceduri interne
. . .
final program program_name
program mainprog
implicit nici unul
real :: a, b
a = 2,0
b = 3,0
Imprimați *, „Înainte de a apela schimbul”
schimb de apeluri (a, b)
Imprimați *, „După apelarea schimbului”
con ine
schimb de subrutine (x, y)
real :: x, y, temp
temp = x
x=y
133
Fortran
y = temp
terminați schimbul de subrutine
final program mainprog
Înainte de a apela swap
a = 2,00000000
b = 3,00000000
După apelarea swap
a = 3,00000000
b = 2,00000000
134
20. Fortran Module Fortran
Un modul este ca un pachet în care vă puteți păstra funcțiile și subrutinele, în cazul în care scrieți un program foarte
mare, sau funcțiile sau subrutinele dvs. pot fi folosite în mai multe programe.
Modulele vă oferă o modalitate de a vă împărți programele între mai multe fișiere.
Modulele sunt folosite pentru:
• Ambalare subprograme, blocuri de date și interfață.
• Definirea datelor globale care pot fi utilizate de mai multe rutine.
• Declararea variabilelor care pot fi puse la dispoziție în cadrul oricăror rutine pe care le alegeți.
• Importarea unui modul în întregime, pentru utilizare, într-un alt program sau subrutină.
Sintaxa unui modul

Un modul este format din două părți:
• o parte de specificații pentru declarația declarațiilor
• a conține o parte pentru definițiile de subrutine și funcții
Forma generală a unui modul este:
numele modulului
[declarații de declarație]
[conține [definiții de subrutine și funcții]]
sfârșit modul [nume]
Utilizarea unui modul în programul dvs

Puteți încorpora un modul într-un program sau subrutină prin instrucțiunea use:
folosește numele
Te rog noteaza asta
• Puteți adăuga câte module este necesar, fiecare va fi în fișiere separate și

compilate separat.
• Un modul poate fi utilizat în diferite programe diferite.
• Un modul poate fi folosit de mai multe ori în același program.
• Variabilele declarate într-o parte a specificațiilor de modul, sunt globale pentru modul.
135
Fortran
• Variabilele declarate într-un modul devin variabile globale în orice program sau
rutină în care este utilizat modulul.
• Instrucțiunea use poate apărea în programul principal sau în orice altă subrutină sau modul care utilizează rutinele
sau variabilele declarate într-un anumit modul.
Exemplu
constantele modulului
implicit nici unul
real, parametru :: e = 2,7182818285
con ine
subrutina show_consts()
print*, "Pi = ", pi
print*, "e = ", e
sfârșitul subrutinei show_consts
constantele modulului final
program module_example
utilizați constante
implicit nici unul
real :: x, ePowerx, zonă, rază
x = 2,0
raza = 7,0
ePowerx = e ** X
aria = pi * raza**2
apelați show_consts()
print*, "e ridicat la puterea de 2.0 = ", ePowerx
print*, "Aria unui cerc cu raza 7,0 = ", zonă
programul final module_example
136
Fortran
Pi = 3,14159274
e = 2,71828175
e ridicat la puterea de 2,0 = 7,38905573
Aria unui cerc cu raza 7,0 = 153,938049
Accesibilitatea variabilelor și subrutinelor dintr-un modul

În mod implicit, toate variabilele și subrutinele dintr-un modul sunt puse la dispoziția programului care utilizează codul
modulului, prin instrucțiunea use .
Cu toate acestea, puteți controla accesibilitatea codului modulului folosind atributele private și public . Când declarați o
variabilă sau subrutină ca fiind privată, aceasta nu este disponibilă în afara modulului.
Exemplu
Următorul exemplu ilustrează conceptul:
În exemplul anterior, am avut două variabile de modul, e și pi. Să le facem private și să observăm rezultatul:
implicit nici unul
real, parametru, privat :: pi = 3,1415926536
real, parametru, privat :: e = 2,7182818285
con ine
print*, "Pi = ", pi
print*, "e = ", e
implicit nici unul
137
Fortran
real :: x, ePowerx, zonă, rază
x = 2,0
raza = 7,0
ePowerx = e ** X
aria = pi * raza**2
print*, "e ridicat la puterea 2.0 = ", ePowerx
print*, "Aria unui cerc cu raza 7,0 = ", zonă
Când compilați și executați programul de mai sus, acesta dă următorul mesaj de eroare:
ePowerx = e ** X
Eroare: simbolul „e” de la (1) nu are tip IMPLICIT
principal.f95:19.13:
aria = pi * raza**2
Eroare: simbolul „pi” de la (1) nu are tip IMPLICIT
Deoarece e și pi, ambele sunt declarate private, programul module_example nu mai poate accesa aceste variabile.
Cu toate acestea, alte subrutine de module le pot accesa:
implicit nici unul
real, parametru, privat :: pi = 3,1415926536
real, parametru, privat :: e = 2,7182818285
con ine
print*, "Pi = ", pi
print*, "e = ", e
138
Fortran
funcția ePowerx(x)result(ePx)
implicit nici unul
real::x
real::ePx
ePx = e ** X
terminați funcția ePowerx
aria funcțieiCerc(r)rezultat(a)
implicit nici unul
real::r
real::a
a = pi * r**2
sfarsit zona functieiCerc
implicit nici unul
Print*, "e ridicat la puterea 2.0 = ", ePowerx(2.0)
print*, "Aria unui cerc cu raza 7.0 = ", areaCircle(7.0)
Pi = 3,14159274
e = 2,71828175
e ridicat la puterea de 2,0 = 7,38905573
Aria unui cerc cu raza 7,0 = 153,938049
139
21. Fortran Funcții intrinseci Fortran
Funcțiile intrinseci sunt câteva funcții comune și importante care sunt furnizate ca parte a limbajului Fortran. Am discutat
deja câteva dintre aceste funcții în capitolele Arrays, Characters și String.
Funcțiile intrinseci pot fi clasificate astfel:
• Func ii numerice
• Func ii matematice
• Func ii de interogare numerică
• Funcții de manipulare în virgulă mobilă
• Funcții de manipulare a biților
• Funcții de caracter
• Funcții amabile
• Func ii logice
• Funcții de matrice.
Am discutat despre funcțiile matricei în capitolul Arrays. În secțiunea următoare oferim scurte descrieri ale tuturor acestor
funcții din alte categorii.
În coloana cu numele funcției,
• A reprezintă orice tip de variabilă numerică
• R reprezintă o variabilă reală sau întreagă
• X și Y reprezintă variabile reale
• Z reprezintă variabilă complexă
• W reprezintă variabila reală sau complexă
Funcții numerice
Func ie Descriere
ABS (A) Returnează valoarea absolută a lui A
AIMAG (Z) Returnează partea imaginară a unui număr complex Z
Trunchiază o parte fracționară a lui A spre zero, returnând un număr real, întreg.
AINT (A [, KIND])
140
Fortran
ANINT (A [, KIND]) Returnează o valoare reală, cel mai apropiat număr întreg sau număr întreg.
Returnează cel mai mic număr întreg mai mare sau egal cu numărul A.
PLAFON (A [, FEL])
Convertește variabilele reale X și Y într-un număr complex X+iY; dacă Y

CMPLX (X [, Y, KIND])
este absent, se utilizează 0.
CONJG (Z) Returnează conjugatul complex al oricărui număr complex Z.
DBLE (A) Acesta transformă A într-un număr real de dublă precizie.
DIM (X, Y) Returnează diferența pozitivă dintre X și Y.
DPROD (X, Y) Acesta returnează produsul real de dublă precizie al lui X și Y.
Acesta oferă cel mai mare număr întreg mai mic sau egal cu numărul A.
ETAJ (A [, KIND])
Convertește un număr (real sau întreg) în întreg, trunchiind partea

INT (A [, KIND])
reală către zero.
Returnează valoarea maximă din argumente, toate fiind de același tip.

MAX (A1, A2 [, A3,...])
Returnează valoarea minimă din argumente, toate fiind de același tip.

MIN (A1, A2 [, A3,...])
Returnează restul lui A la împărțirea cu P, ambele argumente fiind de

MOD (A, P)
același tip (A-INT(A/P)*P)
MODUL (A, P) Returnează A modulo P: (A-FLOOR(A/P)*P)
NINT (A [, KIND]) Returnează cel mai apropiat număr întreg al numărului A
REAL (A [, KIND]) Se convertește la tipul real
Returnează valoarea absolută a lui A înmulțită cu semnul lui P.

SEMNUL (A, B)
Practic, transferă semnul lui B către A.
141
Fortran
Exemplu
program numericFunctions
implicit nici unul
! definiți constante
real :: a, b
complex :: z
! valorile pentru a, b
a = 15,2345
b = -20,7689
scrie (*),*) „abs(a): „,abs(a),” abs(b): „,abs(b)
scrie(*,*) 'aint(a): ',aint(a),' aint(b): ',aint(b)
scrie (*),*) „plafon(a): „,plafon(a),” plafon(b): „,plafon(b)
scrie (*),*) 'etaj (a): ',etaj (a),' etaj (b): ',etaj (b)
z = cmplx(a, b)
scrie(*,*) 'z: ',z
finalul programului numericFunctions
abs(a): 15,2344999 abs(b): 20,7688999 aint(a): 15,0000000
aint(b): -20,0000000
plafon(a): 16 plafon(b): -20
etaj(a): 15 etaj(b): -21
z: (15,2344999, -20,7688999)
142
Fortran
Funcții matematice
Func ie Descriere
ACOS (X) Returnează cosinusul invers în intervalul (0, π), în radiani.
ASIN (X) Returnează sinusul invers în intervalul (-π/2, π/2), în radiani.
ATAN (X) Returnează tangenta inversă în intervalul (-π/2, π/2), în radiani.
ATAN2 (Y, X) Returnează tangenta inversă în interval (-π, π), în radiani.
COS (X) Returnează cosinusul argumentului în radiani.
COSH (X) Returnează cosinusul hiperbolic al argumentului în radiani.
EXP (X) Returnează valoarea exponențială a lui X.
Jurnal (X) Returnează valoarea logaritmică naturală a lui X.
LOG10 (X) Returnează valoarea logaritmică comună (bază 10) a lui X.
PĂCAT (X) Returnează sinusul argumentului în radiani.
SINH (X) Returnează sinusul hiperbolic al argumentului în radiani.
SQRT (X) Returnează rădăcina pătrată a lui X.
TAN (X) Returnează tangenta argumentului în radiani.
TANH (X) Returnează tangenta hiperbolică a argumentului în radiani.
143
Fortran
Exemplu
Următorul program calculează poziția orizontală și verticală x și respectiv y a unui proiectil după un timp, t:
Unde, x = ut cos a și y = ut sin a - g t2 / 2
program projectileMotion
implicit nici unul
! definiți constante
real, parametru :: g = 9,8
!defini variabile
real :: a, t, u, x, y
!valori pentru a, t și u
a = 45,0
t = 20,0
u = 10,0
! converti unghiul în radiani
a=a * pi / 180,0
x=u * cos(a) * t
y=u * sin(a) * t - 0,5 * g *t*t
scrie(*,*) 'x: ',x,' y: ',y
termina programul proiectileMotion
x: 141,421356 y: -1818,57861
144
Fortran
Funcții de interogare numerică

Aceste funcții funcționează cu un anumit model de aritmetică cu numere întregi și virgulă mobilă. Funcțiile
returnează proprietăți ale numerelor de același fel ca și variabila X, care pot fi reale și, în unele cazuri, întregi.
Func ie Descriere
CIFRE (X) Returnează numărul de cifre semnificative ale modelului.
EPSILON (X) Returnează numărul care este aproape neglijabil în comparație cu unul.
Cu alte cuvinte, returnează cea mai mică valoare, astfel încât REAL( 1.0, KIND(X)) +
EPSILON(X) nu este egal cu REAL( 1.0, KIND(X)).
URIAȘĂ (X) Returnează cel mai mare număr al modelului
MAXEXPONENT (X) Returnează exponentul maxim al modelului
MINEXPONENT (X) Returnează exponentul minim al modelului
PRECIZIE (X) Returnează precizia zecimală
RADIX (X) Returnează baza modelului
INTERVAL (X) Returnează intervalul exponentului zecimal
MICĂ (X) Returnează cel mai mic număr pozitiv al modelului
Funcții de manipulare în virgulă mobilă
Func ie Descriere
EXPONENT (X) Returnează partea exponentă a unui număr de model
FRACTIE (X) Returnează partea fracționară a unui număr
CEL MAI APROPIAT (X, S) Acesta returnează cel mai apropiat număr de procesor diferit în direcția
dată
145
Fortran
RRSPATING (X) Returnează reciproca distanței relative a numerelor de model în apropierea

numărului dat
SCALA (X, I) Înmulțește un real cu baza sa la o putere întreagă
SET_EXPONENT (X, I) returnează partea exponentă a unui număr
SPAȚIE (X) Returnează spațierea absolută a numerelor de model în apropierea

numărului dat
Funcții de manipulare a biților
Func ie Descriere
BIT_SIZE (I) Returnează numărul de biți ai modelului
BTEST (I, POS) Testarea biților
IAND (I, J) ȘI logic
IBCLR (I, POS) Bit clar
IBITS (I, POS, LEN) Extragerea biților
IBSET (I, POS) Set bit
IEOR (I, J) Exclusiv sau
IOR (I, J) SAU inclusiv
ISHFT (I, SHIFT) Schimbarea logica
ISHFTC (I, SHIFT [, SIZE]) Schimbarea circulară
NU EU) Complement logic
146
Fortran
Funcții de caracter
Func ie Descriere
Returnează caracterul I-ul din secvența de cola ionare ASCII.

ACHAR (I)
Reglează șirul rămas prin eliminarea oricăror spații libere de

ADJUSTL (STRING)
început și inserarea spațiilor finale
Reglează șirul corect, eliminând spațiile finale și inserând spații de început.

ADJUSTR (ȘIRĂ)
Returnează caracterul I-ul din secvența de colație specifică mașinii

CHAR (Eu [, BINE])
Returnează poziția caracterului în secvența de colating ASCII.

IACHAR (C)
Returnează poziția caracterului în secvența de colație specifică mașinii

ICHAR (C)
(procesorului).
INDEX (ȘIR, Returnează poziția de pornire cea mai din stânga (cea mai din
SUBȘIR [, ÎNAPOI]) dreapta dacă BACK este .TRUE.) a SUBSTRING în cadrul șirului.
LEN (STRING) Returnează lungimea unui șir.
Returnează lungimea unui șir fără caractere necompletate.

LEN_TRIM (STRING)
LGE (STRING_A, STRING_B) Lexical mai mare decât sau egal
LGT (STRING_A, STRING_B) Lexical mai mare decât
LLE (STRING_A, STRING_B) Lexical mai mic sau egal
LLT (STRING_A, STRING_B) Lexical mai mic decât
REPEAT (ȘIR, NCOPIES) Concatenare repetată
147
Fortran
Returnează indexul celui mai din stânga (cel mai din dreapta dacă
SCANARE (ȘIR, SET [, ÎNAPOI]) BACK este .TRUE.) al șirului de caractere care aparțin lui SET sau 0 dacă
nu aparține niciunul.
TRIM (STRING) Elimină caracterele goale din urmă
VERIFY (ȘIR, SET [, BACK]) Verifică setul de caractere dintr-un șir
Funcții amabile
Func ie Descriere
FEL (X) Returnează valoarea parametrului tip tip.
Returnează un fel de parametru de tip pentru exponentul specificat

SELECTED_INT_KIND (R)
gamă.
SELECTED_REAL_KIND ([P, R])

Valoarea parametrului de tip real, dată de precizie și
gamă
Funcția logică
Func ie Descriere
LOGIC (L [, KIND]) Convertiți între obiecte de tip logic cu parametri de tip diferit
148
22. Fortran Precizie numerică Fortran
Am discutat deja că, în versiunile mai vechi de Fortran, existau două tipuri reale : tipul real implicit și tipul cu precizie
dublă .
Cu toate acestea, Fortran 90/95 oferă mai mult control asupra preciziei tipurilor de date reale și întregi prin tipul
specific.
Atributul Bun
Diferite tipuri de numere sunt stocate diferit în interiorul computerului. Atributul kind vă permite
să specificați modul în care un număr este stocat intern. De exemplu,
real, fel = 2 :: a, b, c
real, fel = 4 :: e, f, g
întreg, fel = 2 :: i, j, k
întreg, fel = 3 :: l, m, n
În declarația de mai sus, variabilele reale e, f și g au mai multă precizie decât variabilele reale a, b și c. Variabilele
întregi l, m și n pot stoca valori mai mari și pot avea mai multe cifre pentru stocare decât variabilele întregi i, j și k.
Deși acest lucru depinde de mașină.
Exemplu
program kindSpecifier
implicit nici unul
real(tip = 4) :: a, b, c
real(tip = 8) :: e, f, g
întreg (tip = 2) :: i, j, k
întreg (tip = 4) :: l, m, n
întreg :: kind_a, kind_i, kind_e, kind_l
fel_a = fel(a)
fel_i = fel(i)
kind_e = fel(e)
fel_l = fel(l)
print *,'default kind for real is', kind_a
print *,'tip implicit pentru int este', kind_i
149
Fortran
print *,'extended kind for real is', kind_e
print *,'tip implicit pentru int este', kind_l
program final kindSpecifier
tipul implicit este real 4
tipul implicit pentru int este 2
tipul extins de fapt este 8
tipul implicit pentru int este 4
Întrebarea mărimii variabilelor

Există o serie de funcții intrinseci care vă permit să interogați dimensiunea numerelor.
De exemplu, funcția intrinsecă bit_size(i) specifică numărul de biți utilizați pentru stocare. Pentru numerele
reale, funcția intrinsecă precizie(x) , returnează numărul de cifre zecimale de precizie, în timp ce funcția
intrinsecă range(x) returnează intervalul zecimal al exponentului.
Exemplu
programul getSize
implicit nici unul
real (tip = 4) :: a
real (tip = 8) :: b
întreg (tip = 2) :: i
întreg (tip = 4) :: j
print *,'precizia real(4) =', precizia(a)
print *,'precizia real(8) =', precizia(b)
print *,'interval de real(4) =', interval (a)
print *,'interval de real(8) =', interval (b)
print *,'exponent maxim al real(4) =' , exponent maxim(a)
150
Fortran
print *,'exponent maxim al real(8) =' , maxexponent(b)
print *,'exponent minim al real(4) =' , minexponent(a)

print *,'exponent minim al real(8) =' , exponent minus(b)
print *,'bits in integer(2) =' , bit_size(i)

print *,'bits in integer(4) =' , bit_size(j)
termina programul getSize
precizia realului(4) = 6
precizia realului(8) = 15
intervalul real(4) = 37
intervalul real(8) = 307
exponent maxim al real(4) = 128
exponent maxim al real(8) = 1024
exponent minim al real(4) = -125
exponent minim al real(8) = -1021
biți în număr întreg (2) = 16
biți în număr întreg (4) = 32
Obținerea valorii amabile

Fortran oferă încă două funcții intrinseci pentru a obține valoarea tip pentru precizia necesară a
numerelor întregi și reale:
• select_int_kind (r)
• felul_real_selectat ([p, r])
Funcția selected_real_kind returnează un număr întreg care este valoarea parametrului tip tip
necesară pentru o precizie zecimală dată p și un interval de exponent zecimal r. Precizia zecimală
este numărul de cifre semnificative, iar intervalul exponentului zecimal specifică cel mai mic și cel mai
mare număr reprezentabil. Intervalul este astfel de la 10-r la 10+r.
De exemplu, selected_real_kind (p = 10, r = 99) returnează valoarea tip necesară pentru o precizie de
10 zecimale și un interval de cel puțin 10-99 până la 10+99.
Exemplu
151
Fortran
programul getKind
implicit nici unul
întreg:: i
i = felul_real_selectat (p = 10, r = 99)
print *,'selected_real_kind (p = 10, r = 99)', i
termina programul getKind
felul_real_selectat (p = 10, r = 99) 8
152
23. Fortran Biblioteci de programe Fortran
Există diverse instrumente și biblioteci Fortran. Unele sunt gratuite, iar altele sunt servicii cu plată.
Iată câteva biblioteci gratuite:
• RANDLIB, generatoare de numere aleatoare și distribuție statistică

• BLAS
• EISPACK
• Ghid GAMS–NIST pentru software-ul matematic disponibil
• Câteva rutine statistice și altele de la NIST
• RUPA
• LINPACK
• MINPACK
• PACHET DE NOI
• Biblioteca de matematică NCAR
• Colecția Netlib de software, lucrări și baze de date matematice.

• ODEPACK
• ODERPACK, un set de rutine pentru clasare și ordonare.
• Expokit pentru calculul exponen ialelor matriceale

• SLATEC
• SPECFUN
• STARPAC
• Biblioteca statistică StatLib

• TOMS
• Sortarea și îmbinarea șirurilor
Următoarele biblioteci nu sunt gratuite:
• Biblioteca numerică NAG Fortran
• Biblioteca IMSL Visual Numerics
• Re ete numerice
153
24. Fortran Stil de programare Fortran
Stilul de programare se referă la respectarea unor reguli în timpul dezvoltării programelor. Aceste bune practici
oferă în programul dvs. valori precum lizibilitatea și lipsa de ambiguitate.
Un program bun ar trebui să aibă următoarele caracteristici:
• Lizibilitatea
• Structura logică adecvată
• Note și comentarii autoexplicative
De exemplu, dacă faci un comentariu ca următorul, nu va fi de mare ajutor:
! buclă de la 1 la 10
face i=1,10
Cu toate acestea, dacă calculați coeficientul binomial și aveți nevoie de această buclă pentru nCr, atunci
un comentariu ca acesta va fi util:
! buclă pentru a calcula nCr
face i=1,10
• Blocuri de cod indentate pentru a clarifica diferitele niveluri de cod.
• Coduri de auto-verificare pentru a se asigura că nu vor exista erori numerice precum împărțirea la zero,
rădăcina pătrată a unui număr real negativ sau logaritmul unui număr real negativ.
• Includerea codurilor care asigură că variabilele nu iau valori ilegale sau în afara intervalului,
adică validarea intrărilor.
• Nu pune cecuri acolo unde ar fi inutil și încetinește execuția.

De exemplu:
real :: x
x = sin(y) + 1,0
dacă (x >= 0,0) atunci
z = sqrt(x)
sfâr itul dacă
• Cod scris clar folosind algoritmi corespunzători.
• Împărțirea expresiilor lungi folosind marcatorul de continuare „&”.
• Crearea de nume de variabile semnificative.
154
25. Fortran Program de depanare Fortran
Un instrument de depanare este folosit pentru a căuta erori în programe.
Un program de depanare parcurge codul și vă permite să examinați valorile din variabile și alte obiecte de date în timpul
execuției programului.
Încarcă codul sursă și ar trebui să rulați programul în depanator.

Depanatorii depanează un program prin:
• stabilirea punctelor de întrerupere,
• Trecerea prin codul sursă,
• Stabilirea punctelor de supraveghere.
Punctele de întrerupere specifică unde trebuie să se oprească programul, în special după o linie critică de cod.
Execuțiile programului după ce variabilele sunt verificate la un punct de întrerupere.
Programele de depanare verifică, de asemenea, codul sursă linie cu linie.
Punctele de supraveghere sunt punctele în care este nevoie să fie verificate valorile unor variabile, în special după o
operație de citire sau scriere.
Debuggerul gdb
Depanatorul gdb, depanatorul GNU vine cu sistemul de operare Linux. Pentru sistemul X Windows, gdb vine cu o interfață
grafică și programul se numește xxgdb.
Următorul tabel oferă câteva comenzi în gdb:
Comanda Scop
pauză Stabilirea unui punct de întrerupere
alerga Începe execuția
cont Continuă execuția
Execută numai următoarea linie a codului sursă, fără a intra în niciun apel de funcție
Următorul
Executați următoarea linie de cod sursă pasând într-o funcție în cazul unui apel de funcție.
Etapa
155
Fortran
Debuggerul dbx
Există un alt depanator, dbx debugger, pentru Linux.
Următorul tabel oferă câteva comenzi în dbx:
Comanda Scop
opri[var] Setează un punct de întrerupere când se modifică valoarea variabilei var.
opriți în [proc] Se oprește execuția atunci când este introdus un proces de procedură
opriți la [linia] Setează un punct de întrerupere la o linie specificată.
alerga Începe execuția.
cont Continuă execuția.
Execută numai următoarea linie a codului sursă, fără a intra în niciun apel de funcție.
Următorul
Executați următoarea linie de cod sursă pasând într-o funcție în cazul unui apel de funcție.
Etapa
156

Learn Fortran (Fortran Tutorial)

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Learn Fortran (Fortran Tutorial)

Încărcat de

Drepturi de autor:

Formate disponibile

Machine Translated by Google

Drepturi de autor și declinare a răspunderii

Copyright 2017 by Tutorials Point (I) Pvt. Ltd.

Despre tutorial ···················································· ····································i

Drepturi de autor și declinare a responsabilității ···················································· ·····························i

Cuprins··············································· ···················································· ·····································ii

1. FORTRAN PREZENTARE GENERALĂ ············································ ···················································· ········· 1

Fapte despre Fortran ···················································· ·································1

2. FORTRAN CONFIGURARE MEDIU ············································· ············································ 2

Configurarea Fortran în Windows ···················································· ··················2

3. FORTRAN SINTAXA DE BAZĂ ············································· ···················································· ····· 4

Un program simplu în Fortran ······································ ···················································· ·····················4

Bazele ···················································· ···················································· ·5

Identificator ···················································· ···············································5

4. FORTRAN TIPURI DE DATE ············································· ···················································· ········ 8

Tipul întregi ···················································· ············································8

Tipul complex ···················································· ······································10

Tipul de caractere ···················································· ·····································11

Tastare implicită ···················································· ·····································11

5. FORTRAN VARIABILE ·············································· ···················································· ······· 12

Declarația variabilei ···················································· ····························12

6. FORTRAN CONSTANTE ·············································· ···················································· ····· 15

Constante numite și literale ···················································· ················15

7. FORTRAN OPERATORI ·············································· ···················································· ····· 17

Operatori aritmetici ···················································· ··························17

Operatori relaționali ···················································· ···························19

Operatori logici ···················································· ·································21

Prioritatea operatorilor în Fortran ······································ ···················································· ···········23

8. FORTRAN DECIZII ·············································· ···················································· ······· 26

Dacă... atunci Construiește ············································ ···················································· ··································27

Dacă... atunci... altfel Construiește···································· ···················································· ··························29

if...else if...else Declarație········································ ···················································· ·····························31

Imbricat dacă se construiește ············································ ···················································· ·······························33

Selectați construcția cazului ···················································· ···························34

Construcție de caz selectată imbricată ···················································· ················37

9. FORTRAN BUCLE········································ ···················································· ··············· 39

Declarații de control al buclei ···················································· ·······················46

Declarație de ciclu ···················································· ···································48

Declarație de oprire ···················································· ····································50

10. FORTRAN NUMERE ·············································· ···················································· ········ 51

Tipul întregi ···················································· ·········································51

Tipul complex ···················································· ·······································53

Intervalul, precizia și dimensiunea numerelor ···················································· 55

Specificatorul de fel ················································· ···················································· ·································57

11. FORTRAN PERSONAJE ·············································· ···················································· ··· 59

Declarație de caracter ················································· ···················································· ··························59

Concatenare de caractere ···················································· ················60

Unele funcții de caractere ···················································· ····················61

Verificarea ordinii lexicale a caracterelor ···················································· ·····64

12. FORTRAN CORZI ·············································· ···················································· ············ 66

Concatenare șiruri de caractere ···················································· ···························67

Extragerea șirurilor secundare············································· ···················································· ···························68

Tăierea șirurilor················································· ···················································· ··································70

Reglarea în stânga și în dreapta a șirurilor de caractere ···················································· ·······70

Căutarea unui subșir într-un șir ············································ ···················································· ·········71

13. FORTRAN MATRII ·············································· ···················································· ············· 73

Declararea matricei ···················································· ···································73

Atribuirea de valori ···················································· ···································74

Unii termeni legați de matrice ···················································· ·····················76

Trecerea de matrice la proceduri ···················································· ·················76

Secțiuni matrice ···················································· ······································79

Funcții intrinseci ale matricei ··············································· ···················································· ······················81

14. FORTRAN MATRICE DINAMICE ············································· ··············································· 99