This is the problem:

I have a C code that creates an array `nRows x 2`

, called `InitialArray`

filled with random numbers. Then I split that array into two parts, that is the first column is called `xProcess`

and the second column of the array is `yProcess`

.
The goal is to pass these variables I created (`xProcess`

and `yProcess`

) to Matlab and there a Matlab function based on probabilities rules will put `NaN`

in some of the elements of `xProcess`

and `yProcess`

, and will fill empty arrays called `xC`

and `yC`

with the values of `xProcess`

and `yProcess`

before turning to `NaN`

.
Finally, the C code gets all four arrays back again, perform some operations on them and send them again to Matlab. This process is repeated for a number of time steps.

Here is a piece of the code:

```
int main ( void ){
Engine *ep;
if (!(ep = engOpen(""))) {
fprintf(stderr, "\nCan't start MATLAB engine\n");
return EXIT_FAILURE;
}
mxArray *xProcess = NULL;
mxArray *yProcess = NULL;
mxArray *xC = NULL;
mxArray *yC = NULL;
int timeStep;
int numberProcess = 4e6;
int numberC = 0;
```

So far I created the mxArray, and the number of random numbers that will be stored in `xProcess`

and `yProcess`

. Now comes the loop.

```
for (timeStep=0 ; timeStep<numberTimeSteps ; timeStep++){
double *arrayTempxProcess;
arrayTempxProcess = (double *)calloc(numberProcess, sizeof(double));
double *arrayTempyProcess;
arrayTempyProcess = (double *)calloc(numberProcess, sizeof(double));
double *arrayTempxC;
arrayTempxC=(double *)calloc(numberC, sizeof(double));
double *arrayTempyC;
arrayTempyC=(double *)calloc(numberC, sizeof(double));
xProcess = mxCreateDoubleMatrix(numberProcess, 1, mxREAL);
yProcess = mxCreateDoubleMatrix(numberProcess, 1, mxREAL);
xC = mxCreateDoubleMatrix(numberC, 1, mxREAL);
yC = mxCreateDoubleMatrix(numberC, 1, mxREAL);
memcpy((void *)mxGetPr(yProcess), (void *)arrayTempyProcess, numberProcess*sizeof(double));
memcpy((void *)mxGetPr(xProcess), (void *)arrayTempxProcess, numberProcess*sizeof(double));
```

As you see `xC`

and `yC`

I create them as empty. I believe this is equivalent to `xC = []`

and `yC = []`

in Matlab. And the `arrayTempyProcess`

and `arrayTempxProcess`

are temporal arrays that each of them gets a column of `InitialArray`

.

```
if(timeStep>0){
memcpy((void *)mxGetPr(yC), (void *)arrayTempyC,(numberC)*sizeof(double));
memcpy((void *)mxGetPr(xC), (void *)arrayTempxC, (numberC)*sizeof(double));
}
```

Now I send them to Matlab

```
engPutVariable(ep, "xProcess", xProcess);
engPutVariable(ep, "yProcess", yProcess);
engPutVariable(ep, "xC", xC);
engPutVariable(ep, "yC", yC);
free(arrayTempxProcess);
free(arrayTempyProcess);
free(arrayTempxC);
free(arrayTempyC);
```

Now the Matlab function puts `NaN`

in `xProcess`

and `yProcess`

, and fills `xC`

and `yC`

.

```
printf("Entering MATLAB \n");
engEvalString(ep, "[xProcess,yProcess,xC, yC] = my_matlab_function(xProcess,yProcess,xC, yC);");
printf("Leaving MATLAB \n");
```

Now comes trouble... Now I am trying to get the results... but the function `mxGetM(xC)`

produces a segmentation fault in the first time step that I don't understand.

```
xC = engGetVariable(ep,"xC");
int mRowsC = mxGetM(xC);
double *XC = NULL;
XC = (double *)malloc (mRowsC*sizeof(double) );
memcpy(XC, mxGetData(xC),mRowsC*sizeof(double));
yC = engGetVariable(ep,"yC");
double *YC = NULL;
YC = (double *)malloc (mmy*sizeof(double) );
memcpy(YC, mxGetData(yC),mmy*sizeof(double));
xProcess = engGetVariable(ep,"xProcess");
int mRowsProcess = mxGetM(xProcess);
double *XPROCESS = NULL;
XPROCESS = (double *)malloc (mRowsProcess*sizeof(double) );
memcpy(XPROCESS, mxGetData(xPROCESS),mRowsProcess*sizeof(double));
yProcess = engGetVariable(ep,"yProcess");
double *YPROCESS = NULL;
PROCESS = (double *)malloc (mRowsProcess*sizeof(double) );
memcpy(YPROCESS, mxGetData(yProcess),mRowsProcess*sizeof(double));
numberC = mRowsC;
mxDestroyArray(xProcess);
mxDestroyArray(yProcess);
mxDestroyArray(xC);
mxDestroyArray(yC);
free(XPROCESS);
free(YPROCESS);
free(XC);
free(YC);
}
}
```

I have tried to reduce the number of elements in `xProcess`

and `yProcess`

but I get the segmentation fault at some point later than the first time step.
The weird thing about this, is that I also tried to save the results in Matlab after `printf("Leaving MATLAB \n");`

but it didn't work out. It saved nothing.

I'm new coupling C and Matlab, so my code might be entirely wrong, but is there any limits in which C cannot be coupled with Matlab functions?

Any help is appreciated. Thanks!