Fortran - Kratke Upute Za Rad

SVEUČ ILIŠTE U SPLITU, GRAĐEVINSKO-ARHITEKTONSKI FAKULTET UNIVERSITY OF SPLIT, FACULTY OF CIVIL ENGINEERING AND ARCHITECTURE

MB 3149463 Matice hrvatske 15; 21000 Split - HRVATSKA; fax: + 385 (0)21 465 117; tel: + 385 (0)21 303 333

KRATKE OSNOVE RADA S PROGRAMSKIM JEZIKOM FORTRAN

Interni materijali Alen Harapin, ožujak 2009.

Ovi radni materijali nastali su kao pomoć pri jednom kratkom tečaju (radionici) za programski jezik FORTRAN. Ovi materijali nemaju pretenziju davanja uvida u potpune mogućnosti programskog jezika FORTRAN. U tom smislu čitatelji se upućuju u dokumentaciju: Compaq Developer Studia, kao i niz knjiga koje postoje o ovom programskom jeziku. Izrađeni primjeri i objašnjenja vrijede za Compaq Developer Studio, ver 6.6.0. Neki primjeri koji su ovdje navedeni moguće neće raditi pod nekim drugim okruženjem. Također, u materijalima nisu spomenute neke mogućnosti koje posjeduje moderni FORTRAN. Kolege koje se misle ozbiljnije posvetiti programiranju svakako se upućuje na izučavanje modernih programskih rješenja. Također, u ovim materijalima navedeno je niz programskih rješenja koji su „zastarjeli“ i više se ne koriste. Ovo je isključivo iz razloga što Građevinski fakultet u Splitu ima dugu tradiciju programiranja u ovom jeziku s počecima sa standardom FORTRAN IV na računalima PDP i VAX. Dio kôdova s ovih računala još je prisutan u praksi, efikasan je i nema većih problema pri njihovom kompajliranju i linkanju. Autor

Sveučilište u Splitu, Građevinsko-arhitektonski fakultet Katedra za Betonske konstrukcije i Mostove

Kratke osnove rada s programskim jezikom FORTRAN str. 3

Sadržaj stranica

1. UVOD .....................................................................................................................................................5 1.1 O FORTRAN-u ...................................................................................................................................................................... 5

2. Rad u integriranom okruženju: Compaq Developer Studio (ver. 6.6.0)............................................6 2.1 Kreiranje radnog okruženja.................................................................................................................................................... 6 2.2 Kreiranje datoteke s izvornim kodom programa .................................................................................................................... 7 2.3 Kompajliranje, linkanje i izvršavanje programa...................................................................................................................... 8 2.4 Upozorenja i greške............................................................................................................................................................... 8 2.5 Kompatibilnost ..................................................................................................................................................................... 10 2.6 Release i debug mod........................................................................................................................................................... 10 2.7 Traženje grešaka (debugiranje)........................................................................................................................................... 11

3. Tipovi podataka u FORTRANU ..........................................................................................................12 3.1 Pohrana podataka u računalu.............................................................................................................................................. 12 3.2 Osnovni tipovi podataka....................................................................................................................................................... 12

3.2.1 Tip CHARACTER ...................................................................................................................................................... 12 3.2.2 Tip INTEGER ............................................................................................................................................................ 13 3.2.3 Tip REAL ................................................................................................................................................................... 14 3.2.4 Konverzija tipova varijabli .......................................................................................................................................... 14 3.2.5 Tip LOGICAL............................................................................................................................................................. 15 3.2.6 Tip COMPLEX........................................................................................................................................................... 15 3.2.7 Nepromjenjive konstante........................................................................................................................................... 15

3.3 Izvedeni (složeni) tipovi podataka........................................................................................................................................ 16 3.4 Vektori i Matrice (nizovi podataka)....................................................................................................................................... 16

3.4.1 Općenito .................................................................................................................................................................... 16 3.4.2 Agregatne operacije .................................................................................................................................................. 17 3.4.3 Matrični račun............................................................................................................................................................ 17

3.5 Dinamičko zauzimanje memorije (dinamičko alociranje) ..................................................................................................... 17 3.6 Zajedničko memorijsko područje – COMMON blok i MODULE........................................................................................... 18

4. Strukturiranje programa.....................................................................................................................20 4.1 Pravilo o strukturi programa................................................................................................................................................. 20 4.2 Konvencija o imenima varijabli............................................................................................................................................. 20 4.3 Komentari i aliniranje ........................................................................................................................................................... 21

5. Kontrola toka programa .....................................................................................................................22 5.1 Grananje programa.............................................................................................................................................................. 22

5.1.1 Uvjetna naredba grananja: IF.................................................................................................................................... 22 5.1.1.1 Logička IF naredba............................................................................................................................................. 22 5.1.1.2 Blok IF naredba.................................................................................................................................................. 22 5.1.1.3 Arihmetička IF naredba - zastarjeli oblik IF naredbe .......................................................................................... 23

5.1.2 Uvjetna naredba grananja: CASE ............................................................................................................................. 23 5.1.3 Bezuvjetna naredba grananja: GOTO....................................................................................................................... 24

5.2 Petlje.................................................................................................................................................................................... 24 5.2.1 Petlja s kontrolnim parametrom................................................................................................................................. 24 5.2.2 DO-WHILE petlja....................................................................................................................................................... 25 5.2.3 Beskonačna DO petlja............................................................................................................................................... 25

6. Formatirani ispis podataka i rad s datotekama................................................................................25 6.1 Općenito .............................................................................................................................................................................. 25 6.2 Naredba FORMAT............................................................................................................................................................... 26

6.2.1 Ispis cijelih brojeva .................................................................................................................................................... 26 6.2.2 Ispis logičkih varijabli ................................................................................................................................................. 27 6.2.3 Ispis niza znakova ..................................................................................................................................................... 27 6.2.4 Ispis realnih varijabli .................................................................................................................................................. 27 6.2.5 Posebni znakovi pri formatiranju ispisa ..................................................................................................................... 28 6.2.6 Ostale korisne napomene pri formatiranju ispisa ...................................................................................................... 28



6.3 Naredbe OPEN i CLOSE .....................................................................................................................................................28 6.4 Naredbe WRITE i READ ......................................................................................................................................................29 6.5 Ostale naredbe za upis i ispis ..............................................................................................................................................30 6.6 Pisanje u niz znakova i čitanje iz niza znakova....................................................................................................................31

7. Funkcije i Subrutine............................................................................................................................32 7.1 Općenito...............................................................................................................................................................................32 7.2 Funkcije (FUNCTIONS) .......................................................................................................................................................32 7.3 Subrutine (SUBROUTINE)...................................................................................................................................................33 7.4 O načinu razmjene varijabli ..................................................................................................................................................33

8. PRIMJER – Programsko rješenje: Ravninski štapni sustavi ...........................................................38 8.1 Teorijske postavke ...............................................................................................................................................................38

8.1.1 Jednadžba ravnoteže.................................................................................................................................................38 8.1.2 Diskretizacija sustava i bazne funkcije.......................................................................................................................38 8.1.3 Formulacija principom virtualnog rada.......................................................................................................................39 8.1.4 Otpuštanje veza na rubovima elemenata ..................................................................................................................39 8.1.5 Ravnoteža globalnog sustava....................................................................................................................................39

8.2 Kreiranje novog projekta ......................................................................................................................................................40 8.3 Tok programa.......................................................................................................................................................................41 8.4 Osnovne (globalne) varijable................................................................................................................................................42 8.5 Učitavanje ulaznih podataka iz datoteke – Subroutine INPUT() ..........................................................................................44



1. UVOD 1.1 O FORTRAN-u Fortran (FORmula TRANslation) je najstariji tzv. viši programski jezik. Sintaksa je vremenom mijenjana i propisana je nizom standarda, koji su donošeni u razmacima od 10 ili više godina. Poznati standardi su: fortran II (1958.) fortran IV (1961.), fortran66 (1966.), fortran77 (1977.), fortran90 (1990.), fortran95 (1995.), … Velika razlika u sintaksi nastaje između Fortrana77 i Fortrana90.

Različiti standardi se obično razlikuju prema nastavku (eksenziji) imena datoteke, pa tako nastavke ’.f90’ imaju datoteke koje sadrže izvorni kod u Fortranu-90, a nastavke ’.for’ ili ’.f’ imaju datoteke koje sadrže izvorni kod u Fortranu-77 ili ranijim verzijama.

Kako je naglašeno, osnovna razlika Fortranskih standarda je u sintaksi zapisa, pa tako Fortran 77 (i niže) koristi fiksni format zapisa programa sa sljedećim ograničenjima:

− U jednoj liniji smije biti samo jedna naredba; − Mjesta 1-5 u retku se koriste za labele; − Popunjeno 6. mjesto indicira da je linija nastavak fortranske naredbe iz prethodne linije; − Mjesta 7-72 rezervirana za pisanje fortranskih naredbi; − Preko 72 mjesta je zabranjeno pisati.

Razlika od Fortrana 90 prema novijim verzijama je sljedeća: − Mjesta 1-6 nisu rezervirana; − Naredba u liniji može biti vrlo dugačka; − Nastavljanje naredbe u sljedeći red vrši se s ampersand-om (&) na kraju; − Na istoj liniji može biti više naredbi, a međusobno su razdvojene s točka-zarezom (;); − Posjeduje naredbe za rad s vektorima i matricama; − Dinamičko rezerviranje memorije (velike matrice i vektori).

PRIMJER: FORTRAN77 c234567890123456789012345678901234567890 c komentar c234567890123456789012345678901234567890 Program hello write (*,*) ’Pozdrav i mir cijelom & svijetu’ goto 100 print *,’ovo nece biti ispisano’ 100 continue end program

PRIMJER: FORTRAN90 Program hello write (*,*) ’Pozdrav i mir cijelom & svijetu’ write (*,*) ’svim bicima’ ; write (*,*) ’u svemiru i okolici !’ End program

Fortran 90 prepoznaje kôd pisan u Fortranu 77 ili ranijim verzijama i uredno ih kompajlira i linka. Sitne nekompatibilne razlike kompajler prijavi i lako ih je ispraviti i doraditi. Obrnuti slučaj ne vrijedi.



2. Rad u integriranom okruženju: Compaq Developer Studio (ver. 6.6.0) 2.1 Kreiranje radnog okruženja Developer studio pokreće se kao i svaka druga Windows aplikacija. Nakon pokretanja pojavljuje se inicijalni ekran. Svaka aplikacija koja se razvija putem ovoga okruženja mora biti integrirana u Radno okruženje (Workspace). Stvaranje novog okruženja vrši se izborom sa Menija: File New

Nakon pokretanja ove opcije pojavljuje se novi prozor u kojem je moguće odabrati tip aplikacije koju mislimo razvijati.

Tip akplikacije može biti: Konzolna aplikacija (standardni DOS program), Windows aplikacija, Statička biblioteka, Dinamička biblioteka (Dynamic Link Library) i sl.

Upisivanjem imena projekta (npr. Program1) i izbora lokacije gdje će se taj program nalaziti kreiramo novo Radni okruženje (Workspace).

Radno okruženje je još uvijek prazno. Sad je potrebno kreirati datoteku s izvornim kodom programa.

Prozor s izborom tipa aplikacije

Prozor s imenom budućeg projekta

Lokacija budućeg projekta NAPOMENA: Prilikom upisa imena projekta automatski se stvara poddirektorij s istim imenom



2.2 Kreiranje datoteke s izvornim kodom programa Kreiranje datoteke s izvornim kodom programa vrši se također preko Menija, opcijama: File New

Nakon izbora ove opcije, datoteka „Prog1.for“ se pojavljuje u središnjem dijelu ekrana, a s lijeve strane je vidljivo da je i dodana projektu.

Ako je datoteka s izvornim kôdom ranije kreirana, moguće ju je pridružiti programu desnim klikom miša dok se kursor nalazi u statusnom prozoru nad labelom „Source files“. Tada se otvara dodatni prozor u kojem je potrebno odabrati opciju: „Add files to folder…“. Odabirom ove opcije otvara se standardni prozor za izbor datoteke. Dobra praksa je sve datoteke s izvornim kôdom držati u istom direktoriju (folder-u).

Prozor s izborom tipa datoteke

Tekući projekt NAPOMENA: Ako je check-irano: „Add to project“, datoteka se automatski dodaje projektu

Ime datoteke NAPOMENA: Ako je izabrano: „Fortran fixed format source file“, automatske se dodaje nastavak: „.for“.

Središnji dio ekrana – radni prozor – s datotekom „Prog1.for“ u kojoj se ispisuje izvorni kôd programa. NAPOMENA: Datoteke s nastavkom „.for“ ili „.f“ spremne su za fortranski fiksni zapis. To je vidljivo i po zelenoj oznaci u 6. stupcu – stupcu za nastavak.

Statusni prozor u kojem se nalaze podaci o projektu.

Prozor za poruke o greškama prilikom kompajliranja i linkanja. NAPOMENA: Prilikom kodiranja (pisanja izvornog koda) dok nije potreban, može se sakriti klikom na tipku „Esc“.



2.3 Kompajliranje, linkanje i izvršavanje programa Kompajliranje (eng. Compile – prevesti), kako sama riječ kaže, predstavlja prevođenje izvornog kôda (koji je napisan ljudima koliko-toliko razumljivim jezikom) na jezik računala – strojni jezik.

Linkanje (eng. Link – povezati) predstavlja povezivanje svih (kompajliranih) programskih modula (različitih datoteka) u jedan jedinstven program. Naime, sam projekt se može sastojati, kako će kasnije biti pokazano, od više datoteka s izvornim kôdom. Svaku je moguće kompajlirati zasebno, a linkanjem se sve one povezuju u jedinstvenu cjelinu – Izvršni program (nastavak .exe).

Kompajliranje svake pojedine datoteke s izvornim kôdom može se izvesti odabirom opcije: Build Compile (Ctrl+F7). Jednostavniji način za formiranje izvršne (exe) datoteke, je izbor opcije: Build Build (F7).

Ako kompajler i linker nisu našli (sintaktičke) greške u izvornom kodu, što će biti prikazano u prozoru za poruke, program je spreman za startanje. Izvršavanje programa se provodi opcijom: Build Execute (Ctrl+F5). Rezultat izvršenja programa biti će prikazan u posebnom (DOS) prozoru.

Ako se izabere opcija: Build Execute (Ctrl+F5), prije kompajliranja i linkanja, program će se prvo prekompajlirati i linkati, a zatim i izvršiti.

2.4 Upozorenja i greške Nakon kompajliranja i linkanja u donjem prozoru se pojavljuje izvještaj.Ako je sve u redu, tada izvještaj glasi: Program1.exe - 0 error(s), 0 warning(s)

Ako su prilikom kompajliranja ili linkanja pronađene greške, tada se u istom prozoru pojavljuje poruka o greškama. Kompajlerske greške su najčešće greške sintakse. Dvostrukim klikom na izvještaj o grešci vraćamo se u glavni prozor, a s lijeve strane prozora se pojavljuje mala plava strelica koja upućuje na liniju u kojoj se greška nalazi.



