Fortran Tutorial: A Step-by-Step Guide for Beginners

Fortran, short for "Formula Translation," is one of the oldest high-level programming languages, created in the 1950s to perform scientific and engineering computations. Despite its age, Fortran remains a powerful language for numerical computing, often used in high-performance applications like simulations, computational fluid dynamics, and scientific research. If you're new to Fortran and want to dive into the language, this tutorial is for you! In this article, we'll cover the basics of Fortran, explain its syntax, and walk you through some practical examples.

What Makes Fortran Special?

Fortran was designed to make mathematical computations easier, and it has evolved over the decades to include modern features while maintaining its strength in numerical accuracy. Many scientific applications and high-performance computing systems still rely on Fortran due to its efficiency and optimization capabilities.

If you're planning to work in fields like physics, engineering, climate modeling, or financial modeling, learning Fortran could be incredibly beneficial. Let’s dive in and get you started with this classic language!

Setting Up Fortran on Your System

Before you can start writing Fortran programs, you need to set up a Fortran compiler on your machine. If you're using Linux, you can install the gfortran compiler using your package manager. On Windows or macOS, you can download and install a Fortran compiler like MinGW or Intel Fortran. Here’s a simple installation guide:

• On Ubuntu (Linux), run: sudo apt-get install gfortran
• On macOS, use Homebrew: brew install gcc (this will include gfortran)
• For Windows, download and install MinGW or the Intel Fortran Compiler from their respective websites.

Once installed, you can verify your compiler by typing gfortran --version in your terminal or command prompt.

Understanding Fortran Syntax

Fortran syntax is simple and easy to follow, especially if you’ve used other programming languages before. Below are some key features of Fortran syntax:

• Statements: Each line of code in Fortran is generally one statement. It ends with a newline (no semicolons needed).
• Variables: Variables must be declared before they are used. You can declare variables by specifying their name and type.
• Comments: Comments begin with the exclamation mark (!) and continue to the end of the line.

Basic Fortran Program Structure

Let's write our first Fortran program! A simple Fortran program to print "Hello, World!" to the console is structured as follows:

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

This basic Fortran program consists of the following parts:

• program hello_world declares the program's name.
• print *, "Hello, World!" prints the message to the console.
• end program hello_world marks the end of the program.

Once you've written this program, save it with a .f90 extension, and compile it with the following command:

gfortran hello_world.f90 -o hello_world

Run the program by typing:

./hello_world

You should see the message "Hello, World!" printed to the terminal. Congratulations, you've just written your first Fortran program!

Working with Variables in Fortran

In Fortran, you need to declare the type of a variable before you use it. Here are some common data types in Fortran:

• integer: Used for whole numbers (e.g., integer x).
• real: Used for floating-point numbers (e.g., real x).
• character: Used for strings (e.g., character(len=10) :: name).
• logical: Used for boolean values (e.g., logical :: is_true).

Here's an example program that declares some variables and prints their values:

program variable_example
  integer :: x
  real :: y
  character(len=10) :: name

  x = 10
  y = 3.14
  name = "Fortran"

  print *, "x = ", x
  print *, "y = ", y
  print *, "name = ", name
end program variable_example

This program declares an integer variable x, a real number y, and a character string name. It then assigns values to these variables and prints them to the console.

Control Structures in Fortran

Fortran supports a variety of control structures to make your programs more flexible and interactive. These include loops, conditional statements, and case structures. Let’s look at some examples:

If-Else Statement

The if-else statement allows you to make decisions in your program. Here's an example:

program if_example
  integer :: x

  x = 5

  if (x > 0) then
     print *, "x is positive"
  else
     print *, "x is non-positive"
  end if
end program if_example

In this program, the value of x is checked. If it’s greater than 0, it will print “x is positive.” Otherwise, it will print “x is non-positive.”

For Loop

Fortran also supports loops. The do loop is one of the most commonly used looping constructs. Here's an example that prints the numbers 1 through 5:

program for_loop_example
  integer :: i

  do i = 1, 5
     print *, "i = ", i
  end do
end program for_loop_example

This program uses a do loop to iterate over the numbers 1 to 5 and print them to the console.

Arrays in Fortran

Arrays are a fundamental concept in Fortran, especially for working with large datasets. You can declare arrays with a specific size and access elements by their index. Here’s an example:

program array_example
  integer, dimension(5) :: arr
  integer :: i

  arr = [1, 2, 3, 4, 5]

  do i = 1, 5
     print *, "arr(", i, ") = ", arr(i)
  end do
end program array_example

In this program, we declare an array arr of size 5 and initialize it with values. Then, we loop through the array and print each element.

Conclusion

Congratulations! You've now got a solid foundation in Fortran. From printing simple outputs to working with variables, loops, and arrays, you’ve learned some of the core concepts that will help you tackle more complex problems in Fortran.

While Fortran might seem a bit old-fashioned compared to modern programming languages, it remains a powerful tool for high-performance computing. Whether you’re working with scientific data, simulations, or other numerical tasks, mastering Fortran will undoubtedly open doors to a wide range of opportunities in the programming world.

So, go ahead and explore more advanced topics like subroutines, modules, and file handling in Fortran. The possibilities are endless!