int readCommonSparseComplexMatrix(int _iDatasetId, int _iComplex, int _iRows, int _iCols, int _iNbItem, int *_piNbItemRow, int *_piColPos, double *_pdblReal, double *_pdblImg)
{
hid_t obj = 0;
hobj_ref_t pRef[3] = {0};
herr_t status;
/*
* Read the data.
*/
status = H5Dread(_iDatasetId, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pRef);
if (status < 0)
{
return -1;
}
//read Row data
obj = H5Rdereference(_iDatasetId, H5R_OBJECT, &pRef[0]);
status = readInteger32Matrix(obj, _piNbItemRow);
if (status < 0)
{
return -1;
}
//read cols data
obj = H5Rdereference(_iDatasetId, H5R_OBJECT, &pRef[1]);
status = readInteger32Matrix(obj, _piColPos);
if (status < 0)
{
return -1;
}
//read sparse data
obj = H5Rdereference(_iDatasetId, H5R_OBJECT, &pRef[2]);
if (_iComplex)
{
status = readDoubleComplexMatrix(obj, _pdblReal, _pdblImg);
}
else
{
status = readDoubleMatrix(obj, _pdblReal);
}
if (status < 0)
{
return -1;
}
status = H5Dclose(_iDatasetId);
if (status < 0)
{
return -1;
}
return 0;
}
static int readComplexPoly(int _iDatasetId, int *_piNbCoef, double **_pdblReal, double **_pdblImg)
{
int iComplex = 0;
int iSize = 0;
int iDims = 0;
//Get the datatype and its size.
iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, _piNbCoef);
//Allocate space for string data.
*_pdblReal = (double *)MALLOC(*_piNbCoef * sizeof(double));
*_pdblImg = (double *)MALLOC(*_piNbCoef * sizeof(double));
//Read the data and return result.
return readDoubleComplexMatrix(_iDatasetId, *_pdblReal, *_pdblImg);
}
static types::InternalType* import_double(int dataset)
{
int complex = 0;
int dims = 0;
int ret = getDatasetInfo(dataset, &complex, &dims, NULL);
if (ret < 0)
{
closeDataSet(dataset);
return nullptr;
}
std::vector<int> d(dims);
int size = getDatasetInfo(dataset, &complex, &dims, d.data());
if (dims == 0 || size <= 0)
{
closeDataSet(dataset);
return types::Double::Empty();
}
types::Double* dbl = new types::Double(dims, d.data(), complex == 1);
double* real = dbl->get();
double* img = dbl->getImg();
if (complex)
{
readDoubleComplexMatrix(dataset, real, img);
}
else
{
readDoubleMatrix(dataset, real);
}
return dbl;
}
static bool import_double(int* pvCtx, int _iDatasetId, int _iItemPos, int *_piAddress, char *_pstVarname)
{
SciErr sciErr;
int iRet = 0;
double *pdblReal = NULL;
double *pdblImg = NULL;
int iDims = 0;
int* piDims = NULL;
int iComplex = 0;
int iSize = 0;
iRet = getDatasetInfo(_iDatasetId, &iComplex, &iDims, NULL);
if (iRet < 0)
{
return false;
}
if (iDims)
{
if (iDims > 2)
{
//hypermatrix
return false;
}
piDims = (int*)MALLOC(sizeof(int) * iDims);
iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, piDims);
if (iSize > 0)
{
pdblReal = (double *)MALLOC(iSize * sizeof(double));
if (iComplex)
{
pdblImg = (double *)MALLOC(iSize * sizeof(double));
iRet = readDoubleComplexMatrix(_iDatasetId, pdblReal, pdblImg);
}
else
{
iRet = readDoubleMatrix(_iDatasetId, pdblReal);
}
//to be sure ti have 2 dims
if (iDims == 1)
{
FREE(piDims);
piDims = (int*)MALLOC(sizeof(int) * 2);
piDims[0] = 1;
piDims[1] = iSize;
}
}
}
if (iDims == 0 || iSize == 0) //empty matrix
{
if (piDims)
{
FREE(piDims);
}
/*bug 7224 : to close dataset */
iRet = readEmptyMatrix(_iDatasetId);
if (iRet)
{
return false;
}
// Hack to sure that piDims will not be null at line 372.
iDims = 2;
piDims = (int*)MALLOC(sizeof(int) * iDims);
memset(piDims, 0, sizeof(int) * iDims);
pdblReal = (double*)MALLOC(sizeof(double) * 1);
pdblReal[0] = 0;
iComplex = 0;
}
if (_piAddress == NULL)
{
if (iComplex)
{
sciErr = createNamedComplexMatrixOfDouble(pvCtx, _pstVarname, piDims[0], piDims[1], pdblReal, pdblImg);
}
else
{
sciErr = createNamedMatrixOfDouble(pvCtx, _pstVarname, piDims[0], piDims[1], pdblReal);
}
}
else //if not null this variable is in a list
{
if (iComplex)
{
sciErr = createComplexMatrixOfDoubleInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pdblReal, pdblImg);
}
else
{
sciErr = createMatrixOfDoubleInNamedList(pvCtx, _pstVarname, _piAddress, _iItemPos, piDims[0], piDims[1], pdblReal);
}
}
FREE(piDims);
FREE(pdblReal);
if (iComplex)
{
FREE(pdblImg);
}
if (sciErr.iErr)
{
printError(&sciErr, 0);
return false;
}
return true;
}
static types::InternalType* import_sparse(int dataset)
{
types::Sparse* sp = nullptr;
//get sparse dimensions
int complex = 0;
std::vector<int> pdims;
int size = getDimsNode(dataset, &complex, pdims);
//get non zeros count
int nnz = 0;
int datannz = getDataSetIdFromName(dataset, "__nnz__");
readInteger32Matrix(datannz, &nnz);
if (nnz == 0)
{
closeList6(dataset);
return new types::Sparse(pdims[0], pdims[1]);
}
//get inner vector
int datain = getDataSetIdFromName(dataset, "__inner__");
int dimin = 0;
int sizein = getDatasetInfo(datain, &complex, &dimin, NULL);
std::vector<int> dimsin(dimin);
sizein = getDatasetInfo(datain, &complex, &dimin, dimsin.data());
if (sizein < 0)
{
closeList6(dataset);
return nullptr;
}
std::vector<int> in(sizein);
int ret = readInteger32Matrix(datain, in.data());
if (ret < 0)
{
closeList6(dataset);
return nullptr;
}
//get outer vector
int dataout = getDataSetIdFromName(dataset, "__outer__");
int dimout = 0;
int sizeout = getDatasetInfo(dataout, &complex, &dimout, NULL);
std::vector<int> dimsout(dimout);
sizeout = getDatasetInfo(dataout, &complex, &dimout, dimsout.data());
if (sizeout < 0)
{
closeList6(dataset);
return nullptr;
}
std::vector<int> out(sizeout);
ret = readInteger32Matrix(dataout, out.data());
if (ret < 0)
{
closeList6(dataset);
return nullptr;
}
//get data
int ddata = getDataSetIdFromName(dataset, "__data__");
int dimdata = 0;
int sizedata = getDatasetInfo(ddata, &complex, &dimdata, NULL);
std::vector<int> dimsdata(dimdata);
sizedata = getDatasetInfo(ddata, &complex, &dimdata, dimsdata.data());
if (sizedata < 0)
{
closeList6(dataset);
return nullptr;
}
std::vector<double> real(sizedata);
if (complex)
{
std::vector<double> img(sizedata);
ret = readDoubleComplexMatrix(ddata, real.data(), img.data());
if (ret < 0)
{
closeList6(dataset);
return nullptr;
}
sp = new types::Sparse(pdims[0], pdims[1], nnz, in.data(), out.data(), real.data(), img.data());
}
else
{
ret = readDoubleMatrix(ddata, real.data());
if (ret < 0)
{
closeList6(dataset);
return nullptr;
}
sp = new types::Sparse(pdims[0], pdims[1], nnz, in.data(), out.data(), real.data(), nullptr);
}
closeList6(dataset);
return sp;
}
static types::InternalType* import_poly(int dataset)
{
//get poly dims node
int complex = 0;
std::vector<int> pdims;
int size = getDimsNode(dataset, &complex, pdims);
//get variable name
char* var = NULL;
int varname = getDataSetIdFromName(dataset, "__varname__");
readStringMatrix(varname, &var);
wchar_t* wvar = to_wide_string(var);
std::wstring wvarname(wvar);
FREE(wvar);
freeStringMatrix(varname, &var);
types::Polynom* p = new types::Polynom(wvarname, static_cast<int>(pdims.size()), pdims.data());
types::SinglePoly** pss = p->get();
//open __refs__ node
int refs = getDataSetIdFromName(dataset, "__refs__");
size = p->getSize();
//loop on children
for (int i = 0; i < size; ++i)
{
//forge name
std::string polyname(std::to_string(i));
int poly = getDataSetIdFromName(refs, polyname.data());
//get dims
complex = 0;
int dims = 0;
int ret = getDatasetInfo(poly, &complex, &dims, NULL);
if (ret < 0)
{
return nullptr;
}
std::vector<int> d(dims);
int datasize = getDatasetInfo(poly, &complex, &dims, d.data());
types::SinglePoly* ss = NULL;
//get coef
if (dims == 0 || datasize <= 0)
{
ss = new types::SinglePoly();
}
else if (complex)
{
double* real = NULL;
double* img = NULL;
//create singlepoly
ss = new types::SinglePoly(&real, &img, datasize - 1);
readDoubleComplexMatrix(poly, real, img);
}
else
{
double* real = NULL;
ss = new types::SinglePoly(&real, datasize - 1);
readDoubleMatrix(poly, real);
}
pss[i] = ss;
}
closeList6(refs);
closeList6(dataset);
return p;
}