Npr. u kôdu u nastavku greškom je u četvrtom retku umjesto nule (DO I=1,100) upisano veliko slovo O (DO I=1.10O). PROGRAM ZBRAJANJE INTEGER ZBROJ ZBROJ=0 DO I=1,10O ZBROJ=ZBROJ+I ENDDO PRINT *,' Zbroj : ',ZBROJ END

Prilikom kompajliranja, kompajler javlja poruku o grešci. Dvostruki klik na tu poruku vraća nas u glavni prozor točno na četvrtu liniju.

No pogledajmo sljedeći primjer. U kôdu u nastavku, greškom je u četvrtom retku umjesto zareza (DO I=1,100) upisana točka (DO I=1.100). PROGRAM ZBRAJANJE INTEGER ZBROJ ZBROJ=0 DO I=1.100 ZBROJ=ZBROJ+I ENDDO PRINT *,' Zbroj : ',ZBROJ END

Greška koju kompajler generira ukazuje na 6. redak, a ne na redak gdje mi prividno smatramo da se greška dogodila. U stvarnosti kompajler, zbog točke, nije registrirao da se pojavila (DO) naredba, te se buni na pojavu (ENDDO) naredbe bez prethodne (DO) ili (DO WHILE).

Kod izvještaja kompajliranja/linkanja potrebno je strogo razlikovati greške (errors) od upozorenja (warnings). Kada se pojave greške kompajler/linker neće izraditi izvršnu (.exe) verziju i program se neće moći startati. Potrebno je tada ispraviti sve greške i ponovo prekompajlirati/linkati progam.

Upozorenje (warning) samo napominje programeru da je nešto sumnjivo u programu, ali će izraditi (.exe) verziju koja s može startati. Najčešće i upozorenja predstavljaju nelogičnosti u programu i potrebno im je posvetiti dužnu pažnju.



2.5 Kompatibilnost Izvršni (.exe) program nalazi se u podfolderu: Debug, foldera kojeg smo kreirali kao folder projekta. Taj izvršni program moguće je kopirati na CD, Memory stick ili slično i prebaciti na drugo računalo koje radi na istoj platformi (DOS-DOS, Windows XP-Windows XP…). Nije moguće (bar ne u svim slučajevima) prijenos izvršnog programa između platformi (npr. izvršni program kreiran u Windows XP okružju prebaciti na klaster računalo koje radi pod Linux-om).

Međutim, kako je ranije naglašeno, moguće je prenijeti izvorni kôd programa te ga ponovno prekompajlirati. Podrazumijeva se, naravno, da postoji instaliran kompajler/linker na tom drugom računalu.

2.6 Release i debug mod Izvršni (.exe) program napravljen je u tzv. Debug modu. Ovaj mod omogućava olakšano debugiranje (eng.: debugging) tj. ispravljanje pogrešaka u kôdu. Kada je program u potpunosti gotov tada je moguće prijeći na tzv. Release mod. Ovaj mod isključuje dodatne informacije u izvršnoj verziji (.exe) te stoga ima znatno manje bytova, tj. ostaje više memorije za neposredni rad. Prijelaz iz jednog u drugi mod vrši se odabirom opcija: Build Set Active Configuration… Ne preporuča se prijelaz u Release mod sve dok se program u potpunosti „očisti“ od svih grešaka (bug-ova). Kod manjih programa ovaj prijelaz nije ni potreban.

Kôd u nastavku pokazuje primjer standardne greške koju kompajler ne dojavljuje: drugi korijen iz negativnog broja. PROGRAM KORIJEN REAL A, B A=-10. B=SQRT(A) PRINT *,' Korijen iz: ',A,' je : ',B END

Kompajler/linker će uredno napraviti izvršni file, no prilikom izvršenja programa dolazi do greške (vidjeti sliku). Iako naizgled nije bitna razlika u izvještaju, razlika jest bitna. U oba slučaja javlja se tip greške: sqrt: DOMAIN Error (Kvadratni korijen – Greška u domeni), u prvom slučaju kompajler nam točno javlja liniju gdje je ta greška nastala, dok u drugom slučaju toga nemamo.



Program u Debug modu:

Program u Release modu:

2.7 Traženje grešaka (debugiranje) Ovdje pod pojmom traženja grešaka ne mislimo na greške koje prijavljuje kompajler (iako ponekad i takve greške treba debugirati), već na suštinske greške koje nastaju tokom izvršenja programa i pri kojima program uredno radi ali daje krive rezultate. U nastavku će se spomenuti samo tehnika traženja grešaka dok će više riječi o tome biti kroz primjer.

Kada je program kompajliran/linkan u Debug modu (i samo u Debug modu) tada je moguće program izvršavati liniju po liniju. Ovo se postiže odabirom opcije: Build Start Debug Go (F5). Tehnike upravljanja procesom Debugiranja sortirane su u tablici s kratkim objašnjenjem ikone.

Ikona Hint Namjena

Restart Prekida program, ponovno kompajlira i linka i ponovno pokreće program

Stop debugging Prestanak debugiranja – prekida program i vraća se u glavni prozor s kodom

Step Into Ako je trenutna linija izvršenja programa poziv subrutine ili funkcije program ulazi u nju i zaustavlja se na prvoj izvršnoj naredbi unutar subrutine/funkcije.

Step Over Ako je trenutna linija izvršenja programa poziv subrutine ili funkcije program je izvršava i zaustavlja se na sljedećoj liniji nakon poziva.

Step Out Ako je trenutna linija izvršenja programa unutar subrutine ili funkcije program je izvršava do kraja, izlazi iz nje i zaustavlja se na sljedećoj liniji nakon poziva.

Run to Cursor Program se izvršava sve do trenutne pozicije kursora. U slučaju da naiđe na Prekidnu točku (Brek Point) zaustavlja se na njoj.

Execute Program Startanje programa. Ovim se starta program u izvršnom modu.

Go Startanje programa. Ovim se starta program u debug modu. Program se izvršava do prve Prekidne točke (Brek Point). Ako na nju ne naiđe onda se izvršava do kraja (isti efekt kao i opcije: Execute Program).

Remove All Breakpoints Uklanjanje svih Prekidnih Točaka (Brekpoints). Sve točke se brišu u svim datotekama koji pripadaju trenutno aktivnom projektu.

Insert/Remove Breakpoints

Postavljanje ili uklanjanje Prekidnih Točaka (Brekpoints). Točka se postavlja u liniji na mjestu kursora. Puni crveni krug u sivoj traci skroz lijevo u glavnom prozoru ukazuje da je u toj liniji postavljena prekidna točka . Ako u toj liniji postoji već Breakpoint tada se uklanja. Breakpoint se može postaviti samo na izvršnim linijima, ne može npr. na liniji komentara.

Nakon postavljanja Prekidnih točaka i startanja programa naredbom Go, Prozor u dnu ekrana se mijenja. U lijevom dijelu otvara se prozor sa svim varijablama, a u desnom tzv. Watch prozor u kojem se mogu pratiti željene varijable. Klikom u Watch prozor i upisom imena pojedine varijable moguće je dobiti njenu trenutnu vrijednost.

Prozor u kojem su nabrojane sve varijable Watch prozor



3. Tipovi podataka u FORTRANU 3.1 Pohrana podataka u računalu Podaci se u računalu spremaju na memorijske lokacije u vidu bitova. Bit (eng. bit – komadić, mali dio; oznaka: b) je najmanja jedinica za pohranu podataka i može imati samo dvije vrijednosti: aktivno ili neaktivno, što se obično označava brojevima 0 i 1. Osam bitova sačinjavaju 1 bajt (byte, oznaka: B). Veće jedinice su:

− Kilo bajt (Kilo Byte) 1 KB = 1024 byte (210 B) − Mega bajt (Mega Byte) 1 MB = 1024 KB = 1 048 576 B (220 B) − Giga bajt (Giga Byte) 1 GB = 1024 MB = 1 048 576 KB = 1 073 741 824 B (230 B) − Itd.;

Računalno zapisanom podatku obično se može pristupiti samo na nivou bajta (by), a ne na nivou bita. Dakle, prilikom pisanja ili čitanja podataka može se zapisati ili pročitati samo puni bajt ili više njih (2, 4, 8…). Kada treba izdvojiti vrijednost nekog bita, onda se to radi tako da se izdvaja bit unutar skupine bytova koja se nalazi na toj i toj memorijskoj adresi u računalu.

U Fortranskom programu obično se definiraju imena varijabli, funkcija, procedura, programa… Imena mogu sadržavati: − Slova a-z, A-Z. Nema razlike između velikih i malih slova; − podvučenu crtu (underscore): _; − brojke: 0-9.

Imena moraju početi slovom (a-z, A-Z). Dužina imena je obično ograničena na 31 znak (ograničenja kompajlera). Ime varijable ne smije biti ključna riječ, dakle ime ne smije biti: DO, IF, PROGRAM i sl. Ime varijable ne smije biti niti bibliotečna funkcija (npr. SIN).

Na računalu nije moguće prikazati brojeve (cijele, realne) na način kako ih se u matematici definira. Realni brojevi se spremaju s ograničenom točnošću. Niti sve cijele brojeve nije moguće prikazati, jer jako veliki cijeli brojevi također traže veliki memorijski prostor. Stoga na računalima postoji i ograničenje na veličinu brojeva.

3.2 Osnovni tipovi podataka Osnovni tipovi varijabli u FORTRANU su, kao uostalom i u većini drugih programskih jezika:

− Karakterna varijabla (CHARACTER); − Cjelobrojna varijabla – cijeli broj (INTEGER); − Logička varijabla (LOGICAL); − Realna varijabla – realni broj (REAL); − Kompleksna varijabla – kompleksni broj (COMPLEX);

3.2.1 Tip CHARACTER Varijabla tipa CHARACTER zauzima 1 byte memorije i obično služi za prikaz znakova (slova, brojki, specijalnih znakova i sl.). Varijabla CHARACTER vezana je za tzv. ASCII cod. ASCII: American Standard Code for Information Interchange tj. Američki standardni znakovnik za razmjenu informacija, prvi put je objavljen 1967., a dorađen je 1986. U kasnijoj inačici definira kodove za 33 većinom zastarjela kontrolna znaka koji djeluju na način ispisa teksta, te 95 znakova za ispis teksta (počevši znakom razmaka) (33+95=128). Godine 1972. standard ISO-646 je definirao način prilagođavanja nacionalnim abecedama, pa je tako inačica za hrvatsku abecedu danas poznata pod popularnim nazivom CROSCII.

ASCII za kodiranje znakova koristi samo 7 bita (1. bit je kontrolni), ali se na njemu temelji i većina modernih znakovnika koji imaju veći raspon znakova od engleske abecede kao što su 8-bitni CP437, CP852, Windows-1250 i Windows-1252, te 16-bitni i 32-bitni Unicode.

ASCII tablica: 01234567890123456789 ------------------------------- 30 OO !"#$%&’()*+,-./01 50 23456789:;<=>? @ABCD 70 EFGHIJKLMNOPQRSTUVWX 90 YZ[\]ˆ_‘abcdefghijkl 110 mnopqrstuvwxyz{|}~OO



Definiranje karakterne varijable vrši se naredbom CHARACTER. Pridjeljivanje znakovne vrijednosti karakternoj varijabli vrši se na način da se željeni znak stavi u jednostruke navodnike.

PRIMJER: Program hello CHARACTER a a=’a’ print *,’ Varijabla a = ’,a end

Matrica karakternih varijabli predstavlja string. Važno je imati na umu da dužina pridijeljenog teksta ne prijeđe broj rezerviranih znakovnih mjesta. O stringovima će biti riječi kasnije. Program hello CHARACTER a(20) ! Stari način deklaracije stringa CHARACTER (len=20) :: a ! Novi način deklaracije stringa

3.2.2 Tip INTEGER Varijabla tipa INTEGER predstavlja cjelobrojnu varijablu. Deklaracija ove varijable je sljedeća: INTEGER*1 i ! Stari način INTEGER*2 i INTEGER*4 i ...... INTEGER (KIND=1):: i ! Novi način INTEGER (KIND=2):: j INTEGER (KIND=4):: k INTEGER (KIND=8):: l INTEGER :: m ! ako KIND nije specificiran ! onda je (najčešće) KIND = 4

Riječ KIND, tj. broj iza zvjezdice (kod starog načina) određuje broj byte-ova koji se rezerviraju za varijablu. Ali taj broj ne može biti proizvoljan nego su moguće vrijednosti zadane kompajlerom i hardware-om računala. Maksimalni cijeli broj koji je moguće pohraniti u računalu direktno je ovisan o broju rezerviranih bytova. Pa tako:

INTEGER (KIND=1) : -128 do +127 INTEGER (KIND=2) : -32768 do +32767 INTEGER (KIND=4) : -2147483648 do +2147483647 INTEGER (KIND=8) : -9223372036854775808 do +9223372036854775807

Prvi bit u bajtu služi za prikaz predznaka (0: +; 1: -), a ostali za prikaz broja. Tako npr. Binarni Heksadecimalni Decimalni Binarni Heksadecimalni Decimalni

00000000 01000001 01111111 10000000 10000001 11111111

00 41 7F 80 81 FF

0 65

127 -128 -127

-1

00000000 00000000 00000000 10000000 00000001 00000000 01000000 00000000 10000000 00000001 11111111 11111111

00 00 00 80 01 00 06 00 80 01 FF FF

0 128 256

16384 -32768

-1 Binarni Heksadec. Decimalni Binarni Heksadec. Decimalni Binarni Heksadec. Decimalni

0000 0001 0010 0011 0100

0 1 2 3 4

0 1 2 3 4

0101 0110 0111 1000 1001

5 6 7 8 9

5 6 7 8 9

1010 1011 1100 1101 1110 1111

A B C D E F

10 11 12 13 14 15

( ) ( ) 103112141801603216412121212020212101100111 0123456 =⋅+⋅+⋅+⋅+⋅+⋅+⋅+=⋅+⋅+⋅+⋅+⋅+⋅+⋅+=

Compaq Developer Studio podržava cjelobrojne vrijednosti (INTEGER) od 2 ili 4 byte-a.

Eksplicitno napisani cijeli broj, string ili realni broj u programu zovemo konstantom.



3.2.3 Tip REAL Varijabla tipa REAL predstavlja realnu varijablu ili konstantu. Deklaracija ove varijable je sljedeća: REAL*4 a ! Stari način REAL*8 a ...... REAL (KIND=4):: a ! Novi način REAL (KIND=8):: a REAL (KIND=16):: a REAL :: m ! ako KIND nije specificiran ! onda je (najčešće) KIND = 4

Riječ KIND, tj. broj iza zvjezdice (kod starog načina), kao i kod cjelobrojnih varijabli, određuje broj byte-ova koji se rezerviraju za varijablu. Taj broj, također, ne može biti proizvoljan nego su moguće vrijednosti zadane kompajlerom i hardware-om računala. Preciznost (KIND=16) podržava samo mali broj prevoditelja, ne i Compaq Developer Studio.

Stari način definiranja realne varijable s povećanom preciznošću (REAL*8 a) je: DOUBLE PRECISION a

