How can I transfer the size of the array to mexFunction

      #include "fintrf.h"
      SUBROUTINE mexFunction(nlhs, plhs, nrhs, prhs)
      IMPLICIT NONE

      mwPointer plhs(*), prhs(*)
      integer nlhs, nrhs

      mwPointer mxGetPr
      mwPointer mxGetM
      mwPointer mxCreateDoubleMatrix

      mwPointer P1,P2,P3
      REAL*8 R1,R2,R3
      %R1 is integer number
      %R2(R1,1) - size of R2
      %R3(R1-2,11) - size of R3

      P1 = mxGetPr(prhs(1))
      P2 = mxGetPr(prhs(2))

      CALL mxCopyPtrToREAL8(P1,R1,1)
      CALL mxCopyPtrToREAL8(P2,R2,1)

      plhs(1) = mxCreateDoubleMatrix(M-2,11,0)
      P3 = mxGetPr(plhs(1))

      CALL ProgramName(R1,R2,R3)
      CALL mxCopyREAL8ToPtr(R3,P3,(M-2)*11)    
      return
      end

This program has 2 input parameters: R1 and R2. Dimensions R2 = R2 (R1). Output parameter R3 has dimensions R3 (R1-2, 11). How can I implement this?

[James Tursa]

This is not entirely clear. In the first place, you can get the dimensions of R2 directly from prhs with mxGetM and mxGetN ... you don't have to pass it in separately. Also, "program" is a keyword in Fortran so it is strange and confusing that you apparently have a subroutine with this name.

Can you explain, in words, what you want this mex routine interface to do? E.g., something like this:

• Pass in a full real double 2D variable that is size MxN
• Inside the mex routine, pass this matrix along with its size to a subroutine
• Pass the results of this subroutine call back to MATLAB

Also, can you show me the signature (i.e. the argument list & types) of your "Program" subroutine? And which subroutine arguments are the inputs and which are the outputs?

[Igor Arkhandeev]

Hello! Thank you for your answer! The goal of my mexFunction is the following: 2 input arguments are given to the input of the function: an array (M, 1) and a number whose value is M. The output parameter is an array (M-2, 11). The fact is that the number M is changing and there is definitely no possibility to set it. I also corrected the code, it is given as an example. Let the name of the program - programName

[James Tursa]

So, you still haven't answered my request to see the full signature of the programname subroutine, and identify which are inputs and which are outputs.

[Igor Arkhandeev]

      SUBROUTINE ProgramName(A,B,C)
      integer B
      Real*8 A(B), C(B-2,11)
      !some operations, filling data in array C
      end subroutine ProgramName

Answer 1

[James Tursa]

Try this (caveat, untested). Don't pass in the row size of the matrix ... just pass in the matrix only. Let the code figure out the row size via mxGetM. I highly advise you add some argument checking into this as well. E.g., make sure you have exactly one full double 2D real input, and that nlhs <= 1.

      #include "fintrf.h"
      SUBROUTINE mexFunction(nlhs, plhs, nrhs, prhs)
      IMPLICIT NONE
      mwPointer plhs(*), prhs(*)
      integer nlhs, nrhs
      mwPointer mxGetPr
      mwPointer mxGetM
      mwPointer mxCreateDoubleMatrix
      mwPointer P1, P3
      integer M
      mwSize Cm, Cn
      integer*4 ComplexFlag
      P1 = mxGetPr(prhs(1))
      M = mxGetM(prhs(1))
      if( M <= 2 ) then
          call mexErrMsgTxt("Input size is too small")
      endif
      Cm = M - 2
      Cn = 11
      ComplexFlag = 0
      plhs(1) = mxCreateDoubleMatrix(Cm,Cn,ComplexFlag)
      P3 = mxGetPr(plhs(1))
      CALL ProgramName( %val(P1), M, %val(P3) )
      return
      end

[Igor Arkhandeev]

I followed the advice above and MATLAB gave the following error:

Error using KK
Requested 18446744073709551615x11 (17179869184.0GB) array exceeds maximum array 
size preference. Creation of arrays greater than this limit may take a long time 
and cause MATLAB to become unresponsive. See array size limit or preference panel 
for more information.

I will give the full code, because I do not understand what it is connected with. Here the variable R11 is R1 from the example, R10 = R2, R13 = R3. I hope I explain myself quite clearly.

