Fortran Hello World
Introduction to Fortran Programming Language
Fortran (short for Formula Translation) is a high-level programming language primarily used for scientific and numerical computing. It was developed in the 1950s by IBM and has since become one of the oldest and most widely used programming languages in the field of scientific computing.
Fortran is known for its efficiency and performance, especially in mathematical and scientific calculations, making it a popular choice for tasks such as weather forecasting, computational physics, and engineering simulations. It provides a wide range of features specifically designed for numerical computing and offers excellent support for array operations and mathematical functions.
History of Fortran
Fortran was first developed by a team led by John Backus at IBM in the 1950s for scientific and engineering calculations. Its initial release, Fortran I, was introduced in 1957. Since then, several versions of the language have been released, each introducing new features and improvements.
Fortran II, released in 1958, included support for subroutines and functions. Fortran III, which was never officially released, introduced the concept of nested subroutines. Fortran IV, released in 1962, added character data types and logical variables.
Fortran 66, released in 1966, was the first standardized version of the language. It introduced many significant features, including the DO loop, IF-ELSE statements, and the COMMON statement for sharing data between different program units.
Fortran 77, released in 1978, was another major milestone for the language. It included support for structured programming, allowing programmers to use control structures like WHILE loops and CASE statements. It also introduced the concept of user-defined data types.
Fortran 90, released in 1991, was a major revision of the language that introduced many modern features. It added support for free-form source code, dynamic memory allocation, and modules for organizing code into separate units. It also introduced array operations and powerful intrinsic functions.
Fortran 95, released in 1997, made several minor enhancements to Fortran 90 and improved interoperability with C. Fortran 2003, released in 2004, added support for object-oriented programming and improved support for parallel computing. Fortran 2008, released in 2010, introduced further enhancements to the language, including coarrays for parallel programming.
Features of Fortran
Fortran offers a range of features that make it well-suited for scientific and numerical computing:
Efficiency: Fortran is known for its efficiency and performance, making it ideal for computationally intensive tasks.
Array Operations: Fortran provides extensive support for array operations, allowing programmers to perform calculations on entire arrays with a single statement.
Mathematical Functions: Fortran includes a wide range of built-in mathematical functions, such as trigonometric functions, logarithms, and exponential functions.
Parallel Computing: Fortran offers features for parallel computing, allowing programmers to take advantage of multi-core processors and distributed computing systems.
Interoperability: Fortran can be easily integrated with other programming languages, particularly C and C++, allowing for code reuse and interoperability with existing libraries.
Portability: Fortran programs can be easily ported across different platforms and operating systems.
Hello World Example
Let's start with a simple "Hello World" program in Fortran:
program hello
implicit none
write(*,*) 'Hello, World!'
end program hello
In this example, we define a program called "hello". The implicit none statement ensures that all variables must be explicitly declared. The write(*,*) statement is used to output the string "Hello, World!" to the console.
To compile and run this program, save it in a file named "hello.f90" and use a Fortran compiler. For example, with the GNU Fortran compiler (gfortran), you can run the following commands in the terminal:
gfortran -o hello hello.f90
./hello
This will compile the Fortran source code into an executable file named "hello" and then run it, resulting in the output "Hello, World!" displayed on the console.
More Examples
Fortran is a programming language commonly used for scientific and numerical computations. In this tutorial, we will walk through 10 simple examples in Fortran, starting with the classic "Hello World" program. Each example will include the code, the expected output, and an explanation of how the code works.
Example 1: Hello World
program hello
print *, "Hello, World!"
end program hello
Output:
Hello, World!
Explanation:
The print statement is used to output the string "Hello, World!" to the console. The * symbol represents the standard output. The end program statement marks the end of the program.
Example 2: Basic Arithmetic
program arithmetic
integer :: a, b, sum, product
a = 5
b = 3
sum = a + b
product = a * b
print *, "Sum:", sum
print *, "Product:", product
end program arithmetic
Output:
Sum: 8
Product: 15
Explanation:
In this example, we declare four integer variables a, b, sum, and product. We assign values to a and b using the assignment operator =. The sum of a and b is calculated and stored in the variable sum, while the product is stored in product. Finally, the values of sum and product are printed to the console.
Example 3: User Input
program user_input
integer :: num
print *, "Enter a number:"
read *, num
print *, "You entered:", num
end program user_input
Output:
Enter a number:
10
You entered: 10
Explanation:
In this example, we declare an integer variable num. The print statement prompts the user to enter a number. The read statement reads the input from the user and stores it in the variable num. Finally, the entered number is printed to the console.
Example 4: Conditional Statement
program conditional
integer :: num
print *, "Enter a number:"
read *, num
if (num > 0) then
print *, "The number is positive."
else if (num < 0) then
print *, "The number is negative."
else
print *, "The number is zero."
end if
end program conditional
Output:
Enter a number:
-5
The number is negative.
Explanation:
This example demonstrates the use of a conditional statement (if-else) in Fortran. The user is prompted to enter a number, which is then stored in the variable num. Depending on the value of num, the program prints whether the number is positive, negative, or zero.
Example 5: Loop - Do-While
program do_while_loop
integer :: i
i = 1
do while (i <= 5)
print *, i
i = i + 1
end do
end program do_while_loop
Output:
1
2
3
4
5
Explanation:
This example demonstrates a simple do-while loop. The variable i is initialized to 1. The loop continues as long as i is less than or equal to 5. Inside the loop, the value of i is printed, and then i is incremented by 1 using the i = i + 1 statement.
Example 6: Array
program array_example
integer :: i
integer, dimension(5) :: numbers
numbers = [1, 2, 3, 4, 5]
do i = 1, 5
print *, numbers(i)
end do
end program array_example
Output:
1
2
3
4
5
Explanation:
In this example, an integer array numbers of size 5 is declared. The values 1, 2, 3, 4, and 5 are assigned to the array elements using the array assignment numbers = [1, 2, 3, 4, 5]. The loop iterates over the array elements and prints each one.
Example 7: Subroutine
program main_program
call say_hello()
call say_goodbye()
end program main_program
subroutine say_hello()
print *, "Hello!"
end subroutine say_hello
subroutine say_goodbye()
print *, "Goodbye!"
end subroutine say_goodbye
Output:
Hello!
Goodbye!
Explanation:
This example demonstrates the use of subroutines in Fortran. The main program calls two subroutines say_hello and say_goodbye. Each subroutine contains a single print statement to output a message.
Example 8: Function
program main_program
integer :: result
result = add_numbers(5, 3)
print *, "Result:", result
end program main_program
integer function add_numbers(a, b)
integer, intent(in) :: a, b
add_numbers = a + b
end function add_numbers
Output:
Result: 8
Explanation:
In this example, a function add_numbers is defined to calculate the sum of two integers. The main program calls the function with arguments 5 and 3, and the returned value is stored in the variable result. Finally, the result is printed to the console.
Example 9: Module
module area_module
implicit none
contains
real function calculate_area(radius)
real, intent(in) :: radius
calculate_area = 3.14159 * radius**2
end function calculate_area
end module area_module
program main_program
use area_module
real :: radius, area
radius = 2.5
area = calculate_area(radius)
print *, "Area:", area
end program main_program
Output:
Area: 19.63495
Explanation:
This example demonstrates the use of a module in Fortran. The module area_module contains a function calculate_area that calculates the area of a circle given its radius. The main program uses the area_module and calls the calculate_area function with a radius of 2.5. The returned area is stored in the variable area and then printed to the console.
Example 10: File I/O
program file_io
character(len=20) :: name
integer :: age
! Read data from file
open(unit=1, file="data.txt", status="old")
read(1, *) name, age
close(1)
! Write data to file
open(unit=2, file="output.txt", status="replace")
write(2, *) "Name:", name
write(2, *) "Age:", age
close(2)
end program file_io
Input (data.txt):
John Doe
25
Output (output.txt):
Name: John Doe
Age: 25
Explanation:
In this example, the program reads data from a file (data.txt) and stores it in variables name and age. Then, it writes the data to another file (output.txt) along with labels. The open, read, and close statements are used for file input, while the open, write, and close statements are used for file output.
We covered 10 simple examples in Fortran, ranging from basic output and arithmetic operations to more advanced concepts such as loops, arrays, subroutines, functions, modules, and file I/O. These examples provide a solid foundation for understanding and writing Fortran code.
Comparison with Other Languages
Fortran has several advantages and disadvantages when compared to other programming languages commonly used for scientific computing:
C/C++: Fortran and C/C++ are both widely used for scientific computing. Fortran is known for its efficiency and array operations, making it a better choice for numerical computations. C/C++ provides more flexibility and a larger ecosystem of libraries, making it suitable for a wider range of applications.
Python: Python has gained popularity in the scientific computing community due to its simplicity and ease of use. While Fortran excels in terms of performance, Python offers a larger number of libraries and a more intuitive syntax, making it a good choice for prototyping and data analysis.
MATLAB: MATLAB is a proprietary programming language and environment widely used in scientific and numerical computing. MATLAB is known for its ease of use and extensive library of mathematical functions, but it can be expensive and lacks the performance of Fortran for large-scale simulations.
Overall, Fortran remains a popular choice for scientific and numerical computing due to its efficiency, extensive mathematical functions, and long-standing history in the field.
For more information on Fortran, you can visit the official Fortran website.