What Fortran does better than C-like languages

C-like languages (C, C++, Java) can do many things, but over the decades nothing much has changed with the inadequacies of some of their control structures. Fortran on the other hand, has evolved. Here are some things that just make implementing some algorithms easier. (Yes there are work arounds in C, but they are not as elegant).

Exiting from a nested loop

In C-like languages exiting from a deeply nested loop isn’t exactly trivial (without the use of goto, so don’t even go there). A break statement in C will only exits the loop the break resides in. If the break appears inside a nested loop, the break only leaves the loop it is in. There is no single break statement in C that will break out of more than one level of nesting. It is possible to add an extra condition, for example in C:

exitloop = 0
for (i=1; i<=10 && !exitloop; i=i+1)
   for (j=1; j<=10 && !exitloop; j=j+1)
      for (k=1; k<=10 && !exitloop; k=k+1)
         if (x[i][j][k] == 0) 
            exitloop = 1;

Fortran however allows loops to be named, so exiting nested loops is as simple as naming the loop to be exited.

loop1</strong>: do i = 1, 10
   loop2: do j = 1, 10
      loop3: do k = 1, 10
         if (x(i,j,k) == 0) exit loop1
      end do loop3
   end do loop2
end do loop1

Ranges in a case statement

C doesn’t do ranges in switch… okay so some compilers, like gnu C offer it as an extension, but it’s not part of the spec. Fortran allows it as part of the standard.

integer :: temp_c

! Fujita Scale for wind velocity (mph)
select case (windS)
case (40:72) 
   write (*,*) 'F0 : light-weak'
case (73:112)
   write (*,*) 'F1 : moderate-weak'
case (113:157)
   write (*,*) 'F2 : significant-strong'
case (158:206)
   write (*,*) 'F3 : severe-strong'
case (207:260)
   write (*,*) 'F4 : devastating-violent'
end select

Array slicing

If you deal with arrays, you know how important it is to have array slicing in a language – because it makes manipulating arrays super easy. Why write loops when you don’t have to? Here are two array declarations in Fortran.

integer, dimension(100) :: vec
integer, dimension(1:6,1:6) :: arr2d

Here are some things you can do:

print *, size(vec)   ! print the size of the array
print *, vec(40:50)  ! print elements 40 to 50
print *, vec(40:50:2)! print elements 40 to 50, step size 2, ie. 40,42,...
add2d = 1            ! set all elements of the array to the value 1
arr2d(3:4,3:4) = 2   ! set elements in row 3 and 4, col 3 and 4 to value 2
write (*,*) arr2d    ! print out the whole array (a bit messy)

Arrays in 2D can be messy when printed using the single statement above. It is possible to use a single loop, and slicing to make things look nicer. The loop controls the row, and the columns are all included using the “:” symbol.

do i = 1,size(arr2d,1)
   write(*,'(6i4)') arr2d(i,:)
end do

There is no array slicing mechanism in C.

Arrays with any indices you want

Fortran by default indexes arrays at 1. But, you are not restricted to that, you can specify the index range of any array. Some examples are shown below:

integer, dimension(100) :: v      ! indices-> 1..100
integer, dimension(0..99) :: w    ! indices-> 0..99
real, dimension(-5:5) :: z        ! indices-> -5,-4,...0,...4,5
real, dimension(3,4) :: a         ! indices-> x: 1..3 and y: 1..4
real, dimension(-1:1,4) :: a      ! indices-> x: -1,0,1 and y: 1..4

Makes it much easier to bend a language to an algorithm, rather than the other way around.

No dangling else

Regardless of what people say, dangling else does cause problems in languages like C. The fact that all Fortran control structures are terminated puts a stop to that. There is also no need for { and } or similar to signify the begin and end of a control block.

Few if any dangerous things

Fortran is cool because it is easy to learn, hard to make catastrophic errors with, and for numerical computation there is likely no faster language. Sure, it may lack some of the low-level features of C, but not every language has to be so close to the system.