#include "fintrf.h"
      SUBROUTINE mexFunction(nlhs, plhs, nrhs, prhs)
      IMPLICIT NONE

      mwPointer plhs(*), prhs(*)
      integer nlhs, nrhs

      mwPointer mxGetPr
      mwPointer mxGetM
      mwPointer mxCreateDoubleMatrix
      mwPointer P1,P2,P3,P4,P5,P6,P7,P8,P9,P11,P12,P13
      REAL*8 R1,R2,R3,R4,R5,R6,R7,R8,R9,M,R12(3)
      mwSize Cm, Cn

      P1 = mxGetPr(prhs(1))
      P2 = mxGetPr(prhs(2))
      P3 = mxGetPr(prhs(3))
      P4 = mxGetPr(prhs(4))
      P5 = mxGetPr(prhs(5))
      P6 = mxGetPr(prhs(6))
      P7 = mxGetPr(prhs(7))
      P8 = mxGetPr(prhs(8))
      P9 = mxGetPr(prhs(9))
      
      M = mxGetM(prhs(11))
      Cm = M - 2
      Cn = 11

      CALL mxCopyPtrToREAL8(P1,R1,1)
      CALL mxCopyPtrToREAL8(P2,R2,1)
      CALL mxCopyPtrToREAL8(P3,R3,1)
      CALL mxCopyPtrToREAL8(P4,R4,1)
      CALL mxCopyPtrToREAL8(P5,R5,1)
      CALL mxCopyPtrToREAL8(P6,R6,1)
      CALL mxCopyPtrToREAL8(P7,R7,1)
      CALL mxCopyPtrToREAL8(P8,R8,1)
      CALL mxCopyPtrToREAL8(P9,R9,1)

      plhs(1) = mxCreateDoubleMatrix(1,3,0)
      P12 = mxGetPr(plhs(1))
      plhs(2) = mxCreateDoubleMatrix(Cm,Cn,0)
      P13 = mxGetPr(plhs(2))

      CALL Kramers(R1,R2,R3,R4,R5,R6,R7,R8,R9,M,%val(P11),R12,%val(P13))
      CALL mxCopyREAL8ToPtr(R12,P12,3)   
      return
end

      SUBROUTINE Kramers(EA,DE,EC,NC,EN,CS,CC,MT,ANGLE,NN,ints,y,outs)
      real*8 EA,DE,EC,NC,EN,CS,CC
      real*8 ints,y,outs
      REAL*8 NN,ANGLE,MT
      DIMENSION ints(NN), y(3), outs(NN-2,11)

[James Tursa]

Rule #1 for Fortran: Argument passing for implicit interfaces is typically accomplished as pass-by-reference. As such, there is NO automatic type conversion of the arguments like you would get in C/C++. Thus, in Fortran, you should NEVER use literal constants in arguments with the MATLAB API functions because you cannot guarantee they will match up with mwPointer or mwSize or mwIndex etc. E.g., a literal integer 3 would typically be a 4-byte integer in Fortran, but mwSize might me an 8-byte integer for a MATLAB API function.

What does this mean for your code? You have literal integer constants in your arguments to the MATLAB API functions. NEVER do that! That can cause garbage bytes to be interpreted as part of the integer and you can get crazy values (which is what I think is causing your error). Always use variables of the appropriate type as specified in the MATLAB doc. E.g., this line

plhs(1) = mxCreateDoubleMatrix(1,3,0)

should be this instead

mwSize Dm, Dn
integer*4 ComplexFlag
    :
Dm = 1
Dn = 3
ComplexFlag = 0
plhs(1) = mxCreateDoubleMatrix(Dm,Dn,ComplexFlag) ! Use variables, not literals

You've got other API calls with literal constants as arguments. You need to replace those arguments with variables as well. E.g., these lines have literal 0 and 3 arguments. Replace them with variables of the appropriate type based on the MATLAB API doc.

      plhs(2) = mxCreateDoubleMatrix(Cm,Cn,0)
        :
      CALL mxCopyREAL8ToPtr(R12,P12,3)  

