2. Estructuras de datos

2.1. Tipos 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

2.2. Tipos derivados

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

2.3. Strings

Se declaran así

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

2.4. Estructura paramétrica o template

Los parámetros de una estructura de este tipo pueden tener el atributo len o kind para especificar la longitud de una cadena o la de un tipo de datos como las template de C++.

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 = "Samuel"

end program parametric_structure

2.5. 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

2.6. 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))

2.7. Estructura de arrays

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

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

y se usa de esta manera

type(body_p(n=:)), allocatable ::  vector
allocate(body_p(n=20) :: vector)
array de estructuras y estructura de arrays