Passing array length to function - fortran

Question

I'm sorry if this is a trivial question. My fortran-fu is poor.
Is there a way in Fortran to pass the array length? Using common (which, from what I gather is equivalent to global) is an option as well. What I want is in the main program to call a function with an array. For example (This is typed in, not copy pasted from anywhere)
program prog
integer num
double precision x(num),v
double precision test
....
v=test(x,num)
....
function test(x,num)
double precision test
integer num
double precision x(num)
test=0.0d0
....
return
end
This won't compile since num is not a constant. The important thing is to know what the array size I'm passing is.
Edit: I'm using the GNU Fortran 95 compiler.
Edit2: I tried High Performance Mark's solution without luck:
program prog
integer v
parameter (v=10)
double precision x(v),test,k
k=test(x)
write (*,*) size(x)
stop
end
function test(x)
double precision, dimension(:),intent(in) :: x
double precision test
write (*,*) size(x)
test = 0.0d0
return
end
The output should be two lines where 10 is written. Instead I got this:
/scpc:niels: #$ f95 err.f
/scpc:niels: #$ ./a.out
0
10
/scpc:niels: #$

Answer 1

Fortran arrays 'know' how long they are, you shouldn't need to pass the array and its length as different arguments. (Unless, that is, you are interfacing with old Fortran codes.) Today you'd write something like this
function test(arr)
real, dimension(:), intent(in) :: arr
...
integer :: arrsize
...
arrsize = size(arr)
...
If you have to interface to old code in which array sizes are passed you can make calls like this
call old_fortran_subr(array, size(array, 1), other_arguments)
Oh, and while I'm writing, have nothing to do with common in any code you write from scratch, it's a (rightly) deprecated feature from the 70's and earlier. Instead use module variables.

Answer 2

OK, there's a lot going on here, especially as the Fortran style you are using is a little archaic. Let's do it by steps ...
Firstly make sure you always use implicit none
Secondly if you know the size of the array a priori you can use a symbolic constant to denote its size. You do this via a parameter:
Program prog
Implicit None ! ALWAYS USE THIS
Integer, Parameter :: num = 36
Double Precision x( num )
Double Precision test
Double Precision v
Call Random_number( x )
v = test( x, num )
Write( *, * ) v
End Program prog
Function test( x, num )
Implicit None ! ALWAYS USE THIS
Double Precision test
Integer num
Double Precision x( num )
Integer i
test = 0.0d0
Do i = 1, num
test = test + x( i ) * x( i )
End Do
End Function test
[luser#cromer stackoverflow]$ gfortran -O -std=f95 -Wall -Wextra -pedantic func.f90
[luser#cromer stackoverflow]$ ./a.out
12.129812171430215
Note how num is set to be 36, but the parameter bit means I can not change its value - it is a constant and so can be used to set the size of arrays.
And that is how things stood until 1990. Then a number of things came into the language which change the answer. Most directly connected to your question are allocatable arrays, which allow you to specify the size of the array at run time, and assumed shape arrays, which make passing arrays to subprograms simpler. However a whole slew of other things came in and I suggest you have a look in a book to learn about them - the new language is much more expressive and safer than the old. As an example I would write the above nowadays as something like
[luser#cromer stackoverflow]$ cat func.f90
Module numbers_module
Integer, Parameter :: wp = Selected_real_kind( 12, 70 )
End Module numbers_module
Module funcs_module
Use numbers_module
Implicit None
Public :: test
Private
Contains
Function test( x ) Result( sum_sq )
Implicit None ! ALWAYS USE THIS
Real( wp ) :: sum_sq
Real( wp ), Dimension( : ), Intent( In ) :: x
sum_sq = Sum( x * x )
End Function test
End Module funcs_module
Program prog
Use numbers_module
Use funcs_module
Implicit None ! ALWAYS USE THIS
Real( wp ), Dimension( : ), Allocatable :: x
Real( wp ) :: v
Integer :: num
Write( *, * ) 'How many elements ?'
Read ( *, * ) num
Allocate( x( 1:num ) )
Call Random_number( x )
v = test( x )
Write( *, * ) v
End Program prog
[luser#cromer stackoverflow]$ gfortran -O -std=f95 -Wall -Wextra -pedantic func.f90
[luser#cromer stackoverflow]$ ./a.out
How many elements ?
39
14.151818513394156
If you decide to go this way make sure you understand why to use this method an interface to test needs to be in scope at the calling point - and to do this read a book.
Oh. Common. Just Say No.

Answer 3

Implicit variable declaration was used in earlier versions of Fortran. By this method of variable could simply be used without declaring it explicitly. One statement such as IMPLICIT REAL(A-H, O-Z ) would declare all real variables beginning with letters A-H and O-Z. This is now considered to be too loose and explicit type declaration such as is required by the more powerful language C is to be preferred. My first language was FORTRAN IV but the second language I learned was QBasic which like C requires that all variables be declared explicitly before use.