Přeskočit na obsah
⤶
Fortran

Proměnné

Co jsou

Program si můžeme prozdělit na dvě části: data a algoritmy, které s nimi pracují. Data ukádáme do proměnných, které deklarujeme na začátku programu (za implicit none). Proměných je několik typů a liší se typem dat v nich uložených.

  • integer - celé číslo - 112, -659, 9057
  • real - desetiné číslo - 15., 42.567, 6.022e23, -98.003
  • complex - komplexní číslo - (1.0,0.0), (-98.,15.1), (0.0,-1.0)
  • character - řetězec - "Tohle je text", "pi je priblizne 3.14", "123.9"
  • logical - logická proměnná - nabývá pouze dvou hodnot .true. nebo .false.

Deklarace proměnných

    program priklad_2
    implicit none
    
    	real, parameter :: pi = 3.1415926535
    
    	integer :: n = 5, m = 4
    	integer i,j
    	real a,b,c
    	complex z
    	character g
    
    	!sem budu psat svuj kod
    
    end program
  • Proměnné deklarujeme na začátku programu za implicit none. Později v programu již nemůžeme typ proměnné změnit. Tím že vybíráme typ proměnné, říkáme kolik paměti si má program zabrat a jak má s proměnnou zacházet. Základní deklarace vypadá takto:
    integer i,j
        real a,b,c
        complex z
        character g
  • Pokud chceme proměnné při deklaraci nastavit počáteční hodnotu, musíme použít mezi typem a názvem proměnné operátor ::.
    integer :: n = 5
  • Pokud chceme aby hodnota proměnné byla neměnná, tj. aby byla konstantou, můžeme ji přiřadit specifikaci ,parameter ::.
    real, parameter :: pi = 3.1415926535

Deklarace proměnné typu character

    program priklad_3
    implicit none
    
    	character :: t1 = "?"
    	character(len=15) :: t2 = "answer is 42!"
    
    	write(*,*) t1! Vypíše proměnnou t1
    	write(*,*) t2! Vypíše proměnnou t2
    
    end program

Pokud deklarujeme proměnnou typu character jako v programu priklad_1, získáme proměnnou g, která může obsahovat pouze 1 znak (“a”, “b”, “c”, …, “1”, “2”, …, ”)”, ”!”, ”*”, …). Pokud potřebujeme delší řetězce, postupujeme takto:

    character(len=15) g

Nyní bychom dostaly proměnnou typu character o délce 15.

Deklarace číselných proměnných podrobněji

    program priklad_4
    implicit none
    
    	integer(4) i
    	real(4) a
    	complex(4) z
    
    	integer(8) i2
    	real(8) a2
    
    	write(*,*) huge(a) ! Vypíše nejveší možné číslo které lze uložit do proměnné a tj. real(4)
    	write(*,*) huge(a2) ! Vypíše nejveší možné číslo které lze uložit do proměnné a2 tj. real(8)
    
    	write(*,*) tiny(a) ! Vypíše nejmenší možné kladné, nenulové číslo které lze uložit do proměnné a tj. real(4)
    	write(*,*) tiny(a2) ! Vypíše nejmenší možné kladné, nenulové číslo které lze uložit do proměnné a tj. real(8)
    
    	write(*,*) huge(i) ! Vypíše nejveší možné číslo které lze uložit do proměnné i tj. integer(4)
    	write(*,*) huge(i2) ! Vypíše nejveší možné číslo které lze uložit do proměnné i2 tj. integer(8)
    
    end program

Říkal jsem, že proměnná si zabere místo v paměti. Otázkou je: kolik paměti? a jak velké číslo se do té paměti vejde? nebo kolik desetiných míst?

Deklaraci z programu priklad_2 můžeme přepsat také do této podoby:

    integer(4) i,j
    real(4) a,b,c
    complex(4) z

(tj. real = real(4) apod. integer a complex)

Kde (4) je množství paměti v bajtech, kterou si proměnná zabere. Pro velikost proměnné se používají násobky dvou tj. 1,2,4,8,16,32,… Volbu (4) je běžně nazýváno jako jednoduchá přesnost a (8) jako dvoujtá přesnot. Používání dvojité přesnosti je doporučeno.

Dvojitá přesnost

    program priklad_5
    implicit none
    
    	real(4) :: a4 = 1.234567890123456789
    	real(8) :: a8 = 1.234567890123456789
    	real(8) :: a8_d = 1.234567890123456789d0
    
    	write(*,*) a4 ! Vypíše 1.23456788
    	write(*,*) a8 ! Vypíše 1.23456788 a dalsích 8 cisel ktere byla zadana
    	write(*,*) a8_d ! Vypíse 1.2345678901234567
    
    end program
  • Používání dvojité přesnosti má svá specifika. např. když udáváme hodnotu v exponenciálním tvaru nepoužíváme e, ale d:
    real(4) :: a = 6.022e23
        real(8) :: b = 6.022d23
  • U čísla které je real(8) musí být vždy alespoň d0. V příkladu 5 můžeme vidět, že proměnná a8 je sice inicializována jako real(8), ale ukládáme do ni číslo zapsané ve formátu real(4) tedy bez d0 na konci.
  • V případě že nepotřebujeme desetiná místa zapisujeme číslo real(8) například takto: 123.d0.

