How to write this in Fortran? - matlab

Question

I have the following MATLAB code which does the following.
Suppose I have 3 investments of 10 units. Matrix exits has a value of 1 if the investment is exited. Matrix pos tells me the return of each of the three investments. Then the last line of the code computes the total money earned on exited investments.
I am trying to write a similar lines of code in Fortran. Also below my Fortran attempt.
clear all
X = 10;
ret(1,1) = -0.05;
ret(2,1) = 0.15;
exits = [1 0 1];
pos = [1 1 2];
ret1 = (pos == 1) .* ret(1,1) + (pos == 2) .* ret(2,1);
inv = sum(X * ones(1,3) .* (exits) .* exp(ret1));
My Fortran code:
PROGRAM Matlab_replication
IMPLICIT NONE
INTEGER, DIMENSION(1,1) :: X = 10
REAL, DIMENSION(2,1) :: ret
INTEGER, DIMENSION(1,3) :: exits
INTEGER, DIMENSION(1,3) :: pos
REAL, DIMENSION(1,3) :: ret1
REAL, DIMENSION(1,3) :: ret2
REAL, DIMENSION(1,3) :: ones = 1.0
REAL, DIMENSION(1,3) :: X1
REAL :: inv
ret(1,1) = -0.05
ret(2,1) = 0.15
exits(1,1) = 1
exits(1,2) = 0
exits(1,3) = 1
pos(1,1) = 1
pos(1,2) = 1
pos(1,3) = 2
X1(1,:) = X(1,1) * ones(1,:)
ret1 = (pos == 1) * ret(1,1) + (pos == 2) * ret(2,1)
ret2(1,:) = exp(ret1(1,:))
inv = sum(X1(1,:) * exits(1,:)* ret2(1,:))
end program
Somehow the line ret1 = (pos == 1) * ret(1,1) + (pos == 2) * ret(2,1) is not delivering what I am looking for. Also I had to create two additional variables versus the MATLAB code X1 and ret2. Any way to avoid this?

Answer 1

This may be an extended comment rather than an answer ...
The expression
(pos == 1) * ret(1,1) + (pos == 2) * ret(2,1)
mixes types in a way unacceptable to Fortran. The first term, (pos == 1) is of type logical and evaluates to either .true. or .false.. That is not something that can then be multiplied by a number, or by anything else for that matter.
Actually, matters are slightly worse than I first realised, since pos is an array. Do you expect an array of results, or for a single result from that term ?
I'm not sure what you are trying to do, but you'll need to transform (pos == 1) to a number somehow if you want to multiply it. It is fairly easy to write a Fortran function to return 1 (or whatever you want) for a .true. input, and another number for a .false. input.
Finally I'm surprised that your Fortran code is returning anything at all as you assert in your comment. I'm surprised that it compiles.

Answer 2

pos == 1 in Matlab returns an array consisting of 1 and 0, while it returns an array consisting of .true. and .false. in Fortran (as suggested by #HighPerformanceMark). So, you need to take care of this difference somehow. There are various ways for this, and one such example is like this:
real :: ret( 2 ), vtmp( 3 ), inv, x
integer :: exits( 3 ), pos( 3 )
x = 10.0
ret = [ -0.05, 0.15 ]
exits = [ 1, 0, 1 ]
pos = [ 1, 1, 2 ]
vtmp = abs([ integer:: pos == 1 ]) * ret( 1 ) + abs([ integer:: pos == 2 ]) * ret( 2 )
inv = sum( x * exits * exp( vtmp ) )
where I have assumed gfortran or Intel fortran and changed all 2-D arrays in the original code to 1-D arrays for simplicity.
For other compilers, the above code may be syntactically not allowed; in that case it may be useful to define some utility functions like
module filter_mod
implicit none
interface filter
module procedure filter1D, filter2D
end interface
contains
function filter1D( mask ) result( ints )
logical :: mask(:)
integer :: ints( size( mask ) )
ints = 0 ; where( mask ) ints = 1
end function
function filter2D( mask ) result( ints )
logical :: mask(:,:)
integer :: ints( size( mask, 1 ), size( mask, 2 ) )
ints = 0 ; where( mask ) ints = 1
end function
end module
and modify the original code as
PROGRAM Matlab_replication
use filter_mod
IMPLICIT NONE
...
ret1 = filter( pos == 1 ) * ret(1,1) + filter( pos == 2 ) * ret(2,1)
inv = sum( X(1,1) * exits * exp( ret1 ) )
which hopefully makes the translation from Matlab straight-forward.
EDIT: Actually, use of merge() function seems to be the simplest solution (thanks to #francescalus). With this function the first and second codes can be rewritten as
vtmp = merge( ret(1), 0.0, pos == 1 ) + merge( ret(2), 0.0, pos == 2 )
and
ret1 = merge( ret(1,1), 0.0, pos == 1 ) + merge( ret(2,1), 0.0, pos == 2 )
Because merge() returns an array with the same shape as pos, it is very straight-forward to use even for multi-dimensional arrays.