overhauled physics engine
This commit is contained in:
Dynamitos
Vendored
+655
@@ -0,0 +1,655 @@
|
||||
/*
|
||||
* 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_tool.h>
|
||||
#include <sdpa_call.h>
|
||||
using namespace sdpa;
|
||||
|
||||
extern void _main();
|
||||
|
||||
void sdpasolver(mxArray* At_ptr, mxArray* b_ptr, mxArray* c_ptr,
|
||||
mxArray* K_ptr, mxArray* OPTION_ptr,
|
||||
mxArray* x_ptr, mxArray* y_ptr,
|
||||
mxArray* info_ptr)
|
||||
{
|
||||
time_t ltime;
|
||||
time(<ime);
|
||||
char string_time[1024];
|
||||
strcpy(string_time,ctime(<ime));
|
||||
string_time[strlen(string_time)-1]='\0';
|
||||
|
||||
SDPA sdpa;
|
||||
|
||||
int maxIteration = 0;
|
||||
double param = 0.0;
|
||||
/* mxArray pointer */
|
||||
mxArray *field_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 k;
|
||||
int size;
|
||||
mwSize mwsize;
|
||||
double *tmp_ptr = NULL;
|
||||
char* tmpPrint = NULL;
|
||||
|
||||
TimeStart(SDPA_START);
|
||||
TimeStart(SDPA_CONVERT_START);
|
||||
|
||||
/*** Set SDPA parameters by OPTIONS ***/
|
||||
/* Max Iteration */
|
||||
field_ptr = mxGetField(OPTION_ptr, 0, "maxIteration");
|
||||
if( field_ptr != NULL ){
|
||||
maxIteration = (int)mxGetScalar(field_ptr);
|
||||
// mexPrintf("maxIteration = %d\n",maxIteration);
|
||||
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);
|
||||
if ( strncmp("no", outfile, mwsize - 1) == 0 ) {
|
||||
mexPrintf("resultFile is NULL\n");
|
||||
}
|
||||
else {
|
||||
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 != 0) {
|
||||
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");
|
||||
}
|
||||
nDimacs = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* NumThreads */
|
||||
field_ptr = mxGetField(OPTION_ptr, 0, "NumThreads");
|
||||
if( field_ptr != NULL ){
|
||||
sdpa.setNumThreads((int)mxGetScalar(field_ptr));
|
||||
}
|
||||
|
||||
/*** initialize SDPA class members ***/
|
||||
/* mDIM */
|
||||
mDIM = mxGetN(At_ptr);
|
||||
sdpa.inputConstraintNumber(mDIM);
|
||||
/* nBLOCK */
|
||||
nBLOCK = 0;
|
||||
mwSize K_l = 0;
|
||||
int isK_l = 0; // 1 (K_l > 0) or 0 (K_l == 0)
|
||||
field_ptr = mxGetField(K_ptr, 0, "l");
|
||||
if (field_ptr != NULL) {
|
||||
K_l = (mwSize)((mxGetPr(field_ptr))[0]);
|
||||
#if 0
|
||||
mexPrintf("K_l = %zd\n", K_l);
|
||||
#endif
|
||||
if (K_l > 0) {
|
||||
isK_l = 1;
|
||||
nBLOCK++;
|
||||
}
|
||||
}
|
||||
mwSize* K_s = NULL;
|
||||
mwSize* K_sdpConeStart = NULL;
|
||||
int K_sdpNoCones = 0;
|
||||
field_ptr = mxGetField(K_ptr, 0, "s");
|
||||
if (field_ptr != NULL) {
|
||||
K_sdpNoCones = (int) mxGetM(field_ptr);
|
||||
K_s = (mwSize*) mxCalloc(K_sdpNoCones, sizeof(mwSize));
|
||||
K_sdpConeStart = (mwSize*) mxCalloc(K_sdpNoCones+1, sizeof(mwSize));
|
||||
K_sdpConeStart[0] = 0;
|
||||
for (int l=0; l<K_sdpNoCones; ++l) {
|
||||
K_s[l] = (mwSize)((mxGetPr(field_ptr))[l]);
|
||||
#if 0
|
||||
mexPrintf("K_s[%zd] = %zd\n", l+isK_l+1, K_s[l]);
|
||||
#endif
|
||||
K_sdpConeStart[l+1] = K_sdpConeStart[l] + K_s[l]*K_s[l];
|
||||
nBLOCK++;
|
||||
}
|
||||
}
|
||||
|
||||
#if 0
|
||||
mexPrintf("isK_l = %d, nBlock = %d \n", isK_l, nBLOCK);
|
||||
#endif
|
||||
sdpa.inputBlockNumber(nBLOCK);
|
||||
if (isK_l > 0) {
|
||||
sdpa.inputBlockSize(1, K_l);
|
||||
sdpa.inputBlockType(1, SDPA::LP);
|
||||
}
|
||||
for (int l=0; l<K_sdpNoCones; ++l) {
|
||||
#if 0
|
||||
mexPrintf("l+isK_l+1 = %d, K_s = %d \n", l+isK_l+1, K_s[l]);
|
||||
#endif
|
||||
sdpa.inputBlockSize(l+isK_l+1, K_s[l]);
|
||||
sdpa.inputBlockType(l+isK_l+1, SDPA::SDP);
|
||||
}
|
||||
|
||||
/* Execute initializeUpperTriangleSpace() */
|
||||
sdpa.initializeUpperTriangleSpace();
|
||||
|
||||
/* cVECT = -b*/
|
||||
double* b = mxGetPr(b_ptr);
|
||||
for(mwSize i = 0; i < mDIM; i++){
|
||||
sdpa.inputCVec((int)i+1, -b[i]);
|
||||
}
|
||||
|
||||
/*** Count NonZeroNumber in coefficience matrices ***/
|
||||
// Do nothing for SDPA 7
|
||||
|
||||
/* F_0 = - C */
|
||||
if (mxIsEmpty(c_ptr) || mxGetNzmax(c_ptr) == 0
|
||||
|| (mxGetJc(c_ptr))[1] == 0) {
|
||||
mexPrintf("c = empty\n");
|
||||
}
|
||||
else {
|
||||
mwIndex* C_row = mxGetIr(c_ptr);
|
||||
mwIndex* C_column = mxGetJc(c_ptr);
|
||||
double* C_ele = mxGetPr(c_ptr);
|
||||
mwIndex C_length = C_column[1];
|
||||
int currentSdpCone = 0;
|
||||
for (mwSize index = 0; index<C_length; ++index) {
|
||||
mwSize C_j = C_row[index];
|
||||
/* A_0 = - C */
|
||||
double ele = -C_ele[index];
|
||||
// mexPrintf("C_j = %zd, ele = %e\n", C_j, ele);
|
||||
if (C_j < K_l) {
|
||||
sdpa.inputElement(0, 1, C_j+1, C_j+1, ele);
|
||||
}
|
||||
else {
|
||||
C_j -= K_l;
|
||||
while (K_sdpConeStart[currentSdpCone+1] <= C_j) {
|
||||
currentSdpCone++;
|
||||
}
|
||||
int index2, i,j;
|
||||
index2 = C_j - K_sdpConeStart[currentSdpCone];
|
||||
i = index2 / K_s[currentSdpCone];
|
||||
j = index2 % K_s[currentSdpCone];
|
||||
if (i <= j) {
|
||||
// Only upper triangular is input
|
||||
#if 0
|
||||
mexPrintf("input k=%d, l=%d, i=%d, j=%d, v=%e\n",
|
||||
0, isK_l + currentSdpCone+1,i+1, j+1, ele);
|
||||
#endif
|
||||
sdpa.inputElement(0, isK_l + currentSdpCone+1,i+1, j+1, ele);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* F_{k+1} = - A_k */
|
||||
mwIndex* At_row = mxGetIr(At_ptr);
|
||||
mwIndex* At_column = mxGetJc(At_ptr);
|
||||
double* At_ele = mxGetPr(At_ptr);
|
||||
for (k=0; k<mDIM; ++k) {
|
||||
mwIndex Ak_start = At_column[k ];
|
||||
mwIndex Ak_end = At_column[k+1];
|
||||
int currentSdpCone = 0;
|
||||
for (mwSize index = Ak_start; index<Ak_end; ++index) {
|
||||
mwSize Ak_j = At_row[index];
|
||||
/* F_{k+1} = - A_k */
|
||||
double ele = -At_ele[index];
|
||||
if (Ak_j < K_l) {
|
||||
sdpa.inputElement(k+1, 1, Ak_j+1, Ak_j+1, ele);
|
||||
}
|
||||
else {
|
||||
Ak_j -= K_l;
|
||||
while (K_sdpConeStart[currentSdpCone+1] <= Ak_j) {
|
||||
currentSdpCone++;
|
||||
}
|
||||
int index2, i,j;
|
||||
index2 = Ak_j - K_sdpConeStart[currentSdpCone];
|
||||
i = index2 / K_s[currentSdpCone];
|
||||
j = index2 % K_s[currentSdpCone];
|
||||
if (i <= j) {
|
||||
// Only upper triangular is input
|
||||
#if 0
|
||||
mexPrintf("input k=%d, l=%d, i=%d, j=%d, v=%e\n",
|
||||
k+1, isK_l + currentSdpCone+1,i+1, j+1, ele);
|
||||
#endif
|
||||
sdpa.inputElement(k+1, isK_l + currentSdpCone+1,i+1, j+1, ele);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*** Check the consistence of F, c ***/
|
||||
if( nSymmChk ){
|
||||
sdpa.initializeUpperTriangle(true);
|
||||
}
|
||||
else {
|
||||
sdpa.initializeUpperTriangle(false);
|
||||
}
|
||||
|
||||
// sdpa.writeInputSparse((char*)"b.dat-s",(char*)"%e");
|
||||
|
||||
/*** Solve SDP ***/
|
||||
sdpa.initializeSolve();
|
||||
mexPrintf("Converted to SDPA internal data / ");
|
||||
mexPrintf("Starting SDPA-C main loop\n");
|
||||
TimeEnd(SDPA_CONVERT_END);
|
||||
TimeStart(SDPA_SOLVE_START);
|
||||
sdpa.solve();
|
||||
TimeEnd(SDPA_SOLVE_END);
|
||||
TimeStart(SDPA_RETRIEVE_START);
|
||||
mexPrintf("Converting optimal solution to Sedumi format\n");
|
||||
/**** Set output values to arguments ****/
|
||||
|
||||
/* Optimal value for xVec */
|
||||
double* y = mxGetPr(y_ptr);
|
||||
tmp_ptr = sdpa.getResultXVec();
|
||||
if( tmp_ptr != NULL ){
|
||||
for(k = 0; k < mDIM; k++){
|
||||
y[k] = tmp_ptr[k];
|
||||
}
|
||||
}
|
||||
|
||||
/* Optimal value for YMat */
|
||||
double* x = mxGetPr(x_ptr);
|
||||
// if sdpa.getResultYMat(1) == NULL, YMat is not computed
|
||||
if (sdpa.getResultYMat(1) != NULL) {
|
||||
if (isK_l > 0) {
|
||||
size = sdpa.getBlockSize(1);
|
||||
tmp_ptr = sdpa.getResultYMat(1);
|
||||
for (int index = 0; index < size; ++index) {
|
||||
x[index] = tmp_ptr[index];
|
||||
}
|
||||
}
|
||||
for (int l=0; l<K_sdpNoCones; ++l) {
|
||||
size = sdpa.getBlockSize(l+isK_l+1);
|
||||
tmp_ptr = sdpa.getResultYMat(l+isK_l+1);
|
||||
for (int index = 0; index < size*size; ++index) {
|
||||
x[K_l + K_sdpConeStart[l] + index] = tmp_ptr[index];
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
rMessage("x is not computed by YPrint, and x will be empty matrix.");
|
||||
}
|
||||
TimeEnd(SDPA_RETRIEVE_END);
|
||||
|
||||
/* Dimacs Error Information */
|
||||
if (nDimacs != 0) {
|
||||
field_ptr = mxCreateNumericMatrix(6,1,mxDOUBLE_CLASS,mxREAL);
|
||||
double* dimacs_store = mxGetPr(field_ptr);
|
||||
double dimacs_error[7];
|
||||
if (sdpa.judgeDimacsAvailability() == false) {
|
||||
for (int i=0; i<=6; i++) {
|
||||
dimacs_store[i] = 0.0;
|
||||
}
|
||||
}
|
||||
else {
|
||||
mexPrintf("Computing Dimacs Error\n");
|
||||
sdpa.getDimacsError(dimacs_error);
|
||||
for (int i=1; i<=6; i++) {
|
||||
dimacs_store[i-1] = dimacs_error[i];
|
||||
}
|
||||
}
|
||||
mxSetField(info_ptr, 0, "dimacs", field_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);
|
||||
|
||||
/* primalObj */
|
||||
field_ptr = mxCreateNumericMatrix(1,1,mxDOUBLE_CLASS,mxREAL);
|
||||
*mxGetPr(field_ptr) = -sdpa.getDualObj();
|
||||
mxSetField(info_ptr, 0, "primalObj", field_ptr);
|
||||
/* dualObj */
|
||||
field_ptr = mxCreateNumericMatrix(1,1,mxDOUBLE_CLASS,mxREAL);
|
||||
*mxGetPr(field_ptr) = -sdpa.getPrimalObj();
|
||||
mxSetField(info_ptr, 0, "dualObj", field_ptr);
|
||||
/* primalError */
|
||||
field_ptr = mxCreateNumericMatrix(1,1,mxDOUBLE_CLASS,mxREAL);
|
||||
*mxGetPr(field_ptr) = sdpa.getDualError();
|
||||
mxSetField(info_ptr, 0, "primalError", field_ptr);
|
||||
/* dualError */
|
||||
field_ptr = mxCreateNumericMatrix(1,1,mxDOUBLE_CLASS,mxREAL);
|
||||
*mxGetPr(field_ptr) = sdpa.getPrimalError();
|
||||
mxSetField(info_ptr, 0, "dualError", field_ptr);
|
||||
/* digits */
|
||||
field_ptr = mxCreateNumericMatrix(1,1,mxDOUBLE_CLASS,mxREAL);
|
||||
*mxGetPr(field_ptr) = sdpa.getDigits();
|
||||
mxSetField(info_ptr, 0, "digits", field_ptr);
|
||||
/* dualityGap */
|
||||
field_ptr = mxCreateNumericMatrix(1,1,mxDOUBLE_CLASS,mxREAL);
|
||||
*mxGetPr(field_ptr) = sdpa.getDualityGap();
|
||||
mxSetField(info_ptr, 0, "dualityGap", field_ptr);
|
||||
/* mu */
|
||||
field_ptr = mxCreateNumericMatrix(1,1,mxDOUBLE_CLASS,mxREAL);
|
||||
*mxGetPr(field_ptr) = sdpa.getMu();
|
||||
mxSetField(info_ptr, 0, "mu", field_ptr);
|
||||
|
||||
/* solveTime */
|
||||
field_ptr = mxCreateNumericMatrix(1,1,mxDOUBLE_CLASS,mxREAL);
|
||||
*mxGetPr(field_ptr) = TimeCal(SDPA_SOLVE_START,SDPA_SOLVE_END);
|
||||
mxSetField(info_ptr, 0, "solveTime", field_ptr);
|
||||
/* convertingTime */
|
||||
field_ptr = mxCreateNumericMatrix(1,1,mxDOUBLE_CLASS,mxREAL);
|
||||
*mxGetPr(field_ptr) = TimeCal(SDPA_CONVERT_START,SDPA_CONVERT_END);
|
||||
mxSetField(info_ptr, 0, "convertingTime", field_ptr);
|
||||
/* retrivingTime */
|
||||
field_ptr = mxCreateNumericMatrix(1,1,mxDOUBLE_CLASS,mxREAL);
|
||||
*mxGetPr(field_ptr) = TimeCal(SDPA_RETRIEVE_START,SDPA_RETRIEVE_END);
|
||||
mxSetField(info_ptr, 0, "retrievingTime", field_ptr);
|
||||
/* retrivingTime */
|
||||
field_ptr = mxCreateNumericMatrix(1,1,mxDOUBLE_CLASS,mxREAL);
|
||||
TimeEnd(SDPA_END);
|
||||
*mxGetPr(field_ptr) = TimeCal(SDPA_START,SDPA_END);
|
||||
mxSetField(info_ptr, 0, "sdpaTime", field_ptr);
|
||||
|
||||
time(<ime);
|
||||
strcpy(string_time,ctime(<ime));
|
||||
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);
|
||||
}
|
||||
/* close output file */
|
||||
if( nOutfile ){
|
||||
fclose(fp);
|
||||
}
|
||||
if (fpResult != NULL) {
|
||||
fclose(fpResult);
|
||||
}
|
||||
|
||||
/*** Free allocated memory ****/
|
||||
mxFree(K_s);
|
||||
mxFree(K_sdpConeStart);
|
||||
sdpa.finalize();
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* Matlab gateway function
|
||||
*/
|
||||
void mexFunction(int nlhs, mxArray *plhs[],
|
||||
int nrhs, const mxArray *prhs[])
|
||||
{
|
||||
/* Decleration of variables */
|
||||
|
||||
mxArray* At_ptr;
|
||||
mxArray* b_ptr;
|
||||
mxArray* c_ptr;
|
||||
mxArray* K_ptr;
|
||||
mxArray* OPTION_ptr;
|
||||
|
||||
mxArray* x_ptr;
|
||||
mxArray* y_ptr;
|
||||
mxArray* info_ptr;
|
||||
|
||||
const char *fnames[] = {
|
||||
"phasevalue",
|
||||
"iteration",
|
||||
"cpusec",
|
||||
"primalObj",
|
||||
"dualObj",
|
||||
"primalError",
|
||||
"dualError",
|
||||
"digits",
|
||||
"dualityGap",
|
||||
"mu",
|
||||
"dimacs",
|
||||
"solveTime",
|
||||
"convertingTime",
|
||||
"retrievingTime",
|
||||
"sdpaTime"
|
||||
};
|
||||
|
||||
/* Get the pointer of input variables */
|
||||
At_ptr = (mxArray*)prhs[0];
|
||||
b_ptr = (mxArray*)prhs[1];
|
||||
c_ptr = (mxArray*)prhs[2];
|
||||
K_ptr = (mxArray*)prhs[3];
|
||||
OPTION_ptr = (mxArray*)prhs[4];
|
||||
|
||||
mwSize m = mxGetM(b_ptr);
|
||||
mwSize n = mxGetM(c_ptr);
|
||||
|
||||
mxArray *field_ptr = NULL;
|
||||
field_ptr = mxGetField(OPTION_ptr, 0, "YPrint");
|
||||
bool x_ptr_empty = false;
|
||||
if( field_ptr != NULL ){
|
||||
mwSize mwsize = mxGetM(field_ptr) * mxGetN(field_ptr) + 1;
|
||||
char* tmpPrint = (char*)mxCalloc(mwsize, sizeof(char));
|
||||
mxGetString(field_ptr, tmpPrint, mwsize);
|
||||
#if 0
|
||||
rMessage("tmpPrint = " << tmpPrint
|
||||
<< " : NO_P_FORMAT " << NO_P_FORMAT);
|
||||
#endif
|
||||
if (strcmp(tmpPrint,NO_P_FORMAT) == 0) {
|
||||
x_ptr_empty = true;
|
||||
}
|
||||
mxFree(tmpPrint);
|
||||
}
|
||||
/* Create cellarrays for the output variables */
|
||||
if (x_ptr_empty == true) {
|
||||
rMessage("x is not computed by YPrint, and x will be empty matrix.");
|
||||
plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
|
||||
}
|
||||
else {
|
||||
plhs[0] = mxCreateDoubleMatrix(n,1,mxREAL);
|
||||
}
|
||||
plhs[1] = mxCreateDoubleMatrix(m,1,mxREAL);
|
||||
plhs[2] = mxCreateStructMatrix(1,1,15,fnames);
|
||||
|
||||
//Get the pointer of output variables
|
||||
x_ptr = plhs[0];
|
||||
y_ptr = plhs[1];
|
||||
info_ptr = plhs[2];
|
||||
|
||||
/* Call sdpasolver here */
|
||||
sdpasolver(At_ptr,b_ptr,c_ptr,K_ptr,OPTION_ptr,
|
||||
x_ptr,y_ptr,info_ptr);
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* End of File
|
||||
*/
|
||||
Reference in New Issue
Block a user