Treba imati na umu da realni brojevi na računalu nisu realni brojevi koji postoje u matematici. U matematici realni brojevi čine kontinuum. Za svaka dva, proizvoljno bliska, realna broja postoji realni broj koji se nalazi između njih. Dapače, između njih se nalazi beskonačno mnogo realnih brojeva. Na računalu to nije tako. To je zbog toga što na računalu prikazujemo realni broj s konačnim brojem byte-ova. Tipično koristi se 4 ili 8 byte-ova. Između realnih brojeva na računalu postoji razmak, a između dva susjedna NEMA drugih realnih brojeva. Ovaj je razmak ujedno numerička greška koju činimo prikazujući neki pravi realni broj (u principu s beskonačnim brojem decimala) pomoću konačnog broja byte-ova na računalu.

Stoga, numeričke operacije s realnim brojevima na računalu pate od grešaka. Te greške se ponekad mogu akumulirati, i tako dovesti do velikih nepredvidivih grešaka u konačnom rezultatu.

Računalo realni broj sprema na sljedeći način: − Od ukupnog broja bitova, jedan bit (onaj najviši) se koristi za oznaku predznaka. Ako je on jednak ’1’, radi se o negativnom

broju. − Jedan broj bitova se koristi za binarni prikaz eksponenta. − Ostatak služi za prikaz decimala.

Broj bitova namjenjen za prikaz eksponenta i za broj decimala standardiziran je. Postoje ovi standardi:

Jednostruka preciznost. Ukupno se koriste 32 bita (4 byte-a): − 1 bit - predznak − 24 bita - frakcija (decimale) (jedan bit je implicitan) – mogu se zapisati − 8 bita - eksponent (jedan bit za predznak eksponenta)

Dvostruka preciznost. Ukupno se koriste 64 bita (8 byte-a): − 1 bit - predznak − 53 bita - frakcija (decimale) (jedan bit je implicitan) − 11 bita - eksponent (jedan bit za predznak eksponenta)

Za označavanje ekponenta realne konstante u jednostrukoj preciznosti koristimo slovo E (npr. 1.0E-5). Za označavanje ekponenta realne konstante u dvostrukoj preciznosti koristimo slovo D (npr. 1.0D+50).

Operacije koje se mogu provoditi nad realnim brojevima su standardne matematičke operacije: zbrajanje (+), množenje (*), oduzimanje (-), dijeljenje (/) i potenciranje (**). Također je moguće provoditi i operacije pretvaranja:

cijeli broj realni broj INT(a)

i a

REAL(i)

3.2.4 Konverzija tipova varijabli Kod operacija koje sadrže cijele i realne brojeve, cijeli brojevi se automatski konvertiraju u realne, a rezultat se automatski konvertira u tip podatka koji stoji na lijevoj strani znaka jednakosti.

U izrazima koji sadrže samo cijele brojeve i rezultat je cijeli broj koji se potom pretvara u vrst podatka na lijevoj strani znaka jednakosti. Stoga u sljedećem primjeru dobivamo nulu: na desnoj strani izraz sadrži samo cijele brojeve i rezultat je cijeli broj (tj.



nula) koja se potom konvertira u realni broj na lijevoj strani. Ako se u izraz na desnoj strani umiješa realna konstanta, onda se cijeli brojevi prvo pretvaraju u realne, a tek onda se izvode numeričke operacije. PROGRAM konverzija REAL a a = 1/(1 + 1) PRINT *,a ! ispisuje: 0.0000000E+00 a = 1.0/(1 + 1) PRINT *,a ! ispisuje: 0.5000000 END PROGRAM

3.2.5 Tip LOGICAL Logički podaci imaju dvije vrijednosti: istinu ili laž (true or false). Deklaracija logičke varijable vrši se naredbom: LOGICAL a,b

Operacije s logičkim tipovima podataka su: .NOT. a pretvara istinu u laž i obrnuto a .AND. b i (and) – istinito ako su i a i b istiniti a .OR. b ili (or) – istinito ako su a ili b istiniti a .XOR. b ekskluzivni ili – istina ako je samo jedan istinit a. EQV. b istinito ako su oba ista

3.2.6 Tip COMPLEX Fortran je jedan od rijetkih jezika koji ima kompleksni broj kao standardnu varijablu (ostali imaju kao eksterne funkcije). Kompleksni brojevi na računalu se prikazuju par realnih brojeva koji se posebno tretiraju u numeričkim operacijama. Pri tome realni brojevi mogu biti jednostruke ili dvostruke ili preciznosti. COMPLEX (KIND=4) :: c,d,e c = (1.0,-5.3) d = CMPLX(-2.0) ! (-2.0,0.0) e = CMPLX(0.0,1.0) ! (0.0,1.0) d = e*d ! (0.0,-2.0) PRINT *,d

Iz kompleksnog broja možemo izdvojiti realni dio i imaginarni dio s funkcijama REAL i AIMAG, a konjugirani kompleksni broj dobiva se funkcijom CONJG. COMPLEX (KIND=4) :: c REAL (KIND=4) :: a,b c = (1.0,-5.3) a = REAL(c) ; PRINT *,a ! 1.0 b = AIMAG(c); PRINT *,b ! -5.3 d = CONJG(c)

3.2.7 Nepromjenjive konstante Na početku programa moguće je zadati posebnu vrstu podataka koji će za cijelo vrijeme izvođenja programa ostati konstante. Ovi konstantni podaci se zadaju kroz naredbu PARAMETER. Pokušaj promijene vrijednost parametra prevodilac će javiti kao grešku. INTEGER, PARAMETER :: single = KIND(1E0) INTEGER, PARAMETER :: double = KIND(1D0) REAL(single), PARAMETER :: spi = 3.1415927 REAL(double), PARAMETER :: dpi = 3.141592653589793 REAL(double), PARAMETER :: dpi2 = 0.5*dpi CHARACTERS(LEN=4), PARAMETER :: ime =’Pero’



3.3 Izvedeni (složeni) tipovi podataka Složeni tipovi podataka izvode se iz osnovnih tipova podataka. Postoje dva načina definiranja složenih tipova podataka: preko naredbe STRUCTURE – END STRUCTURE i preko naredbe TYPE – END TYPE. Složeni tipovi podataka služe da bi se svi podaci o jednom objektu držali na jednom mjestu. Tako npr. možemo promatrati položaj nekog čvora u prostoru koji je određen s njegove tri kartezijeve koordinate. Pri tome možemo definirati tri polja koji čuvaju podatke o koordinatama ili jedno dvodimenzionalno polje. Npr. REAL COORD_X(Npoin), COORD_Y(Npoin), COORD_Z(Npoin) REAL COORDS(Npoin,3)

Umjesto ovog pristupa možemo koristiti složeni tip podataka, tzv. strukturu ili objekt: TYPE Koordinate REAL x,y,z END TYPE Koordinate TYPE(Koordinate) :: v1,v2 v1%x = 1.0 v1%y = 1.0 v1%z = 1.0 v2 = Koordinate(-1.0,0.0,5.0) PRINT *,v1 ! 1.0 1.0 1.0 PRINT *,v2 ! -1.0 0.0 5.0

STRUCTURE /Koordinate/ REAL x,y,z END STRUCTURE RECORD /Koordinate/ v1,v2 v1.x = 1.0 v1.y = 1.0 v1.z = 1.0 v2 = Koordinate(-1.0,0.0,5.0) PRINT *,v1 ! 1.0 1.0 1.0 PRINT *,v2 ! -1.0 0.0 5.0

U oba slučaja rezultat je identičan.

Izvedeni tipovi podataka mogu se gnijezditi jedan u drugog, pa je tako moguće definirati npr. strukturu trokut koja sadrži strukturu koordinate: PROGRAM Linija STRUCTURE /Koordinate/ ! definira strukturu koordinate REAL x,y,z END STRUCTURE STRUCTURE /Linija/ ! definira strukturu trokut RECORD /Koordinate/ Cvor(2) ! koja u sebi sadrži strukturu Koordinate END STRUCTURE RECORD /Linija/ L1 L1.Cvor(1).x = 1.0 ! pridjeljivanje pojedinačne vrijednosti L1.Cvor(1).y = 0.0 L1.Cvor(1).z = 2.0 L1.Cvor(2) = Koordinate (4.0,5.0,3.0) PRINT *,' Linija od:',L1.Cvor(1),' do: ',L1.Cvor(2) END PROGRAM

3.4 Vektori i Matrice (nizovi podataka) 3.4.1 Općenito Nizovi podataka, tj. Vektori (jednodimenzionalna polja) i Matrice (arrays – višedimenzionalna polja) deklariraju se ako da se nakon tipa i imena navede njihova dimenzionalnost. Npr. sljedeći dio koda rezervira 120 mjesta za spremanje cjelobrojnih varijabli, 120×130 mjesta za spremanje realnih varijabli jednostruke preciznosti i 240 mjesta za spremanje realnih varijabli dvostruke preciznosti. INTEGER a(120) REAL*4 b(120,130) REAL*8 c(240)

U starijim Fortran programima moguće je naći funkciju DIMENSION, koja postiže isti učinak. U sljedećem primjeru naredbom DIMENSION biti će rezervirano 120 mjesta, ali za spremanje realnih varijabli jednostruke preciznosti (Vidi dalje dio: Konvencija o imenima varijabli). Ako je zadana naredba: IMPLICIT NONE, tada će kompajler dojaviti poruku o grešci. DIMENSION a(120)

Prema novoj konvenciji pisanja Fortran programa također se pri deklariranju koristi naredba DIMENSION. Sljedeća sintaksa vrijedi samo za Fortran 90 i više verzije INTEGER, PARAMETER :: n=3 REAL, DIMENSION(n,n) :: a a = 0.0 ! svi a(i,j) = 0.0



a = a + 1 ! svi a(i,j) = 1.0 a = 2*a ! svi a(i,j) = 2.0 a = SQRT(a) ! Vadi korijen iz svih elemenata a = SIN(a) ! Izracunava sinus iz svih elemenata a = a*a ! kvadrira svaki element

Dakle kada se navede samo ime niza (vektora/matrice) umeričke operacije primjenjuju se svakom pojedinom članu niza, a rezultat se sprema u niz na lijevoj strani znaka jednakosti. U Fortranu 77 bilo je potrebno koristiti DO-petlje da bi se postigao isti rezultat.

U Fortranu matrica se u memoriji računala sprema po stupcima tj. po prvom indeksu. REAL, DIMENSION(3,3) :: a

U memoriju se sprema: a(1,1), a(2,1), a(3,1), a(1,2), a(2,2)…. a(3,3)

U strukturi matrice ne postoji poseban podatak koji govori o obliku matrice. Ako se matrica koristi kao jedan od argumenata u pozivu nekoj funkciji ili potprogramu, onda je potrebno dodatno navesti i dimenziju matrice, odnosno njen oblik. Npr. ako je argument matrica 3x3, funkcija (potprogram) ne zna da li je to 9x1, 3x3 ili 1x9 matrica

3.4.2 Agregatne operacije Agregatna operacija = operacija na nizu podataka koja kao rezultat ima jedan broj. Primjer: REAL, DIMENSION(3) :: a = (/ (REAL(i), i=1,3) /) REAL, DIMENSION(3) :: b = (/ (i**2 , i=1,3) /) REAL, DIMENSION(6) :: c = (/ ((i-2)**2,i=1,6) /) PRINT *,’Broj elemenata = ’,SIZE(a) ! 3 PRINT *,’Najveci element = ’,MAXVAL(b) ! 9.0 PRINT *,’Najmanji element = ’,MINVAL(c) ! 0.0 PRINT *,’Suma elemenata = ’,SUM(a) ! 6.0 PRINT *,’Produkt elemenata = ’,PRODUCT(b) ! 36.0 PRINT *,’Skalarni produkt = ’,DOT_PRODUCT(a,b) ! 36.0

3.4.3 Matrični račun Većina kompajlera sadrži i funkcije za operacije s matricama. Pri tome valja biti oprezan (proučiti help) kako koristiti pojedine funkcije.

Funkcija MATMUL množi matricu s matricom u matematičkom smislu, za razliku od operacije množenja (*) koja množi element s elementom.

Funkcija TRANSPOSE kao rezultat ima transponiranu matricu. REAL :: fi = 0.25*3.1415927 REAL, DIMENSION(2) :: a = (/ 1.0, 0.0 /) REAL, DIMENSION(2) :: b REAL, DIMENSION(2,2) :: r r(1,1:2) = (/ COS(fi), SIN(fi) /) r(2,1:2) = (/ -SIN(fi), COS(fi) /) PRINT *,’vektor a = ’,a b = MATMUL(r,a) ! Rotacija za kut pi/4 PRINT *,’vektor R*a = ’,b b = MATMUL(r,b) ! Jos jedna rotacija PRINT *,’vektor R*b = ’,b PRINT *,’R = ’,r r = MATMUL(r,r) ! Matrica rotacije za 2*fi PRINT *,’R*R = ’,r

3.5 Dinamičko zauzimanje memorije (dinamičko alociranje) Ponekad nije moguće unaprijed znati točnu dužinu niza podataka koji će se rabiti u programu, pa se obično rezervira naviše što se misli da će biti potrebno. S druge strane prevelika količina rezervirane memorije može usporiti program jer ona može nadmašiti dostupni RAM na računalu. U tim situacijama je zgodno koristiti mogućnost naknadne rezervacije memorijskog prostora, za trenutak kada je podatak o količini potrebne memorije poznat.

− Nizovi za koje će se memorijski prostor rezervirati naknadno deklariraju se s naznakom ALLOCATABLE. − Memorija se rezervira s naredbom ALLOCATE a oslobađa se s naredbom DEALLOCATE



− Matrica se ne smije rabiti prije rezervacije memorije, a to se može provjeriti naredbom ALLOCATED. − Umjesto brojke u zagradama se upisuje ’:’ (dvotočka).

Primjer programa koji čita sa standardnog unosa (inputa) podatke te izračunava srednju vrijednost i standardnu devijaciju. PROGRAM analiza REAL, ALLOCATABLE::PODACI(:) INTEGER :: n REAL :: aver,sigma PRINT *,’Upisi broj podataka’; READ (*,*) n ALLOCATE (podaci(n)) PRINT *,’Upisi podatke’; READ (*,*) podaci(1:n) aver = SUM(podaci(1:n))/REAL(n) sigma = SQRT(SUM((podaci(1:n)-aver)**2 )/REAL(n-1)) PRINT *,’prosjecna vrijednost = ’,aver PRINT *,’standardna devijacija = ’,sigma DEALLOCATE (podaci) END PROGRAM

3.6 Zajedničko memorijsko područje – COMMON blok i MODULE Programske cjeline (glavni program, potprogrami, funkcije,) mogu imati zajedničke podatke uskladištene u COMMON bloku. Prije Fortrana 90 to je bio jednini način kako je to bilo moguće postići. U Fortranu 90 preferirani način čuvanja zajedničkih podataka su moduli.

Common blok se zadaje s listom (prethodno deklariranih) varijabli koja slijedi iza naredbe COMMON. Između liste varijabli i naredbe COMMON može biti navedeno i ime common bloka zatvoreno između dvije kose crte. Imenovanih common blokova može biti proizvoljno puno, ali samo jedan bez imena.

Common blok je globalni entitet, ne postoje common blokovi koji postoje samo unutar jedne programske cjeline.

Jedna varijabla se ne može pojavljivati u dva različita common bloka.

Varijable u common bloku zauzimaju memoriju računala po redu kako su izlistane.

