Fortran/Wersja do druku
Z Wikibooks, biblioteki wolnych podręczników.
Aktualna, edytowalna wersja tego podręcznika jest dostępna w Wikibooks, bibliotece wolnych podręczników pod adresem
http://pl.wikibooks.org/wiki/Fortran
Całość tekstu jest objęta licencją GNU Free Documentation License.
[edytuj] Spis treści
-
- O podręczniku
- Wstęp
- Historia języka Fortran
- Wprowadzenie do języka Fortran
- Podstawowe wiadomości
- Zmienne
- Instrukcje sterujące
- Podstawowe działania matematyczne
- Procedury i funkcje
- Podstawowe operacje wejścia i wyjścia
- Wiadomości zaawansowane
- Preprocesor
- Operacje na łańcuchach
- Styl programowania
- Typy złożone
- Zarządzanie pamięcią
- Odnajdowanie błędów
- Przykłady
- Iloczyn macierzy
- Metoda najmniejszych kwadratów
- Dodatek A
- Fortran a C
- Łączenie języka C z językiem Fortran
- Dodatek B
- Inne dialekty języka Fortran
- Licencja
[edytuj] Spis treści
[edytuj] O podręczniku
[edytuj] Dla kogo przeznaczony jest ten podręcznik
Niniejszy podręcznik ma za zadanie wprowadzić każdą chętną osobę w świat programowania w języku Fortran. Nie jest wymagana przy tym umiejętność programowania (jeśli umiesz już programować w innym języku, będziesz mógł pominąć pewne informacje).
[edytuj] Jak ja mogę pomóc?
Twoja pomoc może dotyczyć wszystkiego w tym podręczniku. Możesz zarówno edytować podręcznik w celu powiększenia jego wartości merytorycznej. Jeśli dopiero się uczysz, to poprawiaj zauważone przez Ciebie błędy (przede wszystkim językowe). Nie bój się edycji.
[edytuj] Konwencje przyjęte w tym podręczniku
Aby łatwiej było czytać oraz edytować ten podręcznik wprowadzone zostają pewne zasady.
Kod źródłowy wyróżniamy poprzez wpisywanie go w odległości dwóch pustych znaków (spacji) od lewej krawędzi ekranu. Oto efekt:
oto kod źródłowy
W ten sam sposób możemy prezentować dialog programu z użytkownikiem.
[edytuj] Nawigacja
Aby ułatwić nawigację korzystamy z szablonu {{Subst:Naw}}. Przykład jego użycia możesz zobaczyć np. poprzez przeglądnięcie kodu źródłowego któregoś z modułów tego podręcznika.
[edytuj] Język
Edytując ten podręcznik pamiętaj o tym, że czytać go mogą zarówno inżynierowie, jak i początkujący programiści. Staraj się zatem, by język użyty do opisu działania programów był jak najbardziej przystępny oraz zrozumiały.
[edytuj] Autorzy
Wkład w powstanie tego podręcznika mieli:
[edytuj] Historia języka Fortran
[edytuj] Historia języka Fortran
Zanim w 1956 roku skonstruowano pierwszy komputer tranzystorowy (TX-0), istniał już język programowania wysokiego poziomu. Był nim, stworzony w latach 1954-1957, język Fortran. Wymyślił go wraz ze swoim zespołem John Backus, pracownik firmy IBM. Pierwszym wyzwaniem, z jakim musieli się zmierzyć twórcy Fortranu była wydajność. Obawiano się, że jeśli program napisany w języku wysokiego poziomu będzie zbyt wolny w stosunku do języków assemblerowych, to nikomu nie będzie chciało się go używać. Dołożono zatem wszelkich starań, aby nowy język był jak najbardziej zoptymalizowany. Efektem tego jest wydajność, porównywalna z językiem C. Kolejne standaryzacje przynosiły coraz więcej nowości oraz możliwości języka. W dniu dzisiejszym praktycznie wszystkie obliczenia aerodynamiczne, wytrzymałościowe i cieplne prowadzone są właśnie z użyciem języka Fortran.
[edytuj] Zobacz także
Aby przeczytać całą historię języka Fortran, odwiedź polską Wikipedię.
[edytuj] Wprowadzenie do języka Fortran
[edytuj] O języku Fortran
Język Fortran jest językiem kompilowanym. Oznacza to, że aby uruchomić nasz pierwszy program w Fortranie musimy go skompilować, czyli przetworzyć z postaci czytelnej dla człowieka na kod maszynowy. Historyczne uwarunkowania doprowadziły do tego, że kompilatory języka Fortran generują zoptymalizowany kod, dzięki czemu wykonanie programu, napisanego w Fortranie jest bardzo szybkie. Oprócz tego ważną cechą Fortranu jest jego przenośność. Podobnie, jak język C, także i Fortran jest językiem przenośnym - ale tylko w postaci kodu źródłowego. Natomiast w przeciwieństwie do języka C, Fortran posiada niejako "wbudowane" funkcje obsługi wejścia i wyjścia (Input-Output - I/O) oraz funkcje matematyczne. Np. potęgowanie posiada swój specjalny operator (o nich później). Język Fortran oferuje też ciekawe możliwości dla osób piszących programy pod systemy wieloprocesorowe lub programy równoległe.
[edytuj] Zastosowanie języka Fortran
Z rozdziału historia dowiedziałeś się, niektórych zastosowań języka Fortran. Jednak nie są to jedyne jego zastosowania. W jednym z dialektów napisano nawet system operacyjny.
[edytuj] Czego potrzebujesz
Aby rozpocząć przygodę z językiem Fortran musisz koniecznie zaopatrzyć się w:
- dowolny system operacyjny
- dowolny edytor tekstowy, który nie formatuje tekstu, lub ma funkcję zapisywania plików bez formatowania.
- kompilator języka Fortran - tutaj natrafisz na bardzo duży wybór
[edytuj] Edytor
Zamiast zwykłego edytora możesz wybrać Zintegrowane Środowisko Programistyczne (IDE), na przykład wtyczkę Photran do środowiska Eclipse.
[edytuj] Kompilator
Jak już wspomniałem, wybór kompilatora może sprawić Ci trudność. Będzie on zależał od systemu operacyjnego oraz możliwości Twojego budżetu. Oczywiście do nauki wystarczy Ci najprostszy, darmowy kompilator. W niniejszym podręczniku będziemy opierali się na najnowszym dziecku projektu GCC - gfortran. Krótką listę dostępnych kompilatorów, zawiera artykuł w polskiej Wikipedii. Niezłym punktem startu jest też anglojęzyczna strona The Fortran Company, na której oprócz informacji o komercyjnych pakietach, znajdziesz też sporo darmowych bibliotek i tutoriali.
Dość ciekawą rzeczą jest natomiast działanie kompilatora. Każdy kompilator języka Fortran składa się z dwóch części
- kompilatora właściwego, przetwarzającego program na kod maszynowy
- biblioteki uruchomieniowej
To właśnie w tym drugim elemencie przechowywane są najbardziej podstawowe funkcje. Bibliotekę uruchomieniową możemy porównać do biblioteki języka C w systemach UNIX (tak naprawdę, w systemach Uniksowych część biblioteki uruchomieniowej korzysta z biblioteki języka C). Kompilatory Fortranu umożliwiają także łączenie w jeden program kilku modułów napisanych zarówno w języku Fortran, jak i C. Temu zagadnieniu poświęcony jest ostatni rozdział tego podręcznika (Łączenie języka C z językiem Fortran).
[edytuj] Pierwsze spojrzenie na Fortran 90/95
[edytuj] Witaj świecie!
Zgodnie z tradycją pierwszym przykładem języka programowania powinien być program wyświetlający radosny napis "Hello World!". Oto kod tego programu w Fortranie 95 (albo w Fortranie 90, gdyż niewiele się między sobą różnią):
! ! To jest program przykładowy w Fortranie 90/95 ! program hello ! nieobowiązkowy ale zalecany początek programu print*, "Hello World!" ! wyświetlenie na ekranie napisu end program hello ! koniec programu - obowiązkowy, jeśli wcześniej jest słowo program
Zapiszmy nasz program w pliku hello.f95. Aby go uruchomić musisz wykonać czynność, zwaną kompilacją. Nasze przykłady oprzemy na kompilatorze gfortran. Aby uzyskać program wykonywalny w konsoli musisz wykonać:
gfortran hello.f95 -o hello
Aby uruchomić program należy wywołać ścieżkę dostępu do pliku, np.:
./hello
lub po prostu jego nazwę, jeśli katalog w którym się znajduje został dopisany do zmiennej środowiskowej $PATH.
[edytuj] Wiedza elementarna
- Język Fortran (niezależnie od wersji) nie rozróżnia wielkości znaków, czyli print* i PRINT* to dla kompilatora dokładnie ta sama instrukcja.
- W jednym wierszu można umieścić do 132 znaków.
- Spacje są ważne - służą do oddzielania słów kluczowych i identyfikatorów (oprócz spacji tę funkcję pełnią także inne białe znaki i znaki przestankowe). Nie wolno wstawiać spacji (ani innego znaku) wewnątrz słowa kluczowego lub identyfikatora.
- Komentarzem jest tekst od symbolu wykrzyknika do najbliższego znaku końca linii. Wyjątkiem jest sytuacja, gdy znak ! pojawia się w cytowaniu.
- Znak końca linii jest znakiem kończącym instrukcję.
- Jeśli chcemy kontynuować instrukcję w następnym wierszu musimy na końcu linii postawić znak &. Jeśli jednak chcemy przełamać napis otoczony cudzysłowem lub apostrofami to znak & musimy umieścić na końcu pierwszego i na początku drugiego wiersza.
- W przypadku, gdy chcemy umieścić kilka instrukcji w jednym wierszu oddzielamy je znakiem ;
- Język Fortran pozwala na używanie niezadeklarowanych zmiennych (co nie jest zalecane) - typ zmiennej zależy wówczas od pierwszej litery nazwy zmiennej. Nazwy zaczynające się na I,J,K,L,M,N to liczby całkowite, pozostałe to liczby zmiennoprzecinkowe. Możemy zrezygnować z tej możliwości (zalecamy!) umieszczając instrukcję implicit none zaraz po wierszu ze słowem program.
- Używany alfabet to litery małe: a-z i duże: A-Z, cyfry 0-9, znak podkreślenia _. Dozwolone są również następujące znaki specjalne: spacja, enter oraz +-*/<=>().,'";:!&%$?. Oprócz tego znane nam kompilatory w komentarzach i łańcuchach tekstowych pozwalają na użycie innych znaków, w tym polskich liter "z ogonkami".
- Struktura programu rozdziela część deklaracyjną od wykonywalnej - tzn. po użyciu jakiejkolwiek instrukcji wykonywalnej, nie można już deklarować zmiennych, stałych itp.
- Do cytowania napisów (stałych tekstowych) można używać zarówno znaku cudzysłowu " jak i apostrofu '. Przy czym jeśli rozpoczęliśmy cytowanie jednym znakiem, to trzeba zamknąć je tym samym - dzięki temu bez problemu można umieścić w łańcuchu same znaki cytowania np. "User's guide" (ten sam efekt uzyskamy pisząc 'User''s guide').
[edytuj] Zmienne
[edytuj] Czym jest i do czego służy zmienna?
Język Fortran jest językiem kompilowanym bezpośrednio do kodu maszynowego. Oznacza to, że nie posiada on żadnych mechanizmów, kontrolujących dostęp do pamięci (w przeciwieństwie np. do języka Java). Pamięć jest to nic innego, jak tylko ciąg bitów, które zależnie od interpretacji, mogą dla programu stanowić liczbę całkowitą, znak (jedną literkę), łańcuch (kilka literek) lub liczbę rzeczywistą (w notacji dziesiętnej z kropką). Aby wymusić interpretację ciągu bitów o określonej długości używamy tzw. typów zmiennej. Typ definiuje zwykle też długość zmiennej. Dzięki użyciu typów program wie, że np. zmienna x przechowuje jakąś liczbę całkowitą a zmienna y przechowuje liczbę rzeczywistą. Aby korzystać ze zmiennych musimy je uprzednio zadeklarować. W języku Fortran wykonuje się to w następujący sposób (według normy Fortran95):
typ_zmiennej :: nazwa_zmiennej
lub (według normy Fortran77) :
typ_zmiennej nazwa_zmiennej
[edytuj] Typy zmiennej
Typ zmiennej może odnosić się do różnego rodzaju danych, które mają być przechowywane w zmiennej.
[edytuj] Liczby
| Typ zmiennej | Opis | Przykładowe wartości |
|---|---|---|
| integer | liczba całkowita | 15, -6500, 200000000 |
| real | liczba zmiennoprzecinkowa pojedynczej precyzji | 3.1415, -5.5, .7e3, 12.5E-5 |
| double precision | liczba zmiennoprzecinkowa podwójnej precyzji | 3.1415D0, -5.5D0, .7d3, 12.5D-5 |
| complex | liczby zespolone (kombinacja części rzeczywistej i urojonej) | (3.1415, -5.5), (1.4, 7.1E4) |
Zmienne liczbowe mogą być podawane w różnych systemach liczbowych. Domyślnie przyjmowany jest dziesiętny, jednak, aby kompilator wiedział, że używasz innego systemu, przyjmuje się następujące założenia:
| Zapis | System |
|---|---|
| Z"liczba" lub Z'liczba' | szesnastkowy |
| O"liczba" lub O'liczba' | ósemkowy |
| B"liczba" lub B'liczba' | binarny |
Język Fortran dopuszcza także definiowanie przez programistę rozmiaru zmiennej. Uzyskuje się to poprzez dodanie w deklaracji zmiennej następującej konstrukcji:
real*4 nazwa_zmiennej lub real nazwa_zmiennej -domyślny typ lub real(kind=4)::nazwa_zmiennej
oznacza 4-bajtową liczbę rzeczywistą. Natomiast, aby uzyskać typ podwójnej precyzji używamy konstrukcji:
real*8 nazwa_zmiennej. lub real(kind=8)::nazwa_zmiennej
w niektórych kompilatorach możemy uzyskać poczwórną precyzje.
real(kind=16)::nazwa_zmiennej
[edytuj] Wartości logiczne
Do przechowywania wartości logicznych także przeznaczono specjalny typ danych.
| Typ | Opis | Możliwe wartości |
|---|---|---|
| logical | Przechowywanie wartości logicznej | .TRUE. lub .FALSE. |
[edytuj] Znaki i łańcuchy
Przechowywanie pojedynczych znaków odbywa się przy pomocy typu CHARACTER. Natomiast deklarowanie łańcucha polega na dodaniu * oraz długości łańcucha (w znakach). Oznacza to, że aby przechować np. nazwę "pl.Wikibooks" musimy napisać tak:
character*12 :: nazwa="pl.Wikibooks" print *, nazwa
Uwagi, dotyczące długości poszczególnych typów danych:
- dla typu integer możliwe jest zaalokowanie 1, 2, 4 lub 8 bajtów
- dla typu real odpowiednio 4 lub 8
- dla typu Complex 8 lub 16
- dla typu character nie ma ograniczeń długości
[edytuj] Stałe
Język Fortran umożliwia także deklarację zmiennych, których zawartości nie da się zmieniać. Są to tzw. stałe. Deklaruje się je podobnie do zmiennych, z tą jednak różnicą, że przy nazwie typu dodajemy słowo parameter. Dla standardu Fortran 95 wygląda to następująco:
typ, parameter :: nazwa = wartość
Natomiast według Fortran 77 wygląda to tak:
typ nazwa parameter (nazwa=wartość)
Uwaga: kompilator języka Fortran nie zasygnalizuje błędu, jeśli stałej w kodzie programu przypiszesz inną wartość! Np.
integer, parameter :: p = 3 print *, "p=",p parameter p = 9 print *, "p=",p
[edytuj] Tablice
Czasami zdarza się, że potrzebujemy przechować więcej niż jedną wartość danego typu (np. real). Język Fortran umożliwia nam zestawianie kilku zmiennych w tzw. tablicę. Definiuje się ją następująco:
typ zmienna(wymiar)
gdzie wymiar oznacza ilość zmiennych tego samego rodzaju. W tym przypadku będzie to tablica jednowymiarowa. Możemy jednak używać tablic wielowymiarowych, np. 2x2:
real tablica(2,2)
Nie należy jednak definiować tablicy o zbyt dużej ilości wymiarów - niesie to ze sobą duże zużycie pamięci.
 |
