More binomial coefficients and FORTRAN 95 - fortran

Question

I'm trying to write a function/subroutine which calculates binomial coefficients for large n and k (n choose k). A couple days ago I posted a subroutine which worked okay but with very slight decimal error. The problem seemed to be due to dividing very large numbers. Anyway, I thought it might be better to try a recursive algorithm as addition might not have this problem. Additionally, given the large numbers involved memorization would be necessary. Here is a function I wrote in the statistical language R, which seems to work pretty well,
options("scipen"=100)
mm <- matrix(0,100,100)
combo <- function (n,k) {
if (k==1) {
return(n)
}
if (k==n) {
return(1)
}
if (mm[n,k] != 0) {
return(mm[n,k])
}
if (k!=1 & n!=k) {
ans <<- combo(n-1,k) + combo(n-1,k-1)
mm[n,k] <<- ans
return(combo(n-1,k) + combo(n-1,k-1))
}
}
combo(40,20)
I need to be able to do the same thing in FORTRAN 95. Here is the recursive code without memorization, which works fine
program fctrecur
implicit none
integer (kind=8) i,j,combo
print*,"What is n?"
read*,i
print*,"What is k?"
read*,j
print*,combo(i,j)
end
recursive function combo(n,k) result(cmb)
implicit none
integer (kind=8) n,k,cmb
if (k .EQ. n) then
cmb = 1
endif
if (k .EQ. 1) then
cmb = n
endif
if ((k .NE. 1) .AND. (k .NE. n)) then
cmb = combo(n-1,k-1) + combo(n-1,k)
endif
end function
My question is...can the above FORTRAN program be modified to incorporate memorization? I have tried to mimic the R function but nothing seems to work. Thanks, Jerry
The module suggestion from Vladimir F works very well...but I can't get it to work as an internal function. Here's the code
program fctrecur
implicit none
integer, parameter :: iknd = selected_int_kind(18)
integer(kind=iknd) :: mm(100,100)
integer (kind=iknd) i,j,combo
print*,"What is n?"
read*,i
print*,"What is k?"
read*,j
print*,combo(i,j)
end
recursive function combo(n,k) result(cmb)
integer, parameter :: iknd = selected_int_kind(18)
integer(kind=iknd) :: cmb
integer(kind=iknd), intent(in) :: n,k
if (k == n) then
cmb = 1
else if (k == 1) then
cmb = n
else if (mm(n,k) /=0) then
print*,"hello"
cmb = mm(n,k)
else if ((k /= 1) .and. (k /= n)) then
cmb = combo(n-1,k-1) + combo(n-1,k)
mm(n,k) = cmb
end if
end function
which gives the following error
"The left hand side of an assignment statement must be a variable or a function result" for the line
mm(n,k) = cmb. Even if I declare the array mm within the function it doesn't work (it works, but ignores the memoization, "mm(n,k)=cmb"
I figured it out...
program fctrecur
implicit none
integer i,j,mm(50,50)
print*,"What is n?"
read*,i
print*,"What is k?"
read*,j
print*,combo(i,j)
contains
recursive function combo(n,k) result(cmb)
implicit none
integer cmb
integer, intent(in) :: n,k
if (k == n) then
cmb = 1
else if (k == 1) then
cmb = n
else if (mm(n,k) /=0) then
print*,"hello"
cmb = mm(n,k)
else if ((k /= 1) .and. (k /= n)) then
cmb = combo(n-1,k-1) + combo(n-1,k)
mm(n,k) = cmb
end if
end function
end program
I just used regular INTEGER for now...will adjust to allow much larger n and k.
Here is the final code that works well for quite large n and k
main program
program fctrecur
use binom
implicit none
integer i,j
print *, "What is n?"
read *, i
allocate(mm(i,i))
mm = 0.D0
print *, "What is k?"
read *, j
print *,combo(i,j)
end
module
module binom
implicit none
integer, parameter :: iknd = selected_real_kind(31)
real(iknd), allocatable :: mm(:,:)
contains
recursive function combo(n,k) result(cmb)
real (kind=iknd) :: cmb
integer, intent(in) :: n,k
if (k == n) then
cmb = real(1,16)
else if (k == 1) then
cmb = real(n,16)
else if (mm(n,k) /=0) then
cmb = mm(n,k)
else if ((k /= 1) .and. (k /= n)) then
cmb = combo(n-1,k-1) + combo(n-1,k)
mm(n,k) = cmb
end if
end function
end module

Answer 1

There is a pretty serious error in your R code. You are computing everything twice (although the memoization helps here)!
You should use:
ans <<- combo(n-1,k) + combo(n-1,k-1)
mm[n,k] <<- ans
return(ans)
This how it looks in Fortran. It is a completely straightforward translation.
module binom
implicit none
integer, parameter :: iknd = selected_int_kind(36)
! 36 is necessary for very large n and k, integer(kind=8) wasn't enough!
integer(iknd) :: mm(100,100)
contains
recursive function combo(n,k) result(cmb)
integer(kind=iknd) :: cmb
integer(kind=iknd), intent(in) :: n,k
if (k == n) then
cmb = 1
else if (k == 1) then
cmb = n
else if (mm(n,k) /=0) then
cmb = mm(n,k)
else if ((k /= 1) .and. (k /= n)) then
cmb = combo(n-1,k-1) + combo(n-1,k)
mm(n,k) = cmb
end if
end function
end module
program fctrecur
use binom
implicit none
integer(kind=iknd) i,j
print *, "What is n?"
read *, i
print *, "What is k?"
read *, j
print *,combo(i,j)
print *,combo(i,j)
end
Notice the function is in a module, you could also define it internal to the program and move the array mm to the main program. External functions are remnants of the past and are not preferred for new code. Internal and module procedures receive an "explicit interface" which helps to find errors and enables many advanced passing mechanisms.
In the final code you want the array allocatable and you want to make sure you do not exceed the bounds, but you do not do that in R either, so I left out that for you.
Notice the selected_int_kind to define the kind in a portable way, kind=8 is not portable and is strongly discouraged. In your case kind=8 was actually too low to allow large n close to 100.
You can use the much more readable operators == and /=.
Notice that the structure of the conditionals should be done using else if because you do not have any immediate return statements in the individual branches.
Generally, I would recommend you to read some good modern Fortran tutorial.