Dynamitos/Seele
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
2208ab438a0f4015fcb38d6c10710834c224c391
Seele/external/sdpa/mex/mexsdpaC.cpp
T
Dynamitos 2208ab438a overhauled physics engine
2023-01-21 18:43:21 +01:00

843 lines
22 KiB
C++
Raw Blame History

/*
* This file is a component of SDPA
* Copyright (C) 2004-2013 SDPA Project
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* SDPA-M: 7.3
* mexsdpa.cpp
*/
#include <mex.h>
/*
* SDPA header files
*/
#include <sdpa_call.h>
extern void _main();
void sdpasolver(double *mDIM_ptr,
double *nBLOCK_ptr,
double *bLOCKsTRUCT_ptr,
double *c_ptr,
mxArray *F_ptr,
double *x0_ptr,
mxArray *X0_ptr,
mxArray *Y0_ptr,
mxArray *OPTION_ptr,
int IniPt,
double *objVal_ptr,
double *x_ptr,
mxArray *X_ptr,
mxArray *Y_ptr,
mxArray *INFO_ptr)
{
time_t ltime;
time(&ltime);
char string_time[1024];
strcpy(string_time,ctime(&ltime));
string_time[strlen(string_time)-1]='\0';
SDPA sdpa;
int maxIteration = 0;
double param = 0.0;
/* mxArray pointer */
mxArray *field_ptr = NULL;
mxArray *cell_ptr = NULL;
int nSymmChk = 0;
int nDimacs = 0;
/* strings for phase value */
const char *szPhase[] = {
"noINFO", "pFEAS", "dFEAS", "pdFEAS", "pdINF",
"pFEAS_dINF", "pINF_dFEAS", "pdOPT", "pUNBD", "dUNBD"};
/* output file */
char *outfile = NULL;
FILE *fp = NULL;
FILE *fpResult = NULL;
int nOutfile = 0;
mwSize mDIM;
mwSize nBLOCK;
/* temporary variables */
mwIndex i,j,k,l;
int size;
mwSize mwsize;
mwIndex idx, startidx, endidx;
mwSize sizeM, sizeN;
mwIndex *subscript = NULL;
mwIndex *dims = NULL;
int cell_index = 0;
mwIndex *ir_ptr = NULL;
mwIndex *jc_ptr = NULL;
double *tmp_ptr = NULL;
double *result_ptr = NULL;
char* tmpPrint = NULL;
/*** Set SDPA parameters by OPTIONS ***/
/* Max Iteration */
field_ptr = mxGetField(OPTION_ptr, 0, "maxIteration");
if( field_ptr != NULL ){
maxIteration = (int)mxGetScalar(field_ptr);
sdpa.setParameterMaxIteration(maxIteration);
}
/* epsilonStar */
field_ptr = mxGetField(OPTION_ptr, 0, "epsilonStar");
if( field_ptr != NULL ){
param = *mxGetPr(field_ptr);
sdpa.setParameterEpsilonStar(param);
}
/* lambdaStar */
field_ptr = mxGetField(OPTION_ptr, 0, "lambdaStar");
if( field_ptr != NULL ){
param = *mxGetPr(field_ptr);
sdpa.setParameterLambdaStar(param);
}
/* omegaStar */
field_ptr = mxGetField(OPTION_ptr, 0, "omegaStar");
if( field_ptr != NULL ){
param = *mxGetPr(field_ptr);
sdpa.setParameterOmegaStar(param);
}
/* lowerBound */
field_ptr = mxGetField(OPTION_ptr, 0, "lowerBound");
if( field_ptr != NULL ){
param = *mxGetPr(field_ptr);
sdpa.setParameterLowerBound(param);
}
/* upperBound */
field_ptr = mxGetField(OPTION_ptr, 0, "upperBound");
if( field_ptr != NULL ){
param = *mxGetPr(field_ptr);
sdpa.setParameterUpperBound(param);
}
/* betaStar */
field_ptr = mxGetField(OPTION_ptr, 0, "betaStar");
if( field_ptr != NULL ){
param = *mxGetPr(field_ptr);
sdpa.setParameterBetaStar(param);
}
/* betaBar */
field_ptr = mxGetField(OPTION_ptr, 0, "betaBar");
if( field_ptr != NULL ){
param = *mxGetPr(field_ptr);
sdpa.setParameterBetaBar(param);
}
/* gammaStar */
field_ptr = mxGetField(OPTION_ptr, 0, "gammaStar");
if( field_ptr != NULL ){
param = *mxGetPr(field_ptr);
sdpa.setParameterGammaStar(param);
}
/* epsilonDash */
field_ptr = mxGetField(OPTION_ptr, 0, "epsilonDash");
if( field_ptr != NULL ){
param = *mxGetPr(field_ptr);
sdpa.setParameterEpsilonDash(param);
}
/* xPrint */
field_ptr = mxGetField(OPTION_ptr, 0, "xPrint");
if( field_ptr != NULL ){
mwsize = mxGetM(field_ptr) * mxGetN(field_ptr) + 1;
tmpPrint = (char*)mxCalloc(mwsize, sizeof(char));
mxGetString(field_ptr, tmpPrint, mwsize);
sdpa.setParameterPrintXVec(tmpPrint);
mxFree(tmpPrint);
}
/* XPrint */
field_ptr = mxGetField(OPTION_ptr, 0, "XPrint");
if( field_ptr != NULL ){
mwsize = mxGetM(field_ptr) * mxGetN(field_ptr) + 1;
tmpPrint = (char*)mxCalloc(mwsize, sizeof(char));
mxGetString(field_ptr, tmpPrint, mwsize);
sdpa.setParameterPrintXMat(tmpPrint);
mxFree(tmpPrint);
}
/* YPrint */
field_ptr = mxGetField(OPTION_ptr, 0, "YPrint");
if( field_ptr != NULL ){
mwsize = mxGetM(field_ptr) * mxGetN(field_ptr) + 1;
tmpPrint = (char*)mxCalloc(mwsize, sizeof(char));
mxGetString(field_ptr, tmpPrint, mwsize);
sdpa.setParameterPrintYMat(tmpPrint);
mxFree(tmpPrint);
}
/* infPrint */
field_ptr = mxGetField(OPTION_ptr, 0, "infPrint");
if( field_ptr != NULL ){
mwsize = mxGetM(field_ptr) * mxGetN(field_ptr) + 1;
tmpPrint = (char*)mxCalloc(mwsize, sizeof(char));
mxGetString(field_ptr, tmpPrint, mwsize);
sdpa.setParameterPrintInformation(tmpPrint);
mxFree(tmpPrint);
}
/* isSymmetric */
field_ptr = mxGetField(OPTION_ptr, 0, "isSymmetric");
if( field_ptr != NULL ){
nSymmChk = (int)mxGetScalar(field_ptr);
}
/* isDimacs */
field_ptr = mxGetField(OPTION_ptr, 0, "isDimacs");
if( field_ptr != NULL ){
nDimacs = (int)mxGetScalar(field_ptr);
}
/* print */
field_ptr = mxGetField(OPTION_ptr, 0, "print");
if( field_ptr != NULL ){
mwsize = mxGetM(field_ptr) * mxGetN(field_ptr) + 1;
if (mwsize == 1) {
// mexPrintf("display is NULL\n");
fp = NULL;
}
else {
outfile = (char*)mxCalloc(mwsize, sizeof(char));
mxGetString(field_ptr, outfile, mwsize);
if( strncmp("display", outfile, mwsize - 1) == 0 ){
fp = stdout;
} else if( strncmp("no", outfile, mwsize - 1) == 0 ){
fp = NULL;
} else {
fp = fopen(outfile, "at");
if( fp == NULL ){
mexPrintf("Failed to open %s\n", outfile);
fp = stdout;
} else {
nOutfile = 1;
}
}
mxFree(outfile);
}
} else {
/* default setting is displaying information to stdout */
fp = stdout;
}
sdpa.setDisplay(fp);
/* resultFile */
field_ptr = mxGetField(OPTION_ptr, 0, "resultFile");
if( field_ptr != NULL ){
mwsize = mxGetM(field_ptr) * mxGetN(field_ptr) + 1;
if (mwsize == 1) {
// mexPrintf("resultFile is NULL\n");
}
else {
outfile = (char*)mxCalloc(mwsize, sizeof(char));
mxGetString(field_ptr, outfile, mwsize);
fpResult = fopen(outfile, "w");
if( fpResult == NULL ){
mexPrintf("Failed to open %s\n", outfile);
mexPrintf("Skip the detail file\n");
} else {
sdpa.setResultFile(fpResult);
}
mxFree(outfile);
}
}
if (fp) {
fprintf(fp,"SDPA-C start at [%s]\n",string_time);
}
if (fpResult) {
fprintf(fpResult,"SDPA-C start at [%s]\n",string_time);
}
if (nDimacs) {
if (sdpa.judgeDimacsAvailability() == false) {
if (fp) {
fprintf(fp, "Dimacs will be skipped by XPrint and YPrint parameter.\n");
}
if (fpResult) {
fprintf(fpResult, "Dimacs will be skipped by XPrint and YPrint parameter.\n");
}
}
}
/* NumThreads */
field_ptr = mxGetField(OPTION_ptr, 0, "NumThreads");
if( field_ptr != NULL ){
sdpa.setNumThreads((int)mxGetScalar(field_ptr));
}
/*** initialize SDPA class members ***/
/* mDIM */
mDIM = (mwSize)(*mDIM_ptr);
sdpa.inputConstraintNumber(mDIM);
/* nBLOCK */
nBLOCK = (mwSize)(*nBLOCK_ptr);
sdpa.inputBlockNumber(nBLOCK);
/* bLOCKsTRUCT */
for(i = 0; i < nBLOCK; i++){
int bs = (int)(bLOCKsTRUCT_ptr[i]);
sdpa.inputBlockSize(i+1,bs);
if (bs < 0 || bs == 1) {
sdpa.inputBlockType(i+1,SDPA::LP);
}
else {
sdpa.inputBlockType(i+1,SDPA::SDP);
}
}
/* Execute initializeUpperTriangleSpace() */
sdpa.initializeUpperTriangleSpace();
/* cVECT */
for(i = 0; i < mDIM; i++){
sdpa.inputCVec(i+1, c_ptr[i]);
}
/*** Count NonZeroNumber in coefficience matrices ***/
// Do nothing for SDPA 7
/*** Set coefficience matrices value ***/
subscript = (mwIndex*)mxCalloc(2,sizeof(mwIndex));
dims = (mwIndex*)mxGetDimensions(F_ptr);
for(l = 0; l < dims[0]; l++){
for(k = 0; k < dims[1]; k++){
subscript[0]=l; subscript[1]=k;
cell_index = mxCalcSingleSubscript(F_ptr, 2, subscript);
cell_ptr = mxGetCell(F_ptr, cell_index);
// mxGetDimensions at the next line is redundant,
// but this is necessary to octave
dims = (mwIndex*)mxGetDimensions(F_ptr);
if( cell_ptr == NULL || mxIsEmpty(cell_ptr) ){
/* If the cell is empty, we assume this cell as zero matrix */
continue;
}
sizeM = mxGetM(cell_ptr);
sizeN = mxGetN(cell_ptr);
tmp_ptr = mxGetPr(cell_ptr);
if( mxIsSparse(cell_ptr) ){
/* Sparse Matrix */
ir_ptr = mxGetIr(cell_ptr);
jc_ptr = mxGetJc(cell_ptr);
if( sizeM == 1 && sizeN != 1 ){
/* Row Vector Case */
for(j = 0; j < sizeN; j++){
startidx = jc_ptr[j];
endidx = jc_ptr[j+1];
if( startidx == endidx ){ continue; }
sdpa.inputElement( k, l+1, j+1, j+1, tmp_ptr[startidx]);
}
} else if( sizeM != 1 && sizeN == 1 ){
/* Column Vector Case */
endidx = jc_ptr[sizeN];
for(idx = 0; idx < endidx; idx++){
i = ir_ptr[idx];
sdpa.inputElement( k, l+1, i+1, i+1, tmp_ptr[idx]);
}
} else {
/* Matrix Case */
for(j = 0; j < sizeN; j++){
startidx = jc_ptr[j];
endidx = jc_ptr[j+1];
if( startidx == endidx ){ continue; }
for(idx = startidx; idx < endidx; idx++){
i = ir_ptr[idx];
if( i <= j ){
sdpa.inputElement( k, l+1, i+1, j+1, tmp_ptr[idx]);
}
}
}
}
} else {
/* Dense Matrix */
if( sdpa.getBlockType(l+1)==SDPA::SDP ){
/* Full Matrix */
for(j = 0; j < sizeN; j++){
for(i = 0; i < sizeM; i++){
if( i <= j ){
if( tmp_ptr[j * sizeN + i] != 0 ){
sdpa.inputElement(k, l+1, i+1, j+1,
tmp_ptr[j * sizeN + i]);
}
}
}
}
} else {
/* Diagonal Matrix */
if( sizeM == 1 && sizeN != 1 ){
/* Row Vector Case */
for(j = 0; j < sizeN; j++){
if( tmp_ptr[j] != 0 ){
sdpa.inputElement( k, l+1, j+1, j+1, tmp_ptr[j]);
}
}
} else if( sizeM != 1 && sizeN == 1 ){
/* Column Vector Case */
for(i = 0; i < sizeM; i++){
if( tmp_ptr[i] != 0 ){
sdpa.inputElement( k, l+1, i+1, i+1, tmp_ptr[i]);
}
}
} else {
/* Matrix Case */
for(j = 0; j < sizeN; j++){
if( tmp_ptr[j * sizeN + j] != 0 ){
sdpa.inputElement( k, l+1, j+1, j+1,
tmp_ptr[j * sizeN + j]);
}
}
}
}
}
}
}
/*** Check the consistence of F, c ***/
if( nSymmChk ){
sdpa.initializeUpperTriangle(true);
}
else {
sdpa.initializeUpperTriangle(false);
}
/*** Check initial point ***/
if( IniPt == 1 ){
rMessage("Initial point is ignored in SDPA-C.");
#if 0
sdpa.setInitPoint(true);
/* initial value for xVec */
for(k = 0; k < mDIM; k++){
sdpa.inputInitXVec( k+1, x0_ptr[k]);
}
/* initial value for XMat */
cell_index = 0;
for(l = 0; l < nBLOCK; l++){
cell_ptr = mxGetCell(X0_ptr, cell_index);
if( cell_ptr == NULL || mxIsEmpty(cell_ptr) ){
/* If the cell is empty, we assume this cell as zero matrix */
continue;
}
sizeM = mxGetM(cell_ptr);
sizeN = mxGetN(cell_ptr);
tmp_ptr = mxGetPr(cell_ptr);
if( mxIsSparse(cell_ptr) ){
/* Sparse Matrix */
ir_ptr = mxGetIr(cell_ptr);
jc_ptr = mxGetJc(cell_ptr);
if( sizeM == 1 && sizeN != 1 ){
/* Row Vector Case */
for(j = 0; j < sizeN; j++){
startidx = jc_ptr[j];
endidx = jc_ptr[j+1];
if( startidx == endidx ){ continue; }
sdpa.inputInitXMat(l+1, j+1, j+1, tmp_ptr[startidx]);
}
} else if( sizeM != 1 && sizeN == 1 ){
/* Column Vector Case */
endidx = jc_ptr[sizeN];
for(idx = 0; idx < endidx; idx++){
i = ir_ptr[idx];
sdpa.inputInitXMat(l+1, i+1, i+1, tmp_ptr[idx]);
}
} else {
/* Matrix Case */
for(j = 0; j < sizeN; j++){
startidx = jc_ptr[j];
endidx = jc_ptr[j+1];
if( startidx == endidx ){ continue; }
for(idx = startidx; idx < endidx; idx++){
i = ir_ptr[idx];
if( i <= j ){
sdpa.inputInitXMat( l+1, i+1, j+1, tmp_ptr[idx]);
}
}
}
}
} else {
/* Dense Matrix */
if( sdpa.getBlockType(l+1) == SDPA::SDP ){
/* Full Matrix */
for(j = 0; j < sizeN; j++){
for(i = 0; i < sizeM; i++){
if( i <= j ){
if( tmp_ptr[j * sizeN + i] != 0 ){
sdpa.inputInitXMat( l+1, i+1, j+1,
tmp_ptr[j * sizeN + i]);
}
}
}
}
} else {
/* Diagonal Matrix */
if( sizeM == 1 && sizeN != 1 ){
/* Row Vector Case */
for(j = 0; j < sizeN; j++){
if( tmp_ptr[j] != 0 ){
sdpa.inputInitXMat( l+1, j+1, j+1, tmp_ptr[j]);
}
}
} else if( sizeM != 1 && sizeN == 1 ){
/* Column Vector Case */
for(i = 0; i < sizeM; i++){
if( tmp_ptr[i] != 0 ){
sdpa.inputInitXMat( l+1, i+1, i+1, tmp_ptr[i]);
}
}
} else {
/* Matrix Case */
for(j = 0; j < sizeN; j++){
if( tmp_ptr[j * sizeN + j] != 0 ){
sdpa.inputInitXMat( l+1, j+1, j+1,
tmp_ptr[j * sizeN + j]);
}
}
}
}
}
cell_index++;
}
/* initial value for YMat */
cell_index = 0;
for(l = 0; l < nBLOCK; l++){
cell_ptr = mxGetCell(Y0_ptr, cell_index);
if( cell_ptr == NULL || mxIsEmpty(cell_ptr) ){
/* If the cell is empty, we assume this cell as zero matrix */
continue;
}
sizeM = mxGetM(cell_ptr);
sizeN = mxGetN(cell_ptr);
tmp_ptr = mxGetPr(cell_ptr);
if( mxIsSparse(cell_ptr) ){
/* Sparse Matrix */
ir_ptr = mxGetIr(cell_ptr);
jc_ptr = mxGetJc(cell_ptr);
if( sizeM == 1 && sizeN != 1 ){
/* Row Vector Case */
for(j = 0; j < sizeN; j++){
startidx = jc_ptr[j];
endidx = jc_ptr[j+1];
if( startidx == endidx ){ continue; }
sdpa.inputInitYMat( l+1, j+1, j+1, tmp_ptr[startidx]);
}
} else if( sizeM != 1 && sizeN == 1 ){
/* Column Vector Case */
endidx = jc_ptr[sizeN];
for(idx = 0; idx < endidx; idx++){
i = ir_ptr[idx];
sdpa.inputInitYMat( l+1, i+1, i+1, tmp_ptr[idx]);
}
} else {
/* Matrix Case */
for(j = 0; j < sizeN; j++){
startidx = jc_ptr[j];
endidx = jc_ptr[j+1];
if( startidx == endidx ){ continue; }
for(idx = startidx; idx < endidx; idx++){
i = ir_ptr[idx];
if( i <= j ){
sdpa.inputInitYMat( l+1, i+1, j+1, tmp_ptr[idx]);
}
}
}
}
} else {
/* Dense Matrix */
if( sdpa.getBlockType(l+1) == SDPA::SDP ){
/* Full Matrix */
for(j = 0; j < sizeN; j++){
for(i = 0; i < sizeM; i++){
if( i <= j ){
if( tmp_ptr[j * sizeN + i] != 0 ){
sdpa.inputInitYMat( l+1, i+1, j+1,
tmp_ptr[j * sizeN + i]);
}
}
}
}
} else {
/* Diagonal Matrix */
if( sizeM == 1 && sizeN != 1 ){
/* Row Vector Case */
for(j = 0; j < sizeN; j++){
if( tmp_ptr[j] != 0 ){
sdpa.inputInitYMat( l+1, j+1, j+1, tmp_ptr[j]);
}
}
} else if( sizeM != 1 && sizeN == 1 ){
/* Column Vector Case */
for(i = 0; i < sizeM; i++){
if( tmp_ptr[i] != 0 ){
sdpa.inputInitYMat( l+1, i+1, i+1, tmp_ptr[i]);
}
}
} else {
/* Matrix Case */
for(j = 0; j < sizeN; j++){
if( tmp_ptr[j * sizeN + j] != 0 ){
sdpa.inputInitYMat( l+1, j+1, j+1,
tmp_ptr[j * sizeN + j]);
}
}
}
}
}
cell_index++;
}
#endif
}
/*** Solve SDP ***/
sdpa.initializeSolve();
sdpa.solve();
/*** Dimacs Error Information ****/
if (nDimacs != 0) {
field_ptr = mxCreateNumericMatrix(6,1,mxDOUBLE_CLASS,mxREAL);
double dimacs_error[7];
sdpa.getDimacsError(dimacs_error);
double* dimacs_store = mxGetPr(field_ptr);
if (sdpa.judgeDimacsAvailability() == false) {
for (int i=0; i<=6; i++) {
dimacs_store[i] = 0.0;
}
}
else {
for (int i=1; i<=6; i++) {
dimacs_store[i-1] = dimacs_error[i];
}
}
mxSetField(INFO_ptr, 0, "dimacs", field_ptr);
}
/**** Set output values to arguments ****/
/* Optimal value of Primal objective */
objVal_ptr[0] = sdpa.getPrimalObj();
/* Optimal value of Dual objective */
objVal_ptr[1] = sdpa.getDualObj();
/* Optimal value for xVec */
tmp_ptr = sdpa.getResultXVec();
if( tmp_ptr != NULL ){
for(k = 0; k < mDIM; k++){
x_ptr[k] = tmp_ptr[k];
}
}
/* Optimal value for XMat */
cell_index = 0;
result_ptr = sdpa.getResultXMat(1);
if (result_ptr == NULL) {
rMessage("XMat is not computed by XPrint, and XMat will be empty matrix.");
}
for(l = 0; l < nBLOCK; l++){
result_ptr = sdpa.getResultXMat(l+1);
if (result_ptr == NULL) {
cell_ptr = mxCreateDoubleMatrix(0, 0, mxREAL);
mxSetCell(X_ptr, cell_index++, mxDuplicateArray(cell_ptr));
continue;
}
size = sdpa.getBlockSize(l+1);
if( sdpa.getBlockType(l+1) == SDPA:: SDP){
sizeM = size;
sizeN = size;
} else {
sizeM = 1;
sizeN = abs(size);
}
cell_ptr = mxCreateDoubleMatrix(sizeM, sizeN, mxREAL);
tmp_ptr = mxGetPr(cell_ptr);
idx = 0;
result_ptr = sdpa.getResultXMat(l+1);
if( size >= 0 ){
for(j = 0; j < sizeN; j++){
for(i = 0; i < sizeM; i++){
tmp_ptr[idx++] = result_ptr[j + sizeN * i];
}
}
} else {
for(idx = 0; idx < sizeN; idx++){
tmp_ptr[idx] = result_ptr[idx];
}
}
mxSetCell(X_ptr, cell_index++, mxDuplicateArray(cell_ptr));
}
/* Optimal value for YMat */
result_ptr = sdpa.getResultYMat(1);
if (result_ptr == NULL) {
rMessage("YMat is not computed by YPrint, and YMat will be empty matrix.");
}
cell_index = 0;
for(l = 0; l < nBLOCK; l++){
result_ptr = sdpa.getResultYMat(l+1);
if (result_ptr == NULL) {
cell_ptr = mxCreateDoubleMatrix(0, 0, mxREAL);
mxSetCell(Y_ptr, cell_index++, mxDuplicateArray(cell_ptr));
continue;
}
size = sdpa.getBlockSize(l+1);
if( sdpa.getBlockType(l+1) == SDPA:: SDP){
sizeM = size;
sizeN = size;
} else {
sizeM = 1;
sizeN = abs(size);
}
cell_ptr = mxCreateDoubleMatrix(sizeM, sizeN, mxREAL);
tmp_ptr = mxGetPr(cell_ptr);
idx = 0;
result_ptr = sdpa.getResultYMat(l+1);
if( size >= 0 ){
for(j = 0; j < sizeN; j++){
for(i = 0; i < sizeM; i++){
tmp_ptr[idx++] = result_ptr[j + sizeN * i];
}
}
} else {
for(idx = 0; idx < sizeN; idx++){
tmp_ptr[idx] = result_ptr[idx];
}
}
mxSetCell(Y_ptr, cell_index++, mxDuplicateArray(cell_ptr));
}
/* Phase information */
field_ptr = mxCreateString(szPhase[sdpa.getPhaseValue()]);
mxSetField(INFO_ptr, 0, "phasevalue", field_ptr);
/* Iteration */
field_ptr = mxCreateNumericMatrix(1,1,mxDOUBLE_CLASS,mxREAL);
*mxGetPr(field_ptr) = (double)sdpa.getIteration();
mxSetField(INFO_ptr, 0, "iteration", field_ptr);
/* close output file */
time(&ltime);
strcpy(string_time,ctime(&ltime));
string_time[strlen(string_time)-1]='\0';
if (fp) {
fprintf(fp,"SDPA-C end at [%s]\n",string_time);
}
if (fpResult) {
fprintf(fpResult,"SDPA-C end at [%s]\n",string_time);
}
if( nOutfile ){
fclose(fp);
}
if (fpResult != NULL) {
fclose(fpResult);
}
/*** Free allocated memory ****/
mxFree(subscript);
sdpa.finalize();
return;
}
/*
* Matlab gateway function
*/
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
/* Decleration of variables */
double
*mDIM_ptr,
*nBLOCK_ptr,
*bLOCKsTRUCT_ptr,
*c_ptr,
*x_ptr,
*objVal_ptr,
*x0_ptr;
mxArray
*F_ptr,
*X_ptr,
*Y_ptr,
*X0_ptr,
*Y0_ptr,
*OPTION_ptr,
*INFO_ptr;
int IniPt;
const char *fnames[] = {
"phasevalue",
"iteration",
"dimacs",
"cpusec"
};
/*
* check arguments
*/
if( nrhs != 9 ){
mexErrMsgTxt("Input arguments must be 9.");
}
/* Get the pointer of input variables */
mDIM_ptr = mxGetPr(prhs[0]);
nBLOCK_ptr = mxGetPr(prhs[1]);
bLOCKsTRUCT_ptr = mxGetPr(prhs[2]);
c_ptr = mxGetPr(prhs[3]);
F_ptr = (mxArray*)prhs[4];
x0_ptr = mxGetPr(prhs[5]);
X0_ptr = (mxArray*)prhs[6];
Y0_ptr = (mxArray*)prhs[7];
OPTION_ptr = (mxArray*)prhs[8];
if( mxIsEmpty(prhs[5]) /* x0 */
|| mxIsEmpty(prhs[6]) /* X0 */
|| mxIsEmpty(prhs[7]) /* Y0 */
){
/* nouse of Initial Point*/
IniPt = 0;
} else {
/* use of Initial Point */
IniPt = 1;
/* check of argument dimensions */
/* if(*mDIM_ptr != mxGetM(prhs[5]) || !mxIsDouble(prhs[5]))
mexErrMsgTxt("x0 must be (mDIM x 1) column vector of double");
if( *nBLOCK_ptr != sizeM_X0 || 1 != sizeN_X0 || !mxIsCell(prhs[6]))
mexErrMsgTxt("X0 must be (nBLOCK x 1) cell array");
if( *nBLOCK_ptr != sizeM_Y0 || 1 != sizeN_Y0 || !mxIsCell(prhs[7]))
mexErrMsgTxt("Y0 must be (nBLOCK x 1) cell array");*/
}
/* Create cellarrays for the output variables */
plhs[0] = mxCreateDoubleMatrix(1,2,mxREAL);
plhs[1] = mxCreateDoubleMatrix((int) *mDIM_ptr,1,mxREAL);
plhs[2] = mxCreateCellMatrix((int) *nBLOCK_ptr,1);
plhs[3] = mxCreateCellMatrix((int) *nBLOCK_ptr,1);
plhs[4] = mxCreateStructMatrix(1,1,4,fnames);
//Get the pointer of output variables
objVal_ptr = mxGetPr(plhs[0]);
x_ptr = mxGetPr(plhs[1]);
X_ptr = plhs[2];
Y_ptr = plhs[3];
INFO_ptr = plhs[4];
/* Call sdpasolver here */
sdpasolver(mDIM_ptr,
nBLOCK_ptr,
bLOCKsTRUCT_ptr,
c_ptr,
F_ptr,
x0_ptr,
X0_ptr,
Y0_ptr,
OPTION_ptr,
IniPt,
objVal_ptr,
x_ptr,
X_ptr,
Y_ptr,
INFO_ptr);
return;
}
/*
* End of File
*/
Reference in New Issue View Git Blame Copy Permalink