error when calling a subroutine within subroutine

Question

Hi I have tried to create a minimal, complete, and verifiable example sample code below to emphasize the one error message I am getting. The error is "Type Mismatch in argument 'func0' at (1); passed REAL(4) to COMPLEX(4).

I indicated in the code where the error message from (1) is. It occurs when I try to call a subroutine within another subroutine.

I originally tried to add implicit none into Sub2, however then I get an error message saying func0,func1 do not have implicit types.

I tried to follow the logic of this post : How to call and use a subroutine inside another subroutine in fortran?

Module Sample

integer :: n,m

contains 

subroutine Sub1(func0,func1)

implicit none

   complex, dimension(-10:10, -10:10), intent(inout) :: func0,func1
   complex, dimension(-10:10, -10:10) :: Deriv0,Deriv1


     do while (100 > 0.000001) 

        Deriv0 = Deriv(func0)
        Deriv1 = Deriv(func1)

     end do

end subroutine Sub1

subroutine Sub2(func3)
!implicit none : if this line is not commented out, I still get error messages saying func0,func1 do not have implicit types

   real,dimension(0:20), intent(inout) :: Func3

   call Sub1(func0,func1) !error message from here, this is line (1)

end subroutine  Sub2

function Deriv(func)
implicit none

complex, dimension(-10:10, -10:10) :: func, Deriv

   do n=-9,9
   do m=-9,9

     Deriv(n,m) = func(n+1,m)-2*func(n,m)

   end do
   end do

end function Deriv

End Module Sample

How can I fix this error? Thanks.

Answer 1

There are a number of concepts here we concern ourselves with: scoping; association; and inheritance.

In the code of the question there are four scoping units: the module sample and the three procedures (two subroutines and one function). These are all distinct, but some information is shared between them.

Looking first at the implicit statement. In the module there is no implicit so default typing rules apply in the module's scoping unit. (Although nothing in the module is implicitly typed - the module variables and the function are all explicitly declared.) sub1 and deriv each have implicit none so the typing rule (no implicit typing) is stated clearly there.

With implicit none specified in sub2 there is a compiler complaint about no explicit type declaration of func0 and func1; without implicit none the scoping unit sub2 inherits the typing rules of its host (the module) and so func0 and func1 are real.

You can read about scoping units and typing rules in another question and its answers. In summary, put implicit none in the module.

This typing of func0 and func1 leads us to another aspect of scoping. sub1 and sub2 are entirely different scoping units. The only way those two subroutines can share knowledge about declarations is through association of one form.

There are two forms of association going on here: host association and argument association.

Host association is that each subroutine has access to the variables n and m. They don't reference those variables so let's ignore them. Host association also gives an explicit interface of sub1 in sub2 which allows the compiler to complain about the type mismatch.

In the scoping unit of sub2 there is no explicit declaration of func0 and func1. This is an error with implicit none in force; with default implicit typing rules they are real scalar variables or functions with real scalar results. If you want them to be complex arrays you are just going to have to declare them as such.

Argument association comes about in the following way. We associate the dummy arguments of sub1 with the actual arguments of sub2. The crucial thing here is association: two distinct things happen to refer to the same object. The two procedures don't share anything that isn't explicitly stated in each. To be able to have an actual argument associated with those dummy arguments something appropriate has to exist in the scope of sub2. Currently nothing does.

---

In short: you need to have a suitable declaration of func0 and func1 in sub2. These may be local variables or dummy arguments, depending on how you want the program to flow.

Answer 2

(Disclaimer: I don't actually know Fortran. This answer is a WAG.)

In your Sub2 subroutine, neither func0 nor func1 are declared, and they're not parameters. Unlike the other parts of your code, Sub2 does not contain an implicit none directive, so the compiler assumes you intended func0 to be a REAL variable, which then leads to a type error (because Sub1 requires a COMPLEX variable).

I can't tell you how to fix this because your code never calls Sub2 anywhere, but presumably you have to get two COMPLEX variables from somewhere to pass to Sub1.