Unlocking the Power of Fortran 90 Compiler: A Complete Guide

Fortran 90 is one of the most significant milestones in the evolution of the Fortran programming language. It introduced several important features that greatly enhanced the capabilities of the language, particularly in the areas of modular programming, array handling, and structure definition. However, to unlock its full potential, you need the right tools, and that’s where the Fortran 90 compiler comes into play. In this article, we will dive deep into the Fortran 90 compiler, its key features, usage, and provide practical examples to help you get started.

What Is a Fortran 90 Compiler?

A Fortran 90 compiler is a program that translates Fortran 90 code (a modern version of the Fortran programming language) into machine code that can be executed on a computer. Just like compilers for other languages, the Fortran 90 compiler reads through your source code and performs optimizations and transformations to generate an executable file.

Fortran 90 brought several new features to the language, such as the use of dynamic arrays, user-defined data types (derived types), and more readable syntax. Therefore, compiling Fortran 90 code requires a compiler capable of handling these new features. Many modern compilers, such as GNU Fortran (gfortran), Intel Fortran, and NAG Fortran, support Fortran 90 features, allowing developers to take advantage of the advanced capabilities of the language.

Why Use Fortran 90?

Fortran has been a cornerstone of scientific and engineering applications for decades. Fortran 90, in particular, enhanced the language with features that improved the clarity, flexibility, and power of the code. Some key reasons why you should consider using Fortran 90 for your projects include:

• Array Handling: Fortran 90 allows for dynamic arrays, meaning that arrays no longer need to have a fixed size at compile-time. This flexibility is crucial when working with large datasets.
• Modular Programming: The introduction of modules and subroutines in Fortran 90 enables better organization of code, making it easier to manage and maintain large projects.
• Improved Syntax: Fortran 90’s syntax is more modern, making it easier to write and understand than its predecessor, Fortran 77.
• Enhanced Performance: Fortran compilers are renowned for producing highly optimized code, especially when dealing with numerical and scientific computations.

If you’re looking to take advantage of these features, you need the right Fortran 90 compiler. Let’s take a look at how to set up and use the compiler effectively.

Choosing a Fortran 90 Compiler

Several Fortran 90 compilers are available, each with its own strengths. The most commonly used compilers are:

• GNU Fortran (gfortran): This open-source compiler is part of the GNU Compiler Collection (GCC). It’s widely used because it’s free, efficient, and available on most platforms, including Linux, macOS, and Windows.
• Intel Fortran Compiler (ifort): Intel's compiler is known for producing highly optimized code that performs exceptionally well on Intel processors. It’s a commercial product, but it offers advanced optimization techniques.
• NAG Fortran Compiler: NAG offers a highly reliable and robust Fortran compiler, often used in research and academic environments. It comes with excellent debugging and diagnostic tools.
• PGI Fortran: The PGI compiler suite offers excellent optimization for high-performance computing tasks and is commonly used in scientific computing and simulations.

For beginners and those who need a free solution, we recommend using gfortran. It’s well-documented, easy to install, and provides all the necessary tools to compile and run Fortran 90 code.

Installing a Fortran 90 Compiler

To get started, you first need to install a Fortran 90 compiler. Here’s how you can do that for the most popular options:

Installing gfortran

On Linux, you can install gfortran using the package manager:

sudo apt-get install gfortran

On macOS, you can use Homebrew:

brew install gcc

For Windows, you can download the MinGW-w64 package, which includes gfortran, from the official website. After installing, you can access gfortran from the command line.

Compiling Your Fortran 90 Code

Once you’ve installed a compiler, you’re ready to compile your Fortran 90 code! Let’s go through the basic process of compiling and running a Fortran program using gfortran. First, write your Fortran 90 code in a text file, say example.f90.

Here’s an example of a simple Fortran 90 program that calculates the factorial of a number:

program factorial
    integer :: n, fact, i

    ! Input number
    print *, 'Enter a number:'
    read *, n

    fact = 1

    ! Calculate factorial
    do i = 1, n
        fact = fact * i
    end do

    print *, 'Factorial of ', n, ' is ', fact
end program factorial

Once your code is ready, you can compile it by running the following command in your terminal:

gfortran -o factorial example.f90

This command tells gfortran to compile the code in example.f90 and create an executable named factorial. After successful compilation, you can run the program:

./factorial

It will prompt you for an input number and calculate the factorial of that number.

Advanced Fortran 90 Features

Fortran 90 introduced several features that made the language much more powerful for scientific computing. Here are a few key features to explore:

Modules and Interfaces

Fortran 90 allows you to define modules to group related subroutines, functions, and data types. Modules make it easier to organize your code and reuse components in other parts of your project. You can also define interfaces within modules to improve code clarity and reduce errors.

module math_operations
    contains
        function add(a, b)
            real :: add
            real, intent(in) :: a, b
            add = a + b
        end function add
end module math_operations

In Python, the equivalent would be importing functions from a module. In Fortran 90, you use the use statement to access modules:

program main
    use math_operations
    real :: result

    result = add(3.5, 2.5)
    print *, 'The result is ', result
end program main

Dynamic Arrays

Fortran 90 also introduced dynamic arrays, which allow you to allocate memory for arrays at runtime instead of during compilation. This flexibility is essential when working with large datasets or when the size of an array depends on user input.

program dynamic_array
    integer, dimension(:), allocatable :: arr
    integer :: n

    ! Get array size from user
    print *, 'Enter the size of the array:'
    read *, n

    ! Allocate the array dynamically
    allocate(arr(n))

    ! Fill the array with values
    do i = 1, n
        arr(i) = i
    end do

    ! Print the array
    print *, 'The array is:'
    print *, arr

    ! Deallocate memory
    deallocate(arr)
end program dynamic_array

Conclusion

Fortran 90 compilers provide the tools necessary to unlock the full potential of the Fortran 90 language. With powerful features such as modular programming, dynamic arrays, and improved syntax, Fortran 90 remains a go-to choice for scientific and engineering applications. By following the steps outlined in this guide, you’ll be well on your way to compiling and running your own Fortran 90 programs. Whether you're a beginner or an experienced developer, understanding the capabilities of Fortran 90 and mastering its compiler can greatly improve the efficiency and performance of your projects.

Happy coding and enjoy the world of Fortran 90!