extern "C" int sci_sdpa_read_prob(char * fname)
{
int nb_vars, nb_constr, i, j, k, Index;
struct blockmatrix pC;
double * pa = NULL;
struct constraintmatrix * pconstraints = NULL;
struct sparseblock * tmp_block = NULL;
int printlevel = 0, ret = 0, res = 0;
char ** filename = NULL;
int * filename_address = NULL, filename_rows, filename_cols, * filename_length = NULL;
int * printlevel_address = NULL, printlevel_rows, printlevel_cols;
double * printlevel_value = NULL, * c_out = NULL, * b_out = NULL;
int * c_out_address = NULL, * a_out_address = NULL;
int * constraint_address = NULL;
int constraint_block_rows, constraint_block_cols, constraint_nb_item;
double * block_value = NULL;
int minrhs = 1, maxrhs = 2;
int minlhs = 4, maxlhs = 4;
SciErr sciErr;
CheckRhs(minrhs,maxrhs);
CheckLhs(minlhs,maxlhs);
///////////////////////
// Read the filename //
///////////////////////
sciErr = getVarAddressFromPosition(pvApiCtx,FILENAME_IN,&filename_address); CSDP_ERROR;
sciErr = getMatrixOfString(pvApiCtx,filename_address, &filename_rows, &filename_cols, NULL, NULL); CSDP_ERROR;
if (filename_rows*filename_cols!=1)
{
Scierror(999,"%s: an unique string is requested for the filename\n",fname);
return 0;
}
filename_length = (int *)MALLOC(filename_rows*filename_cols*sizeof(int));
sciErr = getMatrixOfString(pvApiCtx,filename_address, &filename_rows, &filename_cols, filename_length, NULL); CSDP_ERROR;
filename = (char **)MALLOC(filename_rows*filename_cols*sizeof(char *));
for(i=0;i<filename_rows*filename_cols;i++)
{
filename[i] = (char *)MALLOC((filename_length[i]+1)*sizeof(char));
}
sciErr = getMatrixOfString(pvApiCtx,filename_address, &filename_rows, &filename_cols, filename_length, filename); CSDP_ERROR;
/////////////////////
// Read printlevel //
/////////////////////
if (Rhs==2)
{
sciErr = getVarAddressFromPosition(pvApiCtx,PRINTLEVEL_IN, &printlevel_address); CSDP_ERROR;
sciErr = getMatrixOfDouble(pvApiCtx,printlevel_address, &printlevel_rows, &printlevel_cols, &printlevel_value); CSDP_ERROR;
printlevel = (int)*printlevel_value;
}
else
{
printlevel = 0;
}
///////////////////////////
// Read the sdpa problem //
///////////////////////////
ret = read_prob(filename[0], &nb_vars, &nb_constr, &pC, &pa, &pconstraints, printlevel);
#ifdef DEBUG
printf("DEBUG: read file %s, return code = %d nb_vars = %d nb_constr = %d\n", filename[0], ret, nb_vars, nb_constr);
#endif
///////////////
// Process C //
///////////////
sciErr = createList(pvApiCtx,C_OUT,pC.nblocks,&c_out_address); CSDP_ERROR;
#ifdef DEBUG
printf("DEBUG: process c: %d blocks\n", pC.nblocks);
#endif
for(i=0;i<pC.nblocks;i++)
{
#ifdef DEBUG
printf("DEBUG: processing block %d: blockssize = %d blockcat = %d\n", i+1, pC.blocks[i+1].blocksize, pC.blocks[i+1].blockcategory);
#endif
if (pC.blocks[i+1].blockcategory==MATRIX)
{
sciErr = allocMatrixOfDoubleInList(pvApiCtx, C_OUT, c_out_address, i+1, pC.blocks[i+1].blocksize, pC.blocks[i+1].blocksize, &c_out); CSDP_ERROR;
for(j=0;j<pC.blocks[i+1].blocksize;j++)
{
for(k=0;k<pC.blocks[i+1].blocksize;k++)
{
c_out[j + k*pC.blocks[i+1].blocksize] = pC.blocks[i+1].data.mat[ijtok(j+1,k+1,pC.blocks[i+1].blocksize)];
#ifdef DEBUG
printf("DEBUG: MATRIX - c_out_m[%d][%d] = %f - Index = %d\n",j,k,c_out[j + k*pC.blocks[i+1].blocksize], ijtok(j+1,k+1,pC.blocks[i+1].blocksize));
#endif
}
}
}
else if (pC.blocks[i+1].blockcategory==DIAG)
{
sciErr = allocMatrixOfDoubleInList(pvApiCtx, C_OUT, c_out_address, i+1, pC.blocks[i+1].blocksize, 1, &c_out); CSDP_ERROR;
for(j=0;j<pC.blocks[i+1].blocksize;j++)
{
c_out[j] = pC.blocks[i+1].data.vec[j+1];
#ifdef DEBUG
printf("DEBUG: DIAG - c_out_d[%d] = %f\n",j,c_out[j]);
#endif
}
}
else
{
Scierror(999,"%s: wrong blockcat type PACKEDMATRIX\n",fname);
return 0;
}
}
///////////////
// Process A //
///////////////
#ifdef DEBUG
printf("DEBUG: process a - nb_constr = %d\n",nb_constr);
#endif
sciErr = createList(pvApiCtx,A_OUT,nb_constr,&a_out_address); CSDP_ERROR;
for(i=0;i<nb_constr;i++)
{
#ifdef DEBUG
printf("DEBUG: processing constraint %d\n", i+1);
#endif
// constraint_nb_item: nb blocks for constraint i+1
Index = 0;
tmp_block = pconstraints[i+1].blocks;
while (tmp_block)
{
tmp_block = tmp_block->next;
Index++;
}
constraint_nb_item = Index;
sciErr = createListInList(pvApiCtx,A_OUT, a_out_address, i+1, constraint_nb_item, &constraint_address); CSDP_ERROR;
Index = 0;
tmp_block = pconstraints[i+1].blocks;
for(j=0;j<constraint_nb_item;j++)
{
#ifdef DEBUG
printf("DEBUG: processing block %d: nb_block = %d blocksize = %d numentries %d\n", j+1, constraint_nb_item, tmp_block->blocksize, tmp_block->numentries);
printf("DEBUG: blocknum = %d constraintnum = %d issparse = %d\n", tmp_block->blocknum, tmp_block->constraintnum, tmp_block->issparse);
#endif
constraint_block_rows = tmp_block->blocksize;
constraint_block_cols = tmp_block->blocksize;
#ifdef DEBUG
int ii;
for(ii=0;ii<tmp_block->numentries;ii++)
{
printf("entries[%d] = %f\n",ii+1,tmp_block->entries[ii+1]);
}
#endif
sciErr = allocMatrixOfDoubleInList(pvApiCtx, A_OUT, constraint_address, j+1, constraint_block_rows, constraint_block_cols, &block_value); CSDP_ERROR;
if (res)
{
Scierror(999,"%s: error while allocating a matrix A on the stack\n", fname);
return 0;
}
for(k=0;k<constraint_block_rows*constraint_block_cols;k++) block_value[k] = 0.0;
for(k=0;k<tmp_block->numentries;k++)
{
block_value[(tmp_block->iindices[k+1]-1) + (tmp_block->jindices[k+1]-1)*tmp_block->blocksize] = tmp_block->entries[k+1];
#ifdef DEBUG
printf("a_out[%d][%d] = %f\n",tmp_block->iindices[k+1],tmp_block->jindices[k+1],
block_value[(tmp_block->iindices[k+1]-1)+(tmp_block->jindices[k+1]-1)*tmp_block->blocksize]);
#endif
}
tmp_block = tmp_block->next;
}
}
///////////////
// Process B //
///////////////
#ifdef DEBUG
printf("DEBUG: process B\n");
#endif
sciErr = allocMatrixOfDouble(pvApiCtx, B_OUT, nb_constr, 1, &b_out); CSDP_ERROR;
if (res)
{
Scierror(999,"%s: error while allocating a vector on the stack\n", fname);
return 0;
}
for(i=0;i<nb_constr;i++)
{
b_out[i] = pa[i+1];
#ifdef DEBUG
printf("a[%d] = %f\n", i, b_out[i]);
#endif
}
////////////////////
// Process status //
////////////////////
#ifdef DEBUG
printf("DEBUG: process status\n");
#endif
sciErr = allocMatrixOfDouble(pvApiCtx, STATUS_OUT, 1, 1, &b_out); CSDP_ERROR;
*b_out = (double)ret;
#ifdef DEBUG
printf("DEBUG: status = %d,%d\n",*b_out,ret);
#endif
LhsVar(1) = C_OUT;
LhsVar(2) = A_OUT;
LhsVar(3) = B_OUT;
LhsVar(4) = STATUS_OUT;
return 0;
}
int sci_hdf5_listvar_v2(char *fname, int* pvApiCtx)
{
SciErr sciErr;
int *piAddr = NULL;
char* pstFile = NULL;
int iFile = 0;
int iNbItem = 0;
VarInfo* pInfo = NULL;
const int nbIn = nbInputArgument(pvApiCtx);
CheckInputArgument(pvApiCtx, 1, 1);
CheckOutputArgument(pvApiCtx, 1, 4);
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (getAllocatedSingleString(pvApiCtx, piAddr, &pstFile))
{
if (pstFile)
{
FREE(pstFile);
}
Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
return 1;
}
char* pstFileName = expandPathVariable(pstFile);
iFile = openHDF5File(pstFileName, 0);
if (iFile < 0)
{
Scierror(999, _("%s: Unable to open file: %s\n"), fname, pstFile);
FREE(pstFileName);
FREE(pstFile);
return 1;
}
FREE(pstFileName);
FREE(pstFile);
//manage version information
int iVersion = getSODFormatAttribute(iFile);
if (iVersion != SOD_FILE_VERSION)
{
if (iVersion > SOD_FILE_VERSION)
{
//can't read file with version newer that me !
closeHDF5File(iFile);
Scierror(999, _("%s: Wrong SOD file format version. Max Expected: %d Found: %d\n"), fname, SOD_FILE_VERSION, iVersion);
return 1;
}
else
{
//call older import functions and exit or ... EXIT !
if (iVersion == 1 || iVersion == -1)
{
//sciprint("old sci_listvar_in_hdf5_v1\n");
return sci_listvar_in_hdf5_v1(fname, pvApiCtx);
}
}
}
iNbItem = getVariableNames(iFile, NULL);
if (iNbItem != 0)
{
char** pstVarNameList = (char**)MALLOC(sizeof(char*) * iNbItem);
pInfo = (VarInfo*)MALLOC(iNbItem * sizeof(VarInfo));
int b;
if (Lhs == 1)
{
sciprint("Name Type Size Bytes\n");
sciprint("---------------------------------------------------------------\n");
}
iNbItem = getVariableNames(iFile, pstVarNameList);
for (int i = 0; i < iNbItem; i++)
{
int iDataSetId = getDataSetIdFromName(iFile, pstVarNameList[i]);
if (iDataSetId == 0)
{
break;
}
strncpy(pInfo[i].varName, pstVarNameList[i], sizeof(pInfo[i].varName) - 1);
pInfo[i].iSize = 0;
b = read_data(iDataSetId, 0, NULL, &pInfo[i]) == false;
if (b)
{
break;
}
if (Lhs == 1)
{
sciprint("%s\n", pInfo[i].pstInfo);
}
}
freeArrayOfString(pstVarNameList, iNbItem);
}
else
{
//no variable returms [] for each Lhs
for (int i = 0 ; i < Lhs ; i++)
{
createEmptyMatrix(pvApiCtx, nbIn + i + 1);
AssignOutputVariable(pvApiCtx, i + 1) = nbIn + i + 1;
}
ReturnArguments(pvApiCtx);
return 0;
}
closeHDF5File(iFile);
//1st Lhs
char** pstVarName = (char**)MALLOC(sizeof(char*) * iNbItem);
for (int i = 0 ; i < iNbItem ; i++)
{
pstVarName[i] = pInfo[i].varName;
}
sciErr = createMatrixOfString(pvApiCtx, nbIn + 1, iNbItem, 1, pstVarName);
FREE(pstVarName);
if (sciErr.iErr)
{
FREE(pInfo);
printError(&sciErr, 0);
return 1;
}
AssignOutputVariable(pvApiCtx, 1) = nbIn + 1;
if (Lhs > 1)
{
//2nd Lhs
double* pdblType;
sciErr = allocMatrixOfDouble(pvApiCtx, nbIn + 2, iNbItem, 1, &pdblType);
if (sciErr.iErr)
{
printError(&sciErr, 0);
FREE(pInfo);
return 1;
}
for (int i = 0 ; i < iNbItem ; i++)
{
pdblType[i] = pInfo[i].iType;
}
AssignOutputVariable(pvApiCtx, 2) = nbIn + 2;
if (Lhs > 2)
{
//3rd Lhs
int* pList = NULL;
sciErr = createList(pvApiCtx, nbIn + 3, iNbItem, &pList);
for (int i = 0 ; i < iNbItem ; i++)
{
double* pdblDims = NULL;
allocMatrixOfDoubleInList(pvApiCtx, nbIn + 3, pList, i + 1, 1, pInfo[i].iDims, &pdblDims);
for (int j = 0 ; j < pInfo[i].iDims ; j++)
{
pdblDims[j] = pInfo[i].piDims[j];
}
}
AssignOutputVariable(pvApiCtx, 3) = nbIn + 3;
}
if (Lhs > 3)
{
//4th Lhs
double* pdblSize = NULL;
sciErr = allocMatrixOfDouble(pvApiCtx, nbIn + 4, iNbItem, 1, &pdblSize);
for (int i = 0 ; i < iNbItem ; i++)
{
pdblSize[i] = pInfo[i].iSize;
}
AssignOutputVariable(pvApiCtx, 4) = nbIn + 4;
}
}
FREE(pInfo);
ReturnArguments(pvApiCtx);
return 0;
}
int sci_listvar_in_hdf5_v1(char *fname, int* pvCtx)
{
SciErr sciErr;
int *piAddr = NULL;
char* pstFile = NULL;
int iFile = 0;
int iNbItem = 0;
VarInfo_v1* pInfo = NULL;
CheckInputArgument(pvCtx, 1, 1);
CheckOutputArgument(pvCtx, 1, 4);
sciErr = getVarAddressFromPosition(pvCtx, 1, &piAddr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
if (getAllocatedSingleString(pvCtx, piAddr, &pstFile))
{
if (pstFile)
{
FREE(pstFile);
}
Scierror(999, _("%s: Wrong size for input argument #%d: string expected.\n"), fname, 1);
return 1;
}
char* pstFileName = expandPathVariable(pstFile);
iFile = openHDF5File(pstFileName, 0);
if (iFile < 0)
{
FREE(pstFileName);
Scierror(999, _("%s: Unable to open file: %s\n"), fname, pstFile);
FREE(pstFile);
return 1;
}
FREE(pstFileName);
FREE(pstFile);
iNbItem = getVariableNames_v1(iFile, NULL);
if (iNbItem != 0)
{
char** pstVarNameList = (char**)MALLOC(sizeof(char*) * iNbItem);
bool b;
pInfo = (VarInfo_v1*)MALLOC(iNbItem * sizeof(VarInfo_v1));
if (nbOutputArgument(pvCtx) == 1)
{
sciprint("Name Type Size Bytes\n");
sciprint("---------------------------------------------------------------\n");
}
iNbItem = getVariableNames_v1(iFile, pstVarNameList);
for (int i = 0; i < iNbItem; i++)
{
int iDataSetId = getDataSetIdFromName_v1(iFile, pstVarNameList[i]);
if (iDataSetId == 0)
{
break;
}
strncpy(pInfo[i].varName, pstVarNameList[i], sizeof(pInfo[i].varName));
b = read_data_v1(pvCtx, iDataSetId, 0, NULL, &pInfo[i]) == false;
closeDataSet_v1(iDataSetId);
if (b)
{
break;
}
if (nbOutputArgument(pvCtx) == 1)
{
sciprint("%s\n", pInfo[i].pstInfo);
}
}
freeArrayOfString(pstVarNameList, iNbItem);
}
else
{
//no variable returms [] for each Lhs
for (int i = 0 ; i < nbOutputArgument(pvCtx) ; i++)
{
createEmptyMatrix(pvCtx, nbInputArgument(pvCtx) + i + 1);
AssignOutputVariable(pvCtx, i + 1) = nbInputArgument(pvCtx) + i + 1;
}
ReturnArguments(pvCtx);
return 0;
}
closeHDF5File(iFile);
//1st Lhs
char** pstVarName = (char**)MALLOC(sizeof(char*) * iNbItem);
for (int i = 0 ; i < iNbItem ; i++)
{
pstVarName[i] = pInfo[i].varName;
}
sciErr = createMatrixOfString(pvCtx, nbInputArgument(pvCtx) + 1, iNbItem, 1, pstVarName);
FREE(pstVarName);
if (sciErr.iErr)
{
FREE(pInfo);
printError(&sciErr, 0);
return 1;
}
AssignOutputVariable(pvCtx, 1) = nbInputArgument(pvCtx) + 1;
if (nbOutputArgument(pvCtx) > 1)
{
//2nd Lhs
double* pdblType;
sciErr = allocMatrixOfDouble(pvCtx, nbInputArgument(pvCtx) + 2, iNbItem, 1, &pdblType);
if (sciErr.iErr)
{
FREE(pInfo);
printError(&sciErr, 0);
return 1;
}
for (int i = 0 ; i < iNbItem ; i++)
{
pdblType[i] = pInfo[i].iType;
}
AssignOutputVariable(pvCtx, 2) = nbInputArgument(pvCtx) + 2;
if (nbOutputArgument(pvCtx) > 2)
{
//3rd Lhs
int* pList = NULL;
sciErr = createList(pvCtx, nbInputArgument(pvCtx) + 3, iNbItem, &pList);
for (int i = 0 ; i < iNbItem ; i++)
{
double* pdblDims = NULL;
allocMatrixOfDoubleInList(pvCtx, nbInputArgument(pvCtx) + 3, pList, i + 1, 1, pInfo[i].iDims, &pdblDims);
for (int j = 0 ; j < pInfo[i].iDims ; j++)
{
pdblDims[j] = pInfo[i].piDims[j];
}
}
AssignOutputVariable(pvCtx, 3) = nbInputArgument(pvCtx) + 3;
}
if (nbOutputArgument(pvCtx) > 3)
{
//4th Lhs
double* pdblSize;
sciErr = allocMatrixOfDouble(pvCtx, nbInputArgument(pvCtx) + 4, iNbItem, 1, &pdblSize);
for (int i = 0 ; i < iNbItem ; i++)
{
pdblSize[i] = pInfo[i].iSize;
}
AssignOutputVariable(pvCtx, 4) = nbInputArgument(pvCtx) + 4;
}
}
FREE(pInfo);
ReturnArguments(pvCtx);
return 0;
}