Varijable u common bloku u različitim programskim jedinicama mogu imati različita imena ali moraju biti istog tipa. Dvije ili više uzastopnih varijabli u common bloku koje su istog tipa mogu u drugoj programskoj jedinici činiti niz. INTEGER A, B, C(100) STRUCTURE /OPIS_CVORA/ INTEGER ICVOR REAL CX, CY END STRUCTURE RECORD /OPIS_CVORA/ CVOR(NNODE) COMMON /GEOM_1/ CVOR, A, B, C

Dinamički alocirana matrica ne može se nalaziti u COMMON bloku.

U Fortranu 90 umjesto common bloka, preferirani način čuvanja zajedničkih podataka između različitih programskih cjelina su Moduli (MODULE - globalne) programske cjeline. Moduli se moraju nalaziti prije početka programa. MODULE zajedno_smo_jaci IMPLICIT NONE INTEGER :: i,j REAL :: a REAL, DIMENSION(5) :: b END MODULE C----------------------- PROGRAM zajednistvo USE zajedno_smo_jaci IMPLICIT NONE i = 1; j = 2 a = SQRT(2.0) b = 0.0 b(3) = 1.0 PRINT *,a,b a = SQRT(3.0) PRINT *,a END PROGRAM



Za razliku od common bloka:

− kod modula nije potrebno ponovo deklarirati tipove varijabli i zadati im imena. Varijable se mogu odmah koristiti s imenima kakva su im zadana u modulu.

− Upotrebu modula potrebno je odmah navesti kao prvu liniju u programskoj cjelini (USE).

− Osim podataka, moduli mogu sadržavati i zajedničke funkcije i/ili potprograme, te definicije novih tipova varijabli.

− Moduli mogu sadržavati nizove naznačene kao ALLOCATABLE koji se inače ne mogu nalaziti u common bloku.

Programske cjeline koje koriste module mogu koristiti druga imena od onih specificiranih u modulu. To se postiže dodatnim argumentima kod USE naredbe, gdje treba navesti: <novo_ime> => <staro_ime>. USE zajednicki_podaci, novo => b

Programske cjeline ne moraju koristiti sve raspoložive podatke iz modula, već samo dio njih izlistan iza naznake ONLY. USE zajednicki_podaci, ONLY : a,b

Varijable, novi tipovi podataka, funkcije i podprogrami mogu se deklarirati javnim ili privatnim. MODULE zajednicki podaci INTEGER, PRIVATE :: i,j REAL, PUBLIC :: a REAL, DIMENSION(5) :: b ! PUBLIC ! END MODULE

Ako podaci nisu eksplicitno naznačeni da su privatni onda su javni. Javni znači dostupni drugim programskim cjelinama koje koriste taj modul. Ako definicija modula započinje s PRIVATE onda su svi podaci po pretpostavci privatni, osim onih koji su eksplicitno naznačeni da su javni. Privatni podaci dostupni su svim funkcijama i potprogramima unutar modula, pa i onima koje su naznačeni kao javni. Uporaba privatnih podataka moguća je posredno kroz javno dostupne funkcije i potprograme.



4. Strukturiranje programa Prilikom pisanja programa u Fortranu potrebno je poštovati neka pravila strukturiranja programa. Neka pravila su stroga i ne smije se odstupiti od njih, dok su druga opcionalna, ali ih je dobro poštivati.

4.1 Pravilo o strukturi programa Fortranska struktura programa je strogo određena. Fortranska struktura zahtijeva sljedeće pravilo pisanja programa:

− Prva linija: Naredbe: PROGRAM, SUBROUTINE ili FUNCTION – početak programa ili potprograma − 1. dio: deklaracija varijabli − 2. dio: samo tijelo programa ili potprograma

Npr. sljedeći kôd je dobro napisan kôd: PROGRAM ZBRAJANJE Ime programa koji slijedi, ujedno oznaka i početka programa INTEGER I, ZBROJ Deklaracija varijabli ZBROJ=0 DO I=1,100 ZBROJ=ZBROJ+I ENDDO PRINT *,' Zbroj : ',ZBROJ

Tijelo programa

END Kraj programa

Sljedeći kôd je loše napisan kôd. Grešku će javiti kompajler i program neće biti kompajliran. PROGRAM ZBRAJANJE Ime programa koji slijedi, ujedno oznaka i početka programa INTEGER ZBROJ ZBROJ=0 INTEGER I

Deklaracija varijabli u koje se umješala jedna izvršna naredba (ZBROJ=0)

DO I=1,100 ZBROJ=ZBROJ+I ENDDO PRINT *,' Zbroj : ',ZBROJ

Tijelo programa

END Kraj programa

4.2 Konvencija o imenima varijabli Jedno od opcionalnih pravila je, npr. pravilo o deklariranju varijabli. Fortran po default-u sve varijable koje započinju slovima I, J, K, L, M i N shvaća kao cjelobrojne varijable (INTEGER), dok su ostale varijable realne (REAL). Varijable ostalih tipova (CHARACTER, LOGICAL, COMPLEX) potrebno je eksplicitno deklarirati.

Dobra praksa (ali ne i pravilo) je da se sve varijable deklariraju. Također dobra praksa je navođenje naredbe: IMPLICIT NONE prije samog deklariranja. Ova naredba zabranjuje upotrebu nedeklarirane varijable (kompajler javlja grešku).

Npr. sljedeći dio koda: PROGRAM ZBRAJANJE IMPLICIT NONE INTEGER I, ZBROJ ZBROJ=0 DO I=1,100 ZBROJ=ZBROJ+I ENDDO PRINT *,' Zbroj : ',ZBROJ END

javiti će grešku jer varijabla (I) nije eksplicitno deklarirana. Bez naredbe (IMPLICIT NONE) program bi se uredno iskompajlirao i izvršio bez greške. U ovom slučaju (ovom jednostavnom programu) naredba (IMPLICIT NONE) čak nije ni potrebna. Međutim u sljedećem slučaju: PROGRAM ZBRAJANJE INTEGER I,ZBROJ DO I=1,100 ZBROJ=ZBROJ+I ENDDO PRINT *,' Zbroj : ',ZBROJ END



Varijabla (ZBROJ) nije deklarirana niti poništena. U četvrtom retku prilikom prvog korištenja uzima se vrijednost varijable (ZBROJ) i dodaje joj se (I). Kompajler će prilikom izvršenja možda javiti upozorenje (warning) ali neće prekinuti prevođenje programa. Program će se izvršiti s nepredvidivim rezultatom1.

Jedna dobra praksa je označavanje imena varijabli nazivima koji opisuju svrhu te varijable. Npr. u prethodno prikazanom kôdu Varijabla ZBROJ označava zbroj svih brojeva (1-100). Potpuno funkcionalan bio bi i sljedeći kôd: PROGRAM ZBRAJANJE INTEGER I,GFCD DO I=1,100 GFCD = GFCD+I ENDDO PRINT *, GFCD END

Ali njegov izlaz (ispis - varijabla GFCD) ne bi u potpunosti bila jasna.

4.3 Komentari i aliniranje Komentari se u fortranu pišu na način da se u prvom stupcu (fiksni format) upiše (tradicionalno) slovo C (comment) ili bilo koje drugo slovo. Kod slobodnog formata u tu svrhu služi uskličnik (!). Uskličnikom se može služiti i kod fiksnog formata kada se komentar želi postaviti u nastavku izvršne linije.

Sav tekst koji slijedi iza biti će ignoriran od kompajlera i služi samo kao podsjetnik programeru

Iako pisanje komentara često predstavlja opterećenje tijekom kodiranja, komentari su vrlo važni dijelovi programa. Oni pojašnjavaju sami program i olakšavaju čitanje i razumijevanje programa, posebno drugim osobama koje nisu taj program kodirale. Pri pisanju komentara valja se ipak ograničiti na osnovne komentare, jer višak komentara može proizvesti suprotan efekt. PROGRAM analiza REAL PODACI(100) INTEGER n REAL aver, sigma PRINT *,’Upisi broj podataka’ READ (*,*) n C*** Ako je N veci od rezervirane dimenzije - prekini IF (n >= 100) GOTO 100 C*** Citanje podataka s ekrana PRINT *,’Upisi podatke’ READ (*,*) podaci(1:n) C*** Izracunaj srednju vrijednost (aver) i stand. Devijaciju (sigma) aver = SUM(podaci(1:n))/REAL(n) sigma = SQRT(SUM((podaci(1:n)-aver)**2 )/REAL(n-1)) PRINT *,’prosjecna vrijednost = ’,aver PRINT *,’standardna devijacija = ’,sigma 100 CONTINUE END PROGRAM

Također je zgodno pri programu zasebne cjeline (npr. DO petlje, deklaraciju varijabli…) uvlačenjem nastojati vizualno odvojiti od samog tijela programa. Takvi programi su vizualno pregledniji i lakše ih je čitati i analizirati

1 U ovom slučaju vjerojatni rezultat će biti točan jer većina kompajlera poništava sve varijable prije korištenja (izjednačava ih s nulom). Međutim, kod velikih programa rezultat je stvarno nepredvidiv.



5. Kontrola toka programa 5.1 Grananje programa Tijekom izvršavanja programa mogu se pojaviti različite situacije koje je potrebno rješavati na različite načine. To se postiže naredbama grananja. Npr. pri izračunu kvadratnog korijena potrebno je ispitati da li je broj pozitivan ili negativan prije samog izračuna korijena, te postupiti prema trenutnoj vrijednosti.

Generalno se naredbe grananja mogu podijeliti na naredbe uvjetnog grananja (IF i CASE) i naredbe bezuvjetnog grananja (GOTO).

5.1.1 Uvjetna naredba grananja: IF 5.1.1.1 Logička IF naredba

U fortranskom programu postoji veći broj različitih vrsta IF naredbi. Logički IF je najjednostavnija IF-naredba, tj. naredba od samo jedne linije. IF (a.LT.0.0) PRINT *,’Imaginarni broj’ ! Stari način

IF (a < 0.0) PRINT *,’Imaginarni broj’ ! Novi način

Karakteristike logičkog IF-a su sljedeće:

− Iza riječi IF slijedi logički izraz zatvoren u okrugle zagrade.

− Vrijednost logičkog izraza je točno ili pogrešno.

− Iza logičkog izraza slijedi naredba koja se izvršava samo ako je logički izraz točan.

− IF nema direktni utjecaj na izvršavanje naredbi koje slijede iza njega.

Kao operatori usporedbe koriste se sljedeći znakovi/izrazi (logički operatori): Fortran 77 i niže verzije Fortran 90 i više verzije Značenje

.EQ.

.NE.

.LT.

.LE.

.GT.

.GE.

A.EQ.B A.NE.B A.LT.B A.LE.B A.GT.B A.GE.B

== <> < <= > >=

A==B A<>B A<B A<=B A>B A>=B

A je jednako BA nije jednako BA je manje od B

A je manje ili jednako BA je veće od B

A je veće ili jednako B

Primjer jednostavnog programa s logičkom IF naredbom: PROGRAM kvadratni_korijen REAL :: a PRINT *,’Upiši neki realni broj’ READ (*,*) a IF (a < 0.0) PRINT *,’Upisan je negativan broj’ IF (a >= 0.0) PRINT *,’Kvadratni korijen je = ’,SQRT(a) END

5.1.1.2 Blok IF naredba

Umjesto logičkog IF-a, moguće se koristiti IF u kombinaciji s THEN. Primjer: IF (a < 0.0) THEN PRINT *,’Imaginarni broj’ ENDIF

IF (logički izraz) THEN započinje blok (skupinu) naredbi koja će se izvršavati samo ako je logički izraz točan, a ENDIF (ili END IF) je oznaka kraja bloka naredbi. Unutar bloka moguće imati ili jednu ili više naredbi. U blok naredbi IF - THEN - ENDIF moguće je ugnjezditi jedan ili više drugih IF - THEN - ENDIF blokova ili logičkih IF-ova.

Prethodni primjer bi se mogao proširiti na sljedeći način: POGRAM kvadratni_korijen REAL :: a PRINT *,’Upiši neki realni broj’ READ (*,*) a IF (a < 0.0) THEN PRINT *,’Negativni broj’



END IF IF (a >= 0.0) THEN IF (INT(SQRT(a))**2 == a) THEN PRINT *,’Upisani broj je kvadrat cijelog broja = ’,INT(SQRT(a)) END IF IF (INT(SQRT(a))**2 /= a) THEN PRINT *,’Kvadratni korijen je = ’,SQRT(a) END IF END IF END

Još složenija forma IF naredbe (IF-THEN-ELSE-ENDIF) sastoji se od dva bloka. Prvi blok naredbi se izvršava ako je logički izraz točan, a drugi ako je logički izraz pogrešan. IF (a >= 0.0) THEN PRINT *,’Kvadratni korijen je = ’,SQRT(a) ELSE PRINT *,’Zadan je negativni broj’ END IF

Svaki blok naredbi (IF-dio i ELSE-dio) mogu sadržavati druge složenije i jednostavnije verzije IF-naredbe.

Prethodni primjer: POGRAM kvadratni_korijen REAL :: a PRINT *,’Upiši neki realni broj’ READ (*,*) a IF (a .GE. 0.0) THEN IF (INT(SQRT(a))**2 .EQ. a) THEN PRINT *,’Upisani broj je kvadrat cijelog broja = ’,INT(SQRT(a)) ELSE PRINT *,’Kvadratni korijen je = ’,SQRT(a) END IF ELSE PRINT *,’Zadan je negativni broj’ END IF END

Postoji i vrlo složena forma IF naredbe koja može provjeravati više različitih logičkih izraza, te izvršavati blok (skupinu) fortranskih naredbi ako je samo jedan od njih točan, te opcionalno ELSE grupu naredbi ako niti jedan od logičkih izraza nije točan. IF (a < 0.0) THEN PRINT *,’Zadan je negativni broj’ ELSE IF ((a > 0.0) .AND. (a < 100.0)) THEN PRINT *,’Kvadratni korijen broja ’,a,’ je ’,SQRT(a) ELSE PRINT *,’Ne znam vaditi korjene brojeva vecih od 100’ END IF

5.1.1.3 Arihmetička IF naredba - zastarjeli oblik IF naredbe

U pojedinim Fortranskim programima može se pronaći zastarjeli oblik IF naredbe, koju nije više upitno koristiti iako je kompajleri još uvijek prepoznavaju. Ovaj oblik naredbe IF naziava se arihmetička IF naredba i ima oblik: IF (a) lab1,lab2,lab3 Ovisno o broju a, koji može biti manji, jednak ili veći od nule izvršavanje programa se nastavlja od lab1 (a<0), lab2 (a=0) ili lab3 (a>0). Prethodni primjer se može napisati u obliku: IF (a) 1,2,2 1 PRINT *,’Zadan je negativni broj’ GOTO 3 2 PRINT *,’Kvadratni korijen broja ’,a,’ je ’,SQRT(a) 3 CONTINUE

5.1.2 Uvjetna naredba grananja: CASE CASE naredba je vrlo slična najsloženijem obliku IF naredbe, s tim da nije nužno da se izračunavaju logički izrazi, već to može biti bilo koji izraz.

U pojedinim slučajevima može se navesti lista vrijednosti odvojena zarezom.