Also your scalar value copying is way too complicated. These lines:

      P1 = mxGetPr(prhs(1))
      P2 = mxGetPr(prhs(2))
      P3 = mxGetPr(prhs(3))
      P4 = mxGetPr(prhs(4))
      P5 = mxGetPr(prhs(5))
      P6 = mxGetPr(prhs(6))
      P7 = mxGetPr(prhs(7))
      P8 = mxGetPr(prhs(8))
      P9 = mxGetPr(prhs(9))
         :
      CALL mxCopyPtrToREAL8(P1,R1,1)
      CALL mxCopyPtrToREAL8(P2,R2,1)
      CALL mxCopyPtrToREAL8(P3,R3,1)
      CALL mxCopyPtrToREAL8(P4,R4,1)
      CALL mxCopyPtrToREAL8(P5,R5,1)
      CALL mxCopyPtrToREAL8(P6,R6,1)
      CALL mxCopyPtrToREAL8(P7,R7,1)
      CALL mxCopyPtrToREAL8(P8,R8,1)
      CALL mxCopyPtrToREAL8(P9,R9,1)

Can all be replaced with these lines:

real*8, external :: mxGetScalar
      :
      R1 = mxGetScalar(prhs(1))
      R2 = mxGetScalar(prhs(2))
      R3 = mxGetScalar(prhs(3))
      R4 = mxGetScalar(prhs(4))
      R5 = mxGetScalar(prhs(5))
      R6 = mxGetScalar(prhs(6))
      R7 = mxGetScalar(prhs(7))
      R8 = mxGetScalar(prhs(8))
      R9 = mxGetScalar(prhs(9))      

Also, I don't see anywhere in your code where you set P11 to a value before using it as %val(P11) in your Kramers call. This in and of itself would likely crash MATLAB.

Finally, it is odd that you would choose real*8 as the type to hold a dimension value (M and NN). Typically one would use an integer type for this.

[Igor Arkhandeev]

Thank you for your answer. But I do not know how %val works. What should I do?

I do not understand what further my actions should be. The previous comments do not affect the functionality, but this is most likely what destroys my code.

Also, I don't see anywhere in your code where you set P11 ' ...
    'to a value before using it as %val(P11) in your Kramers call.

[James Tursa]

%val( ) simply instructs the compiler to pass the argument by value instead of by reference. This is how to pass a pointer value (e.g., the result of a mxGetPr call) to a Fortran subroutine and avoid a data copy.

As for P11, what is this pointer supposed to be associated with?

[Igor Arkhandeev]

P11 is array of real*8 numbers (M x 1) and I should to transfer it to Kramers

[James Tursa]

So do you need this line?

P11 = mxGetPr(prhs(11))

[Igor Arkhandeev]

This code still causes an error

#include "fintrf.h"
      SUBROUTINE mexFunction(nlhs, plhs, nrhs, prhs)
      IMPLICIT NONE

      mwPointer plhs(*), prhs(*)
      integer nlhs, nrhs

      mwPointer mxGetPr
      mwPointer mxGetM
      mwPointer mxCreateDoubleMatrix
      mwPointer P1,P2,P3,P4,P5,P6,P7,P8,P9,P11,P12,P13
      mwSize Cm, Cn
      mwSize Dm, Dn
      REAL*8 R1,R2,R3,R4,R5,R6,R7,R8,R9,M,R12(3)
      integer*4 ComplexFlag
      real*8, external :: mxGetScalar
      
      M = mxGetM(prhs(11))
      Cm = M - 2
      Cn = 11
      Dm = 1
      Dn = 3
      ComplexFlag = 0

      R1 = mxGetScalar(prhs(1))
      R2 = mxGetScalar(prhs(2))
      R3 = mxGetScalar(prhs(3))
      R4 = mxGetScalar(prhs(4))
      R5 = mxGetScalar(prhs(5))
      R6 = mxGetScalar(prhs(6))
      R7 = mxGetScalar(prhs(7))
      R8 = mxGetScalar(prhs(8))
      R9 = mxGetScalar(prhs(9))
      P11 = mxGetPr(prhs(11))

      plhs(1) = mxCreateDoubleMatrix(Dm,Dn,ComplexFlag)
      P12 = mxGetPr(plhs(1))
      plhs(2) = mxCreateDoubleMatrix(Cm,Cn,ComplexFlag)
      P13 = mxGetPr(plhs(2))

      CALL Kramers(R1,R2,R3,R4,R5,R6,R7,R8,R9,M,%val(P11),R12,%val(P13))
      CALL mxCopyREAL8ToPtr(R12,P12,3)   
      return
      end

