Fortran Call Matlab

program test
!===============================================================================================================
!
! This program serves as a simple example on how to interface a Fortran program to Matlab,
! not the other way round which is well documented elsewhere.
!
!
! ENVIRONMENT
! This will work using the following environment on a Windows XPpro PC, other environments have not been tested
! but may work as well.
!
!   * Matlab v6.5.1 R13 SP1
!   * Matlab compiler v3.0.1
!   * Compaq Visual Fortran Pro v6.6.0 (CVF) (Compaq bought DEC and HP bought Compaq)
!
!
! OVERVIEW
! We start with a simple .m script and create C-code from it, which is then compiled and placed into a .dll.
! This process is performed fairly automatic in the Matlab environment.
!
! Now we write a Fortran program that calls this Matlab routine. For this to work properly we have to setup
! Matlab structures containing the data values (the mx array and pointers to it), take care of the underscores 
! added to routine names in dll's, the way the arguments are referenced because the routine was generated 
! from C-code and the fact that the routine resides in a dll. All this need only be done for the Matlab script 
! we create, we may call any mx* routines in a normal Fortran fashion. All this is described in detail now.
!
!
! DETAIL
! Our task is to call the following Matlab script from a Fortran program.
!
!   function b = matlabinc(a)
!   % Increment given argument a and return result b to caller, displaying both on screen as well
!   disp(a)
!   explore(a)
!   b = a + 1;
!   disp(b)
!   explore(b)
!
! We compile our Matlab script using a function like this
!
!   function compileDLL(progName)
!   % Compile the .m file given and place result into a dll
!   eval(['mcc -t -L C -W lib:QuGeneLib -T link:lib -h ' progName '.m libmmfile.mlib'])
!   % Use this line instead if you call graphics routines in your .m file
!   %eval(['mcc -B sgl -t -L C -W libhg:QuGeneLib -T link:lib -h ' progName '.m libmmfile.mlib'])
!
! This will create two files, QuGeneLib.lib and QuGeneLib.dll. The.lib file contains information for the Fortran 
! compiler on what is in the .dll file. The .dll is the dynamic link library that contains our compiled Matlab 
! routine. Copy both to the Fortran development directory were the .f90 files live. Also copy all Matlab .dll's
! you are using to the same location, libmx.dll is one you will definitely need. If you call graphics routines
! you will also need sgl.dll and you have to place FigureMenuBar.fig and FigureToolBar.fig into the path of 
! the executing Fortran program as well.
!
! In CVF use "project->add to project->files" and pick the QuGeneLib.lib file. Read through the comments in this 
! Fortran program to understand how everything works. You can use the DOS command 
!
!   dumpbin/exports libmx.lib 
!
! or the Windows Dependency Walker
!
!   http://www.dependencywalker.com/
!
! to see the names of the routines included in the corresponding .dll, this is what has to go into the 
! ALIAS directive when defining the interface for the C routine in the dll with the !DEC$ compiler statement.
! You will note an added underscore and sometimes also a @number after the name. The number indicates the number 
! of bytes used for arguments. Also, C is case sensitive so cases in routine names must match.
!
! Note: You do not need to do this for any mx* routines, Matlab has defined an API for all of these. Although you will
! encounter a name such as MXCOPYPTRTOREAL8@12 in libmx.lib, you have to call mxCopyPtrToReal8 instead.
!
! The main way of achieving data transfer between Fortran and the Matlab C program created from our .m file script
! is via the mx routines supplied by Matlab in the libmx.dll. Read through Matlab HELP titled
! "External Interfaces/API Reference: Fortran MX-Functions" before expanding this example.
!
! Note: You do not need to define any interfaces, pointers etc for the mx* routines. You do also not need
! to call loadlibrary or getprocaddress for the mx* routines. It will not work if you do any of this.
!
!
! Alex Pudmenzky, 24 September 2003, The University of Queensland, Brisbane, Australia (http://alex.pudmenzky.com).
!
!===============================================================================================================
! Declaration section
! Definitions for the "loadlibrary", "freelibrary" and "getprocaddress" routines are included in the following files
!use dfwin        ! More stuff than is in kernel32
use kernel32     ! Use this to safe compilation time if other stuff is not needed
IMPLICIT NONE    ! Produce error during compilation if variables aren't declared
!---------------------------------------------------------------------------------------------------------------
INTERFACE
! Define the interfaces to our own Matlab scripts
! The <dllname>LibInitialize() and <dllname>LibTerminate() routines are automatically added by the compilation
! and dll creation progress in Matlab.
SUBROUTINE matlabinc(nlhs,plhs, nrhs,prhs) 
integer*4 :: nlhs,nrhs
integer*4 :: plhs(*),prhs(*)
!DEC$ ATTRIBUTES C, DLLIMPORT, ALIAS:"_mlxMatlabinc" :: matlabinc
!DEC$ ATTRIBUTES VALUE     :: nlhs,nrhs
!DEC$ ATTRIBUTES REFERENCE :: plhs,prhs
END SUBROUTINE 
SUBROUTINE QuGeneLibInitialize() 
!DEC$ ATTRIBUTES C, DLLIMPORT, ALIAS:"_QuGeneLibInitialize" :: QuGeneLibInitialize
END SUBROUTINE 
SUBROUTINE QuGeneLibTerminate() 
!DEC$ ATTRIBUTES C, DLLIMPORT, ALIAS:"_QuGeneLibTerminate"  :: QuGeneLibTerminate
END SUBROUTINE 
END INTERFACE
!---------------------------------------------------------------------------------------------------------------
! This part only required for our own Matlab routine, not the mx* routines
integer :: p_QuGeneLib_dummy, p_libmx_dummy
logical :: status
! QuGeneLib.dll
pointer (p_QuGeneLib,p_QuGeneLib_dummy)
pointer (pr1_QuGeneLib,QuGeneLibInitialize)
pointer (pr2_QuGeneLib,matlabinc)
pointer (pr3_QuGeneLib,QuGeneLibTerminate)
!---------------------------------------------------------------------------------------------------------------
! Declare all mx* routines we call
INTEGER*4 :: mxGetData               ! 
INTEGER*4 :: mxGetNumberOfElements   ! 
INTEGER*4 :: mxCreateScalarDouble    ! 
INTEGER*4 :: mxCreateNumericMatrix   ! 
INTEGER*4 :: mxClassIDFromClassName  ! 
!---------------------------------------------------------------------------------------------------------------
real*8    :: a(3)    ! What I store in Matlab mx array
real*8    :: b(3)    ! What I read out of Matlab mx array
integer*4 :: a_mx_p  ! Pointer to mx array for a
integer*4 :: a_dx_p  ! Pointer to data in mx array for a
integer*4 :: b_mx_p  ! Pointer to mx array for b
integer*4 :: b_dx_p  ! Pointer to data in mx array for b
integer*4 :: na      ! Number of entries in a
integer*4 :: nb      ! Number of entries in b
!===============================================================================================================
! Executable section
! Locate the QuGeneLib.dll and load it into memory
! This library contains all of our own Matlab functions
p_QuGeneLib = loadlibrary("QuGeneLib.dll"C)
if (p_QuGeneLib == 0) then
  type *, "Error occurred opening QuGeneLib.dll"
  type *, "Program aborting"
  goto 1000
endif
! Set up a pointers to the routines of interest
pr1_QuGeneLib = getprocaddress(p_QuGeneLib, "_QuGeneLibInitialize"C)
if (pr1_QuGeneLib == 0) then
  type *, "Error occurred finding _QuGeneLibInitialize in QuGeneLib.dll"
  type *, "Program aborting"
  goto 1000
endif
pr2_QuGeneLib = getprocaddress(p_QuGeneLib, "_mlxMatlabinc"C)
if (pr2_QuGeneLib == 0) then
  type *, "Error occurred finding _mlxMatlabinc in QuGeneLib.dll"
  type *, "Program aborting"
  goto 1000
endif
pr3_QuGeneLib = getprocaddress(p_QuGeneLib, "_QuGeneLibTerminate"C)
if (pr3_QuGeneLib == 0) then
  type *, "Error occurred finding _QuGeneLibTerminate in QuGeneLib.dll"
  type *, "Program aborting"
  goto 1000
endif
!===============================================================================================================
! Initialise interface to our Matlab routine
! (this initialisation routine is automatically created by Matlab during compilation)
call QuGeneLibInitialize()
! The real*4 value we want to pass from this Fortran code to our Matlab routine
a(1) = 1.0
a(2) = 2.0
a(3) = 3.0
! Create mx array for this value and remember pointer to that mx array (not the value!)
! The mx Array is a special structure that can contain any Matlab datatype
! We omit checking pointers from here on to preserve simplicity, if they are returned zero the operation failed
!a_mx_p = mxCreateScalarDouble(a)
a_mx_p = mxCreateNumericMatrix(3, 1, mxClassIDFromClassName('double'), 0)
! Remember pointer to the data in the mx array, given the pointer to the mx array itself
a_dx_p = mxGetData(a_mx_p)
type *, a
! Store data in Matlab mx array
call mxCopyReal8ToPtr(a, a_dx_p, 3)
! Now we want to prove the data above has been stored by retrieving it again
! Retrieve the number of values (elements) in the mx array, given the pointer to the mx array (not the value!)
na = mxGetNumberOfElements(a_mx_p)
! Check
type *, na
! Now call our Matlab routine which returns b given the argument a (actually pointers to a & b)
call matlabinc(1,b_mx_p, 1,a_mx_p)
! Retrieve data pointer given the mx array pointer
b_dx_p = mxGetData(b_mx_p)
! Convert the value(s) stored in the mx array to Fortran representation, given the pointer to the data in the mx array
call mxCopyPtrToReal8(b_dx_p, b, 3)
! Just to see if it worked
type *, b
! Release memory
call mxDestroyArray(a_mx_p)
call mxDestroyArray(b_mx_p)
! Terminate interface to our Matlab routine
! (this termination routine is automatically created by Matlab during compilation)
call QuGeneLibTerminate()
1000 continue
! Release library
status = freelibrary(p_QuGeneLib)
end