Moguće je navesti područje vrijednosti pomoću dvotočke. Ispred dvotočke stoji početna vrijednost, a iza dvotočke stoji konačna vrijednost intervala. Granice su uključene. Za navođenje polubeskonačnog intervala može se donja ili gornja granica ispustiti.

Vrsta vrijednosti (konstanti) mora odgovarati vrsti izraza koji se navodi u početnoj SELECT liniji CASE naredbe.

Izvršava se jedna ili više naredbi koje se nalaze u bloku koji slijedi iza CASE iskaza ovisno o vrijednosti izraza. PROGRAM izbornik CHARACTER i PRINT *,’Odaberi opciju izbornika’; READ (*,*) i SELECT CASE (i) CASE (’f’,'F'); PRINT *,’Odabrao si opciju: File’ CASE (’e’,'E'); PRINT *,’Odabrao si opciju: Edit’ CASE (’i’,'I'); PRINT *,’Odabrao si opciju: Insert’ CASE (’w’,'W'); PRINT *,’Odabrao si opciju: Window’ ... CASE DEFAULT; PRINT *,’Nema takve opcije!’ END SELECT END PROGRAM

S točka-zarezom odvojene su različite fortranske naredbe na istoj liniji!

5.1.3 Bezuvjetna naredba grananja: GOTO GOTO (ili GO TO) je bezuvjetna naredba grananja. Ima oblik: GOTO lab1 Nakon izvršenja ove naredbe program se nastavlja na labeli lab1. Primjer: Program hello write (*,*) ’Pozdrav i mir cijelom svijetu’ goto 100 print *,’ovo nece biti ispisano’ 100 continue end program

Nakon izvršenja naredbe GOTO program nastavlja radom na naredbi: 100 continue i tekst: ’ovo nece biti ispisano’ stvarno neće biti ispisano.

5.2 Petlje Za višestruko ponavljanje grupe naredbi služimo se petljama. U Fortranu petlja počinje s rječju DO a završava s ENDDO (END DO). Postoji više verzija DO-petlje:

− Petlja s kontrolnim parametrom;

− Petlja DO-WHILE koja se ponavlja dok je neki uvjet zadovoljen;

− Beskonačna petlja.

5.2.1 Petlja s kontrolnim parametrom DO petlja s kontrolnim parametrom (I) ima oblik: DO I = poc,kraj,korak ! tijelo petlje ENDDO

Tijelo petlje se izvršava za svaku vrijednost kontrolnog parametra (I). Vrijednost kontrolnog parametra u prvom izvršavanju je (poc). Pri svakom sljedećem izvršavanju povećava se za (korak), sve dok je vrijednost I<kraj.

Primjer zbrajanja samo parnih brojeva od 1 do 256, pomoću DO petlje može se napisati na način: PROGRAM Zbrajanje INTEGER I, ZBROJ ZBROJ=0 DO I = 2, 256, 2 ZBROJ = ZBROJ + I ENDDO PRINT *,’Zbroj=’,ZBROJ END



Za DO petlju vrijedi: − Ako korak nije naveden onda se podrazumijeva da je on jedan. − Ako je početna vrijednost ve´ca od konačne, a korak je pozitivan petlja se ne izvodi. − Ako je početna vrijednost manja od konačne, a korak je negativan petlja se ne izvodi. − Unutar DO petlje mogu se nalaziti druge DO petlje ali se ne smiju preplitati (svaka unutarnja DO petlja mora završiti prije

vanjske).

Također se DO petlju može prisiliti na sljedeći korak ili prisilno izaći iz nje. Vrijedi: − Naredba CYCLE prisiljava izvođenje slijedećeg koraka DO-petlje. Podrazumijeva se da se prelazi na sljedeći korak najniže

petlje ako je nekoliko DO petlji ugnježdeno. − Naredba EXIT prekida izvođenje DO-petlje. Podrazumijeva se da se prekida najniža petlju ako je nekoliko DO petlji

ugnježdeno.

Naredni primjer zbrajat će brojeve samo dok je ZBROJ < 1000. Kada ZBROJ prijeđe 1000 izvršiti će se IF naredba i petlja će biti nasilno prekinuta. Slijedi ispis i kraj programa. PROGRAM Zbrajanje INTEGER I, ZBROJ ZBROJ=0 DO I = 2, 256, 2 ZBROJ = ZBROJ + I IF (ZBROJ > 1000) EXIT ENDDO PRINT *,’Zbroj=’,ZBROJ END

Stari oblik DO petlje s kontrolnim parametrom ima oblik: DO 100 I = poc,kraj,korak ! tijelo petlje 100 CONTINUE

Ovaj oblik ima u potpunosti istu funkciju kao i novi oblik.

5.2.2 DO-WHILE petlja DO WHILE-petlja nema kontrolni parametar, nego ponavljanje izvršavanja je kontrolirano logičkim izrazom. Standardna DO petlja: DO-WHILE petlja: ZBROJ=0 DO I = 2,100,2 ZBROJ = ZBROJ + I ENDDO

ZBROJ=0 I=2 DO WHILE (I <= 100) ZBROJ = ZBROJ + I I=I+2 ENDDO

5.2.3 Beskonačna DO petlja Beskonačna DO nema kontrolnog parametara, niti kontrolni logički izraz. Prestanak izvršavanja prepušten je naredbi EXIT koja se mora nalaziti negdje unutar petlje. Standardna DO petlja: Beskonačna DO petlja: ZBROJ=0 DO I = 2,100,2 ZBROJ = ZBROJ + I ENDDO

ZBROJ=0 I=2 DO IF (I > 100) ZBROJ = ZBROJ + I I=I+2 ENDDO

6. Formatirani ispis podataka i rad s datotekama 6.1 Općenito Fortran sadrži cijeli niz naredbi za pisanje i čitanje, kao i za formatirani unos i ispis.

Podatke ispisujemo pomoću PRINT i WRITE naredbi. Za Razlika između PRINT i WRITE je da PRINT ispisuje na standardni izlaz (ekran), dok WRITE naredba može ispisivati na razne uređaje, te broj mogućih opcija i puno veći (vidjeti u nastavku).

PRINT WRITE:



INTEGER :: a=1, b=2, c=3 PRINT *, a PRINT ’(i)’,b PRINT 100,c 100 FORMAT (i)

INTEGER :: a=1, b=2, c=3 WRITE (*,*) a WRITE (*,’(i)’) b WRITE (*,100) c 100 FORMAT (i)

Način ispisa podatak može se ostaviti nedefiniranim, nego ostaviti sustavu (prevoditelju) da ispiše podatke na predefinirani način za tu vrstu podataka. To je tzv. slobodni format ispisa.

6.2 Naredba FORMAT Ispis podataka može se zadati preko format instrukcija koje su dio PRINT/WRITE naredni ili se može zadati preko FORMAT naredbe. Nema razlike između jednog ili drugog načina. FORMAT naredbe je posebna u tome što to nije naredba koja se izvršava nego je više informacija PRINT/WRITE naredbi.

FORMAT naredba može biti bilo gdje unutar programske cjeline, te ima jedinstvenu numeričku labelu pomoću koje se naredbe PRINT/WRITE referiraju na nju.

FORMAT naredba ima kao argumente listu slovnih oznaka kombiniranih opcionalno s brojkama (te još nekim dodatnim znakovima) međusobno odvojenih zarezima. Svaki član u listi odnosi se na jedan podatak u listi varijabli za ispis u PRINT/WRITE naredbi. Ove slovne oznake u FORMAT naredbi nazivamo uređivanje (eng. editing). Svaka vrsta podataka traži svoju posebnu specifikaciju ispisa, tj. svoje posebno uređivanje, osim slobodnog formata (označen zvjezdicom - *) koji se može koristiti za ispis svih vrsta podataka.

6.2.1 Ispis cijelih brojeva Za ispis cijelih brojeva (INTEGER-a) u decimalnom ispisu, koristi se „I“ format: INTEGER :: i i = -1234 PRINT ’(i)’,i ! -1234

Za ispis cijelih brojeva (INTEGER-a) u binarnom ispisu, koristi se „B“ format: INTEGER :: i i = -1234 PRINT ’(b)’,i ! 11111111111111111111101100101110

Za ispis cijelih brojeva (INTEGER-a) u heksadecimalnom ispisu, koristi se „Z“ format: INTEGER :: i i = -1234 PRINT ’(z)’,i ! FFFFFB2E

Iza oznake uređivanja, slova I, B i Z može stajati broj koji je širina područja unutar kojeg treba ispisati cijeli broj (npr. (I10)). Ako ispis broja ne stane u naznačenu širinu, ispisuju se zvjezdice. Ako je broj kraći od naznačene širine, broj se ispisuje na desnom kraju s prazninom (ne računajući predznak) ispred. Praznina ispred može se popuniti s nulama ako iza naznačene širine se doda točka i dodatna brojka. Dodatna brojka označava minimalni broj znamenki u broju, računajući i nule ispred. Obavezno ili opcionalno ispisivanje predznaka se posebno može regulirati s uređivanjem. i = 1234 ! 123456789_123456789_ PRINT ’(i3)’,i ! *** PRINT ’(i5)’,i ! 1234 PRINT ’(i10)’,i ! 1234 PRINT ’(i10.7)’,i ! 0001234 PRINT ’(i16)’,i ! 1234



6.2.2 Ispis logičkih varijabli Za ispis logičkih varijabli koristi se „L“ format: LOGICAL :: lll lll = .TRUE. PRINT ’(l)’,lll ! T

6.2.3 Ispis niza znakova Za ispis niza znakova (stringa) koristi se „A“ format. Iza a uređivanja može doći opcionalno broj koji je širina područja unutar kojeg se niz znakova ispisuje. Znakovi se ispisuju na lijevoj strani naznačene širine. Ako širina područja nije dovoljna za ispis, ispisuje se onoliko znakova koliko stane u naznačenu širinu. CHARACTER(len=20) :: str str = ’9 znakova u stringu’ PRINT ’(a)',str ! 9 znakova u stringu PRINT ’(a8)’,str ! 9 znakov PRINT ’(a9)’,str ! 9 znakova PRINT ’(a11)’,str ! 9 znakova u PRINT ’(a15)’,str ! 9 znakova u str PRINT ’(a20)’,str ! 9 znakova u stringu

Stari format ispisa niza znakova je „H“ format (Hollerith format). U ovom formatu se ispisuje svaki znak posebno.

6.2.4 Ispis realnih varijabli Za ispis realnih brojeva (REAL-a) u decimalnom ispisu, koriste se F, E, G, EN i ES formati. REAL A A=0.0191881 ! 123456789_123456789_ PRINT ’(f15.5)',A ! 0.01919 PRINT ’(e15.5)’,A ! 0.19188E-01 PRINT ’(g15.5)’,A ! 0.19188E-01 PRINT ’(en15.5)’,A ! 19.18807E-03 PRINT ’(en15.5)’,A ! 1.91881E-02

Format F je normalni ispis. Prvi broj ispred točke označava ukupan broj mjesta rezerviran za ispis broja, a broj iza točke označava broj mjesta rezerviran za decimale. U prvi broj se broje i predznak, decimalna točka, eksponent i predznak eksponenta. Ako je broj koji se želi ispisati malen, biti će ispisane nule, a ako je velik ispisati će se zvjezdice. REAL A A=.123E-12 ! 123456789_123456789_ PRINT ’(f15.5)',A ! 0.00000 A=.123E+12 PRINT ’(f8.2)',A ! ********

Format E je za znanstveni (eksponencijalni) ispis.Kao i kod F formata broj ispred točke označava ukupan broj mjesta rezerviran za ispis broja, a broj iza točke označava broj mjesta rezerviran za decimale. G format, u slučaju kada je broj normalne veličine ispisuje ga u F formatu, a ako je velik ili malen u E formatu REAL A A=.123E-12 ! 123456789_123456789_ PRINT ’(e15.5)',A ! 0.12300-12 PRINT ’(g15.5)',A ! 0.12300-12 A=123.1 PRINT ’(e15.5)',A ! 0.12310+03 PRINT ’(g15.5)',A ! 123.10

Kako je vidljivo na gornjem primjeru, iako broj 123.1 zapisuje u normalnom formatu, G format ostavlja 3 mjesta rezervirana za eksponent i predznak eksponenta, pa to treba uzeti u obzir prilikom dimenzioniranja formata.

Također, treba imati na umu da kod realnih varijabli dvostruke preciznosti (KIND=8), eksponent se sastoji od tri znamenke.

Kod E formata neeksponencijalni dio broja je između 1.0 i 0.1 (broj uvijek ima oblik: 0.xxxx-yy). ES označava tz. znanstveno uređivanje, sve brojke se ispisuju tako da je neeksponencijalni dio broja manji od 10 a veći od 1. EN je tzv. inženjersko uređivanje, neeksponencijalni dio broja je manji od 1000 a veći od 1.

Opcionalno moguće je regulirati broj znamenki u eksponentu (e20.5E3 - 3 znamenke za eksponent).



6.2.5 Posebni znakovi pri formatiranju ispisa Posebni znakovi služe nam za još bolje kontroliranje ispisa. To su:

− x uređivanje - broj praznih mjesta − $ uređivanje - ne prijeći na novu liniju nakon ispisa − / uređivanje – preskače jednu liniju kod ispisa − sp - u nastavku aktivirati ispisivanje znaka + gdje je inače opcionalan − s - deaktivirati obavezno ispisivanje opcionalnog znaka „+“ − t uređivanje služi za pozicioniranje ispisa.

6.2.6 Ostale korisne napomene pri formatiranju ispisa Brojke ispred uređivanja znače broj ponavljanja (npr. 5i10 znači: 5 puta po 10 mjesta za ispis cijelih brojeva).

Zagrade se mogu koristiti za ponavljanje grupe uređivanja (npr. 2(i5,f10.5) znači: 2 puta po 15 mjesta, od toga prvih 5 za cijeli broj a drugih 10 za realni broj).

Ako se ispisuje veći broj varijabli od zadanog broja uređivanja, ispisuje se onoliko varijabli koliko je zadano uređivanjem, a ostatak se ispisuje ponavljanjem cijele format naredbe ali na novim linijama.

Ponekad je moguće koristiti varijabilno uređivanje (nije dio standarda).

6.3 Naredbe OPEN i CLOSE Naredbe OPEN i CLOSE služe za otvaranje/zatvaranje komunikacije s vanjskim uređajima. Vanjskim uređajima se smatraju tvrdi disk, tračna jedinica, konzola (terminal) s tipkovnicom.

Rad s složenim uređajima poput grafičke konzole zahtijeva uporabu biblioteka čije naredbe nisu dio Fortrana kao jezika. Uređaji koji se automatski otvaraju kod pokretanja programa je konzola (ekran) s tipkovnicom. Konzola (ekran) se tretira kao uređaj za standardni ispis (pisanje). Uređaju je pridružen broj 6. Tipkovnica je uređaj za standardni upis (unos, čitanje) i pridružen joj je broj 5. Ovo je napomenuto samo radi boljeg snalaženja u starijim programima (Fortran IV) koji su ovu konvenciju bezuvjetno poštivali. Umjesto standardnih brojeva 5 i 6 praktično se poslužiti zvjezdicom (*) koja zamjenjuje oba broja. Ovo će se u nastavku koristiti.