[James Tursa]

What error are you getting? Please show complete text of error. And you still haven't corrected that 3 literal integer in this line:

CALL mxCopyREAL8ToPtr(R12,P12,3)  

You need to use a variable for the 3. According to the doc this needs to be a mwSize variable.

[Igor Arkhandeev]

KK.F if mexFunction's file name

[Igor Arkhandeev]

I corrected this line

CALL mxCopyREAL8ToPtr(R12,P12,3)

Now it looks like this

CALL mxCopyREAL8ToPtr(R12,P12,Dn)  

[James Tursa]

What does this show:

integer*4, external :: mexPrintf
integer*4 k
character*50 line
    :
write(line,'(A,I)') 'Cm = ',Cm
k = mexPrintf(line//achar(13))
write(line,'(A,I)') 'Cn = ',Cn
k = mexPrintf(line//achar(13))
write(line,'(A,I)') 'Dm = ',Dm
k = mexPrintf(line//achar(13))
write(line,'(A,I)') 'Dn = ',Dn
k = mexPrintf(line//achar(13))

[Igor Arkhandeev]

Where to insert this code?

[James Tursa]

Insert the top stuff in the beginning.

Insert the printing stuff after you set all four of those variables but before you call mxCreateDoubleMatrix.

[James Tursa]

Also print out the value of M.

[Igor Arkhandeev]

James, thank you very much! The error was as follows: I confused the columns and rows, so M = -1 in my code. Unfortunately, my knowledge of FORTRAN is not enough, but thanks to such a specialist as you, everything turned out! Thank you so much!

In a separate comment, I will give a final decision so that others can rely on it in the future.

[James Tursa]

So, I need to gently slap you on the wrist at this point. As you recall, I had put this in my original code for you:

      if( M <= 2 ) then
          call mexErrMsgTxt("Input size is too small")
      endif

You chose not to implement this check, and it cost a lot of wasted time in tracking down the error. So ... I would strongly advise again to put in LOTS of argument checks in your mex routines in the future! :)

[Igor Arkhandeev]

You're damn right!

Answer 2

[Igor Arkhandeev]

      #include "fintrf.h"
      SUBROUTINE mexFunction(nlhs, plhs, nrhs, prhs)
      IMPLICIT NONE

      mwPointer plhs(*), prhs(*)
      integer nlhs, nrhs

      mwPointer mxGetPr
      mwPointer mxGetN
      mwPointer mxCreateDoubleMatrix
      mwPointer P11,P12,P13!P1,P2,P3,P4,P5,P6,P7,P8,P9,P11,P12,P13
      mwSize Cm, Cn
      mwSize Dm, Dn
      REAL*8 R1,R2,R3,R4,R5,R6,R7,R8,R9,M,R12(3)
      integer*4 ComplexFlag
      real*8, external :: mxGetScalar
      
      integer*4, external :: mexPrintf
      integer*4 k
      character*50 line
      
      M = mxGetN(prhs(11))
      Cm = M - 2
      Cn = 11
      Dm = 1
      Dn = 3
      ComplexFlag = 0
      
      if( M <= 2 ) then
          call mexErrMsgTxt("Input size is too small")
      endif
      
      R1 = mxGetScalar(prhs(1))
      R2 = mxGetScalar(prhs(2))
      R3 = mxGetScalar(prhs(3))
      R4 = mxGetScalar(prhs(4))
      R5 = mxGetScalar(prhs(5))
      R6 = mxGetScalar(prhs(6))
      R7 = mxGetScalar(prhs(7))
      R8 = mxGetScalar(prhs(8))
      R9 = mxGetScalar(prhs(9))
      P11 = mxGetPr(prhs(11))

      plhs(1) = mxCreateDoubleMatrix(Dm,Dn,ComplexFlag)
      P12 = mxGetPr(plhs(1))
      plhs(2) = mxCreateDoubleMatrix(Cm,Cn,ComplexFlag)
      P13 = mxGetPr(plhs(2))
      
      CALL Kramers(R1,R2,R3,R4,R5,R6,R7,R8,R9,M,%val(P11),R12,%val(P13))
      CALL mxCopyREAL8ToPtr(R12,P12,Dn)   
      return
      end