Fundamentos de Fortran

Veremos ahora los fundamentos para entender y escribir en Fortran, por si no lo tienes instalado, aquí te dejo el tutorial en español Instalando GFortran que es el compilador que vamos a usar.

Historia

Fortran es un lenguaje compilado que fue publicado en el año 1956, como varios lenguajes que nacen en esta época, Fortran también fue sometido a debate por una comunidad que desconfiaba de su utilidad, pero pronto encontró su nicho y fue adoptado mayoritariamente por científicos

Características

Fortran posee un gran cantidad de características que no solo lo diferencian de otros lenguajes sino que también nos ayuda a tener un mejor flujo de trabajo

• case-insensitive: A diferencia de otros lenguajes, fortran no diferencia entre mayúscula y minúscula.
• precisición numérica: De entre todos los lenguajes su precisición numérica la hizo la favorita entre los científicos.
• fuertemente tipado: En un programa cada variable nace con un tipo de dato ( INTEGER, CHARACTER, COMPLEX, REAL, LOGICAL ) y no se le permite cambiar de tipo en el transcurso en el que corre dicho programa.

Sintaxis

Hello, World!

Como todo lenguaje de programación, comenzaremos con un hello world.

program main
    print *, "Hello, World!"
end program main

En la terminal escribes lo siguiente:

# Para compilarlo
gfortran main.f90 -o main 
# Para ejecutarlo
-/main

Keywords

Como en muchos otros lenguajes en fortran poseemos varias palabras clave o keywords que no deben usarse para nombrar funciones, variables, etc. Puesto que Fortran ya hace uso de ellas, por ejemplo:

Como nota adicional tampoco se pueden usar carácteres especiales u operadores para nombrar variables.

Variables

Cuentan con nombre simbólico (el que desees exceptuando las keywords) y están asociados a un espacio en la memoria, estás se diferencian entre las constantes. Fortran es contamos con 5 tipos de datos intrínsecos INTEGER, REAL, COMPLEX, LOGICAL Y CHARACTER

Para inicializar una variable se sigue la siguiente estructura:

<variable_type>(len=..., kind=...) :: <variable_name>, <variable_name>, <variable_name>

Por ejemplo

program example
    implicit none

    integer :: a
    real :: b
    complex :: c, d
    character :: e
    logical :: f
end program example

Como notarás comenzamos el programa con IMPLICIT NONE, esto le dirá al compilador que todas las variables serán excplícitamente declaradas, hacer esto se considera una buena práctica, no sólo su uso dentro del bloque PROGRAM, sino también de otros como FUNCTION, SUBROUTINE o MODULE.

Loops o Bucles

Cuando necesitamos ejecutar ciertos bloques de código un gran número de veces, el escribir constantemente el mismo código es exhaustivo. Por ello contamos con los bucles, que encierran un bloque de código dentro de una declaración y las ejecutan hasta que se cumpla ciertas condiciones. En fortran contamos con distintos tipos de bucles que nos serán de utilidad para escribir programas.

• DO… END DO: Es el bucle básico en el que declaramos una variable iteradora y un fin en específico. Contando con la siguiente forma:

do <variable_name>=<start>, <end>, <step> 
    <code>
end do

Por ejemplo:

integer :: i
do i = 1, 20
    print *, i
end do

• DO WHILE… END DO: Es un bucle condicional en el que habiendo declarado con anterioridad una variable, le ponemos ciertas condiciones para acabar con el bucle. Contando con la siguiente forma:

do while (<condition>) 
    <code>
end do

Por ejemplo:

integer :: i
do while (i < 20)
    print *, i
    i =+ 1
end do

Además de ello contamos con dos declaraciones principales para poder cerrar el bucle o ir a la siguiente iteración sin necesidad de cerrar el bucle.

• EXIT: Nos sirve para salir completamente del bucle.
• CYCLE: Nos sirve para continuar con la siguiente iteración.

Funciones

Son bloques de código reutilizable, cuentan con parametros y retornan valores.

function add(a,b)
    integer, intent(in) :: a, b
    integer :: sum
    sum = a + b
end function add

El atributo INTENT sirve para declarar los denominados dummy arguments, con este podemos decirle al compilador para que las vamos a usar.

• INTENT(IN): De solo lectura.
• INTENT(OUT): De solo escritura.
• INTENT(INOOUT): De lectura y escritura.

Subrutinas

Son bloques de código, cuentan con parámetros, a diferencia de las funciones, estás no devuelven un valor, sino que puedes modifcar el de los parámetros.

subroutine print_sum(a, b, c)
    implicit none
    integer, intent(in) :: a
    integer, intent(in) :: b
    integer, intent(in) :: c

    c = a + b

    print *, c
end subroutine print_sum

Estas subrutinas se pueden llamar, usando la keyword CALL de esta manera

call print_sum(a, b, c)

Módulos

Esta es una herramiento poderoso dentro de fortran que nos ayuda a modularizar y organizar nuestro código en pequeños bloques, evitando tener todo el código dentro de un mismo archivo. Como punto adicional es recomendable tener los bloques de las subrutinas y funciones adentro de los módulos, de la siguiente manera:

module example_module
    implicit none
    private
    public

    real, parameter :: public_var = 1
    itneger :: private_var

contains

    subroutine print_sum(a, b, c)
        implicit none
        integer, intent(in) :: a
        integer, intent(in) :: b
        integer, intent(in) :: c

        c = a + b

        print *, c
    end subroutine print_sum

end module example_module

Como verán hay dos nuevas keyword llamada PRIVATE y PUBLIC:

• PRIVATE: Se encarga de hacer privado todas las entidades dentro del bloque del módulo
• PUBLIC: Se encarga de hacer público determinadas entidades del bloque.

Para usar un modulo junto con sus entidades públicas dentro del programa principal usaremos la keyword USE.

program main
    use example_module
    implicit none

    integer :: a, b, c

    c = public_var

    call print_sum(a, b, c)

end program main

Muchas gracias por leer, pienso hacer toda una serie de posts sobre este lenguaje y varios tutos.