Konzolu (ekran) i tipkovnicu ne treba posebno otvarati. Za rad s ostalim uređajima (prvenstveno datotekama) treba uređaju pridružiti broj uređaja koristeći naredbu OPEN.

Naredba OPEN ima veliki broj argumenata, od koji je obavezan broj uređaja. Broj uređaja je bilo koji prirodni broj, ali mora biti jedinstven u programu, tj. ne smije se ponoviti za neki drugi uređaj. OPEN([UNIT=]<cijeli_broj>, FILE=<ime_datoteke>, FORM=<string>, ERR=<labela>, & STATUS=<status>, ACCESS=<metod>, ACTION=<nacin>, ...)

Argument [UNIT=]<cijeli_broj> specificira broj uređaja. Ime argumenta UNIT je opcionalno, tj. može se ispustiti, što je naznačeno stavljanjem toga argumenta u uglate zagrade – konvencija iz help-a.

Argument FILE određuje ime datoteke koja se otvara.

Opcionalni argument FORM ima dvije vrijednosti: − ’FORMATTED’ - Zapisi su uređeni i može ih se čitati. Ova vrijednost je pretpostavljena ako drugačije nije navedeno. − ’UNFORMATTED’ - zapisi su u binarnom obliku.

Argument STATUS govori o stanju uređaja, da li je stara ili nova datoteka. Moguće vrijednosti su: − ’OLD’ - radi se o datoteci koja već postoji. − ’NEW’ - treba otvoriti novu datoteku. − ’REPLACE’ - staru datoteku treba zamijeniti novom. − ’SCRATCH’ - privremena datoteka koja će po zatvaranju biti izbrisana. − ’UNKNOWN’ - Ako postoji otvara se kao ’OLD’ datoteka, a ako ne postoji onda kao ’NEW’.

Argument ACCESS specificira način pristupa zapisima u uređaju. Postoje dvije mogućnosti: − ’SEQUENTIAL’ - za čitanje ili pisanje liniju po liniju, − ’DIRECT’ - za direktni pristup pojedinim zapisima uz pomoć ID broja zapisa. U ovom slučaju je potrebno kod otvaranja

navesti i dužinu zapisa pomoću opcionalnog argumenta RECL=dužina_zapisa.



Argument ACTION navodi našu nakanu: čitanje, pisanje ili oboje. Moguće vrijednosti su: − ’READ’ - otvaramo uređaj samo za čitanje, − ’WRITE’ - otvaramo uređaj samo za pisanje, − ’READWRITE’ - otvaramo uređaj za čitanje i pisanje (pretpostavljena vrijednost).

Argument ERR navodi broj labele u Fortranskom programu na koju treba ići ako dođe do greške kod otvaranja uređaja.

Opcionalni argument IOSTAT=<int_varijabla> pridjeljuje vrijednost cjelobrojnoj varijabli u slučaju greške. Iznos varijable indicira vrst greške.

Ako IOSTAT ili/i ERR nisu prisutni u pozivu naredbe OPEN, greška kod otvaranja izazvat će prijevremeni završetak programa.

Uređaj zatvaramo naredbom CLOSE(<broj_uređaja>). Pri tome treba navesti broj uređaja koji se zatvara. Dodatni argument je STATUS s dvije moguće vrijednosti: 'KEEP' ili 'DELETE'. PROGRAM Datoteka INTEGER :: ioerr OPEN(14, FILE=’input.dat’, STATUS=’OLD’, FORM=’FORMATTED’, & ACCESS=’SEQUENTIAL’, ACTION=’READ’, ERR=10, IOSTAT=ioerr) ................ READ(14,..) .... ................ CLOSE(14, STATUS=’KEEP’) 10 IF (ioerr>0) THEN WRITE (*,*) ’Greska kod otvaranja :’,iostat STOP END IF END PROGRAM

6.4 Naredbe WRITE i READ Opća forma naredbe WRITE je: WRITE ([UNIT=]<cijeli_broj>, [FMT=]<ure•enje>, IOSTAT=<int_var>, & ERR=<labela>, ADVANCE=<yes,no>,...) lista_varijabli

Argument [UNIT=]<cijeli_broj> specificira broj uređaja (datoteke) s kojeg se čita.

IOSTAT i ERR argumenti služe za rukovanje izvršavanjem programa u slučaju pojave greške.

ADVANCE=<yes,no> određuje prelazak ispisa na sljedeći redak po završetku.

Kod pisanja u ’UNFORMATTED’ uređaj format se ne specificira.

Najčešće se kod naredbe WRITE koriste samo oznaka jedinice i oznaka formata.

Opća forma naredbe READ je: READ ([UNIT=]<cijeli_broj>,[FMT=]<ure•enje>,ADVANCE=<yes,no>, & IOSTAT=<int_var>,ERR=<labela>,END=<labela>,EOR=<label>, & REC=<id_zapisa>,SIZE=<broj_znakova_var>) lista_varijabli

Većina argumenata ima standardno značenje kao i kod naredbi OPEN, tj. WRITE. Osim njih kao dodatne opcionalne argumente imamo:

END=<labela>, koje imenuje broj labele na koju treba programa skočiti ako se pokuša čitati iza oznake kraja datoteke.

Argument EOR imenuje broj labele s koje se nastavlja izvršavanje programa ako se pokuša čitati iza kraja zapisa datoteke.

S argumentom REC navodi se broj zapisa kod direktnog čitanja.

Argument SIZE se koristi zajedno s argumentom ADVANCE i njime se imenuje varijabla koja sadrži podatak koliko je znakova pročitano.

Kao i kod WRITE kod naredbe READ najčešće se koriste samo oznaka jedinice i oznaka formata.



C SUBROUTINE INPUT CHARACTER*80 TEXT C C*** OTVARANJE ULAZNOG I IZLAZNOG FAJLA OPEN (UNIT=10,FILE='Input.dat',FORM='FORMATTED',STATUS='OLD',ERR=9990) OPEN (UNIT=11,FILE='Output.dat',FORM='FORMATTED') C C*** UCITAVANJE OSNOVNOG RETKA READ (10,'(A80)') TEXT WRITE (11,'(A10,A80)') ' Naslov: ',TEXT C C*** UCITAVANJE OSNOVNIH PARAMETARA MODELA READ (10,*) NELEM,NPOIN,NFIXE,NMATS WRITE (11,20) 20 FORMAT (//,' Broj stapova : ',I5, & ' Broj cvorova : ',I5, & ' Broj pridrz. cvorova : ',I5, & ' Broj materijala : ',I5) C C*** UCITAVANJE KOORDINATA CVOROVA WRITE (11,30) WRITE (11,31) DO I=1,NPOIN READ (10,*) IPOIN, CVOR(IPOIN).CX, CVOR(IPOIN).CY, & CVOR(IPOIN).BC(1),CVOR(IPOIN).BC(2),CVOR(IPOIN).BC(3) WRITE (11,32) IPOIN, CVOR(IPOIN).CX, CVOR(IPOIN).CY, & CVOR(IPOIN).BC(1),CVOR(IPOIN).BC(2),CVOR(IPOIN).BC(3) ENDDO 30 FORMAT (/,/,' CVOR X Y PRIDRZ') 31 FORMAT ( '---------------------------------------------') 32 FORMAT (I5,2F14.3,5X,3I3) ................ C...itd.......... ................ GOTO 9999 9990 WRITE (*,'(/,A40)') ' Nepostojeca ulazna datoteka!' C 9999 CONTINUE RETURN END

6.5 Ostale naredbe za upis i ispis Ostale Fortranske naredbe za rad s datotekama su:

Naredba BACKSPACE (UNIT=8) kod sekvencijalnog čitanja pozicionira čitanje/pisanje na početak prethodnog zapisa. Dodatni argumenti su ERR i IOSTAT.

Naredba REWIND (UNIT=8) pozicionira čitanje/pisanje na početak datoteke (sekvencijalni upis/ispis). Dodatni argumenti su ERR i IOSTAT.

Naredba ENDFILE (UNIT=8) stavlja oznaku kraja datoteke kod sekvencijalnog pisanje. Dodatni argumenti su ERR i IOSTAT.

Podatak o statusu uređaja ili datoteke mogu se saznati pomoću naredbe INQUIRE (FILE=<datoteka>,...) ili INQUIRE (UNIT=...). Osim ERR i IOSTAT postoji i niz drugih argumenata.



6.6 Pisanje u niz znakova i čitanje iz niza znakova Ako neka varijabla tipa niza znakova ima vrijednost cijelog (ili realnog) broja, ili niza brojeva, te se vrijednosti mogu učitati u cjelobrojne (ili realne) varijable korištenjem READ naredbe. Pri tome se umjesto broja uređaja navodi ime string varijable. CHARACTER(LEN=10) :: ch = ’12345’ INTEGER :: i READ (ch,’(i)’) i

Isto tako, nizu znakova možemo zadati vrijednost koja se dobije uređenim ispisom realnih ili cjelobrojnih brojeva uporabom WRITE naredbe. Umjesto broja uređaja navodi se string varijabla. CHARACTER(LEN=10) :: ch INTEGER :: i = 98765 WRITE (ch,’(i)’) i



7. Funkcije i Subrutine 7.1 Općenito Funkcije i Subrutine (FUNCTION i SUBROUTINE) su zasebni dijelovi programa koji obavljaju određenu operaciju. Osnovna razlika Funkcija i Subrutina je ta što funkcije povratno vraćaju samo jednu vrijednost, dok Subrutine mogu imati cijeli niz povratnih vrijednosti.

Veliki niz funkcija su bibliotečne funkcije, koje često i nesvjesno koristimo. To su obično matematičke funkcije koje dolaze s radnim okružjem i automatski se linkaju s programom (ako je potrebno). To su npr. (jedan mali podskup):

FUNKCIJA Što radi

ABS (a) SIGN (a,b) SQRT (a) SIN (a) COS (a) TAN (a) ASIN (a) ACOS (a) ATAN (a) EXP (a) LOG (a) LOG10 (a) SINH (a) COSH (a) TANH (a)

absolutna vrijednost vrijednost od a s predznakom od b kvadratni korjen sinus od a (argument u radijanima) kosinus od a tanges od a arkus sinus - inverzna funkcija od sinusa arkus kosinus arkus tanges od a eksponent (prirodni) prirodni logaritam logaritam u bazi 10 hiperbolični sinus hiperbolični kosinus hiperbolični tanges

Upotreba ovih funkcija je jednostavna, kako je prethodno pokazano na primjeru funkcije SQRT.

Osim bibliotečnih moguće je formirati i cijeli niz drugih funkcija.

7.2 Funkcije (FUNCTIONS) Funkcija vraća podatak ili rezultat čija vrsta treba biti navedena na početnoj liniji definicije funkcije. Funkcija može imati argumente čiji tip treba navesti unutar definicije funkcije. Funkcija treba imati jedinstveno ime unutar programske jedinice. Ime funkcije je varijabla (memorijska lokacija) čija vrijednost treba biti zadana unutar definicije funkcije. PROGRAM N_Faktorijel IMPLICIT NONE INTEGER*4 NN, FACT, FAKTORIJEL WRITE (*,10) READ (*,20) NN FACT = FAKTORIJEL(NN) WRITE (*,30) NN,'! = ',FACT 10 FORMAT (' Upisi broj : ',$) 20 FORMAT (I5) 30 FORMAT (I3,A,I15) END PROGRAM C INTEGER*4 FUNCTION FAKTORIJEL(N) IMPLICIT NONE INTEGER*4 N,I FAKTORIJEL=1 DO I=1,N FAKTORIJEL=FAKTORIJEL*I ENDDO RETURN END

U glavnom programu izvršenje funkcije postiže se pozivom te funkcije, tako da se određenoj varijabli pridoda povratna vrijednost funkcije (FACT = FAKTORIJEL(NN)). Važno je zapamtiti da varijabla kojoj se pridodaje vrijednost funkcije i sama funkcija moraju biti istog tipa (INTEGER*2, INTEGER*4, CHARACTER*12, REAL*4…). Izvršenje gornjeg programa ima sljedeći ispis:



Ako izmijenimo tip funkcije, npr. (vidjeti crveni redak): REAL*4 FUNCTION FAKTORIJEL(N) IMPLICIT NONE INTEGER*4 I,N FAKTORIJEL=1 DO I=1,N FAKTORIJEL=FAKTORIJEL*I ENDDO RETURN END

Izvršenje programa ima ispis:

Kompajler ne prijavljuje grešku u kôdu, pa ako programer ne obrati pažnju na dobivene rezultate, rezultat je stvarno nepredvidiv.

Također, argumenti koji se predaju funkciji i argumenti u funkciji moraju biti istog tipa (iako nije važno da imaju i isto ime). Pogrešan tip varijable često dovodi do nepredvidivih grešaka. Primjer s greškom u argumentima prikazan je kod subrutine.

7.3 Subrutine (SUBROUTINE) Subrutine (Podprogrami) su u svemu slični funkcijama, osim što one ne vraćaju rezultat.

Subrutine se uvode kao posebne skupine naredbi koje obavljaju određenu vrst posla i koja se često se koristi unutar programa.

Definicija subrutine (potprograma) počinje s SUBROUTINE iza koje slijedi ime subrutine koje mora biti jedinstveno unutar programske jedinice. Definicija subrutine završava s END ili s END SUBROUTINE. Iza imena subrutine slijedi lista opcionalnih argumenata zatvorena u okrugle zagrade. Tip argumenata se mora specificirati unutar podprograma. Argumenti koji se predaju subrutini i argumenti u subrutini moraju biti istog tipa (iako nije važno da imaju i isto ime).

U glavnom programu izvršenje subrutine se postiže naredbom CALL ime_subrutine (args).

Po izvršenju zadnje naredbe u subrutini program se nastavlja izvršavati u glavnom programu na naredbama koje slijede iza CALL .. naredbe. Prisilni izlazak iz subrutine može se postići naredbom RETURN. U jednoj subrutini može biti više naredbi RETURN.

Subrutine ili funkcije također mogu zvati (CALL ..) druge definirane subrutine ili funkcije. Postoje subrutine i funkcije koje mogu zvati sami sebe, tz. rekurzivne subrutine ili funkcije.

7.4 O načinu razmjene varijabli Način razmjene varijabli u Fortranu između glavnog programa i subrutina/funkcija, ako i između samih subrutina/funkcija je tzv. by reference, za razliku od npr. C jezika, gdje je prijenos tzv. by value. Naime prilikom prijenosa varijabli u Fortranu ne prenosi se njena vrijednost već njena referenca, tj. adresa memorijske lokacije na kojoj je varijabla spremljena. Ovo ima za posljedicu da ako se vrijednost varijable promijeni u subrutini/funkciji vrijednost varijable mijenja i u glavnom kôdu.

Pogledajmo donji, jednostavni primjer:



PROGRAM NNN IMPLICIT NONE INTEGER*4 NN WRITE (*,10) READ (*,20) NN WRITE (*,30) ' N je : ',NN CALL PROMIJENI(NN) WRITE (*,30) ' N je : ',NN 10 FORMAT (' Upisi broj : ',$) 20 FORMAT (I5) 30 FORMAT (A,I15) END PROGRAM C SUBROUTINE PROMIJENI(N) IMPLICIT NONE INTEGER*4 N N=N+1 RETURN END

Rezultat izvršenja donjeg programa (ako za N upišemo npr. broj 12) je:

Izmijenimo malo subrutinu (izmjene su označene crveno). SUBROUTINE PROMIJENI(N) IMPLICIT NONE REAL*4 N N=N+1 RETURN END

Sada je rezultat izvršenja programa nepredvidiv:

Kratki komentar:

Glavni program inicira cjelobrojnu varijablu NN i učita je s tipkovnice. Tu varijablu sprema na određeno mjesto u memoriji (memorijsku lokaciju) – veličine 4 byte-a. Program zatim poziva subrutinu istovremeno joj šaljući memorijsku lokaciju na kojoj je spremljena varijabla NN. Subrutina prima tu varijablu, ali je greškom inicira kao realnu. Odlazi na dobru memorijsku lokaciju ali čita varijablu na pogrešan način (s nepredvidivim rezultatom). Usput, ime ove varijable je N, što je sasvim nebitno računalu.

Vrijednost varijable uvećava za 1 te tako uvećanu vrijednost sprema na istu lokaciju, te se vraća u glavni program. Glavni program ispisuje vrijednost iz zadane memorijske lokacije, ali sada ponovno čitajući varijablu kao cjelobrojnu. Konačna vrijednost je sasvim nepredvidiva.

Posebnu pažnju treba posvetiti prilikom prijenosa polja (matrica) u subrutinu. Sljedeći primjer pokazuje neke osobitosti prijenosa matrica u i iz subrutine. PROGRAM POLJA IMPLICIT NONE



INTEGER*4 I,J,A(5,5) C Punjenje vrijednsti u 'A' CALL NAPUNI_A(A) C Original matrica 'A' WRITE (*,10) ((A(I,J),J=1,5),I=1,5) WRITE (*,20) '----------------------' C Promijeni vrijednsti u 'A' CALL PROMJENI_A_1(A) C Promijenjena matrica 'A' - 1. put WRITE (*,10) ((A(I,J),J=1,5),I=1,5) WRITE (*,20) '----------------------' C Vrati na staro CALL NAPUNI_A(A) C Promijeni vrijednsti u 'A' CALL PROMJENI_A_2(A) C Promijenjena matrica 'A' - 2. put WRITE (*,10) ((A(I,J),J=1,5),I=1,5) WRITE (*,20) '----------------------' C Vrati na staro CALL NAPUNI_A(A) C Promijeni vrijednsti u trecem stupcu 'A' CALL PROMJENI_A_3(A(1,3)) C Promijenjena matrica 'A' - 3. put WRITE (*,10) ((A(I,J),J=1,5),I=1,5) WRITE (*,20) '----------------------' C 10 FORMAT (5I10) 20 FORMAT (A) C END PROGRAM C------------------------------------------ SUBROUTINE NAPUNI_A(A) IMPLICIT NONE INTEGER*4 I,J,A(5,5) DO I=1,5 DO J=1,5 A(I,J)=I*10+J ENDDO ENDDO RETURN END C------------------------------------------ SUBROUTINE PROMJENI_A_1(A) IMPLICIT NONE INTEGER*4 I,J,A(5,5) DO I=1,5 DO J=1,5 A(I,J)=A(I,J)+100 ENDDO ENDDO RETURN END C------------------------------------------ SUBROUTINE PROMJENI_A_1_1(A) IMPLICIT NONE INTEGER*4 I,J,A(5,5) A=A+100 RETURN END C------------------------------------------ SUBROUTINE PROMJENI_A_2(A) IMPLICIT NONE INTEGER*4 I,A(25) DO I=1,25 A(I)=A(I)+100 ENDDO RETURN END C------------------------------------------ SUBROUTINE PROMJENI_A_3(A) IMPLICIT NONE INTEGER*4 I,A(5) DO I=1,5 A(I)=A(I)+100 ENDDO RETURN END C------------------------------------------



Rezultat gornjeg programa je:

Sljedeća subrutina (FILNAM) prima ime ulazne datoteke, skida joj ekstenziju, te vraća ime s dodanom novom ekstenzijom. Tako se nakon što korisnik upiše ime ulazne datoteke (npr. podaci.dat), stvaraju dvije nove datoteke: podaci.izl za izlazne rezultate i podaci.dxf za dxf (AutoCAD) file. PROGRAM AAAA IMPLICIT NONE CHARACTER*13 INPUT1,OUTPUT,DXFOUT C C*** DEKLARACIJA OSTALIH VARIJABLI U PROGRAMU ................ ................ C C*** UCITAVANJE ULAZNOG I IZLAZNOG FAJLA WRITE (*,14) READ (*,15) INPUT1 CALL FILNAM(INPUT1,OUTPUT,'IZL') CALL FILNAM(INPUT1,DXFOUT,'DXF') WRITE (*,16) OUTPUT WRITE (*,18) DXFOUT C 14 FORMAT (' Ulazna datoteka: ',$) 15 FORMAT (A13) 16 FORMAT (' Izlazna datoteka: ',A13) 18 FORMAT (' DXF datoteka: ',A13) C OPEN (UNIT=10,FILE=INPUT1,FORM='FORMATTED',STATUS='OLD',ERR=9990) OPEN (UNIT=11,FILE=OUTPUT,FORM='FORMATTED') OPEN (UNIT=88,FILE=DXFOUT,FORM='FORMATTED') ................ C...itd.......... ................ CLOSE (UNIT=10) CLOSE (UNIT=11) CLOSE (UNIT=88) END C C C--------------------------------------------------------------------- SUBROUTINE FILNAM(FILEIN,FILEOU,EXT) IMPLICIT NONE CHARACTER*13 FILEIN,FILEOU CHARACTER*3 EXT INTEGER I, NUM NUM=0 DO I=1,9 NUM=I IF(FILEIN(I:I).EQ.' ') EXIT IF(FILEIN(I:I).EQ.'.') EXIT FILEOU(I:I)=FILEIN(I:I) ENDDO C FILEOU(NUM:NUM)='.' DO I=1,3 FILEOU((NUM+I):(NUM+I))=EXT(I:I) ENDDO RETURN END



C---------------------------------------------------------------------



8. PRIMJER – Programsko rješenje: Ravninski štapni sustavi 8.1 Teorijske postavke

8.1.1 Jednadžba ravnoteže Neka je os x uzdužna os elementa, a osi y i z osi tromosti presjeka elementa. Tada se jednadžba ravnoteže linearnog sustava na diferencijalnom dijelu elementa može napisati kao: 0=− fLQ ; 0=− fpLDL (1) gdje su Q – vektor unutrašnjih sila i f – vektor opterećenja:

{ }{ }Tzyx

Tzyx

m,f,f

M,T,N

=

=

f

Q (2)

a L diferencijalni operator oblika:

⎥⎥⎥

⎦

⎤

⎢⎢⎢

⎣

⎡=

dxd000dxd000dxd

L (3)

Formalno, za komponente vektora unutrašnjih sila može se pisati: εDQ = (4) gdje je D matrica krutosti presjeka (koja uključuju njegove materijalne i geometrijske karakteristike)

⎥⎥⎥

⎦

⎤

⎢⎢⎢

⎣

⎡=

z

y

x

EI000GA000EA

D (5)

a ε vektor deformacije presjeka, koji ovisi o vektoru pomaka: { }wv,u,== ppLε (6) Da bi se riješilo gornju jednadžbu potrebno je uvesti rubne uvjete, koji u slučaju statičkog problema, predstavljaju zadane sile i pomake na rubovima sustava.

8.1.2 Diskretizacija sustava i bazne funkcije U nedostatku analitičkih rješenja, rješenje jednadžbe (1) se obično traži numeričkim postupcima. Jedan od najčešće primjenjivanih i najpriznatijih postupaka je Metoda ili Tehnika konačnih elemenata. Bit ove metode je da se sustav koji ima beskonačni broj stupnjeva slobode zamijeni (simulira) sustavom koji ima konačan broj stupnjeva slobode. Da bi se to postiglo pretpostavljamo (programiramo) ponašanje niza točaka sustava na jednom konačnom elementu, vezano uz određeni broj fiksnih, prethodno određenih točaka (čvorova) na tom istom elementu.

Pretpostavimo približno rješenje za polje pomaka: uHpp == ) (7) gdje je H matrica baznih funkcija a u vektor nepoznatih čvornih pomaka. Bazne (oblikovne) funkcije se najčešće za štapne sustave biraju iz grupe Hermite-ovih polinoma, a prikazane su na crtežu.

