Template in Fortran?

Question

I have a module that defines three types and and some operations on them.

In a separate module, I want to define an algorithm that operates on either one of these types using the operations defined in the module. The algorithm is the same, regardless of the type. I can overload it, but I was wondering if I can save a lot of typing by defining some sort of template algorithm. What I have in mind is something like class templates in C++.

Thanks

Answer 1

Fortran does not have templates, but you can put the code common to the functions handling different types in an include file as a kludge to simulate templates, as shown in this code:

! file "cumul.inc"
! function cumul(xx) result(yy)
! return in yy(:) the cumulative sum of xx(:)
! type, intent(in) :: xx(:)
! type             :: yy(size(xx))
integer :: i,n
yy = 0
n  = size(xx)
if (n < 1) return
yy(1) = xx(1)
do i=2,n
   yy(i) = yy(i-1) + xx(i)
end do
return
! end function cumul
! end file "cumul.inc"

module foo
implicit none
integer, parameter :: sp = kind(1.0), dp = kind(1.0d0)
interface cumul
   module procedure cumul_double,cumul_real,cumul_int
end interface cumul
contains
!
function cumul_double(xx) result(yy)
real(kind=dp), intent(in) :: xx(:)
real(kind=dp)             :: yy(size(xx))
include "cumul.inc"
end function cumul_double
!
function cumul_real(xx) result(yy)
real(kind=sp), intent(in) :: xx(:)
real(kind=sp)             :: yy(size(xx))
include "cumul.inc"
end function cumul_real
!
function cumul_int(xx) result(yy)
integer, intent(in) :: xx(:)
integer             :: yy(size(xx))
include "cumul.inc"
end function cumul_int
end module foo

program xcumul
use foo, only: cumul
print*,cumul([10,20,30])
print*,cumul(sin([10.0,20.0,30.0]))
print*,cumul(sin([10.0d0,20.0d0,30.0d0]))
end program xcumul
! output:
! 10 30 60
! -0.5440211 0.36892414 -0.6191075
! -0.5440211108893698 0.3689241398382579 -0.6191074842546039

The tool mentioned in the paper

Car, David and Michael List (2010). PyF95++: A Templating Capability for the Fortran 95/2003 Language. ACM Fortran Forum 29(1), 2-20.

may interest you. I have not tried it.

Answer 2

My answer is similar to @Fortranner's answer but I usually place the whole implementation inside of an include file. It has the advantage that multiple procedures could be handled by one single include file and it is easier to maintain, e.g. you can see the whole procedure's defintion, etc.

Some preprocessor voodoo (see PASTE, CONCATHELP, etc.) is needed but it works. The same example as given by @Fortranner could be written as follows.

The main file main.f90:

program main
  use cumul_m, only: cumul
  implicit none

  print *, cumul([1,     2,     3    ])     ! output: 1   3   6
  print *, cumul([1.1,   2.2,   3.3  ])     ! output: 1.1 3.3 6.6
  print *, cumul([1.1d0, 2.2d0, 3.3d0])     ! output: 1.1 3.3 6.6
end program

The module file cumul.f90:

module cumul_m
  use iso_fortran_env, only: real32, real64
  implicit none

  private
  public cumul

  interface cumul
    module procedure :: cumul_int, cumul_sp, cumul_dp
  end interface

contains

#define T int
#define TT integer
#include "cumul_imp.f90.inc"

#define T sp
#define TT real(real32)
#include "cumul_imp.f90.inc"

#define T dp
#define TT real(real64)
#include "cumul_imp.f90.inc"

end module

The implementation's include file cumul_imp.f90.inc:

#define PASTE(X)         X
#define PASTE2(X)        PASTE(X)_
#define CONCATHELP(X, Y) PASTE2(X)Y
#define CONCAT(X, Y)     CONCATHELP(X,Y)

#define CUMUL            CONCAT(cumul,T)

function CUMUL(x) result(y)
  !! the cumulative sum of x

  TT, intent(in) :: x(:)
    !! array of values
  TT             :: y(size(x))
    !! cumulative sum of x

  integer :: i, n

  n = size(x)
  if (n < 1) return

  y(1) = x(1)
  do i = 2, n
    y(i) = y(i-1) + x(i)
  end do
end function

#undef T
#undef TT

#undef PASTE
#undef PASTE2
#undef CONCATHELP
#undef CONCAT

#undef CUMUL

Note that when compiling you need to enable the preprocessor (e.g. -cpp for gfortran):

$ gfortran -cpp -c cumul.f90
$ gfortran cumul.o main.f90 
$ ./a.out
           1           3           6
   1.10000002       3.30000019       6.60000038    
   1.1000000000000001        3.3000000000000003        6.5999999999999996

Answer 3

The emerging Fortran Standard Library project uses the fypp pre-processor by @BálintAradi for templating.

For example, you can define the types and kinds for which the subprograms should be generated and loop for all those selected types and kinds in a for loop:

#:set REAL_KINDS = ["sp", "dp", "qp"]
#:set REAL_TYPES = ["real({})".format(k) for k in REAL_KINDS]

...

#:set RCI_KINDS_TYPES = REAL_KINDS_TYPES + CMPLX_KINDS_TYPES + INT_KINDS_TYPES

#:for k1, t1 in RCI_KINDS_TYPES
      module procedure trace_${t1[0]}$${k1}$
#:endfor

To include a file with some fypp macros one uses

#:include "macrodefs.fypp"

and then you can use very similar techniques as with other preprocessors like the cpp use in jacks answer and also in other questions and answers on this site (like my https://stackoverflow.com/a/24070364/721644).

The above for loop is then very handy for instantiation of your templates for existing types.