call a function (defined in a subroutine) in another function - fortran

Question

I am writing code in fortran for 2D integral for function func(x,y) with limits on y from y1(x) to y2(x) and limits on x from x1=3 to x2=5.
Basic assumptions are as follows:
Integral[func(x,y),{y=y1 to y2}, {x=x1 to x2}] = Integral[funcx(x),{x = x1 to x2}]. where funcx = Integral[func,{y = y1(x) to y2(x)}]
Please find my question in the middle of code. I write the code as follows,
implicit real*8(a-h,o-z)
external func
external y1
external y2
x1 = 3.d0
x2 = 5.d0
call twodint(func,y1,y2,x1,x2,result)
print*, result
stop
end
!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
subroutine twodint(origfunc,y1,y2,x1,x2,result)
implicit real*8(a-h,o-z)
external funcx
call simpsonintegral(funcx,x1,x2,ss) ! my integral routine funcx = function, x1 and x2 = limits, ss = output
result = ss
return
end
!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
function funcx(x)
implicit real*8(a-h,o-z)
external funcy
external y1
external y2
common/xvalues/xx
xx = x
call simpsonintegral(funcy,y1(x),y2(x),ss)
funcx = ss
return
end
!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
function funcy(y)
implicit real*8(a-h,o-z)
common/xvalues/x
! my question : if i write here funcy = func(x,y), my code works fine. but i want to write here something like funcy = origfunc(x,y), so that it can receive function from subroutine named as twodint. but this does not work. please help...
return
end
!~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
function func(x,y)
implicit real*8(a-h,o-z)
func = (x**2)*y*dsin(x*y) ! some function of x and y
return
end
function y1(x)
implicit real*8(a-h,o-z)
y1 = x ! some limit
return
end
function y2(x)
implicit real*8(a-h,o-z)
y2 = x*x ! some limit
return
end

Answer 1

In my opinion, external is mainly included in modern Fortran for legacy reasons. Its not the best way to pass functions to subroutines. Also, implicit type declaration is dangerous ... much better to use implicit none and explicitly type all of your variables ... you'll catch a lot of mistakes that way. So ... here is a sketch of how to pass various functions to a subroutine such as an integrator.
module MyStuff
implicit none
abstract interface
function funcX (x)
real, intent (in) :: x
real :: funcX
end function funcX
end interface
contains
subroutine twodint(origfunc,y1,y2,x1,x2,result)
real :: y1, y2, x1, x2, result, ss
procedure (funcX) :: origfunc
call simpsonintegral (origfunc,x1,x2,ss) ! my integral routine funcx = function, x1 and x2 = limits, ss = output
result = ss
return
end subroutine twodint
real function funcA (x)
real, intent (in) :: x
funcA = x ** 2
end function funcA
real function funcB (x)
real, intent (in) :: x
funcB = x ** 2
end function funcB
end module MyStuff
program test1
use MyStuff
implicit none
real :: x1, x2, y1, y2, result
x1 = 3.d0
x2 = 5.d0
call twodint(funcA,y1,y2,x1,x2,result)
print*, result
call twodint(funcB,y1,y2,x1,x2,result)
print*, result
stop
end program test1