Datové typy

Odvozené typy

Pomocí základních typů umožňuje fortran též definovat odvozené typy. To umožňuje konstrukci vlastních programových knihoven, použití pointerů a podobně.

Vlastní typy se definují pomocí popisu typedef. Slouží k definování strukturovaných dat. Takto nově definovaný typ pak použijeme příkazem type. Na složky typu se dostaneme prostřednictvím operátoru % Celé si to ukážeme v praxi, kdy se pokusíme nadefinovat operace s quaterniony což jsou čtveřice čísel analogických komplexním číslům. Dnes jsou ve fyzice nahrazeny spinory. Napíšeme modul, který definuje jak typ tak základní operace s nimi. Přitom provedeme takzvané přetížení operátorů. Pomocí definice typu můžeme též rozšířit množinu základních operací běžných operátorů. Zároveň můžeme vytvořit vlastní operátor. Překladač pak na základě proměnných typů, které do daného výrazu vstupují určí jaký je skutečný význam daného operátoru.

module quater
  ! modul umoznujici pouziti kvaternionu v programech
  
  ! definice typu
  type quaternion
     real :: x1, x2, x3, x4
  end type quaternion

  ! scitani 
  interface operator(+)
     module procedure addq
  end interface

  ! odcitani
  interface operator(-)
     module procedure subq
  end interface

  ! nasobeni
  interface operator(*)
     module procedure mulq
  end interface
  
contains

  function addq ( a,b )        ! addq = a + b
    type (quaternion) :: addq
    type (quaternion) :: a,b

    addq = quaternion( a%x1 + b%x1, a%x2 + b%x2, a%x3 + b%x3, a%x4 + b%x4)

  end function addq

  function subq ( a,b )        ! subq = a - b
    type (quaternion) :: subq
    type (quaternion) :: a,b

    subq = quaternion( a%x1 - b%x1, a%x2 - b%x2, a%x3 - b%x3, a%x4 - b%x4)

  end function subq

  function mulq ( a,b )        ! mulq = a * b
    type (quaternion) :: mulq
    type (quaternion) :: a,b

    mulq = quaternion( a%x1 * b%x4 + a%x4 * b%x1 + a%x2 * b%x3 - a%x3 * b%x2, &
                       a%x2 * b%x4 + a%x4 * b%x2 + a%x3 * b%x1 - a%x1 * b%x3, &
                       a%x3 * b%x4 + a%x4 * b%x3 + a%x1 * b%x2 - a%x2 * b%x1, &
                      -a%x1 * b%x1 - a%x2 * b%x2 - a%x3 * b%x2 + a%x4 * b%x4  )

  end function mulq

end module 

program qua

  use quater

  type(quaternion) :: a,b,c

  a = quaternion( 1.0, 1.0, 1.0, 1.0)
  b = quaternion( 2.0, 3.0, 4.0, 5.0)
 
  c = a + b
  write(*,*) c

  c = a - b
  write(*,*) c

  c = a * b
  write(*,*) c

end 

Jinou zajímavou možností je definovat generické funkce. Například potřebujeme mít v knihovně funkci fungující poněkud jinak v závislosti od typu vstupních parametrů.

Module kvadry

  interface qudra
    subroutine qudrar(a,b,c,x1,x2)
      real :: a,b,c,x1,x2
    end subroutine

    subroutine qudrac(a,b,c,x1,x2)
      complex :: a,b,c,x1,x2
    end subroutine
  end interface quadra

contains

subroutine qudrar(a,b,c,x1,x2)
 real :: a,b,c,x1,x2,d

 d = b**2 - 4.0*a*b
 if( d > 0 ) then
   x1 = (-b + sqrt(d))/2.0/a
   x2 = (-b - sqrt(d))/2.0/a
 else
   stop 'nelze resit v oboru realnych cisel'
 endif

end subroutine

subroutine qudrac(a,b,c,x1,x2)
 complex :: a,b,c,x1,x2,d

 d = b**2 - 4.0*a*b
 x1 = (-b + sqrt(d))/2.0/a
 x2 = (-b - sqrt(d))/2.0/a

end subroutine

end module

Dynamické datové typy

Konstrukce odvozených typů umožňuje rovněž použití dynamickách datových stuktur profilujících současné programovací jazyky. pomocí atributů pointer vytvoříme proměnnou která může ukazovat na nějaké místo v paměti a toto místo interpretuje jako specifiovaný datový typ. Na začátku programu ovšem není definováno a tak je jeho hodnota zcela deurčitá. Lze ji definovat pomocí proměnné s atributem target což je uplně normální proměnná která ovšem může sloužit jako cíl pro pointer. Přiřazení se dělá prostřednictvím operátoru =>. Ukážeme si to v praxi. Následující program vytvoří linkovaný seznam. (tohle chce asi trochu víc popsat).

program LinkedList

type(node)
  real :: data
  type(node), pointer :: next
end type node

type(node), pointer :: list, current

nullify(list)                       ! initializace listu na nullu
allocate(list)                      ! vytvori pamet pro promenou
list%data = 0.0
allocate(list%next)                 ! alokuje dalsi prvek seznamu
list%next%data = list%data + 1.0
nuliffy( list%next%next)

current => list                    
do while( associated(current) )
   write(*,*) current%data
   current => current%next
enddo
end program