The following Fortran lines
SUBROUTINE AFprep (ida, idb, jda, jdb, kda, kdb )
IMPLICIT NONE
include 'mpif.h'
USE some_module
interface
SUBROUTINE nothing (azf, ata)
REAL, INTENT(IN) :: azf ( : , : , : )
REAL, INTENT(IN) :: ata ( : , : , : )
END SUBROUTINE nothing
end interface
REAL, PARAMETER :: PI = 3.14159265
REAL( 8 ), PARAMETER :: DPI = 3.14159265358979324D0
REAL, PARAMETER :: PI180 = PI / 180.0
REAL, PARAMETER :: GRAV = 9.80622
INTEGER, INTENT(IN) :: ida, idb, jda, jdb, kda, kdb
REAL :: aensf
REAL, ALLOCATABLE, SAVE :: densq ( : , : , : )
integer :: i, j, status(MPI_STATUS_SIZE)
character (len = 50) :: myfmt
END SUBROUTINE AFprep
are producing the error
Error: USE statement at (1) cannot follow INTERFACE statement at (2)
This is bit odd because USE is before interface (unless the compiler moves it around for some reason that I don't see). some_module is a very large module built earlier and the compiler is GCC-11. I'm not really sure what to do because the compilation goes through if USE some_module is commented out (moving USE after interface results in the same error as expected).
Related
I'm trying to understand the difference between abstract interfaces and "normal" interfaces. What makes an interface abstract? When is each one necessary?
Suppose the examples below
module abstract_type_mod
implicit none
type, abstract :: abstract_t
contains
procedure(abstract_foo), pass, deferred :: Foo
end type
interface
subroutine abstract_foo ( this, a, b )
import :: abstract_t
implicit none
class(abstract_t), intent(in) :: this
real, intent(in) :: a
real, intent(out) :: b
end subroutine
end interface
end module
module concrete_type_mod
use abstract_type_mod
implicit none
type, extends ( abstract_t ) :: concrete_t
contains
procedure, pass :: Foo
end type
contains
subroutine Foo ( this, a, b )
implicit none
class(concrete_t), intent(in) :: this
real, intent(in) :: a
real, intent(out) :: b
b = 2 * a
end subroutine
end module
module ifaces_mod
implicit none
interface
subroutine foo_sub ( a, b )
implicit none
real, intent(in) :: a
real, intent(out) :: b
end subroutine
end interface
end module
module subs_mod
implicit none
contains
pure subroutine module_foo ( a, b )
implicit none
real, intent(in) :: a
real, intent(out) :: b
b = 2 * a
end subroutine
end module
program test
use ifaces_mod
use subs_mod
use concrete_type_mod
implicit none
type(concrete_t) :: concrete
procedure(foo_sub) :: external_sub
procedure(foo_sub), pointer :: foo_ptr
real :: b
foo_ptr => external_sub
call foo_ptr ( 0.0, b )
print*, b
foo_ptr => module_foo
call foo_ptr ( 1.0, b )
print*, b
call concrete%Foo ( 1.0, b )
print*, b
end program
pure subroutine external_sub ( a, b )
implicit none
real, intent(in) :: a
real, intent(out) :: b
b = a + 5
end subroutine
The output is
5.000000
2.000000
2.000000
I haven't used abstract interfaces here. At least I think I havent? I've been doing this for a while and I've never used the abstract "qualifier" on interfaces. It seems that I haven't found a case where using abstract interfaces is required.
Could someone enlighten me here?
PS: Compiler Intel Visual Fortran Composer XE 2013 SP1 Update 3.
Edit:
Quoting Metcalf, Reid and Cohen in Modern Fortran Explained:
In Fortran 95, to declare a dummy or external procedure with an
explicit interface, one needs to use an interface block. This is fine
for a single procedure, but is somewhat verbose for declaring several
procedures that have the same interface (apart from the procedure
names). Furthermore, in Fortran 2003, there are several situations
where this becomes impossible (procedure pointer components or
abstract-type bound procedures).
So, is my compiler in error for accepting the code below and also the one with abstract type above?
module ifaces_mod
implicit none
interface
subroutine foo_sub ( a, b )
implicit none
real, intent(in) :: a
real, intent(out) :: b
end subroutine
end interface
end module
module my_type_mod
use ifaces_mod
implicit none
type my_type_t
procedure(foo_sub), nopass, pointer :: Foo => null()
end type
end module
In both cases, I'd say that I actually have declared abstract interfaces without using the abstract keyword. I think my confusion has roots on the fact that the compiler is accepting code like this.
The "normal" interfaces — known by the standard as specific interface blocks (as you use in the title of the question) — are just normal interface blocks for some procedure. Therefore:
interface
subroutine foo_sub
end subroutine
end interface
means that there exists an actual (external) subroutine named foo_sub and it conforms to the specified interface.
An abstract interface
abstract interface
subroutine foo_sub_abs
end subroutine
end interface
just specifies how some procedure may look like, but the name is the name of the interface, not of any actual procedure. It can be used for a procedure pointers
procedure(foo_sub_abs), pointer :: p
or for a dummy arguments
subroutine bar(f)
procedure(foo_sub_abs) :: f
and it means that the actual procedure to which p will point or which is passed as f conforms to the abstract interface.
Note that you are allowed to use some existing procedure instead of an abstract interface in both two former examples. It just needs to have explicit interface available in the scope (typically it is in the same module, or in a module which is used).
As far as I know (but see #IanH's comment below) the compiler is allowed to refuse your code:
interface
subroutine abstract_foo ( this, a, b )
import :: abstract_t
implicit none
class(abstract_t), intent(in) :: this
real, intent(in) :: a
real, intent(out) :: b
end subroutine
end interface
because there exists no actual procedure named abstract_foo. Some compilers do not diagnose this, but they could.
Quite unrelated are generic interfaces. You can recognize them, because there is a name of a generic procedure after the word interface
interface generic_sub
procedure sub1
subroutine sub2(...)
end subroutine
end interface
Here sub1 and sub2 both exist, sub1 is already known and has already explicit interface available, sub2 is external and looks as the interface specifies, and both are specific procedure of the generic generic_sub. This is quite a different usage.
You then call
call generic_sub(...)
and according to the arguments you pass, the compiler chooses which specific procedure is called, if it is sub1, or sub2.
I would stress that these can be split into sparate interface blocks with the same name declared at different locations. You can add a specific procedure into an existing generic procedure this way.
I have the following problem:
I have a module containing some fortran function, which takes 2 (mathematical) functions as its input. The way I do this at the moment is by defining an interface for the input functions. My module looks like this:
module myModule
implicit none
save
abstract interface
subroutine functype1(x,f)
import dp
real(kind=dp), dimension(:),intent(in) :: x
real(kind=dp), dimension(:),intent(out):: f
end subroutine
subroutine functype2(x,M)
import dp
real(kind=dp), dimension(:),intent(in) :: x
real(kind=dp), dimension(:,:),intent(out):: M
end subroutine
end interface
contains
function taylorExpansion(func,funcdiff)
procedure(functype1) :: func ! The mathematical function f
procedure(functype2) :: funcdiff ! The function evaluating the derivative/gradient of f
! ...
! (further implementation)
! ...
end function
The problem is now that I want functype1 to be kind of general: sometimes the input is just a real, sometimes it's an array of reals. Is it possible to do this smoothly?
(At the moment I'm forced to pass an array of size 1 to func1 instead of a real, which is quite clumsy)
Another way to formulate this is: is it possible to make a type which is a real OR an array of reals? This way both calls would be possible:
program testprog
use myModule
implicit none
save
call taylorExpansion(xsquared,xdiff) ! functype1 can accept reals
call taylorExpansion(vectornorm,vectornormdiff) ! functype1 can also accept vectors
contains
subroutine xsquared(x,fx)
real(kind=dp) :: x
real(kind=dp) :: fx
fx = x**2
end subroutine
subroutine twox(x,fx)
real(kind=dp) :: x
real(kind=dp) :: fx
fx = 2*x
end subroutine
subroutine vectornorm(x,fx)
real(kind=dp), dimension(:) :: x
real(kind=dp) :: fx=0.0
integer i
do i = 1,size(x)
fx = fx + x(i)**2
end do
end subroutine
subroutine vectornormdiff(x,fx)
real(kind=dp), dimension(:) :: x
real(kind=dp), dimension(:) :: fx
integer i
do = 1,size(x)
fx(i) = 2*x(i)
end do
end subroutine
end program
I was wondering if it is somehow possible to define a derived type in Fortran which automatically returns the right type, without calling the type specifically e.g. var%real? Here's an example to explain what I mean:
module DervType
implicit none
type, public :: mytype
real(8) :: r
integer :: i
logical :: l
end type
end module DervType
program TestType
use DervType
implicit none
type(mytype) :: test
test = 1. !! <-- I don't want to use test%r here
end program TestType
Would this be possible by defining some sort of interface assignment (overload the =) or something like that? Is this even possible?
Thanks! Any help appreciated!
Found a solution to this and it was actually quite simple. Here's the code:
module DervType
implicit none
type, public :: mytype
real(8) :: r
integer :: i
character(len=:), allocatable :: c
logical :: l
end type
interface assignment(=) // overload =
module procedure equal_func_class
end interface
contains
subroutine equal_func_class(a,b)
implicit none
type(mytype), intent(out) :: a
class(*), intent(in) :: b
select type (b)
type is (real)
print *, "is real"
a%r = b
type is (integer)
print *, "is int"
a%i = b
type is (character(len=*))
print *, "is char"
a%c = b
type is (logical)
print *, "is logical"
a%l = b
end select
return
end subroutine equal_func_class
end module DervType
program TestType
use DervType
implicit none
type(mytype) :: test
test = 1. // assign real
test = 1 // assign integer
test = "Hey" // assign character
test = .true. // assign logical
print *, "Value (real) : ", test%r
print *, "Value (integer) : ", test%i
print *, "Value (character) : ", test%c
print *, "Value (logical) : ", test%l
end program TestType
I'm trying to use the variables within a program now (e.g. do some arithmetic calculations, etc.) but that seems to be rather difficult if not impossible. I might start another question about that.
I'm attempting to add conversion functions to between different derived types. I'm
wanting them to be functions of the first derived type that returns the other derived type. This is no problem as long as they are in the same file and module. But I'd really like them to be able to be separated into multiple files since otherwise it would be a very large file. I can't figure out how to do this because of dependencies, and the lack of namespace in Fortran.
Is there a way to do this?
Here is an example of what I'd like to be dividing into two files (one for each derived type).
Module ConversionStuff
implicit none
type A_T
real :: a, b, c
contains
procedure :: toX => a_toX
end type A_T
type X_T
real :: x, y, z
contains
procedure :: toA => x_toA
end type X_T
contains
function a_toX(this) result(x)
class(A_T), intent(inout) :: this
type(X_T) :: x
x%x = this%a * 2
x%y = this%b * 2
x%z = this%c * 2
end function a_toX
function x_toA(this) result(a)
class(X_T), intent(inout) :: this
type(A_T) :: a
a%a = this%x * 0.5
a%b = this%y * 0.5
a%c = this%z * 0.5
end function x_toA
End Module ConversionStuff
I do apologize if there is a typo. I don't have an easy way to compile Fortran on this computer.
Within the current language this is easily enough dealt with through submodules - both type definitions go into the ancestor module along with the interfaces for the "shared" separate module procedures, procedure definitions are then split between submodules as it suits.
MODULE ConversionStuff
IMPLICIT NONE
TYPE :: A_T
REAL :: a, b, c
CONTAINS
PROCEDURE :: toX => a_toX
END TYPE A_T
TYPE :: X_T
REAL :: x, y, z
CONTAINS
PROCEDURE :: toA => x_toA
END TYPE x, y, z
INTERFACE
MODULE FUNCTION a_toX(this) RESULT(x)
IMPLICIT NONE
CLASS(A_T), INTENT(IN) :: this
TYPE(X_T) :: x
END FUNCTION a_toX
MODULE FUNCTION x_toA(this) RESULT(a)
IMPLICIT NONE
CLASS(X_T), INTENT(IN) :: this
TYPE(A_T) :: a
END FUNCTION x_toA
END INTERFACE
END MODULE ConversionStuff
SUBMODULE (ConversionStuff) Procedures_for_X
IMPLICIT NONE
CONTAINS
MODULE PROCEDURE a_toX
x%x = this%a * 2
x%y = this%b * 2
x%z = this%c * 2
END PROCEDURE a_toX
END SUBMODULE Procedures_for_X
...
Prior to Fortran 2008, you can sometimes use an alternative approach that emulates the above - the implementation of the procedures goes in a separately compiled set of external procedures that use the module. Care needs to be taken that the external procedures do not have visibility of their own interface.
MODULE ConversionStuff
IMPLICIT NONE
TYPE :: A_T
REAL :: a, b, c
CONTAINS
PROCEDURE :: toX => a_toX
END TYPE A_T
TYPE :: X_T
REAL :: x, y, z
CONTAINS
PROCEDURE :: toA => x_toA
END TYPE x, y, z
INTERFACE
FUNCTION a_toX(this) RESULT(x)
IMPORT :: A_T
IMPORT :: X_T
IMPLICIT NONE
CLASS(A_T), INTENT(IN) :: this
TYPE(X_T) :: x
END FUNCTION a_toX
FUNCTION x_toA(this) RESULT(a)
IMPORT :: A_T
IMPORT :: X_T
IMPLICIT NONE
CLASS(X_T), INTENT(IN) :: this
TYPE(A_T) :: a
END FUNCTION x_toA
END INTERFACE
PRIVATE :: a_toX
PRIVATE :: x_toA
END MODULE ConversionStuff
FUNCTION A_toX(this) RESULT(x)
USE ConversionStuff
IMPLICIT NONE
CLASS(A_T), INTENT(IN) :: this
TYPE(X_T) :: x
...etc...
END FUNCTION A_toX
There are limitations for the use of Fortran's accessibility attributes (PUBLIC and PRIVATE) for this second approach.
Note that the problem has nothing to do with namespaces, as the concept is typically defined.
After working on other things and coming back to this almost 2 months later. I found something I think is far more simple and elegant for this specific usage. I'm going to leave the previously accepted answer because it definitely answers the question, but this is an alternative method.
It uses the include keyword. I didn't understand until now that it doesn't compile included file until it is compiling the including file. Maybe there is something I don't understand, but for this situation where I only want to split into multiple files so that my single file isn't enormous, I think this method is worth the trade off in what I lose for it not being a module. If there is something I'm missing please let me know.
My solution is below.
Module ConversionStuff
implicit none
type A_T
real :: a, b, c
contains
procedure :: toX => a_toX
end type A_T
type X_T
real :: x, y, z
contains
procedure :: toA => x_toA
end type X_T
contains
include "A.f90"
include "X.f90"
End Module ConversionStuff
A.f90
function a_toX(this) result(x)
class(A_T), intent(inout) :: this
type(X_T) :: x
x%x = this%a * 2
x%y = this%b * 2
x%z = this%c * 2
end function a_toX
X.f90
function x_toA(this) result(a)
class(X_T), intent(inout) :: this
type(A_T) :: a
a%a = this%x * 0.5
a%b = this%y * 0.5
a%c = this%z * 0.5
end function x_toA
I'm trying to understand the difference between abstract interfaces and "normal" interfaces. What makes an interface abstract? When is each one necessary?
Suppose the examples below
module abstract_type_mod
implicit none
type, abstract :: abstract_t
contains
procedure(abstract_foo), pass, deferred :: Foo
end type
interface
subroutine abstract_foo ( this, a, b )
import :: abstract_t
implicit none
class(abstract_t), intent(in) :: this
real, intent(in) :: a
real, intent(out) :: b
end subroutine
end interface
end module
module concrete_type_mod
use abstract_type_mod
implicit none
type, extends ( abstract_t ) :: concrete_t
contains
procedure, pass :: Foo
end type
contains
subroutine Foo ( this, a, b )
implicit none
class(concrete_t), intent(in) :: this
real, intent(in) :: a
real, intent(out) :: b
b = 2 * a
end subroutine
end module
module ifaces_mod
implicit none
interface
subroutine foo_sub ( a, b )
implicit none
real, intent(in) :: a
real, intent(out) :: b
end subroutine
end interface
end module
module subs_mod
implicit none
contains
pure subroutine module_foo ( a, b )
implicit none
real, intent(in) :: a
real, intent(out) :: b
b = 2 * a
end subroutine
end module
program test
use ifaces_mod
use subs_mod
use concrete_type_mod
implicit none
type(concrete_t) :: concrete
procedure(foo_sub) :: external_sub
procedure(foo_sub), pointer :: foo_ptr
real :: b
foo_ptr => external_sub
call foo_ptr ( 0.0, b )
print*, b
foo_ptr => module_foo
call foo_ptr ( 1.0, b )
print*, b
call concrete%Foo ( 1.0, b )
print*, b
end program
pure subroutine external_sub ( a, b )
implicit none
real, intent(in) :: a
real, intent(out) :: b
b = a + 5
end subroutine
The output is
5.000000
2.000000
2.000000
I haven't used abstract interfaces here. At least I think I havent? I've been doing this for a while and I've never used the abstract "qualifier" on interfaces. It seems that I haven't found a case where using abstract interfaces is required.
Could someone enlighten me here?
PS: Compiler Intel Visual Fortran Composer XE 2013 SP1 Update 3.
Edit:
Quoting Metcalf, Reid and Cohen in Modern Fortran Explained:
In Fortran 95, to declare a dummy or external procedure with an
explicit interface, one needs to use an interface block. This is fine
for a single procedure, but is somewhat verbose for declaring several
procedures that have the same interface (apart from the procedure
names). Furthermore, in Fortran 2003, there are several situations
where this becomes impossible (procedure pointer components or
abstract-type bound procedures).
So, is my compiler in error for accepting the code below and also the one with abstract type above?
module ifaces_mod
implicit none
interface
subroutine foo_sub ( a, b )
implicit none
real, intent(in) :: a
real, intent(out) :: b
end subroutine
end interface
end module
module my_type_mod
use ifaces_mod
implicit none
type my_type_t
procedure(foo_sub), nopass, pointer :: Foo => null()
end type
end module
In both cases, I'd say that I actually have declared abstract interfaces without using the abstract keyword. I think my confusion has roots on the fact that the compiler is accepting code like this.
The "normal" interfaces — known by the standard as specific interface blocks (as you use in the title of the question) — are just normal interface blocks for some procedure. Therefore:
interface
subroutine foo_sub
end subroutine
end interface
means that there exists an actual (external) subroutine named foo_sub and it conforms to the specified interface.
An abstract interface
abstract interface
subroutine foo_sub_abs
end subroutine
end interface
just specifies how some procedure may look like, but the name is the name of the interface, not of any actual procedure. It can be used for a procedure pointers
procedure(foo_sub_abs), pointer :: p
or for a dummy arguments
subroutine bar(f)
procedure(foo_sub_abs) :: f
and it means that the actual procedure to which p will point or which is passed as f conforms to the abstract interface.
Note that you are allowed to use some existing procedure instead of an abstract interface in both two former examples. It just needs to have explicit interface available in the scope (typically it is in the same module, or in a module which is used).
As far as I know (but see #IanH's comment below) the compiler is allowed to refuse your code:
interface
subroutine abstract_foo ( this, a, b )
import :: abstract_t
implicit none
class(abstract_t), intent(in) :: this
real, intent(in) :: a
real, intent(out) :: b
end subroutine
end interface
because there exists no actual procedure named abstract_foo. Some compilers do not diagnose this, but they could.
Quite unrelated are generic interfaces. You can recognize them, because there is a name of a generic procedure after the word interface
interface generic_sub
procedure sub1
subroutine sub2(...)
end subroutine
end interface
Here sub1 and sub2 both exist, sub1 is already known and has already explicit interface available, sub2 is external and looks as the interface specifies, and both are specific procedure of the generic generic_sub. This is quite a different usage.
You then call
call generic_sub(...)
and according to the arguments you pass, the compiler chooses which specific procedure is called, if it is sub1, or sub2.
I would stress that these can be split into sparate interface blocks with the same name declared at different locations. You can add a specific procedure into an existing generic procedure this way.