Aritmetické operace s proměnnými

    program priklad_6
    implicit none
    
    	integer :: i = 3
    	real a,b
    
    	a = 5.
    	b = 3.5
    
    	write(*,*) a+b ! Sečte a a b a výsledek vypíše
    	write(*,*) a-b ! Odečte a a b a výsledek vypíše
    	write(*,*) a*i ! vynásobí a*i a vysledek vypíše
    	write(*,*) a/b ! vydědí b a a vysledek vypíše
    	write(*,*) b**i ! umocní b na i a vysledek vypíše
    
    end program

Pro číselné proměnné můžeme pužít základní operátory pro sčítání, odčítání, násobení, dělení (+ - * /) a navíc operátor pro mocninu (**).

Převod datových typů

iteger na real

Převod iteger na real se provádi většinou automaticky, např.

    integer :: i = 5
    real a
    
    a = 1
    a = 1.0*i

V tomto kódu se do a uloží 1.0 i když by bylo vhodnější napsat alespň a=1.. V dalším řádku se do a uloží 5.0.

V některých případech je ovšem nutné převod provést explicitně. To uděláme pomocí příkazů real() pro jednoduchou přesnost a dble() pro dvojitou přesnost.

    program priklad_7
    implicit none
    
    	integer :: i=2
    	real(4) :: a
    	real(8) :: b
    
    	a = sin(real(i))
    	write(*,*) a ! vypíše 0.909297407
    
    	a = sin(1.0*i)
    	write(*,*) a! vypíše 0.909297407
    
    	b = sin(dble(i))
    	write(*,*) b! vypíše 0.90929742682568171
    
    	b = sin(1d0*i)
    	write(*,*) b! vypíše 0.90929742682568171
    
    end program

V tomto případě používáme funkci sin(), která vrací sinus argumentu, kde argument musí být real (popř. complex).

real na integer

    program priklad_8
    implicit none
    
    	real :: a = 5.49, b = 5.51
    
    	write(*,*) int(a)! vypíše 5
    	write(*,*) int(b)! vypíše 5
    
    	write(*,*) nint(a)! vypíše 5
    	write(*,*) nint(b)! vypíše 6
    
    	write(*,*) ceiling(a)! vypíše 6
    	write(*,*) ceiling(b)! vypíše 6
    
    	write(*,*) floor(a)! vypíše 5
    	write(*,*) floor(b)! vypíše 5
    
    end program

Pokud potřebujeme získat z realu integer musíme jej zaokrouhlit. K tomuto účelů má fortran několik funkcí: int() - odřízne desetinou část, nint() - zaokrouhlí na nejbližší celé číslo, ceiling() - zakokrouhlí nahoru, floor() - zaokrouhlí dolů.

complex na real, real na complex

Ze dvou raálných čísel lze získat komplexní číslo pomocí funkce cmplx():

    real a,b
    complex c
    
    c = cmplx(a,b)

Zde budeme mít v proměnné c uloženo komplexní číslo, jehož reálná část bude rovna a a imaginární část bude b

Z komplexního čísla můžeme zítskat reálnou část pomocí funkce real() a imaginární část pomocí aimag().

Logické výrazy

    program priklad_9
    implicit none
    
    	logical a, b
    
    	a = 5 > 1
    	b = 5 < 1
    
    	write(*,*) a! vypíše T jako true, protze plati ze 5 je vetsi nez 1
    	write(*,*) b! vypíše F jako false, protze NEplati ze 5 je vetsi nez 1
    
    	write(*,*) a .and. b! vypíše F, protoze a=.false. a b=.true.
    	write(*,*) b .and. b! vypíše F, protoze na obou stranách výrazu je .false. 
    	write(*,*) a .and. a! vypíše T, protoze na obou stranách výrazu je .true., tedy nalevo "a zaroven" napravo 
    	write(*,*) a .or. b! vypíše T, protoze alespon jeden z vrazu je .true. tj. a "nebo" b je .true. 
    	write(*,*) .not. a! vypise F protoze a=.true.
    	write(*,*) a .eqv. b! vypise F protoze vyrazy nejsou ekvivalentni 
    
    end program

Jak již bylo řečeno proměnná typu logical může nábývat pouze hodnot .true.(pravda) nebo .false.(nepravda).

Logický výraz můžeme získat pomocí logických operátorů ==, >=, <=, <, >, /=(není rovno). Tyto operátory aplikujeme na číselné proměnné.

Proměnné typu logical můžeme porovnávat pomocí operátorů .and. - a zároveň, .or. - nebo, .not. - negace, .eqv. - je ekvivalentní, .neqv. - není ekvivalentní.