void homogToFlow(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
/* [us,vs]=homogToFlow(H,m,n,[r0],[r1],[c0],[c1]); */
int ind=0, i, j, m, n, m1, n1; double *H, *us, *vs;
double r, c, r0, c0, r1, c1, m2, n2, z;
/* extract inputs */
H = (double*) mxGetData(prhs[0]);
m = (int) mxGetScalar(prhs[1]);
n = (int) mxGetScalar(prhs[2]);
if(nrhs==7) {
r0 = mxGetScalar(prhs[3]);
r1 = mxGetScalar(prhs[4]);
c0 = mxGetScalar(prhs[5]);
c1 = mxGetScalar(prhs[6]);
m1 = (int) (r1-r0+1);
n1 = (int) (c1-c0+1);
} else {
m1=m; r0 = (-m+1.0)/2.0;
n1=n; c0 = (-n+1.0)/2.0;
}
m2 = (m-1.0)/2.0;
n2 = (n-1.0)/2.0;
/* initialize memory */
us = mxMalloc(sizeof(double)*m1*n1);
vs = mxMalloc(sizeof(double)*m1*n1);
/* Compute flow at each grid point */
for( i=0; i<9; i++ ) H[i]=H[i]/H[8];
if( H[2]==0 && H[5]==0 ) {
for( i=0; i<n1; i++ ) {
r = H[0]*r0 + H[3]*(c0+i) + H[6] + m2;
c = H[1]*r0 + H[4]*(c0+i) + H[7] + n2 - i;
for(j=0; j<m1; j++) {
us[ind]=r-j; vs[ind]=c;
r+=H[0]; c+=H[1]; ind++;
}
}
} else {
for( i=0; i<n1; i++ ) {
r = H[0]*r0 + H[3]*(c0+i) + H[6];
c = H[1]*r0 + H[4]*(c0+i) + H[7];
z = H[2]*r0 + H[5]*(c0+i) + 1;
for(j=0; j<m1; j++) {
us[ind]=r/z+m2-j; vs[ind]=c/z+n2-i;
r+=H[0]; c+=H[1]; z+=H[2]; ind++;
}
}
}
/* create output array */
plhs[0] = mxCreateNumericMatrix(0,0,mxDOUBLE_CLASS,mxREAL);
plhs[1] = mxCreateNumericMatrix(0,0,mxDOUBLE_CLASS,mxREAL);
mxSetData(plhs[0],us); mxSetM(plhs[0],m1); mxSetN(plhs[0],n1);
mxSetData(plhs[1],vs); mxSetM(plhs[1],m1); mxSetN(plhs[1],n1);
}
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
double *xin, *yin, *xout, *yout;
size_t nin, nout;
/* Check for proper number of arguments. */
if (nrhs!=2)
mexErrMsgTxt("Two inputs required.");
if (nlhs>2)
mexErrMsgTxt("Too many output arguments.");
/* Check for matching dimensions. */
if ( mxGetM(prhs[0]) != mxGetM(prhs[1]) ||
mxGetN(prhs[0]) != mxGetN(prhs[1]) )
mexErrMsgTxt("Inputs must have the same dimensions.");
/* Check for proper numeric class and dimensions. */
if ( !mxIsDouble(prhs[0]) || mxIsComplex(prhs[0]) ||
!mxIsDouble(prhs[0]) || mxIsComplex(prhs[0]) ||
( mxGetM(prhs[0]) != 1 && mxGetN(prhs[0]) != 1 ) )
mexErrMsgTxt("Inputs must be double non complex vectors.");
/* Assign pointers to corresponding inputs. */
nin = mxGetNumberOfElements(prhs[0]);
xin = mxGetPr(prhs[0]);
yin = mxGetPr(prhs[1]);
/* Call to triangulation function based on gpc. */
xout = NULL;
yout = NULL;
nout = 0;
poly2tri_gpc(&xout, &yout, &nout, xin, yin, nin);
/* Assign pointers to corresponding outputs. */
if (nlhs > 0)
{
plhs[0] = mxCreateNumericMatrix(0, 0, mxDOUBLE_CLASS, mxREAL);
mxSetM(plhs[0], 3);
mxSetN(plhs[0], nout);
mxSetPr(plhs[0], xout);
}
if (nlhs > 1)
{
plhs[1] = mxCreateNumericMatrix(0, 0, mxDOUBLE_CLASS, mxREAL);
mxSetM(plhs[1], 3);
mxSetN(plhs[1], nout);
mxSetPr(plhs[1], yout);
}
}
static double MatlabCallback(int n, const double *x, int *undefined_flag, void *data) {
mxArray *rhs[2];
mxArray *lhs[2];
double *oldPtr;
double fVal;
bool violatesConstraints;
//feval in Matlab will take the function handle and the state as
//inputs.
//The first function handle is f.
rhs[0]=(mxArray*)data;
rhs[1]=mxCreateNumericMatrix(0, 0, mxDOUBLE_CLASS, mxREAL);
//Set the matrix data to x
oldPtr=mxGetPr(rhs[1]);
//x will not be modified, but the const must be typecast away to use
//the mxSetPr function.
mxSetPr(rhs[1],(double*)x);
mxSetM(rhs[1], (size_t)n);
mxSetN(rhs[1], 1);
//Get the function value and gradient.
mexCallMATLAB(2,lhs,2,rhs,"feval");
//Get the function value.
fVal=getDoubleFromMatlab(lhs[0]);
violatesConstraints=getBoolFromMatlab(lhs[1]);
if(violatesConstraints) {
*undefined_flag=1;
}
//Get rid of the returned Matlab Matrices.
mxDestroyArray(lhs[0]);
mxDestroyArray(lhs[1]);
//Set the data pointer back to what it was during allocation that
//mxDestroyArray does not have a problem.
mxSetPr(rhs[1],oldPtr);
mxSetM(rhs[1], 0);
mxSetN(rhs[1], 0);
//Get rid of the temporary natrix.
mxDestroyArray(rhs[1]);
return fVal;
}
/* MEX GATEWAY */
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
int num, jobid, i;
mwSize idx;
double *arg_p;
arg_p = mxGetPr(prhs[0]);
/* TODO: This uses 2x the minimal necessary memory */
/* UINT8_T data[(int)arg_p[1]]; */
UINT8_T data[4096];
UINT8_T *mesg_data;
get_shmem_mesg(data, prhs[0], &jobid);
mesg_data = mxCalloc((int)arg_p[0], sizeof(UINT8_T));
for ( idx = 0; idx < (int)arg_p[0]; idx++ ) {
mesg_data[idx] = data[idx];
}
plhs[0] = mxCreateNumericMatrix(0, 0, mxUINT8_CLASS, mxREAL);
/*
printf(" mesg_data[0] : %d \n", mesg_data[0]);
printf(" mesg_data[end] : %d \n", mesg_data[(int)arg_p[0]-1]);
printf(" nbytes : %d \n", (int)arg_p[0]);
*/
/* Point mxArray to dynamicData */
mxSetData(plhs[0], mesg_data);
mxSetM(plhs[0], (int)arg_p[0]);
mxSetN(plhs[0], 1);
return;
}
/* return a complex sparse matrix to MATLAB */
mxArray *cs_cl_mex_put_sparse (cs_cl **Ahandle)
{
cs_cl *A ;
double *x, *z ;
mxArray *Amatlab ;
CS_INT k ;
A = *Ahandle ;
if (!A) mexErrMsgTxt ("failed") ;
Amatlab = mxCreateSparse (0, 0, 0, mxCOMPLEX) ;
mxSetM (Amatlab, A->m) ;
mxSetN (Amatlab, A->n) ;
mxSetNzmax (Amatlab, A->nzmax) ;
cs_cl_free (mxGetJc (Amatlab)) ;
cs_cl_free (mxGetIr (Amatlab)) ;
cs_cl_free (mxGetPr (Amatlab)) ;
cs_cl_free (mxGetPi (Amatlab)) ;
mxSetJc (Amatlab, (void *) (A->p)) ; /* assign A->p pointer to MATLAB A */
mxSetIr (Amatlab, (void *) (A->i)) ;
x = cs_dl_malloc (A->nzmax, sizeof (double)) ;
z = cs_dl_malloc (A->nzmax, sizeof (double)) ;
for (k = 0 ; k < A->nzmax ; k++)
{
x [k] = creal (A->x [k]) ; /* copy and split numerical values */
z [k] = cimag (A->x [k]) ;
}
cs_cl_free (A->x) ; /* free copy of complex values */
mxSetPr (Amatlab, x) ;
mxSetPi (Amatlab, z) ;
cs_cl_free (A) ; /* frees A struct only, not A->p, etc */
*Ahandle = NULL ;
return (Amatlab) ;
}
void mexFunction(int nlhs, mxArray *plhs[],int nrhs, const mxArray *prhs[])
{
if (nrhs != 2) mexErrMsgTxt("Takes 2 input arguments");
int N1=mxGetN(prhs[0]); int N2=mxGetN(prhs[1]);
if (!mxIsUint32(prhs[0]) && N1>0) mexErrMsgTxt("Arguments must be sorted uint32s");
if (!mxIsUint32(prhs[1]) && N2>0) mexErrMsgTxt("Arguments must be sorted uint32s");
uint32_t *src, *cmp, *dest;
src = (uint32_t *) mxGetData(prhs[0]);
cmp = (uint32_t *) mxGetData(prhs[1]);
plhs[0] = mxCreateNumericMatrix(1,N1,mxUINT32_CLASS,mxREAL);
dest=(uint32_t *) mxGetData(plhs[0]);
uint32_t* end = std::set_intersection( src, src+N1, cmp, cmp+N2, dest );
mxSetN(plhs[0],end-dest);
/*
unsigned int i,j,k;
for (i=0,j=0,k=0; i<N1 && j<N2; ) {
if (src[i] < cmp[j]) dest[k++]=src[i++];
else if (src[i]==cmp[j]) { i++; }
else if (src[i] > cmp[j] && j<N2) j++;
}
while (i<N1) dest[k++]=src[i++];
mxSetN(plhs[0],k);
*/
}
/* the gateway routine. */
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
double *num_bytes;
num_bytes = mxGetPr(prhs[0]);
int num;
num = (int)*num_bytes;
/* TODO: This uses 2x the minimal necessary memory */
UINT8_T data[num];
get_shmem_mesg(data, num);
UINT8_T *mesg_data;
mwSize idx;
mesg_data = mxCalloc(num, sizeof(UINT8_T));
for ( idx = 0; idx < num; idx++ ) {
mesg_data[idx] = data[idx];
}
plhs[0] = mxCreateNumericMatrix(0, 0, mxUINT8_CLASS, mxREAL);
/* Point mxArray to dynamicData */
mxSetData(plhs[0], mesg_data);
mxSetM(plhs[0], num);
mxSetN(plhs[0], 1);
return;
}
mxArray* GetMexArray(int N, int M) {
mxArray* Array = mxCreateDoubleMatrix(0, 0, mxREAL);
mxSetM(Array, N);
mxSetN(Array, M);
mxSetData(Array, mxMalloc(sizeof(double)*M*N));
return Array;
}
mxArray *spqr_mx_put_sparse
(
cholmod_sparse **Ahandle, // CHOLMOD version of the matrix
cholmod_common *cc
)
{
mxArray *Amatlab ;
cholmod_sparse *A ;
Long nz, is_complex ;
A = *Ahandle ;
is_complex = (A->xtype != CHOLMOD_REAL) ;
Amatlab = mxCreateSparse (0, 0, 0, is_complex ? mxCOMPLEX: mxREAL) ;
mxSetM (Amatlab, A->nrow) ;
mxSetN (Amatlab, A->ncol) ;
mxSetNzmax (Amatlab, A->nzmax) ;
mxFree (mxGetJc (Amatlab)) ;
mxFree (mxGetIr (Amatlab)) ;
mxFree (mxGetPr (Amatlab)) ;
mxSetJc (Amatlab, (mwIndex *) A->p) ;
mxSetIr (Amatlab, (mwIndex *) A->i) ;
nz = cholmod_l_nnz (A, cc) ;
put_values (nz, Amatlab, (double *) A->x, is_complex, cc) ;
A->p = NULL ;
A->i = NULL ;
A->x = NULL ;
A->z = NULL ;
cholmod_l_free_sparse (Ahandle, cc) ;
return (Amatlab) ;
}
void mexFunction( int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[] )
{
double *rPath, *xPath, *deltamRNA;
int offIdx, synthIdx, numGeneOns, numEvents;
/* The input must be a noncomplex scalar double.*/
numEvents = mxGetN(prhs[0]);
/* Create matrix for the return argument. */
plhs[0] = mxCreateDoubleMatrix(1,numEvents, mxREAL);
/* Assign pointers to each input and output. */
rPath = mxGetPr(prhs[0]);
offIdx = mxGetScalar(prhs[1]);
synthIdx = mxGetScalar(prhs[2]);
deltamRNA = mxGetPr(plhs[0]);
/* Call the timestwo subroutine. */
numGeneOns = CountmRNA(rPath, deltamRNA, offIdx, synthIdx, numEvents);
mxSetN(plhs[0], numGeneOns);
}
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
#define spikes_out plhs[0]
#define spikesA_in prhs[0]
#define spikesB_in prhs[1]
#define cespA_in prhs[2]
#define cespB_in prhs[3]
#define length_in prhs[4]
int num_spikesA, num_spikesB, *length, i, j;
float *spikesA, *spikesB, *spikes, *cespA, *cespB;
spikesA = (float *)mxGetPr(spikesA_in);
spikesB = (float *)mxGetPr(spikesB_in);
cespA = (float *)mxGetPr(cespA_in);
cespB = (float *)mxGetPr(cespB_in);
length = (int *)mxGetPr(length_in);
num_spikesA = mxGetN(spikesA_in);
num_spikesB = mxGetN(spikesB_in);
spikes_out = mxCreateNumericArray(0, 0, mxSINGLE_CLASS, mxREAL);
mxSetM(spikes_out, 2);
mxSetN(spikes_out, *length);
mxSetData(spikes_out, mxMalloc(sizeof(float) * 2 * *length));
spikes = (float *)mxGetPr(spikes_out);
i = 0;
j = 0;
while (i + j < *length) {
if ((spikesA[i] < spikesB[j] && i < num_spikesA)||(j == num_spikesB)) {
spikes[2*(i+j)] = cespA[i];
if (j > 0)
spikes[1 + 2*(i+j)] = cespB[j-1];
else
spikes[1 + 2*(i+j)] = 0;
if (i < num_spikesA)
i++;
}
else {
spikes[1 + 2*(i+j)] = cespB[j];
if (i > 0)
spikes[2*(i+j)] = cespA[i-1];
else
spikes[2*(i+j)] = 0;
if (j < num_spikesB)
j++;
}
}
return;
}
void flowToInds(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
/* [rs,cs,is]=flowToInds(us,vs,m,n,flag); */
int m, n, m1, n1, flag; double *us, *vs;
int *is, ind=0, i, j, fr, fc; double *rs, *cs, r, c;
/* extract inputs */
us = (double*) mxGetData(prhs[0]);
vs = (double*) mxGetData(prhs[1]);
m = (int) mxGetScalar(prhs[2]);
n = (int) mxGetScalar(prhs[3]);
flag = (int) mxGetScalar(prhs[4]);
/* initialize memory */
m1=(int)mxGetM(prhs[0]); n1=(int)mxGetN(prhs[0]);
rs = mxMalloc(sizeof(double)*m1*n1);
cs = mxMalloc(sizeof(double)*m1*n1);
is = mxMalloc(sizeof(int)*m1*n1);
/* clamp and compute ids according to flag */
if( flag==1 ) { /* nearest neighbor */
for(i=0; i<n1; i++) for(j=0; j<m1; j++) {
r=us[ind]+j+1; r = r<1 ? 1 : (r>m ? m : r);
c=vs[ind]+i+1; c = c<1 ? 1 : (c>n ? n : c);
is[ind] = ((int) (r-.5)) + ((int) (c-.5)) * m; ind++;
}
} else if(flag==2) { /* bilinear */
for(i=0; i<n1; i++) for(j=0; j<m1; j++) {
r=us[ind]+j+1; r = r<2 ? 2 : (r>m-1 ? m-1 : r); fr = (int) r;
c=vs[ind]+i+1; c = c<2 ? 2 : (c>n-1 ? n-1 : c); fc = (int) c;
rs[ind]=r-fr; cs[ind]=c-fc; is[ind]=(fr-1)+(fc-1)*m; ind++;
}
} else { /* other cases - clamp only */
for(i=0; i<n1; i++) for(j=0; j<m1; j++) {
r=us[ind]+j+1; rs[ind] = r<2 ? 2 : (r>m-1 ? m-1 : r);
c=vs[ind]+i+1; cs[ind] = c<2 ? 2 : (c>n-1 ? n-1 : c); ind++;
}
}
/* create output array */
plhs[0] = mxCreateNumericMatrix(0,0,mxDOUBLE_CLASS,mxREAL);
plhs[1] = mxCreateNumericMatrix(0,0,mxDOUBLE_CLASS,mxREAL);
plhs[2] = mxCreateNumericMatrix(0,0,mxINT32_CLASS,mxREAL);
mxSetData(plhs[0],rs); mxSetM(plhs[0],m1); mxSetN(plhs[0],n1);
mxSetData(plhs[1],cs); mxSetM(plhs[1],m1); mxSetN(plhs[1],n1);
mxSetData(plhs[2],is); mxSetM(plhs[2],m1); mxSetN(plhs[2],n1);
}
void homogsToFlow(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
/* [us,vs]=homogsToFlow(H,M); */
int i, j, k, m, n, q, *dims, affine=1, ind=0; unsigned int *M;
double *H, *H1, *us, *vs; double r, c, r0, c0, z;
/* extract inputs */
H = (double*) mxGetData(prhs[0]);
M = (unsigned int*) mxGetData(prhs[1]);
m = (int) mxGetM(prhs[1]); n = (int) mxGetN(prhs[1]);
if(mxGetNumberOfDimensions(prhs[0])==2) q=1; else {
dims=(int*) mxGetDimensions(prhs[0]); q=dims[2]; }
/* initialize memory */
us = mxMalloc(sizeof(double)*m*n);
vs = mxMalloc(sizeof(double)*m*n);
/* Compute flow at each grid point */
r0=(-m+1.0)/2.0; c0=(-n+1.0)/2.0;
for( k=0; k<q; k++ ) {
H1=H+k*9; for(i=0; i<9; i++) H1[i]=H1[i]/H1[8];
affine=affine && H1[2]==0 && H1[5]==0;
}
if( affine ) {
for( i=0; i<n; i++ ) for(j=0; j<m; j++) {
k=M[ind]; H1=H+k*9; r=r0+j; c=c0+i;
us[ind] = H1[0]*r + H1[3]*c + H1[6] - r;
vs[ind] = H1[1]*r + H1[4]*c + H1[7] - c;
ind++;
}
} else {
for( i=0; i<n; i++ ) for(j=0; j<m; j++) {
k=M[ind]; H1=H+k*9; r=r0+j; c=c0+i;
us[ind] = H1[0]*r + H1[3]*c + H1[6];
vs[ind] = H1[1]*r + H1[4]*c + H1[7];
z = H1[2]*r + H1[5]*c + 1;
us[ind]=us[ind]/z-r; vs[ind]=vs[ind]/z-c; ind++;
}
}
/* create output array */
plhs[0] = mxCreateNumericMatrix(0,0,mxDOUBLE_CLASS,mxREAL);
plhs[1] = mxCreateNumericMatrix(0,0,mxDOUBLE_CLASS,mxREAL);
mxSetData(plhs[0],us); mxSetM(plhs[0],m); mxSetN(plhs[0],n);
mxSetData(plhs[1],vs); mxSetM(plhs[1],m); mxSetN(plhs[1],n);
}
void mexFunction(
int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[]
) {
//--
// DECLARE
//--
double *x, *y, a, b; int x_nr_rows, x_nr_columns;
double *mu, *var, *gamma;
int m;
//--
// HANDLE INPUT
//--
/* GATEWAY */
if (nrhs!=4 || nlhs>1)
mexErrMsgTxt("GGFIT: Supply arguments\nSyntax: Y = GENGG(X,SHAPE,DEV,MEAN)\n");
x_nr_rows = mxGetM(prhs[0]);
x_nr_columns = mxGetN(prhs[0]);
if (x_nr_rows >= x_nr_columns)
{
x_nr_columns = 1;
}
else
{
x_nr_rows = 1;
}
/* match inputs */
x = mxGetPr(prhs[0]); /* Complex parts ignored */
gamma = mxGetPr(prhs[1]); /* Complex parts ignored */
var = mxGetPr(prhs[2]); /* Complex parts ignored */
mu = mxGetPr(prhs[3]); /* Complex parts ignored */
/* match outputs */
y = mxCalloc(x_nr_rows*x_nr_columns,sizeof(double));
plhs[0] = mxCreateDoubleMatrix(x_nr_rows, x_nr_columns, mxREAL);
mxSetM(plhs[0],x_nr_rows);
mxSetN(plhs[0],x_nr_columns);
mxSetPr(plhs[0],y);
/* CALCULATION OF GENERALISED GAUSSIAN */
for (m=0; m<(x_nr_rows*x_nr_columns); m++)
{
b = pow( ( gammaHJB(3/(*gamma))/gammaHJB(1/(*gamma)) ),0.5 )/(*var);
a = b*(*gamma)/(2*gammaHJB(1/(*gamma)));
y[m] = a*exp( -pow( fabs(b*(x[m]- *mu)), *gamma ) );
} /* for */
} /* main */
mxArray *mxCreateEmptyMatrix(void)
{
mxArray *out;
out = mxCreateDoubleScalar(0.0);
mxSetM(out,0);
mxSetN(out,0);
return out;
}
int mfiles_cs2mx(const cs *in, mxArray *out) {
if (!out) {
return EXIT_FAILURE;
}
mxSetM(out, in->m);
mxSetN(out, in->n);
mxSetNzmax(out, in->nzmax);
mxSetJc(out, (mwIndex *) in->p);
mxSetIr(out, (mwIndex *) in->i);
mxSetPr(out, in->x);
return EXIT_SUCCESS;
}
mxArray *mxCreateNumericMatrixE(mwSize m, mwSize n, mxClassID classid,
mxComplexity ComplexFlag)
{
mwSize sz = m*n*sizeof(double);
mxArray *a = mxCreateNumericMatrix(1, 1, classid, ComplexFlag);
mxSetM(a,m);
mxSetN(a,n);
mxSetPr(a, mxRealloc(mxGetPr(a),sz));
if(ComplexFlag == mxCOMPLEX) {
mxSetPi(a, mxRealloc(mxGetPi(a),sz));
}
return a;
}
int csimMexCreate(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
/*
** Create some fresh empty network
*/
if ( !TheNetwork ) TheNetwork = new MexNetwork();
if ( nrhs < 2 || nrhs > 3 || nlhs != 1 )
mexErrMsgTxt("CSIM-Usage: idx = csim('create',className[,n]);\n");
char *className;
if ( getString(prhs[1],&className) )
mexErrMsgTxt("CSIM-Usage: idx = csim('create',className[,n]); className not a string.\n");
int n=1;
if ( nrhs > 2 ) {
double tmp;
if ( getDouble(prhs[2],&tmp) )
mexErrMsgTxt("CSIM-Usage: idx = csim('create',className[,n]); n not a single double.\n");
n = (int)(tmp);
}
uint32 *idx = (uint32 *)mxCalloc(n,sizeof(uint32));
int switchError = 0;
// #define __SWITCH_COMMAND__ { for(int i=0; i<n; i++) if ( (idx[i]=TheNetwork->addNewObject((Advancable *)(new TYPE))) < 0 ) { TheCsimError.add("can not add %s (i=%i)\n",className,i); return -1; } }
Advancable *a; a=0;
#define __SWITCH_COMMAND__ { for(int i=0; i<n; i++) { \
idx[i]=TheNetwork->addNewObject(a=(Advancable *)(new TYPE)); \
if ( a->init(a) < 0 ) { \
TheCsimError.add("csim('create',className,n): error calling init of %s!\n",className); \
return -1; \
} \
} \
}
#include "switch.i"
if ( switchError < 0 ) {
TheCsimError.add("csim('create',className,n): Unknown className %s!\n",className);
return -1;
} else {
plhs[0] = mxCreateNumericMatrix ( 0, 0, mxUINT32_CLASS, mxREAL );
mxSetM(plhs[0],1);
mxSetN(plhs[0],n);
mxSetData(plhs[0],(void *)idx);
}
return 0;
}
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]){
//Input is unit8 matrix. Output is same size uint8 matrix to delete
//Acquire and comfirm inputs/outputs
//Pad with zeros around
//loop through elements, pull the local 3x3, perform connectivity check
//write to delete as 1 true, leave alone as 0 false
#define A_IN prhs[0]
#define X_OUT plhs[0]
mxArray *A, *X, *PAD, *padSize, *toPad[2];
padSize = mxCreateNumericMatrix( 1, 2, mxUINT8_CLASS, mxREAL );
int M, N, m, n, *vals;
vals[0] = 1; vals[1] = 1; mxSetData( padSize, vals );
if( nrhs != 1 )
mexErrMsgTxt("Wrong number of input arguments.");
else if( nlhs != 1 )
mexErrMsgTxt("Wrong number of output arguments.");
if( !IS_REAL_2D_FULL_UINT8( A_IN ) )
mexErrMsgTxt("Input must be uint8, not sparse, and 2D real.");
M = mxGetM(A_IN);
N = mxGetN(A_IN);
A = (mxArray*)mxGetPr(A_IN);
X = (mxArray*)mxGetPr(X_OUT);
X = mxCreateNumericMatrix( 0, 0, mxUINT8_CLASS, mxREAL );
mxSetM( X, M+2 );
mxSetN( X, N+2 );
mxSetData( X, mxMalloc( sizeof(uint8_t)*(M+2)*(N+2) ) );
PAD = mxCreateNumericMatrix( 0, 0, mxUINT8_CLASS, mxREAL );
mxSetM( PAD, M+2 );
mxSetN( PAD, N+2 );
mxSetData( PAD, mxMalloc( sizeof(uint8_t)*(M+2)*(N+2) ) );
toPad[0] = A; toPad[1] = padSize;
mexCallMATLAB( 1, &PAD, 2, toPad, "padarray" );
memcpy( mxGetPr(X), PAD, sizeof(uint8_t)*(M+2)*(N+2) );
return;
}
mxArray* get_marker(Stim &stim) {
extern const int red;
mxArray* marker = mxCreateDoubleMatrix(0, 0, mxREAL);
mxSetM(marker, 1);
mxSetN(marker, stim.marker_stimulation.size());
mxSetData(marker, mxMalloc(sizeof(double)*stim.marker_stimulation.size()));
double* Pr_Marker = mxGetPr(marker);
unsigned counter = 0;
/* Division by res transforms marker time from dt to sampling rate */
for(auto & elem : stim.marker_stimulation) {
Pr_Marker[counter++] = elem/red;
}
return marker;
}
/*
* Main entry
*/
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
char uidstr[40];
uuidgen(uidstr);
const char *s = uidstr;
const char **ps = &s;
plhs[0] = mxCreateCharMatrixFromStrings(1, ps);
if( nrhs == 1 ){
mxSetN( plhs[0] , *(mxGetPr(prhs[0])) );
}
}
realtype *reAllocate2DOutputMemory( realtype *pMem, void *cvode_mem, N_Vector y0, mxArray *plhs, mwSize dim1, mwSize dim2 ) {
void *pOld;
pOld = pMem;
pMem = mxRealloc( pMem, sizeof( realtype ) * dim1 * dim2 );
if ( pMem == NULL ) memErr( cvode_mem, y0, pOld, "ERROR: Insufficient memory for reallocation during simulation loop!" );
mxSetPr( plhs, pMem );
mxSetM( plhs, dim1 );
mxSetN( plhs, dim2 );
return pMem;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
/*
mwSize is a type that represents size values, such as array dimensions.
mxGetN Call mxGetN to determine the number of columns in the specified mxArray.
plhs <-- "left hand side"
prhs <-- "right hand side"
http://cnx.org/content/m12348/latest/ (mex in general)
http://www.mathworks.com/help/matlab/apiref/mwsize.html (mwSize)
http://www.mathworks.com/help/matlab/apiref/mxgetn.html?searchHighlight=mxgetn (mxGetN)
The first line assigns n as a variable that will hold array dimensions
'prhs[0] represents the input array because it is the '0' (first) element input in the function
*/
mwSize n;
if( n = mxGetN(prhs[0]) )
mxSetN(prhs[0], n - 1);
}
mxArray *sfmult_yalloc // return Y
(
Int m,
Int n,
int Ycomplex // true if Y is complex
)
{
// (TO DO): guard against integer overflow
mxArray *Y = mxCreateDoubleMatrix (0, 0, Ycomplex ? mxCOMPLEX : mxREAL) ;
MXFREE (mxGetPr (Y)) ;
mxSetPr (Y, mxMalloc (MAX (m*n, 1) * sizeof (double))) ;
if (Ycomplex)
{
MXFREE (mxGetPi (Y)) ;
mxSetPi (Y, mxMalloc (MAX (m*n, 1) * sizeof (double))) ;
}
mxSetM (Y, m) ;
mxSetN (Y, n) ;
return (Y) ;
}
/* return a real sparse matrix to MATLAB */
mxArray *cs_dl_mex_put_sparse (cs_dl **Ahandle)
{
cs_dl *A ;
mxArray *Amatlab ;
A = *Ahandle ;
if (!A) mexErrMsgTxt ("failed") ;
Amatlab = mxCreateSparse (0, 0, 0, mxREAL) ;
mxSetM (Amatlab, A->m) ;
mxSetN (Amatlab, A->n) ;
mxSetNzmax (Amatlab, A->nzmax) ;
cs_free (mxGetJc (Amatlab)) ;
cs_free (mxGetIr (Amatlab)) ;
cs_free (mxGetPr (Amatlab)) ;
mxSetJc (Amatlab, (void *) (A->p)) ; /* assign A->p pointer to MATLAB A */
mxSetIr (Amatlab, (void *) (A->i)) ;
mxSetPr (Amatlab, A->x) ;
cs_free (A) ; /* frees A struct only, not A->p, etc */
*Ahandle = NULL ;
return (Amatlab) ;
}
mxArray *spqr_mx_put_dense2
(
Long m,
Long n,
double *Ax, // size nz if real; size 2*nz if complex
int is_complex,
cholmod_common *cc
)
{
mxArray *A ;
if (cc == NULL) return (NULL) ;
A = mxCreateDoubleMatrix (0, 0, is_complex ? mxCOMPLEX : mxREAL) ;
mxSetM (A, m) ;
mxSetN (A, n) ;
mxFree (mxGetPr (A)) ;
mxFree (mxGetPi (A)) ;
put_values (m*n, A, Ax, is_complex, cc) ;
return (A) ;
}
/* return a sparse matrix to MATLAB */
mxArray *cs_mex_put_sparse (cs **Ahandle)
{
cs *A ;
mxArray *Amatlab ;
A = *Ahandle ;
Amatlab = mxCreateSparse (0, 0, 0, mxREAL) ;
mxSetM (Amatlab, A->m) ;
mxSetN (Amatlab, A->n) ;
mxSetNzmax (Amatlab, A->nzmax) ;
cs_free (mxGetJc (Amatlab)) ;
cs_free (mxGetIr (Amatlab)) ;
cs_free (mxGetPr (Amatlab)) ;
mxSetJc (Amatlab, A->p) ; /* assign A->p pointer to MATLAB A */
mxSetIr (Amatlab, A->i) ;
mxSetPr (Amatlab, A->x) ;
mexMakeMemoryPersistent (A->p) ; /* ensure MATLAB does not free A->p */
mexMakeMemoryPersistent (A->i) ;
mexMakeMemoryPersistent (A->x) ;
cs_free (A) ; /* frees A struct only, not A->p, etc */
*Ahandle = NULL ;
return (Amatlab) ;
}
/* Gateway of releaseinplace */
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[]) {
/* Check arguments */
if (nrhs!=1)
mexErrMsgTxt("RELEASEINPLACE: One input argument required.");
if( nlhs != 0 ) {
mexErrMsgTxt("RELEASEINPLACE: Zero output arguments required.");
}
mxSetM((mxArray *)prhs[0], 0);
mxSetN((mxArray *)prhs[0], 0);
/* Equivalent to doing this: mxSetPr(prhs[0], NULL);
but access directly to data pointer in order to by pass Matlab
checking - Thanks to James Tursa */
((Internal_mxArray*)(prhs[0]))->data.number_array.pdata = NULL;
((Internal_mxArray*)(prhs[0]))->data.number_array.pimag_data = NULL;
return;
} /* Gateway of releaseinplace.c */
/* ************************************************************
PROCEDURE mexFunction - Entry for Matlab
[lab,q] = eigK(x,K)
Computes spectral coefficients of x w.r.t. K
REMARK If this function is used internally by SeDuMi, then
complex numbers are stored in a single real vector. To make
it invokable from the Matlab command-line by the user, we
also allow Matlab complex vector x.
************************************************************ */
void mexFunction(const int nlhs, mxArray *plhs[],
const int nrhs, const mxArray *prhs[])
{
mxArray *output_array[3], *Xk, *hXk;
coneK cK;
int k, nk, nksqr, lendiag,i,ii,nkp1, lenfull;
double *lab,*q,*qpi,*labk,*xwork,*xpiwork;
const double *x,*xpi;
/* ------------------------------------------------------------
Check for proper number of arguments
------------------------------------------------------------ */
mxAssert(nrhs >= NPARIN, "eigK requires more input arguments");
mxAssert(nlhs <= NPAROUT, "eigK produces less output arguments");
/* ------------------------------------------------------------
Disassemble cone K structure
------------------------------------------------------------ */
conepars(K_IN, &cK);
/* ------------------------------------------------------------
Compute statistics based on cone K structure
------------------------------------------------------------ */
lendiag = cK.lpN + 2 * (cK.lorN + cK.rconeN) + cK.rLen + cK.hLen;
lenfull = cK.lpN + cK.qDim + cK.rDim + cK.hDim;
if(cK.rconeN > 0)
for(i = 0; i < cK.rconeN; i++)
lenfull += cK.rconeNL[i];
/* ------------------------------------------------------------
Get input vector x
------------------------------------------------------------ */
mxAssert(mxGetM(X_IN) * mxGetN(X_IN) == lenfull, "Size mismatch x");
mxAssert(!mxIsSparse(X_IN), "x must be full (not sparse).");
x = mxGetPr(X_IN);
if(mxIsComplex(X_IN))
xpi = mxGetPi(X_IN) + cK.lpN;
/* ------------------------------------------------------------
Allocate output LAB(diag), eigvec Q(full for psd)
------------------------------------------------------------ */
LAB_OUT = mxCreateDoubleMatrix(lendiag, 1, mxREAL);
lab = mxGetPr(LAB_OUT);
if(nlhs > 1){
if(mxIsComplex(X_IN)){
Q_OUT = mxCreateDoubleMatrix(cK.rDim, 1, mxCOMPLEX);
qpi = mxGetPi(Q_OUT);
}
else
Q_OUT = mxCreateDoubleMatrix(cK.rDim + cK.hDim, 1, mxREAL);
q = mxGetPr(Q_OUT);
}
/* ------------------------------------------------------------
Allocate working arrays:
------------------------------------------------------------ */
Xk = mxCreateDoubleMatrix(0,0,mxREAL);
hXk = mxCreateDoubleMatrix(0,0,mxCOMPLEX);
if(mxIsComplex(X_IN)){
xwork = (double *) mxCalloc(MAX(1,2 * SQR(cK.rMaxn)), sizeof(double));
xpiwork = xwork + SQR(cK.rMaxn);
}
else
xwork =(double *) mxCalloc(MAX(1,SQR(cK.rMaxn)+2*SQR(cK.hMaxn)),
sizeof(double));
/* ------------------------------------------------------------
The actual job is done here:.
------------------------------------------------------------ */
if(cK.lpN){
/* ------------------------------------------------------------
LP: lab = x
------------------------------------------------------------ */
memcpy(lab, x, cK.lpN * sizeof(double));
lab += cK.lpN; x += cK.lpN;
}
/* ------------------------------------------------------------
CONSIDER FIRST MATLAB-REAL-TYPE:
------------------------------------------------------------ */
if(!mxIsComplex(X_IN)){ /* Not Matlab-type complex */
/* ------------------------------------------------------------
LORENTZ: (I) lab = qeig(x)
------------------------------------------------------------ */
for(k = 0; k < cK.lorN; k++){
nk = cK.lorNL[k];
qeig(lab,x,nk);
lab += 2; x += nk;
}
/* ------------------------------------------------------------
RCONE: LAB = eig(X) (Lorentz-Rcone's are not used internally)
------------------------------------------------------------ */
for(k = 0; k < cK.rconeN; k++){
nk = cK.rconeNL[k];
rconeeig(lab,x[0],x[1],realssqr(x+2,nk-2));
lab += 2; x += nk;
}
/* ------------------------------------------------------------
PSD: (I) LAB = eig(X)
------------------------------------------------------------ */
if(nlhs < 2){
for(k=0; k < cK.rsdpN; k++){ /* real symmetric */
nk = cK.sdpNL[k];
symproj(xwork,x,nk); /* make it symmetric */
mxSetM(Xk, nk);
mxSetN(Xk, nk);
mxSetPr(Xk, xwork);
mexCallMATLAB(1, output_array, 1, &Xk, "eig");
memcpy(lab, mxGetPr(output_array[0]), nk * sizeof(double));
/* ------------------------------------------------------------
With mexCallMATLAB, we invoked the mexFunction "eig", which
allocates a matrix struct *output_array[0], AND a block for the
float data of that matrix.
==> mxDestroyArray() does not only free the float data, it
also releases the matrix struct (and this is what we want).
------------------------------------------------------------ */
mxDestroyArray(output_array[0]);
lab += nk; x += SQR(nk);
}
/* ------------------------------------------------------------
WARNING: Matlab's eig doesn't recognize Hermitian, hence VERY slow
------------------------------------------------------------ */
for(; k < cK.sdpN; k++){ /* complex Hermitian */
nk = cK.sdpNL[k]; nksqr = SQR(nk);
symproj(xwork,x,nk); /* make it Hermitian */
skewproj(xwork + nksqr,x+nksqr,nk);
mxSetM(hXk, nk);
mxSetN(hXk, nk);
mxSetPr(hXk, xwork);
mxSetPi(hXk, xwork + nksqr);
mexCallMATLAB(1, output_array, 1, &hXk, "eig");
memcpy(lab, mxGetPr(output_array[0]), nk * sizeof(double));
mxDestroyArray(output_array[0]);
lab += nk; x += 2 * nksqr;
}
}
else{
/* ------------------------------------------------------------
SDP: (II) (Q,LAB) = eig(X)
------------------------------------------------------------ */
for(k=0; k < cK.rsdpN; k++){ /* real symmetric */
nk = cK.sdpNL[k];
symproj(xwork,x,nk); /* make it symmetric */
mxSetM(Xk, nk);
mxSetN(Xk, nk);
mxSetPr(Xk, xwork);
mexCallMATLAB(2, output_array, 1, &Xk, "eig");
nksqr = SQR(nk); /* copy Q-matrix */
memcpy(q, mxGetPr(output_array[0]), nksqr * sizeof(double));
nkp1 = nk + 1; /* copy diag(Lab) */
labk = mxGetPr(output_array[1]);
for(i = 0, ii = 0; i < nk; i++, ii += nkp1)
lab[i] = labk[ii];
mxDestroyArray(output_array[0]);
mxDestroyArray(output_array[1]);
lab += nk; x += nksqr; q += nksqr;
}
for(; k < cK.sdpN; k++){ /* complex Hermitian */
nk = cK.sdpNL[k]; nksqr = SQR(nk);
symproj(xwork,x,nk); /* make it Hermitian */
skewproj(xwork + nksqr,x+nksqr,nk);
mxSetM(hXk, nk);
mxSetN(hXk, nk);
mxSetPr(hXk, xwork);
mxSetPi(hXk, xwork+nksqr);
mexCallMATLAB(2, output_array, 1, &hXk, "eig");
memcpy(q, mxGetPr(output_array[0]), nksqr * sizeof(double));
q += nksqr;
if(mxIsComplex(output_array[0])) /* if any imaginary part */
memcpy(q, mxGetPi(output_array[0]), nksqr * sizeof(double));
nkp1 = nk + 1; /* copy diag(Lab) */
labk = mxGetPr(output_array[1]);
for(i = 0, ii = 0; i < nk; i++, ii += nkp1)
lab[i] = labk[ii];
mxDestroyArray(output_array[0]);
mxDestroyArray(output_array[1]);
lab += nk; x += 2 * nksqr; q += nksqr;
}
} /* [lab,q] = eigK */
} /* !iscomplex */
else{ /* is MATLAB type complex */
/* ------------------------------------------------------------
LORENTZ: (I) lab = qeig(x)
------------------------------------------------------------ */
for(k = 0; k < cK.lorN; k++){
nk = cK.lorNL[k];
cxqeig(lab,x,xpi,nk);
lab += 2; x += nk; xpi += nk;
}
/* ------------------------------------------------------------
RCONE: LAB = eig(X) (Lorentz-Rcone's are not used internally)
------------------------------------------------------------ */
for(k = 0; k < cK.rconeN; k++){
nk = cK.rconeNL[k];
rconeeig(lab,x[0],x[1],
realssqr(x+2,nk-2) + realssqr(xpi+2,nk-2));
lab += 2; x += nk; xpi += nk;
}
/* ------------------------------------------------------------
PSD: (I) LAB = eig(X)
------------------------------------------------------------ */
for(k = 0; k < cK.sdpN; k++){
nk = cK.sdpNL[k]; nksqr = SQR(nk);
symproj(xwork,x,nk); /* make it Hermitian */
skewproj(xpiwork,xpi,nk);
mxSetM(hXk, nk);
mxSetN(hXk, nk);
mxSetPr(hXk, xwork);
mxSetPi(hXk, xpiwork);
if(nlhs < 2){
mexCallMATLAB(1, output_array, 1, &hXk, "eig");
memcpy(lab, mxGetPr(output_array[0]), nk * sizeof(double));
}
else{
mexCallMATLAB(2, output_array, 1, &hXk, "eig");
memcpy(q, mxGetPr(output_array[0]), nksqr * sizeof(double));
if(mxIsComplex(output_array[0])) /* if any imaginary part */
memcpy(qpi, mxGetPi(output_array[0]), nksqr * sizeof(double));
nkp1 = nk + 1; /* copy diag(Lab) */
labk = mxGetPr(output_array[1]);
for(i = 0, ii = 0; i < nk; i++, ii += nkp1)
lab[i] = labk[ii];
mxDestroyArray(output_array[1]);
q += nksqr; qpi += nksqr;
}
mxDestroyArray(output_array[0]);
lab += nk; x += nksqr; xpi += nksqr;
}
} /* iscomplex */
/* ------------------------------------------------------------
Release PSD-working arrays.
------------------------------------------------------------ */
mxSetM(Xk,0); mxSetN(Xk,0);
mxSetPr(Xk, (double *) NULL);
mxDestroyArray(Xk);
mxSetM(hXk,0); mxSetN(hXk,0);
mxSetPr(hXk, (double *) NULL); mxSetPi(hXk, (double *) NULL);
mxDestroyArray(hXk);
mxFree(xwork);
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
const mxArray *MatlabFunctionHandle;
direct_algorithm theAlgorithm=DIRECT_ORIGINAL;
const direct_objective_func f=&MatlabCallback;
size_t numDim;
double *lowerBounds;
double *upperBounds;
int maxFEval=500;
int maxIter=100;
double epsilon=1e-4;
double epsilonAbs=0;
double volumeRelTol=1e-10;
double sigmaRelTol=0;
double fGlobal=DIRECT_UNKNOWN_FGLOBAL;
double fGlobalRelTol=DIRECT_UNKNOWN_FGLOBAL;
int maxDiv=5000;
//To hold return values
direct_return_code retVal;
double *x;
double fVal;
if(nrhs<3||nrhs>4){
mexErrMsgTxt("Wrong number of inputs");
}
if(nlhs>3) {
mexErrMsgTxt("Wrong number of outputs.");
}
//Check that a function handle was passed.
if(!mxIsClass(prhs[0],"function_handle")) {
mexErrMsgTxt("The first input must be a function handle.");
}
MatlabFunctionHandle=prhs[0];
//Check the lower and upper bounds
checkRealDoubleArray(prhs[1]);
checkRealDoubleArray(prhs[2]);
numDim=mxGetM(prhs[1]);
if(numDim<1||mxGetN(prhs[1])!=1) {
mexErrMsgTxt("The lower bounds have the wrong dimensionality.");
}
if(mxGetM(prhs[2])!=numDim||mxGetN(prhs[1])!=1) {
mexErrMsgTxt("The upper bounds have the wrong dimensionality.");
}
//The function in the library only uses integers for dimensions.
if(numDim>INT_MAX) {
mexErrMsgTxt("The problem has too many dimensions to be solved using this function.");
}
lowerBounds=(double*)mxGetData(prhs[1]);
upperBounds=(double*)mxGetData(prhs[2]);
//If a structure of options was given
if(nrhs>3&&!mxIsEmpty(prhs[3])) {
//We have to check for every possible structure member.
mxArray *theField;
if(!mxIsStruct(prhs[3])) {
mexErrMsgTxt("The options must be given in a structure.");
}
theField=mxGetField(prhs[3],0,"algorithm");
if(theField!=NULL) {//If the field is present.
int algType=getIntFromMatlab(theField);
//Algorithm type
switch(algType) {
case 0:
theAlgorithm=DIRECT_ORIGINAL;
break;
case 1:
theAlgorithm=DIRECT_GABLONSKY;
break;
default:
mexErrMsgTxt("Invalid algorithm specified");
}
}
theField=mxGetField(prhs[3],0,"maxDiv");
if(theField!=NULL) {//If the field is present.
maxDiv=getIntFromMatlab(theField);
if(maxDiv<1) {
mexErrMsgTxt("Invalid maxDiv specified");
}
}
theField=mxGetField(prhs[3],0,"maxIter");
if(theField!=NULL) {//If the field is present.
maxIter=getIntFromMatlab(theField);
if(maxIter<1) {
mexErrMsgTxt("Invalid maxIter specified");
}
}
theField=mxGetField(prhs[3],0,"maxFEval");
if(theField!=NULL) {//If the field is present.
maxFEval=getIntFromMatlab(theField);
if(maxIter<1) {
mexErrMsgTxt("Invalid maxFEval specified");
}
}
theField=mxGetField(prhs[3],0,"epsilon");
if(theField!=NULL) {//If the field is present.
epsilon=getDoubleFromMatlab(theField);
if(fabs(epsilon)>=1) {
mexErrMsgTxt("Invalid epsilon specified");
}
}
theField=mxGetField(prhs[3],0,"epsilonAbs");
if(theField!=NULL) {//If the field is present.
epsilonAbs=getDoubleFromMatlab(theField);
if(epsilonAbs>=1||epsilonAbs<0) {
mexErrMsgTxt("Invalid epsilonAbs specified");
}
}
theField=mxGetField(prhs[3],0,"volumeRelTol");
if(theField!=NULL) {//If the field is present.
volumeRelTol=getDoubleFromMatlab(theField);
if(volumeRelTol>=1||volumeRelTol<0) {
mexErrMsgTxt("Invalid volumeRelTol specified");
}
}
theField=mxGetField(prhs[3],0,"sigmaRelTol");
if(theField!=NULL) {//If the field is present.
sigmaRelTol=getDoubleFromMatlab(theField);
if(sigmaRelTol>=1||sigmaRelTol<0) {
mexErrMsgTxt("Invalid sigmaRelTol specified");
}
}
theField=mxGetField(prhs[3],0,"fGlobal");
if(theField!=NULL) {//If the field is present.
fGlobal=getDoubleFromMatlab(theField);
fGlobalRelTol=1e-12;//Default value if fGlobal is given.
}
theField=mxGetField(prhs[3],0,"fGlobalRelTol");
if(theField!=NULL) {//If the field is present.
fGlobalRelTol=getDoubleFromMatlab(theField);
if(fGlobalRelTol<0) {
mexErrMsgTxt("Invalid fGlobalRelTol specified");
}
}
}
//Allocate space for the return values
x=mxCalloc(numDim, sizeof(double));
retVal=direct_optimize(f,//Objective function pointer
(void*)MatlabFunctionHandle,//Data that passed to the objective function. Here, the function handle passed by the user.
(int)numDim,//The dimensionality of the problem
lowerBounds,//Array of the lower bound of each dimension.
upperBounds,//Array of the upper bound of each dimension.
x,//An array that will be set to the optimum value on return.
&fVal,//On return, set to the minimum value.
maxFEval,//Maximum number of function evaluations.
maxIter,//Maximum number of iterations
epsilon,//Jones' epsilon parameter (1e-4 is recommended)
epsilonAbs,//An absolute version of magic_eps
//Relative tolerance on the hypercube volume (use 0 if none). This is
//a percentage (0-1) of the volume of the original hypercube
volumeRelTol,
//Relative tolerance on the hypercube measure (0 if none)
sigmaRelTol,
//A pointer to a variable that can terminate the optimization. This is
//in the library's code so that an external thread can write to this
//and force the optimization to stop. Here, we are not using it, so we
//can pass NULL.
NULL,
fGlobal,//Function value of the global optimum, if known. Use DIRECT_UNKNOWN_FGLOBAL if unknown.
fGlobalRelTol,//Relative tolerance for convergence if fglobal is known. If unknown, use DIRECT_UNKNOWN_FGLOBAL.
NULL,//There is no output to a file.
theAlgorithm,//The algorithm to use
maxDiv);//The maximum number of hyperrectangle divisions
//If an error occurred
if(retVal<0) {
mxFree(x);
switch(retVal){
case DIRECT_INVALID_BOUNDS:
mexErrMsgTxt("Upper bounds are <= lower bounds for one or more dimensions.");
case DIRECT_MAXFEVAL_TOOBIG:
mexErrMsgTxt("maxFEval is too large.");
case DIRECT_INIT_FAILED:
mexErrMsgTxt("An initialization step failed.");
case DIRECT_SAMPLEPOINTS_FAILED:
mexErrMsgTxt("An error occurred creating sampling points.");
case DIRECT_SAMPLE_FAILED:
mexErrMsgTxt("An error occurred while sampling the function.");
case DIRECT_OUT_OF_MEMORY:
mexErrMsgTxt("Out of memory");
case DIRECT_INVALID_ARGS:
mexErrMsgTxt("Invalid arguments provided");
//These errors should not occur either because they should
//never be called or because retVal>=0 so these are not
//actually errors.
case DIRECT_FORCED_STOP:
case DIRECT_MAXFEVAL_EXCEEDED:
case DIRECT_MAXITER_EXCEEDED:
case DIRECT_GLOBAL_FOUND:
case DIRECT_VOLTOL:
case DIRECT_SIGMATOL:
case DIRECT_MAXTIME_EXCEEDED:
default:
mexErrMsgTxt("An unknown error occurred.");
}
}
//Set the return values
plhs[0]=mxCreateNumericMatrix(0, 0, mxDOUBLE_CLASS, mxREAL);
mxFree(mxGetPr(plhs[0]));
mxSetPr(plhs[0], x);
mxSetM(plhs[0], numDim);
mxSetN(plhs[0], 1);
if(nlhs>1) {
plhs[1]=doubleMat2Matlab(&fVal,1,1);
if(nlhs>2) {
plhs[2]=intMat2MatlabDoubles(&retVal,1,1);
}
}
}