W przeciwieństwie do innych języków programowania (np. do C, ale nie do Pascala), Fortran numeruje elementy tablicy od 1!! (Chyba, że ustalimy inaczej) |
[edytuj] Sposoby deklaracji tablic
W przeciwieństwie do np. języka C, język Fortran umożliwia programiście deklarację tablicy na wiele różnych sposobów. Oto niektóre z nich:
Sposób pierwszy:
real tablica(10)
Sposób drugi:
real tablica dimension tablica(10)
Sposób trzeci:
integer index parameter (index=10) real tablica(index)
Sposób czwarty:
real tablica(0:9)
W specyfikacji F95, deklaracja różni się tylko tym, że używany jest dwukropek (::).
[edytuj] Modyfikowanie zawartości tablicy
Aby zmodyfikować jakiś element tablicy, musimy znać jego położenie. Do tego celu służy tzw. indeks. Aby zmodyfikować pierwszy i drugi element tablicy piszemy:
tablica(1) = 0.4 tablica(2) = 0.3
Odczyt zawartości jakiegoś elementu tablicy dokonuje się w analogiczny sposób:
print *, "Tablica[1]=", tablica(1)
[edytuj] Instrukcje sterujące
[edytuj] Logika
Na początku warto zastanowić się, na podstawie czego komputer może podejmować decyzję. Zwykle odbywa się to na podstawie jednej z dwóch wartości - prawdy, oznaczanej w Fortranie jako .TRUE. oraz fałszu, oznaczanego jako .FALSE.. Mamy również pewien zbiór operacji logicznych. Oto one:
| operacja | nazwa |
|---|---|
| .NOT. | negacja |
| .AND. | koniunkcja |
| .OR. | alternatywa |
| .EQV. | równoważność |
| .NEQV. | zaprzeczenie równoważności |
Działanie tych operatorów najlepiej zademonstruje ta tabelka:
| A | B | .NOT. A | A .AND. B | A .OR. B | A .EQV. B | A .NEQV. B |
|---|---|---|---|---|---|---|
| .TRUE. | .TRUE. | .FALSE. | .TRUE. | .TRUE. | .TRUE. | .FALSE. |
| .TRUE. | .FALSE. | .FALSE. | .FALSE. | .TRUE. | .FALSE. | .TRUE. |
| .FALSE. | .TRUE. | .TRUE. | .FALSE. | .TRUE. | .FALSE. | .TRUE. |
| .FALSE. | .FALSE. | .TRUE. | .FALSE. | .FALSE. | .TRUE. | .FALSE |
Porównując dwie liczby możemy np. ocenić ich wzajemną relację, tzn. czy liczba a jest większa, mniejsza a może równa. W języku Fortran możemy do tego celu użyć dwóch grup operatorów. Jedna grupa znana jest zapewne programistom, tworzącym swe programy w językach C oraz Pascal (tzn. >, <, = (lub == w C), >=, <=). Oprócz nich w języku Fortran możemy także używać:
| operator | opis |
|---|---|
| .LT. | ang. less than - inaczej < |
| .LE. | ang. less equal - inaczej <= |
| .GT. | ang. greater than - inaczej > |
| .GE. | ang. greater equal - inaczej >= |
| .EQ. | ang. equal - inaczej == (lub = w Pascalu) |
| .NE. | ang. not equal - inaczej != (lub <> w Pascalu) |
[edytuj] GOTO
Jest to pierwsza instrukcja, jaką poznasz. Czytając wprowadzenie do tego podręcznika zapamiętałeś (a jeśli nie, to masz tutaj link), że w języku Fortran ma znaczenie liczba spacji. Wiesz także, że pierwsze 1-5 spacji przeznaczone jest na pewną liczbę z zakresu od 1 do 99999. Owe liczby nie są tylko po to, aby numerować linijki kodu źródłowego (zresztą i tak czasami byłoby ich za mało). Oznaczają one mniej więcej to, co etykiety w języku C. To dzięki nim możemy określić punkt w kodzie programu, do którego możemy potem "przeskoczyć". Do "skakania" po kodzie programu służy instrukcja GOTO. Oto przykład użycia:
program skok goto 10 write (*,*) "Skakanka..." 10 continue end program skok
Efekt działania tego programu jest oczywisty... program po prostu zakończy swe działanie. W kodzie programu została także użyta instrukcja CONTINUE, która powoduje po prostu dalsze wykonywanie programu.
|
Porada Instrukcja goto łamie sekwencję instukcji i powoduje skok do dowolnie odległego miejsca w programie - co może mieć nieprzewidziane skutki. Zbyt częste używanie goto może prowadzić do trudnych do zlokalizowania błędów. Oprócz tego kompilatory mają kłopoty z optymalizacją kodu, w którym występują skoki. Z tego powodu zaleca się ograniczenie zastosowania tej instrukcji wyłącznie do opuszczania wielokrotnie zagnieżdżonych pętli. |
[edytuj] IF
Nasz program powinien mieć możliwość reagowania na zawartość np. zmiennych. Przyjrzyjmy się zatem instrukcji IF. Służy ona do zdefiniowania czynności, które mają być wykonane w momencie prawdziwości jakiegoś warunku. Użycie instrukcji IF wygląda mniej więcej tak:
IF (warunek) instrukcje do wykonania
Ważne jest przy tym, aby instrukcje te były wpisane w tej samej linijce, co IF - w przeciwnym wypadku kompilator zasygnalizuje błąd.
[edytuj] IF - THEN
Jedna linijka to mało. Czasami potrzebujemy wykonać tak dużo instrukcji, że po prostu nie zmieszczą się w jednej linijce. Do tego celu powstała konstrukcja IF - THEN. Ogólnie rzecz biorąc jej zastosowanie wygląda tak:
IF (warunek) THEN instrukcje do wykonania END IF
[edytuj] IF - THEN - ELSE
W tworzeniu programu zdarzają się też przypadki, w których program powinien zareagować także na sytuację przeciwną do warunku. Wtedy z pomocą przychodzi konstrukcja IF - THEN - ELSE:
IF (warunek) THEN instrukcje do wykonania ELSE instrukcje do wykonania w przeciwnym wypadku END IF
[edytuj] SELECT - CASE
Jeśli musimy zareagować na większą ilość warunków, to zamiast powtarzać konstrukcję if-else lepiej użyć select-case. Użycie tej konstrukcji jest bardzo proste:
select case (wyrażenie)
case (warunek1)
instrukcje do wykonania w przypadku wyrażenie == warunek1
case (warunek2)
instrukcje do wykonania w przypadku wyrażenie == warunek2
[case default
instrukcje do wykonania w innych przypadkach ]
end select
Zastosowanie tej pętli w praktyce jest bardzo proste. Przeanalizujmy następujący przykład:
program test
implicit none
integer :: i
i = 123
select case (i)
case (123, 125)
print *, "i=123 lub i=125"
case (10:30)
print *, "i zawiera się w przedziale od 10 do 30"
case default
print *, "inny przypadek"
end select
end program test
[edytuj] Pętle
Może się zdarzyć, że w twoim programie jakaś czynność (bądź kilka czynności) będzie musiała być wykonana kilka razy pod rząd. Oczywiście nie ma sensu kilka razy kopiować i wklejać tego samego kodu. W takich przypadkach z pomocą przychodzą nam pętle. Pętla jest to instrukcja, która umożliwia wielokrotne powtarzanie tego samego kodu. W języku Fortran wyróżnia się kilka rodzajów pętli. Zostaną one omówione poniżej.
[edytuj] do
Najprostszą pętlą jest pętla do. Wygląda ona tak:
[nazwa] do zmienna=wartość początkowa, wartość końcowa [,skok co]
instrukcje
end do [nazwa]
Aby np. policzyć do dziesięciu, licząc po dwa możemy napisać coś takiego:
do i=0, 10, 2
print *, "Doliczyłem do ",i
end do
Jak widzisz, nie musisz wcześniej deklarować zmiennej i. Kompilator automatycznie użyje typu integer. Minusem tej pętli jest to, że krokiem może być tylko liczba całkowita. Za to wielkim plusem jest automatyczne sprawdzanie zakresów. Np. pisząc pętlę od 0 do 10 z krokiem 3 ostatnią wartością będzie 9.
[edytuj] do-if-exit
Pętla ta wykonuje się w nieskończoność, dopóki nie wystąpi instrukcja exit. Instrukcja ta jest zwykle efektem spełnienia jakiegoś warunku. Zwykle wygląda to tak:
[nazwa] do
instrukcje
if (warunek logiczny) exit
instrukcje
end do [nazwa]
W przeciwieństwie do pętli omówionej powyżej, możemy tutaj użyć typu real jako licznika. Oto przykład:
real :: p=0
do
p = p+0.5
if (p>10) exit
print *, "A teraz jest: ",p
end do
[edytuj] Podstawowe działania matematyczne
[edytuj] Operatory matematyczne
Język Fortran posiada specjalną grupę operatorów, które służą tylko do działań matematycznych. Są to m.in.:
| operator | działanie |
|---|---|
| + | dodawanie |
| - | odejmowanie |
| * | mnożenie |
| / | dzielenie |
| ** | potęgowanie |
Oprócz nich, w skład specyfikacji języka Fortran wchodzą także funkcje matematyczne, które zostaną omówione poniżej.
[edytuj] ABS
Oblicza wartość bezwzględną z danej liczby. Przykład użycia:
program abcd
real :: x
x = abs (-0.45)
print *, "|-0.45|=",x
end program abcd
[edytuj] ACOS
Jest to instrukcja, obliczająca wartość arcus cosinus dla podanego argumentu. Funkcja zwróci wynik w radianach. Przykład użycia:
program abc real :: x x = acos (0.9) print *, "arccos(0.9)=",x end program abc
[edytuj] dACOS
Jest to instrukcja, obliczająca wartość arcus cosinus z liczby o podwójnej precyzji dla podanego argumentu. Funkcja zwróci wynik o podwójnej precyzji w radianach. Przykład użycia:
program Dabc real (kind=8):: x,a a=0.9 x = dacos (a) print *, "arccos(0.9)=",x end program Dabc
[edytuj] dACOSd
Jest to instrukcja, obliczająca wartość arcus cosinus z liczby o podwójnej precyzji dla podanego argumentu. Funkcja zwróci wynik o podwójnej precyzji w stopniach. Przykład użycia:
program Dabcd real (kind=8):: x,a a=0.9 x = dacosd (a) print *, "arccos(0.9)=",x,stopnie' end program Dabcd
 |
