cubbi.com: fibonacci numbers in fortran
FORTRAN
Date: 1954 (Standardized in: ANSI X3.9-1966, ANSI X3.9-1978, ISO/IEC 1539:1991, ISO/IEC 1539-1:1997, ISO/IEC 1539-1:2004)
Type: Imperative low-level language
Usage: huge libraries of scientific/math code are written in this language and are still used.

ALGORITHM 1A: NAIVE BINARY RECURSION
! This program calculates the nth fibonacci number
! using alrogirhtm 1A: naive binary recursion
!
! compiled: gfortran -O2 -std=f2003 -o f1a f1a.f
! executed: ./f1a n
!
! (note, only Fortran 2003 supports command line arguments)
!

! main program checks the number of command line arguments
! makes sure the first argument is an integer, and executs f(i)
      program f1a
      use f1a_module
      integer:: i,k
      character:: arg*128
      if (command_argument_count() == 1) then
          call get_command_argument(1, arg)
          if (verify(arg, "0123456789- ")==0) then
              read(arg, fmt=*) i
              k = f(i)
              print "(i0,a,i0)",i,"th Fibonacci number is ",k
              stop
          endif
      endif
      print *,"Usage: f1a <n>"
      stop
      end program

      module f1a_module
      implicit none
      public :: f
      contains
! Naive binary recursion: F(n) = F(n-1) + F(n-2)
      integer pure recursive function fib(n) result(ret)
      integer,intent(in):: n
      if (n>1) then
          ret = fib (n-1) + fib (n-2)
      else
          ret = n
      endif
      end function fib
! f handles the negative arguments: F(-n) = F(n)*(-1)^(n+1)
      integer elemental function f(n)
      integer,intent(in):: n
      f = sign(1,n)**(n+1) * fib(abs(n))
      end function f
      end module f1a_module

ALGORITHM 2A-3: DATA STRUCTURE - SIMPLE LIST
      PROGRAM F2A
      I=35; K=I
      CALL F(I)
      PRINT *,K,'th Fibonacci number is',I
      STOP
      END PROGRAM
CCCCC
C Subroutine F(I) calculates the I'th Fibonacci number
C It uses ALGORITHM 2A-3: DATA STRUCTURE - SIMPLE LIST
C
      SUBROUTINE F(I)
      DIMENSION A(I+1)
      A(1)=1; A(2)=1
      DO1J=3,I+1
      A(J)=A(J-1)+A(J-2)
1     CONTINUE
      I=A(I+1)
      RETURN
      END SUBROUTINE

ALGORITHM 2B: SIMPLE RECURSION
FORTRAN does not support recursion.
Rewriting this algorithm in simple loops produces ALGORITHM 2C.

ALGORITHM 2C: NON-RECURSIVE LOOP
      PROGRAM F2C
      I=45; K=I
      CALL F(I)
      PRINT *,K,'th Fibonacci number is',I
      STOP
      END PROGRAM
CCCCC
C Subroutine F(I) calculates the I'th Fibonacci number
C It uses ALGORITHM 2C: NON-RECURSIVE LOOP
C
      SUBROUTINE F(I)
      I1=1; I2=1
      DO 2 J=2,I
      I3=I1+I2
      I2=I1
      I1=I3
2     I=I1
      RETURN
      END SUBROUTINE

ALGORITHM 3A: MATRIX EQUATION
      PROGRAM F3A
      I=35; K=I
      CALL F(I)
      PRINT *,K,'th Fibonacci number is',I
      STOP
      END PROGRAM
CCCCC
C Subroutine F(I) calculates the I'th Fibonacci number
C It uses ALGORITHM 3A: MATRIX EQUATION, rewritten
C to use non-recursive loops.
C
      SUBROUTINE F(I)
      DIMENSION A(2,2),B(2,2),C(2,2)
      INTEGER L
      A(1,1)=2; A(1,2)=1; A(2,1)=1; A(2,2)=1
      B(1,1)=1; B(1,2)=0; B(2,1)=0; B(2,2)=1
      J=I/2; J1=1
      IF(AND(J,J1).NE.0) CALL MCOPY(A,B)
4     IF(J1.GE.J) GO TO 3
      CALL MMULT (A,A,C)
      CALL MCOPY (C,A)
      J=J/2
      IF(AND(J,J1).EQ.0) GO TO 4
      CALL MMULT(A,B,C)
      CALL MCOPY(C,B)
      GO TO 4
3     IF(MOD(I,2).NE.0) GO TO 2
      I=B(1,1)
      RETURN
2     I=B(1,1)+B(1,2)
      RETURN
      END SUBROUTINE
C Subroutine MMULT mutiplies two 2x2 matrices D and E and writes the result to C
      SUBROUTINE MMULT(D,E,C)
      DIMENSION D(2,2),E(2,2),C(2,2)
      C(1,1)=D(1,1)*E(1,1)+D(1,2)*E(2,1);
      C(1,2)=D(1,1)*E(1,2)+D(1,2)*E(2,2);
      C(2,1)=D(2,1)*E(1,1)+D(2,2)*E(2,1);
      C(2,2)=D(2,1)*E(1,2)+D(2,2)*E(2,2);
      RETURN
      END SUBROUTINE
C  Subroutine MCOPY(D,E) copies the 2x2 matrix D into 2x2 matrix E
      SUBROUTINE MCOPY(D,E)
      DIMENSION D(2,2),E(2,2)
      E(1,1)=D(1,1); E(1,2)=D(1,2)
      E(2,1)=D(2,1); E(2,2)=D(2,2)
      RETURN
      END SUBROUTINE

ALGORITHM 3B: FAST RECURSION
      PROGRAM F3B
      I=45; K=I
      CALL F(I)
      PRINT *,K,'th Fibonacci number is',I
      STOP
      END PROGRAM
CCCCC
C Subroutine F(I) calculates the I'th Fibonacci number
C It uses ALGORITHM 3B: FAST RECURSION, rewritten
C to use non-recursive loops, because FORTRAN does not
C support recursion.
C
      SUBROUTINE F(I)
      J1=LOG(I+1.)/LOG(2.)
      JL=2**J1-2
      JR=2**(J1+1)-2
      JM=(JL+JR)/2
      IF(I-JM)2,2,1
1     JL=JM
      I1=2; I2=1; N=2
      GO TO 3
2     JR=JM
      I1=1; I2=1; N=1
3     IF(N-I)11,7,7
11    JM=(JL+JR)/2
      IF(I-JM)5,5,4
4     JL=JM
      N=(N+1)*2
      ITMP=(I1+I2)**2+I1**2
      I2=(I1+I2)*I1+I1*I2
      I1=ITMP
      GO TO 6
5     JR=JM
      N=2*N+1
      ITMP=I1*(I1+I2)+I1*I2
      I2=I1**2+I2**2
      I1=ITMP
6     IF(N-I)11,7,7
7     I=I1
      RETURN
      END SUBROUTINE

ALGORITHM 3C: BINET'S FORMULA
      PROGRAM F3C
      I=31; K=I
      CALL F(I)
      PRINT *,K,'th Fibonacci number is',I
      STOP
      END PROGRAM
CCCCC
C Subroutine F(I) calculates the I'th Fibonacci number
C It uses ALGORITHM 3C: BINET'S FORMULA
C
      SUBROUTINE F(I)
      REAL*8 PHI
      IF(I.LT.2) GO TO 1
      PHI=(1+SQRT(5.))/2.
      I=(PHI**(I+1) - (1.-PHI)**(I+1)) / SQRT(5.)
      RETURN
1     I=1
      RETURN
      END SUBROUTINE