Fortran (.f, .f90, .f95)

Overview

Fortran (FORmula TRANslation) is one of the oldest high-level programming languages, specifically designed for scientific and engineering computations. Created by IBM in the 1950s, Fortran remains the language of choice for numerical computing, high-performance computing (HPC), and scientific applications due to its efficiency and extensive mathematical libraries.

Technical Details

• File Extensions: .f, .f90, .f95, .f03, .f08, .f18
• MIME Type: text/x-fortran
• Category: Programming Language
• First Appeared: 1957
• Paradigm: Procedural, object-oriented (modern versions)
• Platform: Cross-platform

Key Features

High Performance Computing

• Optimized for numerical computations
• Excellent compiler optimizations
• Efficient array operations
• Parallel processing support

Mathematical Focus

• Built-in mathematical functions
• Complex number support
• Extensive numerical libraries
• Matrix and vector operations

Modern Language Features

• Object-oriented programming (Fortran 2003+)
• Generic programming with parameterized derived types
• Interoperability with C
• Parallel programming constructs

Syntax Examples

Fortran 90/95 Style

program hello_world
    implicit none
    character(len=20) :: name
    integer :: age
    
    write(*,*) 'Enter your name: '
    read(*,*) name
    write(*,*) 'Enter your age: '
    read(*,*) age
    
    write(*,*) 'Hello, ', trim(name), '! You are ', age, ' years old.'
end program hello_world

! Subroutine example
subroutine matrix_multiply(a, b, c, n)
    implicit none
    integer, intent(in) :: n
    real, intent(in) :: a(n,n), b(n,n)
    real, intent(out) :: c(n,n)
    integer :: i, j, k
    
    do i = 1, n
        do j = 1, n
            c(i,j) = 0.0
            do k = 1, n
                c(i,j) = c(i,j) + a(i,k) * b(k,j)
            end do
        end do
    end do
end subroutine matrix_multiply

Modern Fortran (2003+)

module vector_mod
    implicit none
    
    type :: vector
        real, allocatable :: data(:)
    contains
        procedure :: add => vector_add
        procedure :: dot => vector_dot
    end type vector
    
contains
    function vector_add(this, other) result(sum_vec)
        class(vector), intent(in) :: this, other
        type(vector) :: sum_vec
        
        allocate(sum_vec%data(size(this%data)))
        sum_vec%data = this%data + other%data
    end function vector_add
    
    function vector_dot(this, other) result(dot_product)
        class(vector), intent(in) :: this, other
        real :: dot_product
        
        dot_product = sum(this%data * other%data)
    end function vector_dot
end module vector_mod

Language Evolution

Fortran 77

• Fixed-form source code
• GOTO statements
• CHARACTER data type
• Standard I/O

Fortran 90/95

• Free-form source code
• Dynamic arrays
• Modules and interfaces
• Derived data types

Fortran 2003/2008

• Object-oriented programming
• Parameterized derived types
• C interoperability
• IEEE arithmetic support

Fortran 2018

• Parallel programming features
• Error handling improvements
• Extended interoperability

Development Tools

Compilers

• GNU Fortran (gfortran): Free compiler
• Intel Fortran: High-performance compiler
• PGI/NVIDIA HPC SDK: GPU-accelerated computing
• IBM XL Fortran: AIX and Linux compiler

IDEs and Editors

• Intel Fortran IDE: Integrated development environment
• Code::Blocks: Cross-platform IDE
• VSCode with Modern Fortran extension
• Vim/Emacs with Fortran modes

Build Systems

• Make: Traditional build system
• CMake: Cross-platform build system
• Autotools: GNU build system
• FoBiS: Fortran Building System

Libraries and Frameworks

Mathematical Libraries

• BLAS: Basic Linear Algebra Subprograms
• LAPACK: Linear Algebra Package
• FFTW: Fast Fourier Transform
• GSL: GNU Scientific Library

Parallel Computing

• OpenMP: Shared memory parallelization
• MPI: Message Passing Interface
• Coarray Fortran: Built-in parallelization
• OpenACC: Accelerator directives

Scientific Libraries

• NetCDF: Scientific data format
• HDF5: Hierarchical data format
• PETSC: Scalable linear algebra
• NAG: Numerical algorithms

Common Use Cases

Weather and Climate Modeling

• Atmospheric simulation
• Ocean modeling
• Climate prediction
• Meteorological forecasting

Computational Fluid Dynamics

• Aerodynamics simulation
• Heat transfer analysis
• Turbulence modeling
• Flow visualization

Astrophysics and Space Science

• Galaxy simulation
• Stellar evolution modeling
• Orbital mechanics
• Cosmological calculations

Engineering Simulation

• Structural analysis
• Electromagnetic modeling
• Nuclear reactor simulation
• Materials science

File Structure

Program Structure

program main_program
    ! Variable declarations
    implicit none
    
    ! Program logic
    
end program main_program

Module Structure

module module_name
    implicit none
    private  ! Default accessibility
    
    ! Public declarations
    public :: public_subroutine, public_type
    
    ! Type definitions
    type :: my_type
        real :: value
    end type my_type
    
contains
    ! Procedures
    subroutine public_subroutine()
        ! Implementation
    end subroutine public_subroutine
    
end module module_name

Performance Optimization

Array Operations

! Vectorized operations
real :: a(1000), b(1000), c(1000)
c = a + b  ! Optimized by compiler

! Array sections
c(1:500) = a(1:500) * b(501:1000)

Parallel Constructs

!$OMP PARALLEL DO
do i = 1, n
    result(i) = expensive_computation(data(i))
end do
!$OMP END PARALLEL DO

Notable Applications

• NASTRAN: Structural analysis software
• ANSYS: Engineering simulation
• Weather Research and Forecasting (WRF): Weather modeling
• GROMACS: Molecular dynamics
• VASP: Electronic structure calculations

Learning Resources

• "Modern Fortran Explained" by Metcalf, Reid, and Cohen
• "Introduction to Programming with Fortran" by Ian Chivers
• Official Fortran standards documents
• Fortran-lang.org community resources
• NASA Fortran programming tutorials

Fortran continues to evolve and remains essential for high-performance scientific computing, offering unmatched performance for numerical applications and maintaining backward compatibility with decades of scientific code.