Do zrobienia: dorobić resztę funkcji |
[edytuj] Procedury i funkcje
Tworząc programy niejednokrotnie zdarzy Ci się powtarzać kilkakrotnie ten sam fragment kodu. Będzie on dotyczył różnego rodzaju czynności. Może także się zdarzyć, że będziesz potrzebował użyć języka Fortran w projekcie, który będzie tworzony przy użyciu języka C. W podobnych przypadkach użyjesz funkcji. Funkcję można zdefiniować jako wydzielony fragment programu wyspecjalizowany do wykonywania określonej czynności. W tytule tego rozdziału zostało także użyte słowo procedura. Jest to z kolei pewien przypadek funkcji, kiedy nie zwraca ona żadnej wartości - np. wyniku obliczeń. Różni się ona przy tym sposobem deklaracji oraz wywołania.
[edytuj] Korzystanie z funkcji
Ucząc się trudnej sztuki programowania z tego podręcznika spotkałeś się już z funkcjami. Dobrym przykładem mogą tu być funkcje write oraz print, które służą do obsługi wyjścia programu. Funkcję wywołuje się w następujący sposób (elementy w nawiasach kwadratowych są nieobowiązkowe):
[zmienna =] nazwa_funkcji([argumenty funkcji])
W języku Fortran istnieje także możliwość przypisania funkcji pewnej wartości i korzystania z niej jako ze zmiennej. Oto jej deklaracja:
nazwa_funkcji([argumenty funkcji]) = wartość
[edytuj] Deklarowanie funkcji
W języku Fortran funkcję definiuje się w sposób następujący:
[typ danych] FUNCTION nazwa_funkcji ([argumenty funkcji])
instrukcje...
END
[edytuj] Zwracanie wartości
W przeciwieństwie, do np. C w Fortranie wartość, która ma zostać zwrócona jest przypisywana nazwie funkcji. Natomiast słowo RETURN powoduje natychmiastowe wyjście z funkcji. Wygląda to mniej więcej tak:
real function kwadrat (a)
real, intent(in) :: a
kwadrat = a**2
return
end function
[edytuj] Funkcja rekurencyjna
W języku Fortran stworzenie funkcji rekurencyjnej nie jest takie proste a dodatkowo nie jest zgodne ze standardem f77. Aby funkcja mogła wywołać samą siebie musimy użyć słowa recursive:
recursive function nazwa
nazwa()
end function nazwa
[edytuj] Procedura
Oprócz funkcji, wyróżniamy jeszcze procedurę. Definiuje się ją tak:
subroutine nazwa_procedury ([argumenty])
instrukcje
[return]
end subroutine nazwa_procedury
Aby wywołać procedurę musisz użyć instrukcję call:
call nazwa_procedury ([argumenty])
[edytuj] Podstawowe operacje wejścia i wyjścia
Język Fortran posiada własne mechanizmy zarządzania wejściem i wyjściem. W przeciwieńtwie do języków niskopoziomowych nie korzysta bezpośrednio z zestawu funkcji dostarczanych przez system operacyjny[1]. Dlatego też w Fortranie samemu można definiować takie elementy, jak np. uchwyt pliku, który w innych językach (np. C) otrzymuje się od funkcji otwierającej plik.
[edytuj] Podstawowe funkcje
[edytuj] open
Aby móc wykonywać jakiekolwiek operacje na pliku (np. odczytywanie lub zapis do pliku) musimy go najpierw otworzyć, czyli powiadomić system operacyjny komputera, że dany plik będzie używany przez nasz program. W języku Fortran otwarcie pliku wiąże się także z przypisaniem mu identyfikatora (czyli dodatniej liczby całkowitej), który posłuży do identyfikacji pliku w kodzie programu. Otwarcie pliku może nastąpić także z różnymi opcjami. Na przykład, jeśli chcemy tylko odczytywać dane z pliku to nasz plik powinien zostać otwarty w trybie tylko do odczytu (ro, read only).
Język Fortran do otwierania plików korzysta z funkcji open. Najogólniej dany plik można otworzyć tak:
open (20, file="sciezka/nazwa pliku", iostat=stat)
Takie wywołanie fukcji oznacza "otwórz plik 'sciezka/nazwa pliku' i nadaj mu identyfikator 20". Od tego momentu funkcje odczytujące i zapisujące dane do pliku mogą korzystać z pliku.
[edytuj] Preprocesor
[edytuj] Operacje na łańcuchach
[edytuj] Styl programowania
[edytuj] Typy złożone
[edytuj] Zarządzanie pamięcią
[edytuj] Odnajdowanie błędów
[edytuj] ftnchek
Jednym z użytecznych programów do odnajdowania błędów w kodzie napisanym w języku Fortran jest program ftnchek.
Dla przykładu sprawdźmy plik test.f:
program test
call nie_ma(0.4)
print*,'zapomnialem ostatnie apostrof
end
komenda
ftnchek test.f
daje następującą informację:
FTNCHEK Version 3.3 November 2004
File test.f:
3 print*,'zapomnialem ostatnie apostrof
^
Error near line 3 col 46 file test.f: Closing quote missing from string
1 syntax error detected in file test.f
Warning: Subprogram NIE_MA never defined
Invoked in module TEST line 2 file test.f
Pokazuje on jeden błąd w lini 3 w kolumnie 46 (brakuje apostrof (quote)), i uważa, że subroutine nie_ma (lub NIE_MA) nie jest zdefiniowany.
[edytuj] Linki zewnętrzne
[edytuj] Iloczyn macierzy
Poniższy program w FORTRAN-77 sprawdza wymiary macierzy, następnie, jeżeli wymiary macierzy umożliwiają wykonanie operacji mnożenia, pobiera od użytkownika zawartość macierzy i wyświetla macierz będącą iloczynem wprowadzonych macierzy.
PROGRAM iloczyn macierzy
REAL A(10,10), B(10,10), C(10,10)
INTEGER Aw,Ak,Bw,Bk,Cw,Ck,i,j,k
PRINT *,'Wprowadz wymiary macierzy A (w,k)'
READ *,Aw,Ak
PRINT *,'Wprowadz wymiary macierzy B (w,k)'
READ *,Bw,Bk
IF (Ak.NE.bw) THEN
PRINT *,'Nie zgadzaja sie wymiary macierzy'
STOP
ENDIF
Cw=Aw
Ck=Bk
PRINT *,'Wprowadz wiersze macierzy A'
DO i=1,Aw
READ *,(A(i,j),j=1,Ak)
ENDDO
PRINT *,'Wprowadz wiersze macierzy B'
DO i=1,Bw
READ *,(B(i,j),j=1,Bk)
ENDDO
DO i=1,Cw
DO j=1,Ck
C(i,j)=0
DO k=1,Ak
C(i,j)=C(i,j)+A(i,k)*B(k,j)
ENDDO
ENDDO
ENDDO
PRINT *,'Macierz wynikowa ='
DO i=1,Cw
PRINT *,(C(i,j),j=1,Ck)
ENDDO
END
[edytuj] Metoda najmniejszych kwadratów
Poniższy program w FORTRAN-77 przybliża punkty pomiarowe prostą o równaniu y = ax + b wyliczając wartości współczynników a i b oraz ich niepewności.
PROGRAM metoda_najmniejszych_kwadratow
REAL x(20), y(20), a, b, xSredn, D,
1 yDelta, aDelta, bDelta
INTEGER n
PRINT *,
PRINT *,
PRINT *, 'Program dopasowuje prosta do zbioru punktow'
PRINT *, 'doswiadczalnych wykorzystujac metode najmniejszych'
PRINT *, 'kwadratow, ponadto oblicza odchylenia standardowe'
PRINT *, 'obydwu parametrow prostej.'
PRINT *,
PRINT *, 'Wprowadz liczbe punktow dosw. (min=3,maks=20)..'
READ *, n
IF ( (n.GT.20) .OR. (n.LT.3) ) THEN
PRINT *, 'Liczba spoza zakresu !!'
STOP
ENDIF
PRINT *, 'Wprowadz wspolrzedne punktow (na przemian: odcieta'
PRINT *, 'i rzedna oddzielone spacja lub ENTER bez nawiasow'
PRINT *, 'i przecinkow, wartosci calkowite od dziesietnych'
PRINT *, 'oddzielone kropka)...'
READ *, (x(i), y(i), i=1, n)
xSredn=0
DO i=1, n
xSredn = xSredn + x(i)
ENDDO
xSredn = xSredn / n
D=0
DO i=1, n
D = D + ( x(i) - xSredn )**2
ENDDO
IF (D.EQ.0) THEN
PRINT *, 'Wprowadzone punkty sugeruja, ze szukana prosta'
PRINT *, 'bedzie rownolegla do osi Oy, co uniemozliwia'
PRINT *, 'obliczenie wartosci wspolczynnikow a i b rownania.'
STOP
ENDIF
a=0
DO i=1, n
a = a + y(i) * ( x(i) - xSredn )
ENDDO
a = a / D
b=0
DO i=1, n
b = b + ( y(i) - a*x(i) )
ENDDO
b = b / n
yDelta = 0
DO i=1, n
yDelta = yDelta + ( y(i) - a*x(i) - b )**2
ENDDO
yDelta = yDelta / (n-2)
yDelta = SQRT(yDelta)
aDelta = yDelta / SQRT( D )
bDelta = yDelta * SQRT( 1/n + (xSredn**2)/D )
PRINT *, 'Wprowadzone punkty najlepiej przybliza prosta:'
PRINT *, ' y =', a, ' x +', b, ' ,'
PRINT *, 'przy czym bledy wspolczynnikow a i b maja wartosc odp.:'
PRINT *, ' ', aDelta, ' , ', bDelta
END
[edytuj] Fortran a C
[edytuj] Łączenie języka C z językiem Fortran
[edytuj] Inne dialekty języka Fortran
[edytuj] FORTRAN-77
W języku FORTRAN-77 i starszych pozycja znaku w lini kodu wpływała na jego znaczenie. Instrukcje języka umieszczano między 7 a 72 kolumną. Zatem program hello.f (zwróć uwagę na rozszerzenie) będzie wyglądał tak:
C To jest program przykładowy w FORTRAN-77
program hello
write (*,*) "Hello world"
end program hello
Uwaga - znaki odstępu (spacje) na początku linijki kodu mają znaczenie! Kompilacja i uruchomienie wygląda tak:
gfortran hello.f -o hello ./hello
Oto ściąga, która wyjaśnia co oznaczają odpowiednie odstępy:
| Odległość (w spacjach) | Zawartość | Znaczenie |
|---|---|---|
| 1 | znak C lub * | Komentarz, lub kontynuacja komentarza |
| 1 do 5 | liczba pomiędzy 1 do 99999 | numer linijki (działa jako etykieta w instrukcji skoku) |
| 6 | wyrażenia, rozpoczynające określony blok kodu | |
| 7 do 72 | różne wyrażenia | instrukcje Fortranu |
| 73 do 80 | komentarz |
Błąd rozszerzenia cite: Istnieje znacznik <ref>, ale nie odnaleziono znacznika <references/>
