Styjun

During the last few years, I have been creating several modules with subroutines that I then use for different projects. I am having problems when I define parameter variables in one of those project-specific files that conflict with a variable name defined within those modules. Is it possible to make those names subroutine-private or module-private?

Here is an example. Suppose I have the following module:

module mymod

 implicit none
 contains

 subroutine test1(x)
 real, intent(in) :: x(:)
 print *, x**2.0 

 end subroutine test1

end module mymod

This module is then called by the main program

program main

 use mymod
 implicit none

 real :: y
 real,dimension(2,1),parameter :: x = [1.0,2.0]

 y = 3.0
 call test1(y)

end program main

In this case, given that x in the main program is defined as a parameter with different dimensions to the x in subroutine test1, there will be problems when compiling (shape matching rules violated). Is there any way of making x in module mymod private within the module?

I know an option could be to use "non-common" variable names in my modules or have a list of forbidden names, but that seems complicated at this point (requires editing too many files and lose consistency of notation with books/papers where these procedures are outlined), and would make collaboration with colleagues more difficult.

Two different questions in one:

Why is the example program failing to compile:

This has nothing to do with public or private, or x being defined in the program itself.

It has everything to do with the fact that in the module, x as a parameter is defined as a 1-d array, and in the main program, y is a scalar.

Try it, remove the declaration of x in the main program and it will still fail.

(In fact, the declaration doesn't work like that anyway, you declare x as a 2-d array (shape 2, 1), but then give it a 1-d array. You'd have to do something like:

real, dimension(2, 1), parameter x = reshape([1.0, 2.0], [2, 1])

But to get rid of the error you describe, you either need to change the subroutine interface by removing the (:) behind the real, intent(in) :: x, or change the call to call test1([y]).

What can you do when 2 modules import different variables of the same name:

It would be different if you were to say have this:

module modA
 implicit none
 real, parameter :: x = 2.0
contains
 subroutine subA(k)
 real, intent(in) :: k
 print *, k*x
 end subroutine subA
end module modA

module modB
 implicit none
 real :: x(3)
end module modB

program progtest
 use modA
 use modB
 implicit none
 call subA(x(1))
end program progtest

In this example, it would try to import the variable x from both modules.

Ways to avoid it:

1. 
   

   Make one x private:

   
   
   

   implicit none
   real, parameter, private :: x = 2.0
   

   
   
   

   or

   
   
   

   real, parameter :: x = 2.0
   private :: x
   

   
   
   

   or

   
   
   

   implicit none
   private
   real, parameter :: x = 2.0
   public :: subA
   

   
   


2. 
   

   Only import the parts that you need:

   
   
   

   program progtest
    use modA, only: subA
    use modB
    implicit none
   ...
   

   
   


3. 
   

   Rename one or both of the x:

   
   
   

   use modA
   use modB, only: xB => x
   ...
   call subA(xB(1))