Datos

Tipos de datos

Los tipos de datos que permite Fortran son:

Enteros

Integer Entero con precisión estándar.
Integer(kind=n) Entero con precisión específica, donde 'n' puede ser 1, 2, 4, 8, u otros valores dependiendo del compilador.

Reales o punto flotante

Real Número real en punto flotante con precisión estándar.
Real(kind=n) Número real en punto flotante con precisión específica, donde 'n' puede variar según el compilador.
Real*4 y Real*8 Tipos de datos históricos para precisión sencilla y doble.

Complejos

Complex Números complejos con precisión estándar.
Cmoplex(kind=n) Números complejos con precisión específica.

Caractéres o cadenas

Character Cadenas de caracteres de longitud variable.
Character(len=n) Cadenas de caracteres de longitud fija.

Booleanos o lógicos

Logical Valores lógicos (.TRUE. o .FALSE.).

Arrays o arreglos

Arrays unidimensionales, bidimensionales y multidimensionales de los tipos de datos mencionados anteriormente.

Punteros y referencias

Pointer Para manejar la asignación dinámica de memoria.
Target Para declarar variables que pueden ser apuntadas por punteros.

Tipo ISO


program Tipos_iso
    use iso_fortran_env
    integer, parameter :: N = 3
    real(real64)       :: A(N,N)
    integer(int64)     :: B(N,N)

    A = .0_real64           ! Matriz de ceros reales
    B = 0_int64             ! Matriz de ceros enteros

    write (*,"(3f6.1)") A   ! Mostrar la matriz en tres filas y tres columnas
    write (*,"(3i6)") B     ! Mostrar la matriz en tres filas y tres columnas
end program Tipos_iso

Tipos de datos personalizados

Con selected_int_kind y selected_real_kind podemos definir tipos de datos en función de la precisión que necesitemos.

selected_int_kind(a) Devuelve un valor númerico que representa el menor tipo integer que puede contener un valor de a dígitos.
selected_real_kind([p,r,radix]) Devuelve un valor númerico que representa el menor tipo real que puede contener un valor de al menos p dígitos significativos, un exponente decimal de al menos r.


program real_kinds
  integer,parameter  :: p6 = selected_real_kind(6)
  integer,parameter  :: p10r100 = selected_real_kind(10,100)
  integer,parameter  :: r400 = selected_real_kind(r=400)
  real(kind=p6)      :: x
  real(kind=p10r100) :: y
  real(kind=r400)    :: z

  print *, precision(x), range(x)
  print *, precision(y), range(y)
  print *, precision(z), range(z)
end program real_kinds

Tipos derivados

En otros lenguajes se llaman registros y contienen campos

type Persona
    character(len=6)  :: id
    character(len=10) :: nombre
    real              :: edad
end type Persona

Strings


program Strings
    use iso_fortran_env
    implicit none

    character(len=5) :: s            ! Una cadena
    character(len=:) :: s_array(:)   ! Un array de cadenas

    ! SETUP -----------
    ! Reserva espacio para la 10 cadenas de 5 caractéres cada una
    allocate(character(len=5) :: s_array(10))

end program Strings

Estructura paramétrica o template


program parametric_structure
    type :: persona(n)
        integer, len     :: n = 10     ! Parámetro de la estructura con valor por defecto
        character(len=n) :: nombre, apellidos
        integer:: edad
    end type

    type(persona(20)) :: p1

    p1 % nombre = "Francisco"

end program parametric_structure

Array allocatable

Se trata de un array que reserva memoria en tiempo de ejecución. Tampoco es necesario especificar su tamaño en el código.

Reservar memoria dos veces para el mismo array genera un error, por eso es conveniente comprobar antes de reservar la memoria si ya ha sido previamente reservada.


program allocatable_array
    integer, allocatable :: a(:)
    real, allocatable    :: b(:)
    real, parameter      :: pi = 3.141592
    integer              :: i

    a = [(i, i=1,10)]                    ! a = [1, 2, .., 9, 10]
    b = [(sin(2*pi*i/1000.), i=0,1000)]  ! b = [0, 6.28e-3, ...]

    if (.not. allocated(a)) then         ! Para evitar error de doble asignación
        allocate(a(10))
    end if
end program allocatable_array

Array de estructuras


type :: body
  character(len =4) :: units
  real :: mass
  real :: pos(3), vel(3)
end type body

y la forma de usarlo es


type(body), allocatable :: vector(:)
allocate(vector(n))

Estructura de arrays

Permite vectorizar y optimizar código. En este caso se usa una estructura paramétrica.


module Body
type :: body_p(k, n)                ! Estructura paramétrica template
  integer, kind    :: k = kind(1.0) ! Tipo
  integer, len     :: n = 1         ! Número
  character(len=4) :: units
  real(kind=k)     :: mass(n)
  real(kind=k)     :: pos(n,3),   vel (n,3)
end type body_p
end module Body

program main
use tipo

end program main

y se usa de esta manera:


type(body_p(n=:)), allocatable :: vector
allocate(body_p(n=20)          :: vector)