l

1.0

0

h3

l

1.0

0

h1

l

1.0

0

h5

l

1.0

0

h2

l0

h4

l0 h61.0

1.0



8.1.3 Formulacija principom virtualnog rada Ako virtualne pomake odaberemo iz porodice Hermite-ovih funkcija, od kojih je konstruirano i približno rješenje (7), tada iz jednakosti vanjskih i unutrašnjih sila slijedi: dxdxˆ T ∫∫ =+ εεΤ DfpsuT (8) odnosno: ( ) dxdxTT ∫∫ =+ uBDBufHusu TT Τ (9)

tj., nakon množenja s lijeve strane s Tu : ( ) dxdx T∫∫ −= fHuBDBs T (10) ili skraćeno: ee Fukse −= (11) gdje su:

− es - vektor reznih sila na krajevima konačnog elementa

− ek - matrica krutosti elementa

− eF - vektor sila pune upetosti

8.1.4 Otpuštanje veza na rubovima elemenata Numerički modeli obično predviđaju mogućnost oslobađanja neke od veza rubova elemenata s okolinom. Time se eliminira (nulira) odgovarajuća sila na rubovima. Postupak kojim se to provodi predstavlja jedan vid lokalne eliminacije.

Jednadžbu ravnoteže konačnog elementa možemo zapisati u obliku: [ ]{ } { }e

iieij

e Fuks −= (12)

i presložiti tako da u prve retke postavimo one jednadžbe čija pripadna veza nije otpuštena. Te jednadžbe označimo indeksom „n“. Iza njih složimo jednadžbe onih veza koje su otpuštene i označimo ih indeksom „o“, pa imamo:

⎭⎬⎫

⎩⎨⎧

−⎭⎬⎫

⎩⎨⎧⎥⎦

⎤⎢⎣

⎡=

⎭⎬⎫

⎩⎨⎧

o

n

o

n

ooon

nonnen

FF

uu

kkkks

0 (13)

Kombinacija otpuštanja mora dati nnk kao regularnu matricu, inače smo otpuštanjem element pretvorili u lokalni mehanizam. Iz grupe jednadžbi otpuštenih veza otpušteni pomaci se mogu izraziti u funkciji neotpuštenih, prema: ( )nonoooo ukFku −= −1 (14) Sile u neotpuštenim vezama dobivamo iz grupe jednadžbi neotpuštenih veza kao: nononnn

en Fukuks −−= (15)

Uvođenjem (6.16) u (6.17) možemo eliminirati otpuštene pomake: nooonononoononnn

en FFkkukkkuks −−+= −− 11 (16)

ili skraćeno ( ) nnnnnnn

en FFukks −−+= ˆˆ (17)

odnosno Fuks n

en

ˆˆ −= (18) Posljednja relacija (18) predstavlja kondenzirane jednadžbe ravnoteže konačnog elementa koje moramo rastegnuti na početno stanje tako da svaku pojedinu jednadžbu vratimo na poziciju veze koja nije otpuštena, dok će se na pozicijama otpuštenih veza javiti nul jednadžbe.

8.1.5 Ravnoteža globalnog sustava Ravnoteža globalnog sustava uspostavlja se slaganjem sila na rubovima konačnog elementa i sila upetosti u odgovarajućim čvorovima mreže konačnih elemenata. Prije toga potrebno je izvršiti preslikavanje krutosti i sila iz lokalnog u globalni sustav.



ee

gl

eegl

FTF

TkTk

=

= T

(19)

Preslikavanje se vrši matricom transformacije (T), koja ima oblik:

( ) ( )( ) ( )⎥⎦

⎤⎢⎣

⎡=

glgl

glgl

y,ycosy,xcosx,ycosx,xcos

T (20)

Uvrštavanjem rubnih uvjeta dobivamo ravnotežu globalnog sustava u sljedećem obliku:

FuK

FFkK egl

egl

=

== ∑∑ee

; (21)

gdje su K i F matrice krutosti i opterećenja, a u vektor globalnih pomaka.

8.2 Kreiranje novog projekta Kreirajmo novi projekt. Nazovimo ga npr. Stasus2D (Štapni sustavi za 2D probleme). Postavimo osnovne parametre:

Odmah zatim kreirajmo i osnovnu datoteku s izvornim Fortranskim kôdom. Koristit ćemo fiksni zapis.

Definirajmo odmah i dužinu zapisa realnih i cjelobrojnih varijabli. Upotrijebimo opcije: Project Settings…, pa na tabu: „Fortran“ izaberimo opciju „Fortran data“.

Podesimo „Default real kind“ na 8 (8 byte-ova po jednoj realnoj varijabli) i „Default integer kind“ na 4 (4 byte-a po jednoj cjelobrojnoj varijabli – što je i default vrijednost).



8.3 Tok programa Prije početka pisanja samog koda dobro je izvesti dvije predradnje. Prva je definiranje toka programa, a druga definiranje osnovnih (globalnih) varijabli.

Tok programa je načelna shema kako bi naš program trebao izgledati. On bi mogao funkcionirati npr. na ovaj način:

Ako prihvatimo ovaj tok programa, tada možemo kreirati (kodirati) osnovno tijelo programa: PROGRAM Stasus2D C Definiranje varijabli C Ucitavanje ulaznih podataka CALL INPUT() C Izracunavanje matrica krutosti CALL STIFFS() C Izracunavanje vektora opterecenja CALL LOADS() C Proracun sustava CALL SOLVE() C Izracunavanje reznih sila CALL FORCE() C Ispis CALL OUTPUT() C Kraj END

Ovaj program je sasvim korektan, iako još uvijek nije funkcionalan. Ako ga probamo kompajlirati vidjet ćemo da ga kompajler uredno prevodi. S druge strane linker javlja greške. To je sasvim razumljivo jer navedene subrutine nismo još definirali niti se one nalaze u standardnim bibliotekama okruženja.

Prije prijelaza na definiranje samih dijelova programa (subrutina), definirajmo osnovne varijable.

START

INPUT Učitavanje ulaznih podataka

Početak programa

STIFFS Izračunavanje lokalnih i globalne matrice krutosti

LOADS Izračunavanje sila pune upetosti za svaki štap i proračun globalnog vektora opterećenja

SOLVE Proračun sustava i izračunavanje pomaka

FORCE Izračunavanje reznih sila za svaki štap

OUTPUT

END

Ispis rezultata

Kraj programa



8.4 Osnovne (globalne) varijable Postoje neki podaci koji će nam biti potrebni tijekom cijelog toka izvršenja programa. To su npr. podaci o čvorovima i štapovima, dakle geometrijski podaci. Koji čvorovi definiraju početak i kraj štapa, kojeg je materijala štap, da li su njegovi krajevi slobodni ili pridržani u prostoru i sl. Također su tu podaci o materijalu i njegovim karakteristikama, te rezultati proračuna. Sve ove podatke dobro je definirati kao globalne varijable koje će moći dosegnuti bilo koji dio programa.

