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 readPoly(int _iDatasetId, int *_piNbCoef, double **_pdblData) { int iComplex = 0; int iSize = 0; int iDims = 0; //Get the datatype and its size. iSize = getDatasetInfo(_iDatasetId, &iComplex, &iDims, _piNbCoef); *_pdblData = (double *)MALLOC(*_piNbCoef * sizeof(double)); //Read the data and return result. return readDoubleMatrix(_iDatasetId, *_pdblData); }
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; }