What is the Basic Structure of a Function in FORTRAN?

Question

This is something that's I've wanted to know recently, mostly out of curiousity. I'm in the mood to learn some old coding styles, and FORTRAN seems like a good place to start.

I guess I should help you guys out by providing a good starting point.
So how would this C procedure be written in FORTRAN?

int foo ( int x , int y )
{
    int tempX = x ;
    x += y / 2 ;
    y -= tempX * 3 ;    // tempX holds x's original value.
    return x * y ;
}

I know the entire function could be a single line:

return ( x + ( y / 2 ) ) * ( y - ( x * 3 ) ) ;

But the point of me asking this question is to see how those four statements would be written individually in FORTRAN, not neccessarily combined into a single statement.

Answer 1

Don't blame me - you said old coding styles:

C234567
      SUBROUTINE FOO(I,J,K)
C SAVE THE ORIGINAL VALUES
      IORIG = I
      JORIG = J
C PERFORM THE COMPUTATION
      I = I + J/2
      J = J - IORIG*3
      K = I * J
C RESTORE VALUES
      I = IORIG
      J = JORIG
      END SUBROUTINE FOO

I shudder as I write this, but

• all variables are implicitly integers, since they start with letters between I and N
• FORTRAN passes by reference, so reset I and J at the end to give the same effect as the original function (i.e. pass-by-value, so x and y were unchanged in the calling routine)
• Comments start in column 1, actual statements start in column 7

Please, please, please never write new code like this unless as a joke.

Answer 2

See Functions and Subroutines:

INTEGER FUNCTION foo(i, j)
...
foo = 42
END

then later:

k = foo(1, 2)

Answer 3

Your function might look like this in Fortran

 integer function foo(m, n)
 integer i

 i = m
 m = m + n/2
 n = n - i*3
 foo = m*n

 end function foo

You should be able to get started with any tutorial on Fortran. Some thing like this might help http://www.cs.mtu.edu/~shene/COURSES/cs201/NOTES/fortran.html

cheers

Answer 4

Where do you learn FORTRAN from? Just take a look at the wikibooks!

Derived from the example, I'd say:

function func(x, y) result(r)
   integer, intent(in) :: x, y 
   integer             :: r 
   integer             :: tempX
   tempX = x
   x = x / 2
   y = y - tempX * 3
   r = x * y
end function foo

Answer 5

Similar to above, but with a main program to illustrate how it would be called.

C2345678
       program testfoo
         implicit none   
         integer r, foo 
         r = foo(4,5)
         print *, 'result = ', r
       end

       integer function foo(x,y)
         integer x, y
         integer tx, ty
         tx = x + y / 2
         ty = y - x * 3
         foo = tx * ty
         return
       end

Note that this is Fortran 77, which is what I learned 23 years ago.

Answer 6

True old style in applying the rule IJKLMN for integer

C2345678
      FUNCTION IFOO(I,J)
      II = I + J/2
      JJ = J - I*3
      IFOO = II*JJ
      END