template <> bool DataOutputNode<lbfloat>::mat_write(std::string file_path, std::string var_name) { //Copy data to buffer lbfloat* buf = nullptr; size_t buf_size; contract(buf,buf_size,false); std::cout << "Output matrix will be [" << _n_samples << "] x [" << _n_channels << "]." << std::endl; //setup the output mat_t *mat; matvar_t *matvar; size_t dims[2] = {_n_samples,_n_channels}; mat = Mat_Open(file_path.c_str(),MAT_ACC_RDWR); if(mat) { //output matrix matvar = Mat_VarCreate(var_name.c_str(),MAT_C_DOUBLE,MAT_T_DOUBLE,2,dims,buf,0); Mat_VarWrite(mat, matvar, MAT_COMPRESSION_NONE); Mat_Close(mat); Mat_VarFree(matvar); std::cout << "Output data to " << var_name << " variable in file " << file_path << "!" << std::endl; delete [] buf; return true; } std::cerr << "Couldn't output to file." << std::endl; delete [] buf; return false; }
/** \brief save Array-struct as MATLAB .mat file. Currently, the function converts all arrays to double-arrays. Should be easy to implement for arbitrary types if needed. \param a the Array \param varname MATLAB-name of the array \param file the filename \param append if TRUE, the function tries to open() the file, else it is overwritten \return error code */ int write_array_matlab( const Array *a, const char *varname, const char *file, bool append ){ mat_t *mfile; matvar_t *marr=NULL; int i; if( append ){ if( !(mfile=Mat_Open( file, MAT_ACC_RDWR )) ){ errprintf("Could not open '%s', creating new file\n", file); } } if( !mfile ){ if( !(mfile=Mat_Create( file, NULL )) ){ errprintf("Could not open '%s' for writing\n", file); return -1; } } int ndim = MAX(2, a->ndim); int *size = (int*)malloc( ndim*sizeof(int)); if( a->ndim==1 ){ size[0]=1; size[1]=a->size[0]; } else { memcpy( size, a->size, ndim*sizeof(int)); } dprintf("Writing to file '%s' variable '%s', ndim=%i\n", file, varname, ndim); /* convert to column major for MATLAB */ Array *b=array_convert_rowcolmajor( (Array*)a, TRUE ); dprintf("Up-cast, b->ndim=%i, b->size=%p, b->size[0]=%i\n", b->ndim, b->size, b->size[0]); /* up-cast to DOUBLE - copy of b */ Array *c=array_new( DOUBLE, b->ndim, b->size ); dprintf("casting\n"); for( i=0; i<array_NUMEL(b); i++ ){ array_dtype_to_double( array_INDEXMEM1(c,i), array_INDEXMEM1(b,i), b->dtype ); } array_free( b ); dprintf("Creating MATLAB-rep\n"); marr = Mat_VarCreate( varname, MAT_C_DOUBLE, MAT_T_DOUBLE, ndim, size, c->data, MEM_CONSERVE /* Array remains owner */ ); dprintf("mfile=%p, marr=%p, rank=%i,\n", mfile, marr, marr->rank ); int succ=Mat_VarWrite( mfile, marr, 0 ); dprintf("done writing with succ=%i\n", succ); Mat_Close( mfile ); Mat_VarFree( marr ); array_free( c ); free( size ); return 0; }
/* * matWrite - write signals from measurement structure to MAT file */ int matWrite(measurement_t *measurement, const char *outFileName) { size_t dims[2]; int err = 0; mat_t *mat; matvar_t *matvar; mat = Mat_Create(outFileName, NULL); if (mat != NULL) { /* loop over all time series */ struct hashtable *timeSeriesHash = measurement->timeSeriesHash; /* Iterator constructor only returns a valid iterator if * the hashtable is not empty */ if (hashtable_count(timeSeriesHash) > 0) { struct hashtable_itr *itr = hashtable_iterator(timeSeriesHash); do { char *signalName = hashtable_iterator_key(itr); timeSeries_t *timeSeries = hashtable_iterator_value(itr); double *timeValue = (double *)malloc(sizeof(double)*2*timeSeries->n); unsigned int i; /* * build up a 1x2n array with time stamps in [0..n-1] and * values in [n..2n-1]. */ for(i=0;i<timeSeries->n;i++) { timeValue[i] = timeSeries->time[i]; } for(i=0;i<timeSeries->n;i++) { timeValue[timeSeries->n + i] = timeSeries->value[i]; } dims[0] = timeSeries->n; dims[1] = 2; /* output signal to mat structure and free up temp array. */ matvar = Mat_VarCreate(signalName, MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, timeValue, 0); Mat_VarWrite(mat, matvar, 0); Mat_VarFree(matvar); free(timeValue); } while (hashtable_iterator_advance(itr)); free(itr); } Mat_Close(mat); } else { fprintf(stderr, "error: could not create MAT file %s\n", outFileName); err = 1; } return err; }
/* put string in mat file*/ void matPutStr (char *name,char *str) { matvar_t *matvar = NULL; size_t dims[2]; dims[0] = 1; dims[1] = strlen(str); matvar = Mat_VarCreate(name, MAT_C_CHAR, MAT_T_UINT8, 2, dims, str, MAT_F_DONT_COPY_DATA); Mat_VarWrite(mat_file, matvar, MAT_COMPRESSION_NONE); Mat_VarFree(matvar); }
/* put integer in mat file*/ void matPutInt (char *name,int n1,int n2, int *pd) { matvar_t *matvar = NULL; size_t dims[2]; dims[0] = n1; dims[1] = n2; matvar = Mat_VarCreate(name, MAT_C_INT32, MAT_T_INT32, 2, dims, pd, MAT_F_DONT_COPY_DATA); Mat_VarWrite(mat_file, matvar, MAT_COMPRESSION_ZLIB); Mat_VarFree(matvar); }
// save a .mat matlab matrix // will store a single matrix (sparse or dense) in a .mat file // returns 0 on success static int write_mat(char const *const filename, matrix_t *const A) { #ifndef HAVE_MATIO return 1; #else const char created_by[] = "created by " PACKAGE_STRING; // "created by Meagre-Crowd x.y.z" mat_t* matfp; matfp = Mat_Create(filename, created_by); if(matfp == NULL) return 1; // failed to open file // create a matrix convert into matvar_t* t = NULL; int ret = 0; if(A->format == DCOL || A->format == DROW) { // dense ret = convert_matrix(A, DCOL, FIRST_INDEX_ZERO); // DROW -> DCOL if DROW if(ret != 0) ret = 2; // conversion failure if(ret == 0) { // TODO check for integer overflow in cast from unsigned int -> int size_t dims[] = { A->m, A->n }; t = Mat_VarCreate( "x", MAT_C_DOUBLE, MAT_T_DOUBLE, 2, // always at least rank 2 dims, A->dd, 0 // MAT_F_COMPLEX if complex, could avoid copying data: MAT_F_DONT_COPY_DATA if not sparse ); if(t == NULL) { ret = 3; // failed to malloc data for storage } else { ret = Mat_VarWrite(matfp, t, 1); // compress if(ret != 0) ret = 4; // failed data write } } } else { // sparse assert(0); // do we ever get sparse results? } Mat_Close(matfp); Mat_VarFree(t); return ret; // success? #endif }
/* put integer in mat file*/ int matPutInt (const char *name,int n1,int n2, int *pd) { int error = 0; matvar_t *matvar = nullptr; size_t dims[2]; dims[0] = n1; dims[1] = n2; matvar = Mat_VarCreate(name, MAT_C_INT32, MAT_T_INT32, 2, dims, pd, MAT_F_DONT_COPY_DATA); if (matvar != nullptr) { error = Mat_VarWrite(mat_file, matvar, MAT_COMPRESSION_ZLIB); Mat_VarFree(matvar); } else { error = 1; } return error; }
/* put string in mat file*/ int matPutStr (const char *name, char *str) { int error = 0; matvar_t *matvar = nullptr; size_t dims[2]; dims[0] = 1; dims[1] = strlen(str); matvar = Mat_VarCreate(name, MAT_C_CHAR, MAT_T_UINT8, 2, dims, str, MAT_F_DONT_COPY_DATA); if (matvar != nullptr) { error = Mat_VarWrite(mat_file, matvar, MAT_COMPRESSION_NONE); Mat_VarFree(matvar); } else { error = 1; } return error; }
template <> bool DataOutputNode<lbcomplex>::mat_write(std::string file_path, std::string var_name) { //Copy data to buffer lbcomplex* buf = nullptr; size_t buf_size; contract(buf,buf_size,false); std::cout << "Output matrix will be [" << _n_samples << "] x [" << _n_channels << "]." << std::endl; //setup the output mat_t *mat; matvar_t *matvar; mat_complex_split_t data; data.Re = malloc(buf_size*sizeof(lbfloat)); data.Im = malloc(buf_size*sizeof(lbfloat)); for(size_t ii=0; ii<buf_size; ++ii) { reinterpret_cast<lbfloat*>(data.Re)[ii] = std::real(buf[ii]); reinterpret_cast<lbfloat*>(data.Im)[ii] = std::imag(buf[ii]); } size_t dims[2] = {_n_samples,_n_channels}; mat = Mat_Open(file_path.c_str(),MAT_ACC_RDWR); if(mat) { //output matrix matvar = Mat_VarCreate(var_name.c_str(),MAT_C_DOUBLE,MAT_T_DOUBLE,2,dims,&data,MAT_F_COMPLEX); Mat_VarWrite(mat, matvar, MAT_COMPRESSION_NONE); Mat_Close(mat); Mat_VarFree(matvar); std::cout << "Output data to " << var_name << " variable in file " << file_path << "!" << std::endl; delete [] buf; return true; } std::cerr << "Couldn't output to file." << std::endl; delete [] buf; return false; }
void write_mat(const char *filename, const char *varname, double *array, size_t *dims) { mat_t *mat; matvar_t *var; mat = Mat_CreateVer(filename, NULL, MAT_FT_DEFAULT); if (!mat) { fprintf(stderr, "Error creating MAT file \"%s\"\n", filename); exit(EXIT_FAILURE); } var = Mat_VarCreate(varname, MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, array, 0); if (!var) { fprintf(stderr, "Error creating variable %s.\n", varname); Mat_Close(mat); exit(EXIT_FAILURE); } Mat_VarWrite(mat, var, MAT_COMPRESSION_NONE); Mat_VarFree(var); Mat_Close(mat); }
matvar_t *GetIntegerVariable(void *pvApiCtx, int iVar, const char *name, int * parent, int item_position) { int rank = 0; size_t *pszDims = NULL; int *piDims = NULL; matvar_t *createdVar = NULL; int * var_addr = NULL; int i; int var_type; int integerType; SciErr sciErr; char * tmp_int8 = NULL; short * tmp_int16 = NULL; int * tmp_int32 = NULL; int * item_addr = NULL; unsigned char * tmp_uint8 = NULL; unsigned short * tmp_uint16 = NULL; unsigned int * tmp_uint32 = NULL; #ifdef __SCILAB_INT64__ long long * tmp_int64 = NULL; unsigned long long * tmp_uint64 = NULL; #endif if (parent == NULL) { sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &var_addr); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } sciErr = getVarType(pvApiCtx, var_addr, &var_type); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } } else { sciErr = getListItemAddress(pvApiCtx, parent, item_position, &item_addr); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } sciErr = getVarType(pvApiCtx, item_addr, &var_type); if (sciErr.iErr) { printError(&sciErr, 0); return 0; } } if (var_type == sci_ints) /* 2-D array */ { rank = 2; if ((pszDims = (size_t*)MALLOC(sizeof(size_t) * rank)) == NULL) { Scierror(999, _("%s: No more memory.\n"), "GetIntegerVariable"); return NULL; } if ((piDims = (int*)MALLOC(sizeof(int) * rank)) == NULL) { Scierror(999, _("%s: No more memory.\n"), "GetIntegerVariable"); return NULL; } if (parent == NULL) { sciErr = getMatrixOfIntegerPrecision(pvApiCtx, var_addr, &integerType); } else { sciErr = getMatrixOfIntegerPrecision(pvApiCtx, item_addr, &integerType); } switch (integerType) { case SCI_INT8: /* INT8 */ if (parent == NULL) { sciErr = getMatrixOfInteger8(pvApiCtx, var_addr, &piDims[0], &piDims[1], &tmp_int8); } else { sciErr = getMatrixOfInteger8InList(pvApiCtx, parent, item_position, &piDims[0], &piDims[1], &tmp_int8); } for (i = 0; i < rank; i++) { pszDims[i] = piDims[i]; } createdVar = Mat_VarCreate(name, MAT_C_INT8, MAT_T_INT8, rank, pszDims, tmp_int8, 0); break; case SCI_INT16: /* INT16 */ if (parent == NULL) { sciErr = getMatrixOfInteger16(pvApiCtx, var_addr, &piDims[0], &piDims[1], &tmp_int16); } else { sciErr = getMatrixOfInteger16InList(pvApiCtx, parent, item_position, &piDims[0], &piDims[1], &tmp_int16); } for (i = 0; i < rank; i++) { pszDims[i] = piDims[i]; } createdVar = Mat_VarCreate(name, MAT_C_INT16, MAT_T_INT16, rank, pszDims, tmp_int16, 0); break; case SCI_INT32: /* INT32 */ if (parent == NULL) { sciErr = getMatrixOfInteger32(pvApiCtx, var_addr, &piDims[0], &piDims[1], &tmp_int32); } else { sciErr = getMatrixOfInteger32InList(pvApiCtx, parent, item_position, &piDims[0], &piDims[1], &tmp_int32); } for (i = 0; i < rank; i++) { pszDims[i] = piDims[i]; } createdVar = Mat_VarCreate(name, MAT_C_INT32, MAT_T_INT32, rank, pszDims, tmp_int32, 0); break; case SCI_UINT8: /* UINT8 */ if (parent == NULL) { sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, var_addr, &piDims[0], &piDims[1], &tmp_uint8); } else { sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, parent, item_position, &piDims[0], &piDims[1], &tmp_uint8); } for (i = 0; i < rank; i++) { pszDims[i] = piDims[i]; } createdVar = Mat_VarCreate(name, MAT_C_UINT8, MAT_T_UINT8, rank, pszDims, tmp_uint8, 0); break; case SCI_UINT16: /* UINT16 */ if (parent == NULL) { sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, var_addr, &piDims[0], &piDims[1], &tmp_uint16); } else { sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, parent, item_position, &piDims[0], &piDims[1], &tmp_uint16); } for (i = 0; i < rank; i++) { pszDims[i] = piDims[i]; } createdVar = Mat_VarCreate(name, MAT_C_UINT16, MAT_T_UINT16, rank, pszDims, tmp_uint16, 0); break; case SCI_UINT32: /* UINT32 */ if (parent == NULL) { sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, var_addr, &piDims[0], &piDims[1], &tmp_uint32); } else { sciErr = getMatrixOfUnsignedInteger32InList(pvApiCtx, parent, item_position, &piDims[0], &piDims[1], &tmp_uint32); } for (i = 0; i < rank; i++) { pszDims[i] = piDims[i]; } createdVar = Mat_VarCreate(name, MAT_C_UINT32, MAT_T_UINT32, rank, pszDims, tmp_uint32, 0); break; default: createdVar = NULL; break; } } else { Scierror(999, _("%s: Wrong type for first input argument: Integer matrix expected.\n"), "GetIntegerVariable"); } FREE(pszDims); FREE(piDims); return createdVar; }
matvar_t* GetSparseMatVar(types::Sparse* pSparse, const char *name) { int Dims = pSparse->getDims(); int* pDims = pSparse->getDimsArray(); int isize = pSparse->getSize(); size_t* psize_t = NULL; matvar_t * pMatVarOut = NULL; if (pSparse->getDims() > 2) { Scierror(999, _("%s: No more memory.\n"), "GetSparseMatVar"); return NULL; } mat_sparse_t *sparseData = NULL; sparseData = (mat_sparse_t*)MALLOC(sizeof(mat_sparse_t)); if (sparseData == NULL) { Scierror(999, _("%s: No more memory.\n"), "GetSparseMatVar"); return NULL; } int nonZeros = pSparse->nonZeros(); int* colPos = new int[nonZeros]; int* itemsRow = new int[pSparse->getRows()]; pSparse->getNbItemByRow(itemsRow); int* colIndexes = (int*)MALLOC(sizeof(int) * (pSparse->getRows() + 1)); if (colIndexes == NULL) { FREE(sparseData); Scierror(999, _("%s: No more memory.\n"), "GetSparseMatVar"); return NULL; } colIndexes[0] = 0; for (int K = 0; K < pSparse->getRows(); ++K) { colIndexes[K + 1] = colIndexes[K] + itemsRow[K]; } int* rowIndexes = (int*)MALLOC(sizeof(int) * nonZeros); if (rowIndexes == NULL) { FREE(sparseData); FREE(colIndexes); Scierror(999, _("%s: No more memory.\n"), "GetSparseVariable"); return NULL; } pSparse->getColPos(colPos); for (int K = 0; K < nonZeros; ++K) { rowIndexes[K] = colPos[K] - 1; } /* Create Matlab Sparse matrix data */ sparseData->nzmax = nonZeros; sparseData->nir = nonZeros; sparseData->ir = rowIndexes; /* sparseData->njc = scilabSparse.nel + 1; */ sparseData->njc = pSparse->getRows() + 1; sparseData->jc = colIndexes; sparseData->ndata = nonZeros; /* get position data*/ int* iPositVal = new int[nonZeros]; int idx = 0; for (int i = 0; i < pSparse->getRows(); i++) { for (int j = 0; j < itemsRow[i]; j++) { iPositVal[idx] = (colPos[idx] - 1) * pSparse->getRows() + i; ++idx; } } psize_t = (size_t*)MALLOC(Dims * sizeof(size_t)); if (rowIndexes == NULL) { FREE(sparseData); FREE(rowIndexes); FREE(colIndexes); Scierror(999, _("%s: No more memory.\n"), "GetSparseVariable"); return NULL; } psize_t[0] = (int)pDims[1]; psize_t[1] = (int)pDims[0]; if (pSparse->isComplex()) { struct mat_complex_split_t* data; double* dataReal = NULL; double* dataImg = NULL; if ((dataReal = (double*)MALLOC(sizeof(double) * nonZeros)) == NULL) { FREE(psize_t); FREE(sparseData); FREE(colIndexes); FREE(rowIndexes); Scierror(999, _("%s: No more memory.\n"), "GetSparseMatVar"); return NULL; } if ((dataImg = (double*)MALLOC(sizeof(double) * nonZeros)) == NULL) { FREE(dataReal); FREE(psize_t); FREE(sparseData); FREE(colIndexes); FREE(rowIndexes); Scierror(999, _("%s: No more memory.\n"), "GetSparseMatVar"); return NULL; } if ((data = (mat_complex_split_t*)MALLOC(sizeof(mat_complex_split_t))) == NULL) { FREE(dataImg); FREE(dataReal); FREE(psize_t); FREE(sparseData); FREE(colIndexes); FREE(rowIndexes); Scierror(999, _("%s: No more memory.\n"), "GetSparseMatVar"); return NULL; } std::complex<double> complexData; for (int K = 0; K < nonZeros; ++K) { complexData = pSparse->getImg(iPositVal[K]); dataReal[K] = complexData.real(); dataImg[K] = (-1 * complexData.imag()); } data->Re = dataReal; data->Im = dataImg; sparseData->data = (void*)data; pMatVarOut = Mat_VarCreate(name, MAT_C_SPARSE, MAT_T_DOUBLE, Dims, psize_t, sparseData, MAT_F_COMPLEX | MAT_F_DONT_COPY_DATA); } else { double* data = NULL; if ((data = (double*)MALLOC(sizeof(double) * nonZeros)) == NULL) { FREE(psize_t); FREE(sparseData); FREE(colIndexes); FREE(rowIndexes); Scierror(999, _("%s: No more memory.\n"), "GetSparseMatVar"); return NULL; } for (int K = 0; K < nonZeros; ++K) { data[K] = pSparse->getReal(iPositVal[K]); } sparseData->data = (void*)data; pMatVarOut = Mat_VarCreate(name, MAT_C_SPARSE, MAT_T_DOUBLE, Dims, psize_t, sparseData, 0 | MAT_F_DONT_COPY_DATA); } FREE(psize_t); return pMatVarOut; }
void CSMatrix<Scalar>::export_to_file(const char *filename, const char *var_name, MatrixExportFormat fmt, char* number_format, bool invert_storage) { switch (fmt) { case EXPORT_FORMAT_MATRIX_MARKET: { FILE* file = fopen(filename, "w"); if(!file) throw Exceptions::IOException(Exceptions::IOException::Write, filename); if(Hermes::Helpers::TypeIsReal<Scalar>::value) fprintf(file, "%%%%Matrix<Scalar>Market matrix coordinate real\n"); else fprintf(file, "%%%%Matrix<Scalar>Market matrix coordinate complex\n"); fprintf(file, "%d %d %d\n", this->size, this->size, this->nnz); if(invert_storage) this->switch_orientation(); for (unsigned int j = 0; j < this->size; j++) { for (int i = Ap[j]; i < Ap[j + 1]; i++) { Hermes::Helpers::fprint_coordinate_num(file, i_coordinate(Ai[i] + 1, j + 1, invert_storage), j_coordinate(Ai[i] + 1, j + 1, invert_storage), Ax[i], number_format); fprintf(file, "\n"); } } if(invert_storage) this->switch_orientation(); fclose(file); } break; case EXPORT_FORMAT_MATLAB_MATIO: { #ifdef WITH_MATIO mat_sparse_t sparse; sparse.nzmax = this->nnz; if(invert_storage) this->switch_orientation(); sparse.nir = this->nnz; sparse.ir = Ai; sparse.njc = this->size + 1; sparse.jc = (int *) Ap; sparse.ndata = this->nnz; size_t dims[2]; dims[0] = this->size; dims[1] = this->size; mat_t *mat = Mat_CreateVer(filename, "", MAT_FT_MAT5); matvar_t *matvar; // For complex. No allocation here. double* Ax_re = nullptr; double* Ax_im = nullptr; // For real. if(Hermes::Helpers::TypeIsReal<Scalar>::value) { sparse.data = Ax; matvar = Mat_VarCreate(var_name, MAT_C_SPARSE, MAT_T_DOUBLE, 2, dims, &sparse, MAT_F_DONT_COPY_DATA); } else { // For complex. Ax_re = new double[this->nnz]; Ax_im = new double[this->nnz]; struct mat_complex_split_t z = {Ax_re, Ax_im}; for(int i = 0; i < this->nnz; i++) { Ax_re[i] = ((std::complex<double>)(this->Ax[i])).real(); Ax_im[i] = ((std::complex<double>)(this->Ax[i])).imag(); sparse.data = &z; } matvar = Mat_VarCreate(var_name, MAT_C_SPARSE, MAT_T_DOUBLE, 2, dims, &sparse, MAT_F_DONT_COPY_DATA | MAT_F_COMPLEX); } if (matvar) { Mat_VarWrite(mat, matvar, MAT_COMPRESSION_ZLIB); Mat_VarFree(matvar); } if(invert_storage) this->switch_orientation(); if(Ax_re) delete [] Ax_re; if(Ax_im) delete [] Ax_im; Mat_Close(mat); if(!matvar) throw Exceptions::IOException(Exceptions::IOException::Write, filename); #endif } break; case EXPORT_FORMAT_PLAIN_ASCII: { FILE* file = fopen(filename, "w"); if(!file) throw Exceptions::IOException(Exceptions::IOException::Write, filename); if(invert_storage) this->switch_orientation(); for (unsigned int j = 0; j < this->size; j++) { for (int i = Ap[j]; i < Ap[j + 1]; i++) { Helpers::fprint_coordinate_num(file, i_coordinate(Ai[i], j, invert_storage), j_coordinate(Ai[i], j, invert_storage), Ax[i], number_format); fprintf(file, "\n"); } } if(invert_storage) this->switch_orientation(); fclose(file); } } }
matvar_t* GetIntegerMatVar(types::InternalType* pITIn, const char *name) { int Dims = pITIn->getAs<types::GenericType>()->getDims(); int* pDims = pITIn->getAs<types::GenericType>()->getDimsArray(); matvar_t * pMatVarOut = NULL; size_t* psize_t = (size_t*)MALLOC(Dims * sizeof(size_t)); if (psize_t == NULL) { Scierror(999, _("%s: No more memory.\n"), "GetIntegerMatVar"); return NULL; } for (int i = 0; i < Dims; i++) { psize_t[i] = (int)pDims[i]; } switch (pITIn->getType()) { case types::GenericType::ScilabInt8: { types::Int8* pInt8 = pITIn->getAs<types::Int8>(); pMatVarOut = Mat_VarCreate(name, MAT_C_INT8, MAT_T_INT8, Dims, psize_t, pInt8->get(), 0); } break; case types::GenericType::ScilabUInt8: { types::UInt8* pUInt8 = pITIn->getAs<types::UInt8>(); pMatVarOut = Mat_VarCreate(name, MAT_C_UINT8, MAT_T_UINT8, Dims, psize_t, pUInt8->get(), 0); } break; case types::GenericType::ScilabInt16: { types::Int16* pInt16 = pITIn->getAs<types::Int16>(); pMatVarOut = Mat_VarCreate(name, MAT_C_INT16, MAT_T_INT16, Dims, psize_t, pInt16->get(), 0); } break; case types::GenericType::ScilabUInt16: { types::UInt16* pUInt16 = pITIn->getAs<types::UInt16>(); pMatVarOut = Mat_VarCreate(name, MAT_C_UINT16, MAT_T_UINT16, Dims, psize_t, pUInt16->get(), 0); } break; case types::GenericType::ScilabInt32: { types::Int32* pInt32 = pITIn->getAs<types::Int32>(); pMatVarOut = Mat_VarCreate(name, MAT_C_INT32, MAT_T_INT32, Dims, psize_t, pInt32->get(), 0); } break; case types::GenericType::ScilabUInt32: { types::UInt32* pUInt32 = pITIn->getAs<types::UInt32>(); pMatVarOut = Mat_VarCreate(name, MAT_C_UINT32, MAT_T_UINT32, Dims, psize_t, pUInt32->get(), 0); } break; #ifdef __SCILAB_INT64__ case types::GenericType::ScilabInt64: { types::Int64* pInt64 = pITIn->getAs<types::Int64>(); pMatVarOut = Mat_VarCreate(name, MAT_C_INT64, MAT_T_INT64, Dims, psize_t, pInt64->get(), 0); } break; case types::GenericType::ScilabUInt64: { types::UInt64* pUInt64 = pITIn->getAs<types::UInt64>(); pMatVarOut = Mat_VarCreate(name, MAT_C_UINT64, MAT_T_UINT64, Dims, psize_t, pUInt64->get(), 0); } break; #endif default: Scierror(999, _("%s: Wrong type for input argument #%d: Integer matrix expected.\n"), "GetIntegerMatVar", 1); FREE(psize_t); return NULL; } FREE(psize_t); return pMatVarOut; }
void CSMatrix<Scalar>::export_to_file(const char *filename, const char *var_name, MatrixExportFormat fmt, char* number_format, bool invert_storage) { switch (fmt) { case EXPORT_FORMAT_MATRIX_MARKET: { FILE* file = fopen(filename, "w"); if (!file) throw Exceptions::IOException(Exceptions::IOException::Write, filename); if (Hermes::Helpers::TypeIsReal<Scalar>::value) fprintf(file, "%%%%MatrixMarket matrix coordinate real general\n"); else fprintf(file, "%%%%MatrixMarket matrix coordinate complex general\n"); fprintf(file, "%d %d %d\n", this->size, this->size, this->nnz); if (invert_storage) this->switch_orientation(); for (unsigned int j = 0; j < this->size; j++) { for (int i = Ap[j]; i < Ap[j + 1]; i++) { Hermes::Helpers::fprint_coordinate_num(file, i_coordinate(Ai[i] + 1, j + 1, invert_storage), j_coordinate(Ai[i] + 1, j + 1, invert_storage), Ax[i], number_format); fprintf(file, "\n"); } } if (invert_storage) this->switch_orientation(); fclose(file); } break; case EXPORT_FORMAT_MATLAB_MATIO: { #ifdef WITH_MATIO mat_sparse_t sparse; sparse.nzmax = this->nnz; if (invert_storage) this->switch_orientation(); sparse.nir = this->nnz; sparse.ir = Ai; sparse.njc = this->size + 1; sparse.jc = (int *)Ap; sparse.ndata = this->nnz; size_t dims[2]; dims[0] = this->size; dims[1] = this->size; mat_t *mat = Mat_CreateVer(filename, "", MAT_FT_MAT5); matvar_t *matvar; // For complex. No allocation here. double* Ax_re = nullptr; double* Ax_im = nullptr; // For real. if (Hermes::Helpers::TypeIsReal<Scalar>::value) { sparse.data = Ax; matvar = Mat_VarCreate(var_name, MAT_C_SPARSE, MAT_T_DOUBLE, 2, dims, &sparse, MAT_F_DONT_COPY_DATA); } else { // For complex. Ax_re = malloc_with_check<CSMatrix<Scalar>, double>(this->nnz, this); Ax_im = malloc_with_check<CSMatrix<Scalar>, double>(this->nnz, this); struct mat_complex_split_t z = { Ax_re, Ax_im }; for (int i = 0; i < this->nnz; i++) { Ax_re[i] = ((std::complex<double>)(this->Ax[i])).real(); Ax_im[i] = ((std::complex<double>)(this->Ax[i])).imag(); sparse.data = &z; } matvar = Mat_VarCreate(var_name, MAT_C_SPARSE, MAT_T_DOUBLE, 2, dims, &sparse, MAT_F_DONT_COPY_DATA | MAT_F_COMPLEX); } if (matvar) { Mat_VarWrite(mat, matvar, MAT_COMPRESSION_ZLIB); Mat_VarFree(matvar); } if (invert_storage) this->switch_orientation(); free_with_check(Ax_re); free_with_check(Ax_im); Mat_Close(mat); if (!matvar) throw Exceptions::IOException(Exceptions::IOException::Write, filename); #endif } break; case EXPORT_FORMAT_PLAIN_ASCII: { FILE* file = fopen(filename, "w"); if (!file) throw Exceptions::IOException(Exceptions::IOException::Write, filename); if (invert_storage) this->switch_orientation(); for (unsigned int j = 0; j < this->size; j++) { for (int i = Ap[j]; i < Ap[j + 1]; i++) { Helpers::fprint_coordinate_num(file, i_coordinate(Ai[i], j, invert_storage), j_coordinate(Ai[i], j, invert_storage), Ax[i], number_format); fprintf(file, "\n"); } } if (invert_storage) this->switch_orientation(); fclose(file); } break; #ifdef WITH_BSON case EXPORT_FORMAT_BSON: { // Init bson bson bw; bson_init(&bw); // Matrix size. bson_append_int(&bw, "size", this->size); // Nonzeros. bson_append_int(&bw, "nnz", this->nnz); if (invert_storage) this->switch_orientation(); bson_append_start_array(&bw, "Ap"); for (unsigned int i = 0; i < this->size; i++) bson_append_int(&bw, "p", this->Ap[i]); bson_append_finish_array(&bw); bson_append_start_array(&bw, "Ai"); for (unsigned int i = 0; i < this->nnz; i++) bson_append_int(&bw, "i", this->Ai[i]); bson_append_finish_array(&bw); bson_append_start_array(&bw, "Ax"); for (unsigned int i = 0; i < this->nnz; i++) bson_append_double(&bw, "x", real(this->Ax[i])); bson_append_finish_array(&bw); if (!Hermes::Helpers::TypeIsReal<Scalar>::value) { bson_append_start_array(&bw, "Ax-imag"); for (unsigned int i = 0; i < this->nnz; i++) bson_append_double(&bw, "x-i", imag(this->Ax[i])); bson_append_finish_array(&bw); } bson_append_finish_array(&bw); if (invert_storage) this->switch_orientation(); // Done. bson_finish(&bw); // Write to disk. FILE *fpw; fpw = fopen(filename, "wb"); const char *dataw = (const char *)bson_data(&bw); fwrite(dataw, bson_size(&bw), 1, fpw); fclose(fpw); bson_destroy(&bw); } break; #endif } }
int main(int argn, char **argc){ if(argn != 3){ printf("usage: convert infile.bin outfile.mat\n"); exit(0); } else { FILE* in = fopen(argc[1], "r"); if(!in) { printf("could not open %s\n", argc[1]); exit(0); } mat_t *mat; mat = Mat_Create(argc[2],NULL); if(!mat){ printf("could not open for writing %s\n", argc[2]); exit(0); } //this is (for now) a two-stage process: //have to scan through the file, //determine what's there, allocate memory appropritately, //then fill those structures up and write *that* out. unsigned int u; unsigned int pos = 0; unsigned int rxpackets = 0; unsigned int txpackets = 0; unsigned int msgpackets = 0; bool done = false; while(!done){ fread((void*)&u,4,1,in); if(ferror(in) || feof(in)) done = true; else { if(u == 0xdecafbad){ fread((void*)&u,4,1,in); unsigned int siz = u & 0xffff; //printf("u 0x%x\n",u); rxpackets += (siz-4)/(32+4); fseek(in,siz+8, SEEK_CUR); pos += 16+siz; }else if(u == 0xc0edfad0){ fread((void*)&u,4,1,in); unsigned int siz = u & 0xffff; //printf("u 0x%x\n",u); txpackets++; fseek(in,siz+8, SEEK_CUR); pos += 16+siz; }else if(u == 0xb00a5c11){ fread((void*)&u,4,1,in); unsigned int siz = u & 0xffff; //printf("u 0x%x\n",u); msgpackets += 1; fseek(in,siz+8, SEEK_CUR); pos += 16+siz; } else { printf("magic number seems off, is 0x%x, %d bytes, %d packets\n", u,pos,rxpackets); exit(0); } if(ferror(in) || feof(in)) done = true; } } printf("total %d rxpackets, %d txpackets, %d messages\n", rxpackets, txpackets, msgpackets); fseek(in,0, SEEK_SET); //okay, allocate appropriate data structs: // time (double), analog(i8), channel (i8), // spike_time (double), spikes(i32) double* time; mat_uint32_t* mstimer; mat_int8_t* analog; mat_int8_t* channel; mat_uint32_t* spike_ts; mat_int8_t* spike_ch; mat_int8_t* spike_unit; // store timestamp (in samples), rx time (not necessarily accurate) - one per pkt // store channel # and sample // store channel & timestamp for spikes. // just ignore dropped packets for now. time = (double*)malloc(rxpackets * sizeof(double)); if(!time){ printf("could not allocate time variable."); exit(0);} mstimer = (mat_uint32_t*)malloc(rxpackets * sizeof(int) ); if(!mstimer){ printf("could not allocate mstimer variable."); exit(0);} analog = (mat_int8_t*)malloc(rxpackets * 24 ); if(!analog){ printf("could not allocate analog variable."); exit(0);} channel = (mat_int8_t*)malloc(rxpackets * 24 ); if(!channel){ printf("could not allocate channel variable."); exit(0);} spike_ts = (mat_uint32_t*)malloc(rxpackets * sizeof(int)*32); if(!spike_ts){ printf("could not allocate spike_ts variable."); exit(0);} spike_ch = (mat_int8_t*)malloc(rxpackets * 32); if(!spike_ch){ printf("could not allocate spike_ch variable."); exit(0);} spike_unit = (mat_int8_t*)malloc(rxpackets * 32); if(!spike_unit){ printf("could not allocate spike_unit variable."); exit(0);} //also need to inspect the messages, to see exactly when the channels changed. rxpackets = 0; int tp = 0; // packet position (index time, aka timestamp) int sp = 0; // spike position (index spike variables) char msgs[16][128]; //use this to save messages ; appy them when their echo appears. for(int i=0; i<16*128; i++){ msgs[0][i] = 0; //yes, you can do that in c! } int chans[4] = {0,32,64,96}; done = false; while(!done){ fread((void*)&u,4,1,in); if(ferror(in) || feof(in)) done = true; else { if(u == 0xdecafbad){ fread((void*)&u,4,1,in); unsigned int siz = u & 0xffff; int npak = (siz-4)/(4+32); //first 4 is for dropped packet count //second 4 is for 4 byte bridge milisecond counter //printf("npak %d siz %d\n",npak,siz); double rxtime = 0.0; unsigned int dropped = 0; fread((void*)&rxtime,8,1,in); //rx time in seconds. fread((void*)&dropped,4,1,in); int channels[32]; char match[32]; for(int i=0;i<npak; i++){ packet p; fread((void*)&p,sizeof(p),1,in); if(ferror(in) || feof(in)) done = true; else{ /*int headecho = ((p.flag) >> 4) & 0xf; //check to see if we can apply the command that was echoed. char m = msgs[headecho][0]; if(m >= 'A' && m <= 'A' + 15){ printf("applying %s\n", msgs[headecho]); msgs[headecho][0] = 0; }*/ time[tp] = rxtime + (double)i * 6.0 / 31250.0; mstimer[tp] = p.ms; for(int j=0; j<6; j++){ for(int k=0; k<4; k++){ char samp = p.data[j*4+k]; analog[tp*24+j*4+k] = samp; channel[tp*24+j*4+k] = chans[k]; } } decodePacket(&p, channels, match); for(int j=0; j<32; j++){ if(match[j]){ spike_ts[sp] = tp; spike_ch[sp] = channel[j]; spike_unit[sp] = match[j]; sp++; } } tp++; } } pos += 16+siz; } else if( u == 0xc0edfad0){ //ignore tx packets (for now?) fread((void*)&u,4,1,in); unsigned int siz = u & 0xffff; //printf("u 0x%x\n",u); txpackets += (siz)/32; fseek(in,siz+8, SEEK_CUR); pos += 16+siz; } else if(u == 0xb00a5c11){ fread((void*)&u,4,1,in); unsigned int siz = u & 0xffff; //printf("u 0x%x\n",u); double rxtime = 0.0; fread((void*)&rxtime,8,1,in); char buf[128]; fread((void*)buf,siz,1,in); buf[siz] = 0; //really need to wait for the echo here. //bummish. printf("message: %s\n", buf); //first char: A-P (0-15, corresponds to echo); second space char* b = buf; b+=2; if(strncmp(b, "chan", 4) == 0){ int ii = b[5] - 'A'; if(ii >= 0 && ii < 4){ b += 7; chans[ii] = atoi(b); //printf(" chan %d changed to %d\n", ii, chans[ii]); } } pos += 16+siz; } else { printf("magic number seems off, is 0x%x, %d bytes\n", u,pos); exit(0); } } } printf("finished reading in data file, now writing matlab file.\n"); matvar_t *matvar; matvar = Mat_VarCreate("time",MAT_C_DOUBLE,MAT_T_DOUBLE, 1,&tp,time,0); Mat_VarWrite( mat, matvar, 0 ); Mat_VarFree(matvar); free(time); //I wish I had more. matvar = Mat_VarCreate("mstimer",MAT_C_UINT32,MAT_T_UINT32, 1,&tp,mstimer,0); Mat_VarWrite( mat, matvar, 0 ); Mat_VarFree(matvar); free(mstimer); int m = tp * 24; matvar = Mat_VarCreate("analog",MAT_C_INT8,MAT_T_INT8, 1,&m,analog,0); Mat_VarWrite( mat, matvar, 0 ); Mat_VarFree(matvar); free(analog); matvar = Mat_VarCreate("channel",MAT_C_INT8,MAT_T_INT8, 1,&m,channel,0); Mat_VarWrite( mat, matvar, 0 ); Mat_VarFree(matvar); free(channel); matvar = Mat_VarCreate("spike_ts",MAT_C_UINT32,MAT_T_UINT32, 1,&sp,spike_ts,0); Mat_VarWrite( mat, matvar, 0 ); Mat_VarFree(matvar); free(spike_ts); matvar = Mat_VarCreate("spike_ch",MAT_C_UINT32,MAT_T_UINT32, 1,&sp,spike_ch,0); Mat_VarWrite( mat, matvar, 0 ); Mat_VarFree(matvar); free(spike_ch); matvar = Mat_VarCreate("spike_unit",MAT_C_UINT32,MAT_T_UINT32, 1,&sp,spike_unit,0); Mat_VarWrite( mat, matvar, 0 ); Mat_VarFree(matvar); free(spike_unit); Mat_Close(mat); fclose(in); } }
static void read_selected_data(mat_t *mat,matvar_t *matvar,char *index_str) { char *next_tok_pos, next_tok = 0; char *open = NULL, *close = NULL; int err, i = 0, j, done = 0; next_tok_pos = get_next_token(index_str); next_tok = *next_tok_pos; while ( !done ) { /* Check If the user is selecting a subset of the dataset */ if ( next_tok == '(' ) { int rank, *start, *stride, *edge,nmemb; open = next_tok_pos; close = strchr(open+1,')'); /* Get the next token after this selection */ next_tok_pos = get_next_token(close+1); if ( next_tok_pos != (close+1) ) { *next_tok_pos = '\0'; next_tok = *next_tok_pos; } else { done = 1; } /* Make sure that the partial I/O is the last token */ if ( !done ) { fprintf(stderr,"Partial I/O must be the last operation in " "the expression"); break; } /* Get the rank of the dataset */ rank = slab_get_rank(open,close); start = malloc(rank*sizeof(int)); stride = malloc(rank*sizeof(int)); edge = malloc(rank*sizeof(int)); for ( j = 0; j < rank; j++ ) { start[j] = 0; stride[j] = 1; edge[j] = 1; } /* Get the start,stride,edge using matlab syntax */ slab_get_select(open,close,rank,start,stride,edge); /* Check if the users selection is valid and if so read the data */ if ((nmemb = slab_select_valid(rank,start,stride,edge,matvar))) { matvar->data_size = Mat_SizeOfClass(matvar->class_type); matvar->nbytes = nmemb*matvar->data_size; if ( matvar->isComplex ) { mat_complex_split_t *z; matvar->data = malloc(sizeof(*z)); z = matvar->data; z->Re = malloc(matvar->nbytes); z->Im = malloc(matvar->nbytes); } else { matvar->data = malloc(matvar->nbytes); } if ( matvar->data == NULL ) { fprintf(stderr,"Couldn't allocate memory for the data"); err = 1; } else if ( rank == 1 ) { Mat_VarReadDataLinear(mat,matvar,matvar->data,*start, *stride,*edge); if (matvar->rank == 2 && matvar->dims[0] == 1) { matvar->dims[1] = *edge; } else if (matvar->rank == 2 && matvar->dims[1] == 1) { matvar->dims[0] = *edge; } else { matvar->rank = 2; matvar->dims[0] = *edge; matvar->dims[1] = 1; } } else { Mat_VarReadData(mat,matvar,matvar->data,start,stride,edge); for ( i = 0; i < rank; i++ ) matvar->dims[i] = (size_t)edge[i]; } } free(start); free(stride); free(edge); } else if ( next_tok == '.' ) { matvar_t *field; char *varname; if ( matvar->class_type == MAT_C_STRUCT ) { varname = next_tok_pos+1; next_tok_pos = get_next_token(next_tok_pos+1); if ( next_tok_pos != varname ) { next_tok = *next_tok_pos; *next_tok_pos = '\0'; } else { done = 1; } /* FIXME: Handle structures > 1x1 */ field = Mat_VarGetStructFieldByName(matvar, varname, 0); if ( field == NULL ) { fprintf(stderr,"field %s was not found in structure %s", varname,matvar->name); break; } field = Mat_VarDuplicate(field,1); Mat_VarFree(matvar); matvar = field; } else if ( matvar->class_type == MAT_C_CELL ) { int ncells; matvar_t *cell, **cells; ncells = matvar->nbytes / matvar->data_size; cells = matvar->data; varname = next_tok_pos+1; next_tok_pos = get_next_token(next_tok_pos+1); if ( next_tok_pos != varname ) { next_tok = *next_tok_pos; *next_tok_pos = '\0'; } else { done = 1; } for ( j = 0 ; j < ncells; j++ ) { cell = Mat_VarGetCell(matvar,j); if ( cell == NULL || cell->class_type != MAT_C_STRUCT ) { fprintf(stderr,"cell index %d is not a structure",j); break; } else { /* FIXME: Handle structures > 1x1 */ field = Mat_VarGetStructFieldByName(cell,varname,0); if ( field == NULL ) { fprintf(stderr,"field %s was not found in " "structure %s",varname,matvar->name); break; } field = Mat_VarDuplicate(field,1); Mat_VarFree(cell); cells[j] = field; } } if ( j != ncells ) break; } else { fprintf(stderr,"%s is not a structure", varname); break; } } else if ( next_tok == '{' ) { int rank, *start, *stride, *edge,nmemb, err = 0; if ( matvar->class_type != MAT_C_CELL ) { fprintf(stderr,"Only Cell Arrays can index with {}"); break; } open = next_tok_pos; close = strchr(open+1,'}'); /* Get the next token after this selection */ next_tok_pos = get_next_token(close+1); if ( *next_tok_pos != '\0' ) { next_tok = *next_tok_pos; *next_tok_pos = '\0'; } else { done = 1; } /* Get the rank of the dataset */ rank = slab_get_rank(open,close); start = malloc(rank*sizeof(int)); stride = malloc(rank*sizeof(int)); edge = malloc(rank*sizeof(int)); for ( j = 0; j < rank; j++ ) { start[j] = 0; stride[j] = 1; edge[j] = 1; } /* Get the start,stride,edge using matlab syntax */ slab_get_select(open,close,rank,start,stride,edge); /* Check if the users selection is valid and if so read the data */ if ((nmemb = slab_select_valid(rank,start,stride,edge,matvar))) { matvar_t **cells, *tmp; if ( rank == 1 ) { cells = Mat_VarGetCellsLinear(matvar,*start, *stride,*edge); if (matvar->rank == 2 && matvar->dims[0] == 1) { matvar->dims[1] = *edge; } else if (matvar->rank == 2 && matvar->dims[1] == 1) { matvar->dims[0] = *edge; } else { matvar->rank = 1; matvar->dims[0] = *edge; } } else { cells = Mat_VarGetCells(matvar,start,stride,edge); memcpy(matvar->dims,edge,matvar->rank*sizeof(int)); } if ( cells == NULL ) { fprintf(stderr,"Error getting the indexed cells"); err = 1; } else { for ( j = 0; j < nmemb; j++ ) cells[j] = Mat_VarDuplicate(cells[j],1); tmp = Mat_VarCreate(matvar->name,MAT_C_CELL, MAT_T_CELL,matvar->rank,matvar->dims,cells, MAT_F_DONT_COPY_DATA); Mat_VarFree(matvar); matvar = tmp; } } else { fprintf(stderr,"Cell selection not valid"); err = 1; } free(start); free(stride); free(edge); if ( err ) break; } } }
void SimpleVector<Scalar>::export_to_file(const char *filename, const char *var_name, MatrixExportFormat fmt, char* number_format) { if(!v) throw Exceptions::MethodNotOverridenException("Vector<Scalar>::export_to_file"); switch (fmt) { case EXPORT_FORMAT_MATRIX_MARKET: { FILE* file = fopen(filename, "w"); if(!file) throw Exceptions::IOException(Exceptions::IOException::Write, filename); if(Hermes::Helpers::TypeIsReal<Scalar>::value) fprintf(file, "%%%%Matrix<Scalar>Market matrix coordinate real\n"); else fprintf(file, "%%%%Matrix<Scalar>Market matrix coordinate complex\n"); fprintf(file, "%d 1 %d\n", this->size, this->size); for (unsigned int j = 0; j < this->size; j++) { Hermes::Helpers::fprint_coordinate_num(file, j + 1, 1, v[j], number_format); fprintf(file, "\n"); } fclose(file); } break; case EXPORT_FORMAT_MATLAB_MATIO: { #ifdef WITH_MATIO size_t dims[2]; dims[0] = this->size; dims[1] = 1; mat_t *mat = Mat_CreateVer(filename, "", MAT_FT_MAT5); matvar_t *matvar; // For complex. double* v_re = nullptr; double* v_im = nullptr; void* data; if(Hermes::Helpers::TypeIsReal<Scalar>::value) { data = v; matvar = Mat_VarCreate(var_name, MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, data, MAT_F_DONT_COPY_DATA); } else { v_re = new double[this->size]; v_im = new double[this->size]; struct mat_complex_split_t z = {v_re, v_im}; for(int i = 0; i < this->size; i++) { v_re[i] = ((std::complex<double>)(this->v[i])).real(); v_im[i] = ((std::complex<double>)(this->v[i])).imag(); data = &z; } matvar = Mat_VarCreate(var_name, MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, data, MAT_F_DONT_COPY_DATA | MAT_F_COMPLEX); } if (matvar) { Mat_VarWrite(mat, matvar, MAT_COMPRESSION_ZLIB); Mat_VarFree(matvar); } if(v_re) delete [] v_re; if(v_im) delete [] v_im; Mat_Close(mat); if(!matvar) throw Exceptions::IOException(Exceptions::IOException::Write, filename); #else throw Exceptions::Exception("MATIO not included."); #endif } break; case EXPORT_FORMAT_PLAIN_ASCII: { FILE* file = fopen(filename, "w"); if(!file) throw Exceptions::IOException(Exceptions::IOException::Write, filename); for (unsigned int i = 0; i < this->size; i++) { Hermes::Helpers::fprint_num(file, v[i], number_format); fprintf(file, "\n"); } fclose(file); } } }
void SimpleVector<Scalar>::export_to_file(const char *filename, const char *var_name, MatrixExportFormat fmt, char* number_format) { if (!v) throw Exceptions::MethodNotOverridenException("Vector<Scalar>::export_to_file"); switch (fmt) { case EXPORT_FORMAT_MATRIX_MARKET: { FILE* file = fopen(filename, "w"); if (!file) throw Exceptions::IOException(Exceptions::IOException::Write, filename); if (Hermes::Helpers::TypeIsReal<Scalar>::value) fprintf(file, "%%%%MatrixMarket matrix coordinate real general\n"); else fprintf(file, "%%%%MatrixMarket matrix coordinate complex general\n"); fprintf(file, "%d 1 %d\n", this->size, this->size); for (unsigned int j = 0; j < this->size; j++) { Hermes::Helpers::fprint_coordinate_num(file, j + 1, 1, v[j], number_format); fprintf(file, "\n"); } fclose(file); } break; case EXPORT_FORMAT_MATLAB_MATIO: { #ifdef WITH_MATIO size_t dims[2]; dims[0] = this->size; dims[1] = 1; mat_t *mat = Mat_CreateVer(filename, "", MAT_FT_MAT5); matvar_t *matvar; // For complex. double* v_re = nullptr; double* v_im = nullptr; void* data; if (Hermes::Helpers::TypeIsReal<Scalar>::value) { data = v; matvar = Mat_VarCreate(var_name, MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, data, MAT_F_DONT_COPY_DATA); } else { v_re = malloc_with_check<SimpleVector<Scalar>, double>(this->size, this); v_im = malloc_with_check<SimpleVector<Scalar>, double>(this->size, this); struct mat_complex_split_t z = { v_re, v_im }; for (int i = 0; i < this->size; i++) { v_re[i] = ((std::complex<double>)(this->v[i])).real(); v_im[i] = ((std::complex<double>)(this->v[i])).imag(); data = &z; } matvar = Mat_VarCreate(var_name, MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, data, MAT_F_DONT_COPY_DATA | MAT_F_COMPLEX); } if (matvar) { Mat_VarWrite(mat, matvar, MAT_COMPRESSION_ZLIB); Mat_VarFree(matvar); } free_with_check(v_re); free_with_check(v_im); Mat_Close(mat); if (!matvar) throw Exceptions::IOException(Exceptions::IOException::Write, filename); #else throw Exceptions::Exception("MATIO not included."); #endif } break; case EXPORT_FORMAT_PLAIN_ASCII: case EXPORT_FORMAT_MATLAB_SIMPLE: { FILE* file = fopen(filename, "w"); if (!file) throw Exceptions::IOException(Exceptions::IOException::Write, filename); for (unsigned int i = 0; i < this->size; i++) { Hermes::Helpers::fprint_num(file, v[i], number_format); fprintf(file, "\n"); } fclose(file); } break; #ifdef WITH_BSON case EXPORT_FORMAT_BSON: { // Init bson bson bw; bson_init(&bw); // Matrix size. bson_append_int(&bw, "size", this->size); bson_append_start_array(&bw, "v"); for (unsigned int i = 0; i < this->size; i++) bson_append_double(&bw, "v_i", real(this->v[i])); bson_append_finish_array(&bw); if (!Hermes::Helpers::TypeIsReal<Scalar>::value) { bson_append_start_array(&bw, "v-imag"); for (unsigned int i = 0; i < this->size; i++) bson_append_double(&bw, "v_i", imag(this->v[i])); bson_append_finish_array(&bw); } // Done. bson_finish(&bw); // Write to disk. FILE *fpw; fpw = fopen(filename, "wb"); const char *dataw = (const char *)bson_data(&bw); fwrite(dataw, bson_size(&bw), 1, fpw); fclose(fpw); bson_destroy(&bw); } #endif } }
static void mat_write_signal(const mdf_t *const mdf, const uint32_t can_channel, const uint32_t number_of_records, const uint16_t channel_type, const char *const message_name, const char *const signal_name, const double *const timeValue, const filter_t *const filter, const void *const cbData) { char *filter_signal_name_in; char *filter_message_name_in; char *filter_name_out; size_t dims[2]; mdftomat_t *const mdftomat = (mdftomat_t *)cbData; dims[0] = number_of_records; dims[1] = 2; if( ((can_channel != 0) && (channel_type == 0)) /* Vector CAN */ || ((can_channel == 0) && (channel_type == 0)) /* DIM */ ) { if(mdf->verbose_level >= 2) { uint32_t ir; printf("ch=%lu n=%lu m=%s s=%s\n", (unsigned long)can_channel, (unsigned long)number_of_records, message_name, signal_name); if(mdf->verbose_level >= 3) { for(ir=0;ir<number_of_records;ir++) { printf("%g %g\n",timeValue[ir],timeValue[ir+number_of_records]); } } } /* sanitize variable name */ filter_signal_name_in = sanitize_name(signal_name); filter_message_name_in = sanitize_name(message_name); filter_name_out = filter_apply(filter, can_channel, filter_message_name_in, filter_signal_name_in); if(mdf->verbose_level >= 2) { printf(" CNBLOCK can_ch=%lu\n" " message = %s\n" " signal_name = %s\n" " filter_input = %s\n" " filter_output= %s\n", (unsigned long)can_channel, filter_message_name_in, signal_name, filter_signal_name_in, (filter_name_out!=NULL)?filter_name_out:"<rejected by filter>" ); if(filter_name_out != NULL) { printf("+ %d %s %s %s\n", can_channel, filter_message_name_in, filter_signal_name_in, filter_name_out ); } } free(filter_signal_name_in); free(filter_message_name_in); if(filter_name_out != NULL) { matvar_t *matvar; int rv; /* write matlab variable */ matvar = Mat_VarCreate(filter_name_out, MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, (double *)timeValue, 0); rv = Mat_VarWrite(mdftomat->mat, matvar, mdftomat->compress); assert(rv == 0); Mat_VarFree(matvar); free(filter_name_out); } } }
matvar_t *GetCharVariable(int iVar, const char *name, int * parent, int item_position) { char * dataAdr = NULL; int rank = 0, i = 0, j = 0; int *dims = NULL; matvar_t *createdVar = NULL; int* piLen = NULL; char** pstData = NULL; char* pstMatData = NULL; int * piAddr = NULL; int * item_addr = NULL; int var_type; int saveDim = 0; /* Used to save old dimension before restoring it */ SciErr sciErr; if (parent==NULL) { sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &piAddr); if(sciErr.iErr) { printError(&sciErr, 0); return NULL; } sciErr = getVarType(pvApiCtx, piAddr, &var_type); if(sciErr.iErr) { printError(&sciErr, 0); return NULL; } } else { sciErr = getListItemAddress(pvApiCtx, parent, item_position, &item_addr); if(sciErr.iErr) { printError(&sciErr, 0); return NULL; } sciErr = getVarType(pvApiCtx, item_addr, &var_type); if(sciErr.iErr) { printError(&sciErr, 0); return NULL; } } if(var_type == sci_strings) /* 2-D array */ { rank = 2; if ((dims = (int*)MALLOC(sizeof(int) * rank)) == NULL) { Scierror(999, _("%s: No more memory.\n"), "GetCharVariable"); return NULL; } if (parent==NULL) { // First call to retrieve dimensions sciErr = getMatrixOfString(pvApiCtx, piAddr, &dims[0], &dims[1], NULL, NULL); if(sciErr.iErr) { printError(&sciErr, 0); return 0; } piLen = (int *)MALLOC(dims[0] * dims[1] * sizeof(int)); // Second call to retrieve length of each string sciErr = getMatrixOfString(pvApiCtx, piAddr, &dims[0], &dims[1], piLen, NULL); if(sciErr.iErr) { printError(&sciErr, 0); return 0; } pstData = (char**)MALLOC(sizeof(char*) * dims[0] * dims[1]); for(i = 0 ; i < dims[0] * dims[1] ; i++) { pstData[i] = (char*)MALLOC(sizeof(char) * (piLen[i] + 1)); //+ 1 for null termination } // Third call to retrieve data sciErr = getMatrixOfString(pvApiCtx, piAddr, &dims[0], &dims[1], piLen, pstData); if(sciErr.iErr) { printError(&sciErr, 0); return 0; } dataAdr = strdup(pstData[0]); } else { // First call to retrieve dimensions sciErr = getMatrixOfStringInList(pvApiCtx, parent, item_position, &dims[0], &dims[1], NULL, NULL); if(sciErr.iErr) { printError(&sciErr, 0); return NULL; } piLen = (int *)MALLOC(dims[0] * dims[1] * sizeof(int)); // Second call to retrieve length of each string sciErr = getMatrixOfStringInList(pvApiCtx, parent, item_position, &dims[0], &dims[1], piLen, NULL); if(sciErr.iErr) { printError(&sciErr, 0); return NULL; } pstData = (char**)MALLOC(sizeof(char*) * dims[0] * dims[1]); for(i = 0 ; i < dims[0] * dims[1] ; i++) { pstData[i] = (char*)MALLOC(sizeof(char) * (piLen[i] + 1)); //+ 1 for null termination } // Third call to retrieve data sciErr = getMatrixOfStringInList(pvApiCtx, parent, item_position, &dims[0], &dims[1], piLen, pstData); if(sciErr.iErr) { printError(&sciErr, 0); return NULL; } dataAdr = strdup(pstData[0]); } if (dims[0] == 0) /* Empty character string */ { createdVar = Mat_VarCreate(name, MAT_C_CHAR, MAT_T_UINT8, rank, dims, pstData[0], 0); } else if (dims[0]*dims[1] == 1) /* Scalar character string */ { saveDim = dims[1]; dims[1] = piLen[0]; createdVar = Mat_VarCreate(name, MAT_C_CHAR, MAT_T_UINT8, rank, dims, pstData[0], 0); dims[1] = saveDim; } else /* More than one character string -> save as a Cell */ { if (dims[0] == 1) { /* TODO: Should be saved as a cell */ Scierror(999, _("%s: Row array of strings saving is not implemented.\n"), "GetCharVariable"); freeArrayOfString(pstData, dims[0]*dims[1]); FREE(dims); FREE(dataAdr); FREE(piLen); return NULL; } else if (dims[1] == 1) { /* Check that all strings have the same length */ for (i = 0 ; i < dims[0] ; i++) { if (piLen[0] != piLen[i]) { /* TODO: Should be saved as a cell */ Scierror(999, _("%s: Column array of strings with different lengths saving is not implemented.\n"), "GetCharVariable"); freeArrayOfString(pstData, dims[0]*dims[1]); FREE(dims); FREE(dataAdr); FREE(piLen); return NULL; } } /* Reorder characters */ pstMatData = (char*)MALLOC(sizeof(char) * dims[0] * piLen[0]); for (i = 0 ; i < dims[0] ; i++) { for (j = 0 ; j < piLen[0] ; j++) { pstMatData[i+j*dims[0]] = pstData[i][j]; } } /* Save the variable */ saveDim = dims[1]; dims[1] = piLen[0]; createdVar = Mat_VarCreate(name, MAT_C_CHAR, MAT_T_UINT8, rank, dims, pstMatData, 0); dims[1] = saveDim; freeArrayOfString(pstData, dims[0]*dims[1]); /* FREE now because dimensions are changed just below */ FREE(pstMatData); FREE(dims); FREE(dataAdr); FREE(piLen); } else { /* TODO: Should be saved as a cell */ Scierror(999, _("%s: 2D array of strings saving is not implemented.\n"), "GetCharVariable"); freeArrayOfString(pstData, dims[0]*dims[1]); FREE(dims); FREE(dataAdr); FREE(piLen); return NULL; } } } else { Scierror(999, _("%s: Wrong type for first input argument: String matrix expected.\n"), "GetCharVariable"); freeArrayOfString(pstData, dims[0]*dims[1]); FREE(dims); FREE(dataAdr); FREE(piLen); return NULL; } return createdVar; }
void Job::run(){ if (Print) cout << endl << "------ new run ------ iRip==" << iRip << endl << endl; // int iTr=0,iTs=0,iVar,iV,iFRip, i,ii, trsz=ds.pr->TrSzD, tssz=ds.pr->TsSzD, valdim=ds.LabelValSelSize; double acc[trsz][tssz][FRip], mse[trsz][tssz][FRip], scc[trsz][tssz][FRip], featNum[FeatSelSize][FRip], *res,trends[valdim][trsz][FRip],actualLabel[valdim],ValidTrend[valdim]; matvar_t *varnameC; // for (iVar=0; iVar<LabelSelSize; ++iVar){ iV=LabelSelIdx[iVar]; // questa e` la variabile che vogliamo decodificare // -------------- cambio il nome del file in modo da coincidere con la variabile -------------------------------------- string resFile_=resFile,VARNAME; // cosi` lo scope e` locale in questo ciclo varnameC = Mat_VarGetCell(VARIABLEs,iV); // recupero il nome di questa variabile VARNAME=(const char*)varnameC->data; // segnalo dove sono a video if (Print) cout << endl << "------ iV=" << VARNAME << endl << endl; // resFile_+=VARNAME; resFile_+="-"; // riporto quale variabile sto esaminando nel filename resFile_+="nF_"; resFile_+=to_string(FeatSelSize); resFile_+="-"; // e quante features resFile_+="res.mat"; // aggiungo l'estensione // elimino gli spazi resFile_.erase(remove_if(resFile_.begin(), resFile_.end(), [](char x){return isspace(x);}), resFile_.end()); // -------------------------------------------------------------------------------------------------------------------- // // ---------------------------- recupero l'andamento della label sul validation set ---------------------------------- for (ii=0; ii<valdim; ++ii){ i=ds.label_valid_selection[ii]; actualLabel[ii]=labels[LabelSize[0]*iV+i]; // prendo l'i-esimo indice del del validation set della variabile iV // LabelSize[0] e` il numero totale delle istanze } // --------------------------------------------------------------------------------------------------------------------- // for (iTr=0; iTr<trsz; ++iTr){ ds.assegnoTrainingSet(iTr); for (iFRip=0; iFRip<FRip; ++iFRip){ if (Print) cout << endl << "------ iTr%=" << (double)iTr/trsz << endl << "------ iFRip%=" << (double)iFRip/FRip << endl << endl; UpdateFeatureSelection(); // cambio, se devo, la selezione delle features // // ----------------------------------------- recupero gli indici delle features --------------------------------------- for (i=0; i<FeatSelSize; ++i) // recupero gli indici delle feature che ho usato featNum[i][iFRip]=(double)(feature_sel[i]+1); // per metterla nel ws di matio // aggiungo 1.0 per come funziona l'indicizzazione su matlab // --------------------------------------------------------------------------------------------------------------------- // // per debug if (0){ cout << endl << "feat idx" << endl; for (int i=0; i<FeatSelSize; ++i) cout << " " << feature_sel[i]; cout << endl; } assegnato_svm=false; // devo riaddestrare per ogni Training Set o per ogni sottocampionamento delle features TrainingFromAssignedProblem(iV); // addestro con lo stesso Training Set ma (forse) diverse Features predictValidationSet(ValidTrend,iV); // Test sul Validation Set // ------------------------------- recupero i trends sul Validation Set ----------------------------------------- for (ii=0; ii<valdim; ++ii) trends[ii][iTr][iFRip]=ValidTrend[ii]; // -------------------------------------------------------------------------------------------------------------- // for (iTs=0; iTs<tssz; ++iTs){ ds.assegnoTestSet(iTs); predictTestSet(iV); // recupero le performance del modello res = (double *)((matvar_t *)RES[1])->data; acc[iTr][iTs][iFRip]=res[0]; mse[iTr][iTs][iFRip]=res[1]; scc[iTr][iTs][iFRip]=res[2]; } } } // -------------- salvo un file per ogni variabile | setto il workspace da salvare -------------------------------------- int WsSize=12; matvar_t *workspace[WsSize]; size_t dims_3[3], dims_2[2], dims_1[1]; dims_3[2]=trsz; dims_3[1]=tssz; dims_3[0]=FRip; dims_2[1]=FeatSelSize; dims_2[0]=FRip; dims_1[0]=1; workspace[0] = Mat_VarCreate("acc",MAT_C_DOUBLE,MAT_T_DOUBLE,3,dims_3,acc,0); workspace[1] = Mat_VarCreate("mse",MAT_C_DOUBLE,MAT_T_DOUBLE,3,dims_3,mse,0); workspace[2] = Mat_VarCreate("scc",MAT_C_DOUBLE,MAT_T_DOUBLE,3,dims_3,scc,0); workspace[3] = Mat_VarCreate("featIdx",MAT_C_DOUBLE,MAT_T_DOUBLE,2,dims_2,featNum,0); dims_2[1]=valdim; dims_2[0]=1; workspace[4] = Mat_VarCreate("actualLabel",MAT_C_DOUBLE,MAT_T_DOUBLE,2,dims_2,actualLabel,0); dims_3[2]=valdim; dims_3[1]=trsz; dims_3[0]=FRip; workspace[5] = Mat_VarCreate("trends",MAT_C_DOUBLE,MAT_T_DOUBLE,3,dims_3,trends,0); double FRip_ws[1], trsz_ws[1], tssz_ws[1], FeatSelSize_ws[1], validSz_ws[1]; FRip_ws[0]=FRip; trsz_ws[0]=trsz; tssz_ws[0]=tssz; FeatSelSize_ws[0]=FeatSelSize; validSz_ws[0]=valdim; workspace[6] = Mat_VarCreate("FeatSelectionRip",MAT_C_DOUBLE,MAT_T_DOUBLE,1,dims_1,FRip_ws,0); workspace[7] = Mat_VarCreate("NumFeatures",MAT_C_DOUBLE,MAT_T_DOUBLE,1,dims_1,FeatSelSize_ws,0); workspace[8] = Mat_VarCreate("TrSz",MAT_C_DOUBLE,MAT_T_DOUBLE,1,dims_1,trsz_ws,0); workspace[9] = Mat_VarCreate("TsSz",MAT_C_DOUBLE,MAT_T_DOUBLE,1,dims_1,tssz_ws,0); workspace[10] = Mat_VarCreate("ValidationSetSize",MAT_C_DOUBLE,MAT_T_DOUBLE,1,dims_1,validSz_ws,0); string help ="CONTENUTO DEL MATFILE:\n"; help+="{acc,mse,scc}\n"; help+="\tdimensione RxTsxTr\n"; help+="\t(accuratezza,mean squared error ed r2\n\toutput di libsvm)\n"; help+="featIdx\n"; help+="\tdimensione RxN\n"; help+="\t(indice delle features usate per addestrare\n\t il modello ad ogni ricampionamento)\n"; help+="actualLabel\n"; help+="\tdimensione 1xV\n"; help+="\t(valore della label corrispondente al validation set\n\tNB: salvo un file diverso per ogni label)\n"; help+="trends\n"; help+="\tdimensione RxTrxV\n"; help+="\t(predizione della label, ne ho una diverso per ogni modello\n\tNB: ho un modello diverso per ogni\n\t +ricampionamento delle features\n\t +ricampionamento del training set)\n"; help+="***LEGENDA***\n"; help+="\tR=FeatSelectionRip\n"; help+="\tTs=TsSz\n"; help+="\tTr=TrSz\n"; help+="\tN=NumFeatures\n"; help+="\tV=ValidationSetSize\n"; dims_2[1]=help.size(); dims_2[0]=1; workspace[11] = Mat_VarCreate("README",MAT_C_CHAR,MAT_T_UINT8,2,dims_2,(char*)help.c_str(),0); // Apro scrivo e chiudo il matfile mat_t *Out_MATFILE = Mat_CreateVer((const char*)resFile_.c_str(),NULL,MAT_FT_DEFAULT); for (int iWS=0; iWS<WsSize; ++iWS) Mat_VarWrite(Out_MATFILE, workspace[iWS], MAT_COMPRESSION_NONE); Mat_Close(Out_MATFILE); // ---------------------------------------------------------------------------------------------------------------------- } return; }
matvar_t *GetStructVariable(int iVar, const char *name, int matfile_version, char **fieldNames, int nbFields, int * parent, int item_position) { int fieldIndex = 0; int valueIndex = 0; int K = 0; int prodDims = 1; matvar_t *dimensionsVariable = NULL; matvar_t **structEntries = NULL; int * var_addr = NULL; int * list_addr = NULL; SciErr sciErr; if (parent==NULL) { sciErr = getVarAddressFromPosition(pvApiCtx, iVar, &var_addr); } else { sciErr = getListItemAddress(pvApiCtx, parent, item_position, &var_addr); } if(sciErr.iErr) { printError(&sciErr, 0); return NULL; } /* FIRST LIST ENTRY: fieldnames --> NO NEED TO BE READ */ /* SECOND LIST ENTRY: dimensions */ /* Second input argument = "data" beacause we do not need to give the format because this variable is just temp */ dimensionsVariable = GetMatlabVariable(iVar, "data", 0, var_addr, 2); /* Total number of entries */ for (K=0; K<dimensionsVariable->rank; K++) { prodDims *= ((int *)dimensionsVariable->data)[K]; } /* OTHERS LIST ENTRIES: ALL STRUCT VALUES */ if ((structEntries = (matvar_t **) MALLOC (sizeof(matvar_t*)*(prodDims*(nbFields-2)+1))) == NULL) { Scierror(999, _("%s: No more memory.\n"), "GetStructVariable"); freeArrayOfString(fieldNames, nbFields); return NULL; } for (K = 0; K < prodDims*(nbFields-2)+1; K++) { structEntries[K] = NULL; } if (prodDims == 1) /* Scalar struct array */ { for (fieldIndex = 2; fieldIndex < nbFields; fieldIndex++) { structEntries[fieldIndex - 2] = GetMatlabVariable(iVar ,fieldNames[fieldIndex], matfile_version, var_addr, fieldIndex+1); } } else { /* All the values of each field are stored in a list */ /* Read all entries */ for (fieldIndex = 2; fieldIndex < nbFields; fieldIndex++) { sciErr = getListInList(pvApiCtx, var_addr, fieldIndex+1, &list_addr); if(sciErr.iErr) { printError(&sciErr, 0); return NULL; } for (valueIndex = 0; valueIndex < prodDims; valueIndex++) { structEntries[(fieldIndex-1) + (nbFields-2)*valueIndex] = GetMatlabVariable(iVar ,fieldNames[fieldIndex], matfile_version, list_addr, valueIndex+1); } } } return Mat_VarCreate(name, MAT_C_STRUCT, MAT_T_STRUCT, dimensionsVariable->rank, dimensionsVariable->data, structEntries, 0); }
G_MODULE_EXPORT void save_as(const char *filename, int type) { FILE *fp; unsigned int i, j; double freq, k; mat_t *mat; matvar_t *matvar; int dims[2]; char tmp[20]; GdkPixbuf *pixbuf; GError *err=NULL; GdkColormap *cmap; gint width, height; gboolean ret = true; char *name; gdouble *tmp_data; name = malloc(strlen(filename) + 5); switch(type) { /* Response Codes encoded in glade file */ case GTK_RESPONSE_DELETE_EVENT: case GTK_RESPONSE_CANCEL: break; case SAVE_VSA: /* Allow saving data when only in Time Domanin */ if ((gtk_combo_box_get_active(GTK_COMBO_BOX(plot_domain)) != TIME_PLOT) && (gtk_combo_box_get_active(GTK_COMBO_BOX(plot_domain)) != XY_PLOT)) { create_blocking_popup(GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, "Invalid Plot Type", "Please make sure to set the Plot Type to \"Time Domanin\" before saving data."); return; } /* Save as Agilent VSA formatted file */ if (!strncasecmp(&filename[strlen(filename)-4], ".txt", 4)) strcpy(name, filename); else sprintf(name, "%s.txt", filename); fp = fopen(name, "w"); if (!fp) break; fprintf(fp, "InputZoom\tTRUE\n"); fprintf(fp, "InputCenter\t0\n"); fprintf(fp, "InputRange\t1\n"); fprintf(fp, "InputRefImped\t50\n"); fprintf(fp, "XStart\t0\n"); if (!strcmp(adc_scale, "M")) freq = adc_freq * 1000000; else if (!strcmp(adc_scale, "k")) freq = adc_freq * 1000; else { printf("error in writing\n"); break; } fprintf(fp, "XDelta\t%-.17f\n", 1.0/freq); fprintf(fp, "XDomain\t2\n"); fprintf(fp, "XUnit\tSec\n"); fprintf(fp, "YUnit\tV\n"); fprintf(fp, "FreqValidMax\t%e\n", freq / 2); fprintf(fp, "FreqValidMin\t-%e\n", freq / 2); fprintf(fp, "Y\n"); for (j = 0; j < num_samples; j++) { for (i = 0; i < num_active_channels ; i++) { fprintf(fp, "%g", channel_data[i][j]); if (i < (num_active_channels - 1)) fprintf(fp, "\t"); } fprintf(fp, "\n"); } fprintf(fp, "\n"); fclose(fp); break; case SAVE_MAT: /* Allow saving data when only in Time Domanin */ if (gtk_combo_box_get_active(GTK_COMBO_BOX(plot_domain)) != TIME_PLOT) { create_blocking_popup(GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, "Invalid Plot Type", "Please make sure to set the Plot Type to \"Time Domanin\" before saving data."); return; } /* Matlab file * http://na-wiki.csc.kth.se/mediawiki/index.php/MatIO */ if (!strncasecmp(&filename[strlen(filename)-4], ".mat", 4)) strcpy(name, filename); else sprintf(name, "%s.mat", filename); dims[1] = 1; dims[0] = num_samples; mat = Mat_Open(name, MAT_ACC_RDWR); if(mat) { for (i = 0; i < num_active_channels; i++) { sprintf(tmp, "in_voltage%d", i); if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(save_mat_scale))) { matvar = Mat_VarCreate(tmp, MAT_C_SINGLE, MAT_T_SINGLE, 2, dims, channel_data[i], 0); } else { tmp_data = g_new(gdouble, num_samples); if (channels[i].is_signed) k = channels[i].bits_used - 1; else k = channels[i].bits_used; for (j = 0; j < num_samples; j++) { tmp_data[j] = (gdouble)channel_data[i][j] / (pow(2.0, k)); } matvar = Mat_VarCreate(tmp, MAT_C_DOUBLE, MAT_T_DOUBLE, 2, dims, tmp_data, 0); g_free(tmp_data); } if (!matvar) printf("error creating matvar on channel %i\n", i); else { Mat_VarWrite(mat, matvar, 0); Mat_VarFree(matvar); } } Mat_Close(mat); } break; case SAVE_CSV: /* Allow saving data when only in Time Domanin */ if (gtk_combo_box_get_active(GTK_COMBO_BOX(plot_domain)) != TIME_PLOT) { create_blocking_popup(GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, "Invalid Plot Type", "Please make sure to set the Plot Type to \"Time Domanin\" before saving data."); return; } /* save comma seperated valus (csv) */ if (!strncasecmp(&filename[strlen(filename)-4], ".csv", 4)) strcpy(name, filename); else sprintf(name, "%s.csv", filename); fp = fopen(name, "w"); if (!fp) break; for (j = 0; j < num_samples; j++) { for (i = 0; i < num_active_channels ; i++) { fprintf(fp, "%g", channel_data[i][j]); if (i < (num_active_channels - 1)) fprintf(fp, ", "); } fprintf(fp, "\n"); } fprintf(fp, "\n"); fclose(fp); break; case SAVE_PNG: /* save_png */ if (!strncasecmp(&filename[strlen(filename)-4], ".png", 4)) strcpy(name, filename); else sprintf(name, "%s.png", filename); cmap = gdk_window_get_colormap( GDK_DRAWABLE(gtk_widget_get_window(capture_graph))); gdk_drawable_get_size(GDK_DRAWABLE(gtk_widget_get_window(capture_graph)), &width, &height); pixbuf = gdk_pixbuf_get_from_drawable(NULL, GDK_DRAWABLE(gtk_widget_get_window(capture_graph)), cmap, 0, 0, 0, 0, width, height); if (pixbuf) ret = gdk_pixbuf_save(pixbuf, name, "png", &err, NULL); if (!pixbuf || !ret) printf("error creating %s\n", name); break; default: printf("ret : %i\n", ret); } free(name); }