Globalne varijable možemo definirati u okviru osnovnog dijela programa, međutim znatno ih je jednostavnije (i čitljivije) definirati u posebnoj datoteci. Definirajmo novu datoteku koja (inicijalno) neće biti sastavni dio projekta. Neka ta datoteka ima nastavak .inc (include). Odaberimo opciju: File New

Datoteka „Stasus2D.inc“ se pojavljuje u radnom dijelu okruženja (središnji prozor). Vidljivo je da nema „zelenu crtu“, jer je program ne prepoznaje kao fortransku datoteku.

Definirajmo odmah na početku neke maksimalne vrijednosti. Ove vrijednosti je, dakako, kasnije moguće mijenjati. Definirajmo vrijednosti za maksimalni broj štapova, maksimalni broj čvorova i maksimalni broj materijala. Upotrijebit ćemo naredbu PARAMETER koja definira nepromjenjivu konstantu. C--------------------------------------------------- C INCLUDE FILE ZA PROGRAM C STAPNI SUSTAVI C C--------------------------------------------------- C MAKSIMALNI PARAMETRI C C MXNODE - MAKSIMALNI BROJ CVOROVA C MXELEM - MAKSIMALNI BROJ ELEMENATA C MXMATE - MAKSIMALNI BROJ MATERIJALA C PARAMETER (MXNODE=500, MXELEM=100, MXMATE=10) C---------------------------------------------------

Definirajmo također i stvarni broj štapova, čvorova, pridržanih čvorova i materijala. Ovi podaci će se učitavati za svaki model posebno. Dakle, to su cjelobrojne varijable. C--------------------------------------------------- C STVARNI PARAMETRI MODELA C C NELEM - BROJ STAPOVA C NPOIN - BROJ CVOROVA C NFIXE - BROJ PRIDRZANIH CVOROVA C NMATS - BROJ MATERIJALA C INTEGER NELEM,NPOIN,NFIXE,NMATS C---------------------------------------------------

Za opis čvorova definirat ćemo složeni tip podataka u kojem ćemo čuvati sve podatke za svaki pojedini čvor. Dakle, svaki čvor ima svoju oznaku, koordinate (x i y), oznaku rubnog uvjeta, način pridržanja, prisilni (početni) pomak u x i/ili y smjeru te rotaciju i rezultate proračuna: pomak u x i y smjeru i rotaciju. Svaki ovaj podatak može se čuvati u posebnoj varijabli (polju, matrici) ili se može kreirati složeni tip podataka koji će sve ove podatke čuvati na jednom mjestu. C--------------------------------------------------- C STRUKTURA CVORA C C ICVOR - oznaka cvora C COORD(2) - koordinata cvora: X-COORD(1) i Y-COORD(2) C BC - rubni uvjet cvora (0 - slobodan, 1 - pridrzan)

Prozor s izborom tipa datoteke NAPOMENA: Odabrati „Text file“.

Tekući projekt NAPOMENA: Isključiti „Add to project“, datoteka se ne dodaje projektu

Ime datoteke NAPOMENA: Upisati ime i dodati nastavak: „.inc“.



C DISP(3) - pocetni pomaci (DISP(1)-x,DISP(2)-y,DISP(3)-fi) C DIST(3) - izracunati pomaci (DIST(1)-x,DIST(2)-y,DIST(3)-fi) C STRUCTURE /OPIS_CVORA/ INTEGER ICVOR REAL CX, CY INTEGER BC(3) REAL DISP(3) REAL DIST(3) END STRUCTURE RECORD /OPIS_CVORA/ CVOR(MXNODE) C---------------------------------------------------

Zadnji redak kreira složeni tip podataka CVOR, koji je tipa OPIS_CVORA i ukupno sadržava MXNODE članova.

Jednaki postupak ćemo upotrijebiti za štapove. Kreirati ćemo složeni tip podataka – strukturu, koja će u sebi sadržavati: oznaku (ime) štapa, početni i krajnji čvor štapa, oznaku materijala od kojeg je štap izrađen te dužinu štapa (koja će se naknadno izračunati i upisati u strukturu). Također u strukturi ćemo čuvati izlazne rezultate: rezne sile na oba kraja štapa C--------------------------------------------------- C STRUKTURA STAPA C C ISTAP - oznaka stapa C C1 - Pocetni cvor na stapu C C2 - Krajnji cvor na stapu C MAT - materijal stapa C LEN - duzina stapa (interno) C FORC(6) – izracunate rezne sile C N1,T1,M1 i N2,T2,M2 C STRUCTURE /OPIS_STAPA/ INTEGER ISTAP INTEGER C1,C2 INTEGER MAT REAL LEN REAL FORC(6) END STRUCTURE RECORD /OPIS_STAPA/ STAP(MXELEM) C C---------------------------------------------------

Zadnji redak kreira složeni tip podataka STAP, koji je tipa OPIS_STAPA i ukupno sadržava MXELEM članova.

Također, isti postupak ćemo upotrijebiti za opis materijala. U strukturu materijala uvrstiti ćemo materijalne karakteristike štapa i karakteristike poprečnog presjeka štapa: C--------------------------------------------------- C C MATERIJALNE I GEOMETRIJSKE KARAKTERISTIKE C C E - modul elasticnosti C NI – Poissonov koeficijent C G - MODUL POSMIKA C A - POVRSINA C I - MOMENT INERCIJE C STRUCTURE /MAT_GEOM_KAR/ REAL A,I,E,NI,G END STRUCTURE RECORD /MAT_GEOM_KAR/ GEOM(MXMATE) C C---------------------------------------------------

Zadnji redak,kao i u ranijim slučajevima, kreira složeni tip podataka GEOM, koji je tipa MAT_GEOM_KAR i ukupno sadržava MXMATE članova.

Definirajmo i strukturu opterećenje, koju ćemo detaljno komentirati kasnije: C--------------------------------------------------- C C STRUKTURA OPTERECENJA C C TIP OPTERECENJA 1 - CVORNO C MOZE SE ZADATI: SILA U SMJEROVIMA X I Y I MOMENT OKO Z C TIP OPTERECENJA 2 - JEDNOLIKO PO STAPU C ZADAJE SE Q - INTENZITET C L1 - POCETAK DJELOVANJA OD CVORA 1 C L - DUZINA DJELOVANJA STRUCTURE /OPTERECENJE/



REAL A,B,C ! Fx,Fy,Mz ili Q,L1,L END STRUCTURE RECORD /OPTERECENJE/ PLOAD(MXNODE) RECORD /OPTERECENJE/ MLOAD(MXELEM) C C---------------------------------------------------

Ovdje su definirana dva polja iz složenog tipa podataka – strukture OPTERECENJE: PLOAD (Point Load) koja čuva podatke o čvornom opterećenju i MLOAD (Member Load) koja čuva podatke o opterećenju po elementima.

Konačno, omogućimo da svi ovi globalni podaci budu na zajedničkom dijelu memorije: C--------------------------------------------------- C C ZAJEDNICKO PODRUCJE ZA DOSTUPNOST PODATAKA COMMON /GEOM_1/ CVOR, STAP, GEOM COMMON /GEOM_2/ NELEM,NPOIN,NFIXE,NMATS COMMON /GEOM_3/ PLOAD, SLOAD C C---------------------------------------------------

Da bi glavni dio programa „vidio“ ove globalne podatke potrebno ih je uključiti u njemu. To postižemo naredbom INCLUDE u glavnom dijelu programa. Dakle, u glavnom programu dodajmo sljedeći redak (…… označavaju da ostatak ostaje nepromijenjen): PROGRAM Stasus2D C Definiranje varijabli INCLUDE „Stasus2D.inc“ C Ucitavanje ulaznih podataka ......

Naredba: INCLUDE „Stasus2D.inc“ daje nalog kompajleru da na tom mjestu u potpunosti uključi sadržaj datoteke Stasus2D.inc. Ovo ujedno i znači da datoteka mora biti pisana po svim pravilima fortranskog zapisa. Dakle, ako je fiksni zapis tada stupci 1-6 moraju ostati slobodni, ne smije se pisati preko 72. stupca itd.

8.5 Učitavanje ulaznih podataka iz datoteke – Subroutine INPUT() Definiranje ulaznih podataka za korištenje programa (u konačnici kad ga u potpunosti izradimo) odvijat će se preko datoteke s ulaznim podacima. Ovu datoteku je potrebno prije startanja programa kreirati u nekom editoru (može i u samom Developer Studiu), prema uputama koje ćemo sami definirati.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

OSUBROUTINE INPUT() C Definiranje varijabli OIMPLICIT NONE OINCLUDE „Stasus2D.inc“ OCHARACTER*13 INPUT1,OUTPU1,DXFOU1 C C Ucitavanje imena datoteka OWRITE (*,14) OREAD (*,15) INPUT1 OCALL FILNAM(INPUT1,OUTPU1,'IZL') OCALL FILNAM(INPUT1,DXFOU1,'DXF') OWRITE (*,16) OUTPUT OWRITE (*,18) DXFOUT C 14OFORMAT (' Ulazna datoteka: ',$) 15OFORMAT (A13) 16OFORMAT (' Izlazna datoteka: ',A13) 18OFORMAT (' DXF datoteka: ',A13) C OOPEN (UNIT=10,FILE=INPUT1,FORM='FORMATTED',STATUS='OLD',ERR=9990) OOPEN (UNIT=11,FILE=OUTPU1,FORM='FORMATTED') OOPEN (UNIT=88,FILE=DXFOU1,FORM='FORMATTED') C C Ucitavanje osnovnog retka READ (10,'(A80)') TEXT WRITE (11,'(A10,A80)') ' Naslov: ',TEXT C C UCITAVANJE OSNOVNIH PARAMETARA MODELA READ (10,*) NELEM,NPOIN,NFIXE,NMATS WRITE (11,20) 20 FORMAT (//,' Broj stapova : ',I5, & ' Broj cvorova : ',I5, & ' Broj pridrz. cvorova : ',I5,



34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 97 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112

& ' Broj materijala : ',I5) C C UCITAVANJE KOORDINATA CVOROVA WRITE (11,30) WRITE (11,31) DO I=1,NPOIN READ (10,*) IPOIN, CVOR(IPOIN).CX, CVOR(IPOIN).CY, & CVOR(IPOIN).BC(1),CVOR(IPOIN).BC(2),CVOR(IPOIN).BC(3) WRITE (11,32) IPOIN, CVOR(IPOIN).CX, CVOR(IPOIN).CY, & CVOR(IPOIN).BC(1),CVOR(IPOIN).BC(2),CVOR(IPOIN).BC(3) ENDDO 30 FORMAT (/,/,' CVOR X Y PRIDRZ') 31 FORMAT ( '---------------------------------------------') 32 FORMAT (I5,2F14.3,5X,3I3) C C UCITAVANJE VEZE STAPOVA WRITE (11,40) WRITE (11,41) DO I=1,NELEM READ (10,*) IELEM, STAP(IELEM).MAT, & STAP(IELEM).C1, STAP(IELEM).C2, STAP(IELEM).C3 WRITE (11,42) IELEM, STAP(IELEM).MAT, & STAP(IELEM).C1, STAP(IELEM).C2, STAP(IELEM).C3 ENDDO 40 FORMAT (/,/,' STAP MAT C1 C2 C3') 41 FORMAT ( '---------------------------------') 42 FORMAT (2I5,3I7) C C UCITAVANJE MATERIJALNIH I GEOM. KARAKTERISTIKA DO I=1,NMATS READ (10,*) IMATS,GEOM(IMATS).A, GEOM(IMATS).I, & GEOM(IMATS).E, GEOM(IMATS).NI WRITE (11,50) IMATS,GEOM(IMATS).A, GEOM(IMATS).I, & GEOM(IMATS).E, GEOM(IMATS).NI ENDDO 50 FORMAT (//,' Materijal : ',I5,/ & ' Povrsina : ',F15.6,/ & ' Moment inercije : ',F15.6,/ & ' Modul elsticnosti : ',F15.6,/ & ' Poissonov koef. : ',F15.6) C C CRTANJE GEOMETRIJE U DXF-FILE C*** Entities section WRITE (88,'(A,/,A)') ' 0','SECTION' WRITE (88,'(A,/,A)') ' 2','ENTITIES' C L1='Konstrukci' DO ISTAP=1,NELEM X1=CVOR(STAP(ISTAP).C1).CX Y1=CVOR(STAP(ISTAP).C1).CY Z1=0.0 X2=CVOR(STAP(ISTAP).C2).CX Y2=CVOR(STAP(ISTAP).C2).CY Z2=0.0 CALL DXF_LINE (L1,X1,Y1,Z1,X2,Y2,Z2,1) ENDDO C CALL DXF_CLOSE() C C UCITAVANJE OPTERECENJA.... C C TIP OPTERECENJA 1 - CVORNO C MOZE SE ZADATI: SILA U SMJEROVIMA X I Y I MOMENT OKO Z C TIP OPTERECENJA 2 - JEDNOLIKO PO STAPU C ZADAJE SE Q - INTENZITET C L1 - POCETAK DJELOVANJA OD CVORA 1 C L - DUZINA DJELOVANJA DO LCVOR=1,NPOIN PLOAD(LCVOR).A=0.0 PLOAD(LCVOR).B=0.0 PLOAD(LCVOR).C=0.0 ENDDO DO LELEM=1,NELEM SLOAD(LELEM).A=0.0 SLOAD(LELEM).B=0.0 SLOAD(LELEM).C=0.0 ENDDO C 100 CONTINUE



113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146

READ (10,*) LCVOR,A,B,C PLOAD(LCVOR).A=A PLOAD(LCVOR).B=B PLOAD(LCVOR).C=C IF (LCVOR.NE.NPOIN) GOTO 100 C 200 CONTINUE READ (10,*) LELEM,A,B,C SLOAD(LELEM).A=A SLOAD(LELEM).B=B SLOAD(LELEM).C=C IF (LELEM.NE.NELEM) GOTO 200 C WRITE (11,61) DO LCVOR=1,NPOIN WRITE (11,60) LCVOR, & PLOAD(LCVOR).A,PLOAD(LCVOR).B,PLOAD(LCVOR).C ENDDO C WRITE (11,62) DO LELEM=1,NELEM WRITE (11,60) LELEM, & SLOAD(LELEM).A,SLOAD(LELEM).B,SLOAD(LELEM).C ENDDO C 60 FORMAT (I5,3F12.3) 61 FORMAT (/,' SILE U CVOROVIMA') 62 FORMAT (/,' OPTERECENJE NA ELEMENTIMA') C GOTO 9999 9990 WRITE (*,'(/,A40)') ' Nepostojeca ulazna datoteka!' C 9999 CONTINUE RETURN END

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

OSUBROUTINE FILNAM(FILEIN,FILEOU,EXT) OIMPLICIT NONE OCHARACTER*13 FILEIN, FILEOU OCHARACTER*3 EXT OINTEGER NUM, I ONUM=0 O DO I=1,9 O NUM=I O IF(FILEIN(I:I).EQ.' ') EXIT O IF(FILEIN(I:I).EQ.'.') EXIT O FILEOU(I:I)=FILEIN(I:I) O ENDDO C O FILEOU(NUM:NUM)='.' O DO I=1,3 O FILEOU((NUM+I):(NUM+I))=EXT(I:I) O ENDDO ORETURN OEND

Documents

Fortran - Kratke Upute Za Rad