add missing functions in api, add export/import boolean sparses in HDF5
antoine ELIAS [Mon, 6 Jul 2009 14:35:00 +0000 (16:35 +0200)]
16 files changed:
scilab/modules/core/includes/api_boolean_sparse.h
scilab/modules/core/includes/api_double.h
scilab/modules/core/includes/api_list.h
scilab/modules/core/includes/api_sparse.h
scilab/modules/core/src/c/api_boolean_sparse.c
scilab/modules/core/src/c/api_double.c
scilab/modules/core/src/c/api_internal_boolean_sparse.h [new file with mode: 0644]
scilab/modules/core/src/c/api_internal_sparse.h [new file with mode: 0644]
scilab/modules/core/src/c/api_list.c
scilab/modules/core/src/c/api_sparse.c
scilab/modules/fileio/includes/h5_readDataFromFile.h
scilab/modules/fileio/includes/h5_writeDataToFile.h
scilab/modules/fileio/sci_gateway/cpp/sci_export_to_hdf5.cpp
scilab/modules/fileio/sci_gateway/cpp/sci_import_from_hdf5.cpp
scilab/modules/fileio/src/c/h5_readDataFromFile.c
scilab/modules/fileio/src/c/h5_writeDataToFile.c

index 4285816..30647b2 100644 (file)
@@ -37,10 +37,9 @@ int getBooleanSparseMatrix(int* _piAddress, int* _piRows, int* _piCols, int* _pi
  * @param[in] _iNbItem Number of item
  * @param[out] _piNbItemRow return array of number of item for each row
  * @param[out] _piColPos return array of item column position ( 1 indexed )
- * @param[out] _piAddress return pointer on new variable
  * @return if the operation successed (0) or not ( !0 )
  */
-int allocBooleanSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos, int** _piAddress);
+int allocBooleanSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos);
 
 /**
  * Create boolean sparse variable
@@ -50,10 +49,9 @@ int allocBooleanSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, in
  * @param[in] _iNbItem Number of item
  * @param[in] _piNbItemRow array of number of item for each row
  * @param[in] _piColPos array of item column position ( 1 indexed )
- * @param[out] _piAddress return pointer on new variable
  * @return if the operation successed (0) or not ( !0 )
  */
-int createBooleanSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, int** _piAddress);
+int createBooleanSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos);
 
 /**
  * Create named boolean sparse variable
index 1dfa593..d9e9e7d 100644 (file)
@@ -55,7 +55,6 @@ int getComplexZMatrixOfDouble(int* _piAddress, int* _piRows, int* _piCols, doubl
  * @param[in] _iRows Number of row
  * @param[in] _iCols Number of column
  * @param[out] _pdblReal return pointer on data
- * @param[out] _piAddress return pointer on new variable
  * @return if the operation successed (0) or not ( !0 )
  */
 int allocMatrixOfDouble(int _iVar, int _iRows, int _iCols, double** _pdblReal);
@@ -67,7 +66,6 @@ int allocMatrixOfDouble(int _iVar, int _iRows, int _iCols, double** _pdblReal);
  * @param[in] _iCols Number of column
  * @param[out] _pdblReal return pointer on real data
  * @param[out] _pdblImg return pointer on img data
- * @param[out] _piAddress return pointer on new variable
  * @return if the operation successed (0) or not ( !0 )
  */
 int allocComplexMatrixOfDouble(int _iVar, int _iRows, int _iCols, double** _pdblReal, double** _pdblImg);
@@ -78,7 +76,6 @@ int allocComplexMatrixOfDouble(int _iVar, int _iRows, int _iCols, double** _pdbl
  * @param[in] _iRows Number of row
  * @param[in] _iCols Number of column
  * @param[in] _pdblReal pointer on data
- * @param[out] _piAddress return pointer on new variable
  * @return if the operation successed (0) or not ( !0 )
  */
 int createMatrixOfDouble(int _iVar, int _iRows, int _iCols, double* _pdblReal);
@@ -90,13 +87,24 @@ int createMatrixOfDouble(int _iVar, int _iRows, int _iCols, double* _pdblReal);
  * @param[in] _iCols Number of column
  * @param[in] _pdblReal pointer on real data
  * @param[in] _pdblImg pointer on img data
- * @param[out] _piAddress return pointer on new variable
  * @return if the operation successed (0) or not ( !0 )
  */
 int createComplexMatrixOfDouble(int _iVar, int _iRows, int _iCols, double* _pdblReal, double* _pdblImg);
 
 /**
  * Get double variable data
+ * @param[in] _iVar variable number
+ * @param[in] _iRows Number of row
+ * @param[in] _iCols Number of column
+ * @param[in] _pdblReal pointer on real data
+ * @param[in] _pdblImg pointer on img data
+ * @param[in] _pdblZ pointer on Z format data ( Real1, Img1, Real2, Img2, ... )
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int createComplexZMatrixOfDouble(int _iVar, int _iRows, int _iCols, doublecomplex* _pdblData);
+
+/**
+ * Get double variable data
  * @param[in] _pstName variable name
  * @param[in] _iRows Number of row
  * @param[in] _iCols Number of column
@@ -117,6 +125,16 @@ int createNamedMatrixOfDouble(char* _pstName, int _iRows, int _iCols, double* _p
 int createNamedComplexMatrixOfDouble(char* _pstName, int _iRows, int _iCols, double* _pdblReal, double* _pdblImg);
 
 /**
+ * Get double variable data
+ * @param[in] _pstName variable name
+ * @param[in] _iRows Number of row
+ * @param[in] _iCols Number of column
+ * @param[in] _pdblZ pointer on Z format data ( Real1, Img1, Real2, Img2, ... )
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int createNamedComplexZMatrixOfDouble(char* _pstName, int _iRows, int _iCols, doublecomplex* _pdblData);
+
+/**
  * Get double named variable data
  * @param[in] _pstName variable name
  * @param[out] _piRows return number of row
index b39120b..c274ce0 100644 (file)
@@ -300,7 +300,7 @@ int allocComplexMatrixOfDoubleInList(int _iVar, int* _piParent, int _iItemPos, i
  * @param[in] _iItemPos item postion in the list
  * @param[in] _iRows Number of row
  * @param[in] _iCols Number of column
- * @param[in] _pdblReal return pointer on data
+ * @param[in] _pdblReal pointer on data
  * @return if the operation successed (0) or not ( !0 )
  */
 int createMatrixOfDoubleInList(int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, double* _pdblReal);
@@ -312,20 +312,32 @@ int createMatrixOfDoubleInList(int _iVar, int* _piParent, int _iItemPos, int _iR
  * @param[in] _iItemPos item postion in the list
  * @param[in] _iRows Number of row
  * @param[in] _iCols Number of column
- * @param[in] _pdblReal return pointer on real data
- * @param[in] _pdblImg return pointer on imaginary data
+ * @param[in] _pdblReal pointer on real data
+ * @param[in] _pdblImg pointer on imaginary data
  * @return if the operation successed (0) or not ( !0 )
  */
 int createComplexMatrixOfDoubleInList(int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, double* _pdblReal, double* _pdblImg);
 
 /**
+ * create double variable in a list
+ * @param[in] _iVar variable number
+ * @param[in] _piParent address of parent node
+ * @param[in] _iItemPos item postion in the list
+ * @param[in] _iRows Number of row
+ * @param[in] _iCols Number of column
+ * @param[in] _pdblData pointer on real data
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int createComplexZMatrixOfDoubleInList(int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, doublecomplex* _pdblData);
+
+/**
  * create double named variable in a list
  * @param[in] _pstName variable name
  * @param[in] _piParent address of parent node
  * @param[in] _iItemPos item postion in the list
  * @param[in] _iRows Number of row
  * @param[in] _iCols Number of column
- * @param[in] _pdblReal return pointer on data
+ * @param[in] _pdblReal pointer on data
  * @return if the operation successed (0) or not ( !0 )
  */
 int createMatrixOfDoubleInNamedList(char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, double* _pdblReal);
@@ -337,13 +349,25 @@ int createMatrixOfDoubleInNamedList(char* _pstName, int* _piParent, int _iItemPo
  * @param[in] _iItemPos item postion in the list
  * @param[in] _iRows Number of row
  * @param[in] _iCols Number of column
- * @param[in] _pdblReal return pointer on real data
- * @param[in] _pdblImg return pointer on imaginary data
+ * @param[in] _pdblReal pointer on real data
+ * @param[in] _pdblImg pointer on imaginary data
  * @return if the operation successed (0) or not ( !0 )
  */
 int createComplexMatrixOfDoubleInNamedList(char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, double* _pdblReal, double* _pdblImg);
 
 /**
+ * create double named variable in a list
+ * @param[in] _pstName variable name
+ * @param[in] _piParent address of parent node
+ * @param[in] _iItemPos item postion in the list
+ * @param[in] _iRows Number of row
+ * @param[in] _iCols Number of column
+ * @param[in] _pdblData pointer on real data
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int createComplexZMatrixOfDoubleInNamedList(char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, doublecomplex* _pdblData);
+
+/**
  * read double named variable in a list
  * @param[in] _pstName variable name
  * @param[in] _piParent address of parent node
@@ -418,7 +442,6 @@ int createMatrixOfStringInNamedList(char* _pstName, int* _piParent, int _iItemPo
  * @param[in] _iRows Number of row
  * @param[in] _iCols Number of column
  * @param[in] _pstStrings array of strings ( null terminated )
- * @param[out] _piAddress return pointer on new variable
  * @return if the operation successed (0) or not ( !0 )
  */
 int readMatrixOfStringInNamedList(char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piLength, char** _pstStrings);
@@ -475,6 +498,18 @@ int createMatrixOfBooleanInList(int _iVar, int* _piParent, int _iItemPos, int _i
  */
 int createMatrixOfBooleanInNamedList(char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, int* _piBool);
 
+/**
+ * Read string variable in a named list
+ * @param[in] _pstName variable name
+ * @param[in] _piParent address of parent node
+ * @param[in] _iItemPos item postion in the list
+ * @param[in] _iRows Number of row
+ * @param[in] _iCols Number of column
+ * @param[in] _piBool pointer on data
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int readMatrixOfBooleanInNamedList(char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piBool);
+
 /*************************
  * polynomials functions *
  *************************/
@@ -587,6 +622,10 @@ int createMatrixOfPolyInNamedList(char* _pstName, int* _piParent, int _iItemPos,
  */
 int createComplexMatrixOfPolyInNamedList(char* _pstName, int* _piParent, int _iItemPos, char* _pstVarName, int _iRows, int _iCols, int* _piNbCoef, double** _pdblReal, double** _pdblImg);
 
+/*********************
+ * integer functions *
+ *********************/
+
 /**
  * create integer 8 variable in a list
  * @param[in] _iVar variable number
@@ -636,6 +675,57 @@ int createMatrixOfInteger32InList(int _iVar, int* _piParent, int _iItemPos, int
 #ifdef __SCILAB_INT64__
 int createMatrixOfInteger32InList(int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, int* _piData);
 #endif
+
+/**
+ * read integer 8 variable in a list
+ * @param[in] _iVar variable number
+ * @param[in] _piParent address of parent node
+ * @param[in] _iItemPos item postion in the list
+ * @param[out] _iRows Number of row
+ * @param[OUT] _iCols Number of column
+ * @param[in] _pcData pointer on data
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int getMatrixOfInteger8InList(int _iVar, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, char* _pcData);
+
+/**
+ * read integer 16 variable in a list
+ * @param[in] _iVar variable number
+ * @param[in] _piParent address of parent node
+ * @param[in] _iItemPos item postion in the list
+ * @param[out] _iRows Number of row
+ * @param[OUT] _iCols Number of column
+ * @param[in] _psData pointer on data
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int getMatrixOfInteger16InList(int _iVar, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, short* _psData);
+
+/**
+ * read integer 32 variable in a list
+ * @param[in] _iVar variable number
+ * @param[in] _piParent address of parent node
+ * @param[in] _iItemPos item postion in the list
+ * @param[out] _iRows Number of row
+ * @param[OUT] _iCols Number of column
+ * @param[in] _piData pointer on data
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int getMatrixOfInteger32InList(int _iVar, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piData);
+
+/**
+ * read integer 64 variable in a list
+ * @param[in] _iVar variable number
+ * @param[in] _piParent address of parent node
+ * @param[in] _iItemPos item postion in the list
+ * @param[out] _iRows Number of row
+ * @param[OUT] _iCols Number of column
+ * @param[in] _pllData pointer on data
+ * @return if the operation successed (0) or not ( !0 )
+ */
+#ifdef __SCILAB_INT64__
+int getMatrixOfInteger64InList(int _iVar, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, long long* _pllData);
+#endif
+
 /**
  * Create integer 8 bis variable in named list
  * @param[in] _pstName variable name
@@ -686,5 +776,244 @@ int createMatrixOfInteger32InNamedList(char* _pstName, int* _piParent, int _iIte
 int createMatrixOfInteger64InNamedList(char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, long long* _pllData);
 #endif
 
+/**
+ * read integer 8 named variable in a list
+ * @param[in] _pstName variable name
+ * @param[in] _piParent address of parent node
+ * @param[in] _iItemPos item postion in the list
+ * @param[out] _piRows Number of row
+ * @param[out] _piCols Number of column
+ * @param[in] _pcData return data
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int readMatrixOfIntger8InNamedList(char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, char* _pcData);
+
+/**
+ * read integer 16 named variable in a list
+ * @param[in] _pstName variable name
+ * @param[in] _piParent address of parent node
+ * @param[in] _iItemPos item postion in the list
+ * @param[out] _piRows Number of row
+ * @param[out] _piCols Number of column
+ * @param[in] _psData return data
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int readMatrixOfIntger16InNamedList(char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, short* _psData);
+
+/**
+ * read integer 32 named variable in a list
+ * @param[in] _pstName variable name
+ * @param[in] _piParent address of parent node
+ * @param[in] _iItemPos item postion in the list
+ * @param[out] _piRows Number of row
+ * @param[out] _piCols Number of column
+ * @param[in] _piData return data
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int readMatrixOfIntger32InNamedList(char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piData);
+
+/**
+ * read integer 64 named variable in a list
+ * @param[in] _pstName variable name
+ * @param[in] _piParent address of parent node
+ * @param[in] _iItemPos item postion in the list
+ * @param[out] _piRows Number of row
+ * @param[out] _piCols Number of column
+ * @param[in] _pllData return data
+ * @return if the operation successed (0) or not ( !0 )
+ */
+#ifdef __SCILAB_INT64__
+int readMatrixOfIntger64InNamedList(char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, long long* _pllData);
+#endif
+
+/********************
+ * sparse functions *
+ ********************/
+
+/**
+ * Create complex sparse variable in a list
+ * @param[in] _iVar variable number
+ * @param[in] _piParent address of parent node
+ * @param[in] _iItemPos item postion in the list
+ * @param[in] _iRows Number of row
+ * @param[in] _iCols Number of column
+ * @param[in] _iNbItem Number of item
+ * @param[in] _piNbItemRow array of number of item for each row
+ * @param[in] _piColPos array of item column position ( 1 indexed )
+ * @param[in] _pdblReal pointer on real data
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int createSparseMatrixInList(int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal);
+
+/**
+ * Create complex sparse variable in a list
+ * @param[in] _iVar variable number
+ * @param[in] _piParent address of parent node
+ * @param[in] _iItemPos item postion in the list
+ * @param[in] _iRows Number of row
+ * @param[in] _iCols Number of column
+ * @param[in] _iNbItem Number of item
+ * @param[in] _piNbItemRow array of number of item for each row
+ * @param[in] _piColPos array of item column position ( 1 indexed )
+ * @param[in] _pdblReal pointer on real data
+ * @param[in] _pdblImg pointer on img data
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int createComplexSparseMatrixInList(int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg);
+
+/**
+ * Create sparse variable in a named list
+ * @param[in] _pstName variable name
+ * @param[in] _piParent address of parent node
+ * @param[in] _iItemPos item postion in the list
+ * @param[in] _iRows Number of row
+ * @param[in] _iCols Number of column
+ * @param[in] _iNbItem Number of item
+ * @param[in] _piNbItemRow array of number of item for each row
+ * @param[in] _piColPos array of item column position ( 1 indexed )
+ * @param[in] _pdblReal pointer on real data
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int createSparseMatrixInNamedList(char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal);
+
+/**
+ * Create complex sparse variable in a named list
+ * @param[in] _pstName variable name
+ * @param[in] _piParent address of parent node
+ * @param[in] _iItemPos item postion in the list
+ * @param[in] _iRows Number of row
+ * @param[in] _iCols Number of column
+ * @param[in] _iNbItem Number of item
+ * @param[in] _piNbItemRow array of number of item for each row
+ * @param[in] _piColPos array of item column position ( 1 indexed )
+ * @param[in] _pdblReal pointer on real data
+ * @param[in] _pdblImg pointer on img data
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int createComplexSparseMatrixInNamedList(char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg);
+
+/**
+ * get complex sparse variable in a list
+ * @param[in] _iVar variable number
+ * @param[in] _piParent address of parent node
+ * @param[out] _piItemPos item postion in the list
+ * @param[out] _piRows Number of row
+ * @param[out] _piCols Number of column
+ * @param[out] _piNbItem Number of item
+ * @param[out] _piNbItemRow array of number of item for each row
+ * @param[out] _piColPos array of item column position ( 1 indexed )
+ * @param[out] _pdblReal pointer on data
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int getSparseMatrixInList(int _iVar, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal);
+
+/**
+ * get complex sparse variable in a list
+ * @param[in] _iVar variable number
+ * @param[in] _piParent address of parent node
+ * @param[out] _piItemPos item postion in the list
+ * @param[out] _piRows Number of row
+ * @param[out] _piCols Number of column
+ * @param[out] _piNbItem Number of item
+ * @param[out] _piNbItemRow array of number of item for each row
+ * @param[out] _piColPos array of item column position ( 1 indexed )
+ * @param[out] _pdblReal pointer on real data
+ * @param[out] _pdblImg pointer on img data
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int getComplexSparseMatrixInList(int _iVar, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg);
+
+/**
+ * read sparse variable in a named list
+ * @param[in] _pstName variable name
+ * @param[in] _piParent address of parent node
+ * @param[in] _piItemPos item postion in the list
+ * @param[out] _piRows Number of row
+ * @param[out] _piCols Number of column
+ * @param[out] _piNbItem Number of item
+ * @param[in] _piNbItemRow array of number of item for each row
+ * @param[in] _piColPos array of item column position ( 1 indexed )
+ * @param[in] _pdblReal pointer on data
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int readSparseMatrixInNamedList(char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal);
+
+/**
+ * read complex sparse variable in a named list
+ * @param[in] _pstName variable name
+ * @param[in] _piParent address of parent node
+ * @param[in] _piItemPos item postion in the list
+ * @param[out] _piRows Number of row
+ * @param[out] _piCols Number of column
+ * @param[out] _piNbItem Number of item
+ * @param[in] _piNbItemRow array of number of item for each row
+ * @param[in] _piColPos array of item column position ( 1 indexed )
+ * @param[in] _pdblReal pointer on real data
+ * @param[in] _pdblImg pointer on img data
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int readComplexSparseMatrixInNamedList(char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg);
+
+
+/****************************
+ * boolean sparse functions *
+ ****************************/
+
+/**
+ * Create boolean variable in a list
+ * @param[in] _iVar variable number
+ * @param[in] _piParent address of parent node
+ * @param[in] _iItemPos item postion in the list
+ * @param[in] _iRows Number of row
+ * @param[in] _iCols Number of column
+ * @param[in] _iNbItem Number of item
+ * @param[in] _piNbItemRow array of number of item for each row
+ * @param[in] _piColPos array of item column position ( 1 indexed )
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int createBooleanSparseMatrixInList(int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos);
+
+/**
+ * Create boolean sparse variable in a named list
+ * @param[in] _pstName variable name
+ * @param[in] _piParent address of parent node
+ * @param[in] _iItemPos item postion in the list
+ * @param[in] _iRows Number of row
+ * @param[in] _iCols Number of column
+ * @param[in] _iNbItem Number of item
+ * @param[in] _piNbItemRow array of number of item for each row
+ * @param[in] _piColPos array of item column position ( 1 indexed )
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int createBooleanSparseMatrixInNamedList(char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos);
+
+/**
+ * get boolean sparse variable in a list
+ * @param[in] _iVar variable number
+ * @param[in] _piParent address of parent node
+ * @param[out] _piItemPos item postion in the list
+ * @param[out] _piRows Number of row
+ * @param[out] _piCols Number of column
+ * @param[out] _piNbItem Number of item
+ * @param[out] _piNbItemRow array of number of item for each row
+ * @param[out] _piColPos array of item column position ( 1 indexed )
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int getBooleanSparseMatrixInList(int _iVar, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos);
+
+/**
+ * read sparse variable in a named list
+ * @param[in] _pstName variable name
+ * @param[in] _piParent address of parent node
+ * @param[in] _piItemPos item postion in the list
+ * @param[out] _piRows Number of row
+ * @param[out] _piCols Number of column
+ * @param[out] _piNbItem Number of item
+ * @param[in] _piNbItemRow array of number of item for each row
+ * @param[in] _piColPos array of item column position ( 1 indexed )
+ * @return if the operation successed (0) or not ( !0 )
+ */
+int readBooleanSparseMatrixInNamedList(char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos);
+
 #endif /* __LIST_API__ */
 
index 126c2a0..60a4a27 100644 (file)
@@ -52,10 +52,9 @@ int getComplexSparseMatrix(int* _piAddress, int* _piRows, int* _piCols, int* _pi
  * @param[out] _piNbItemRow return array of number of item for each row
  * @param[out] _piColPos return array of item column position ( 1 indexed )
  * @param[out] _pdblReal return pointer on data
- * @param[out] _piAddress return pointer on new variable
  * @return if the operation successed (0) or not ( !0 )
  */
-int allocSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, int** _piAddress);
+int allocSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal);
 
 /**
  * alloc sparse variable data
@@ -67,10 +66,9 @@ int allocSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int** _pi
  * @param[out] _piColPos return array of item column position ( 1 indexed )
  * @param[out] _pdblReal return pointer on data
  * @param[out] _pdblImg return pointer on img data
- * @param[out] _piAddress return pointer on new variable
  * @return if the operation successed (0) or not ( !0 )
  */
-int allocComplexSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg, int** _piAddress);
+int allocComplexSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg);
 
 /**
  * Create sparse variable
@@ -81,10 +79,9 @@ int allocComplexSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, in
  * @param[in] _piNbItemRow array of number of item for each row
  * @param[in] _piColPos array of item column position ( 1 indexed )
  * @param[in] _pdblReal pointer on data
- * @param[out] _piAddress return pointer on new variable
  * @return if the operation successed (0) or not ( !0 )
  */
-int createSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, int** _piAddress);
+int createSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal);
 
 /**
  * Create sparse variable
@@ -96,10 +93,9 @@ int createSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int* _pi
  * @param[in] _piColPos array of item column position ( 1 indexed )
  * @param[in] _pdblReal pointer on real data
  * @param[out] _pdblImg pointer on img data
- * @param[out] _piAddress return pointer on new variable
  * @return if the operation successed (0) or not ( !0 )
  */
-int createComplexSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg, int** _piAddress);
+int createComplexSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg);
 
 /**
  * Create named sparse variable
@@ -110,7 +106,6 @@ int createComplexSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, i
  * @param[in] _piNbItemRow array of number of item for each row
  * @param[in] _piColPos array of item column position ( 1 indexed )
  * @param[in] _pdblReal pointer on data
- * @param[out] _piAddress return pointer on new variable
  * @return if the operation successed (0) or not ( !0 )
  */
 int createNamedSparseMatrix(char* _pstName, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal);
@@ -125,7 +120,6 @@ int createNamedSparseMatrix(char* _pstName, int _iRows, int _iCols, int _iNbItem
  * @param[in] _piColPos array of item column position ( 1 indexed )
  * @param[in] _pdblReal pointer on real data
  * @param[out] _pdblImg pointer on img data
- * @param[out] _piAddress return pointer on new variable
  * @return if the operation successed (0) or not ( !0 )
  */
 int createNamedComplexSparseMatrix(char* _pstName, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg);
@@ -139,7 +133,6 @@ int createNamedComplexSparseMatrix(char* _pstName, int _iRows, int _iCols, int _
  * @param[out] _piNbItemRow return array of number of item for each row
  * @param[out] _piColPos return array of item column position ( 1 indexed )
  * @param[out] _pdblReal pointer on data
- * @param[out] _piAddress return pointer on new variable
  * @return if the operation successed (0) or not ( !0 )
  */
 int readNamedSparseMatrix(char* _pstName, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal);
@@ -154,7 +147,6 @@ int readNamedSparseMatrix(char* _pstName, int* _piRows, int* _piCols, int* _piNb
  * @param[out] _piColPos return array of item column position ( 1 indexed )
  * @param[out] _pdblReal pointer on real data
  * @param[out] _pdblImg pointer on img data
- * @param[out] _piAddress return pointer on new variable
  * @return if the operation successed (0) or not ( !0 )
  */
 int readNamedComplexSparseMatrix(char* _pstName, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg);
index 0df4f1c..878a4e2 100644 (file)
 #include "api_common.h"
 #include "api_internal_common.h"
 #include "api_boolean_sparse.h"
+#include "api_internal_boolean_sparse.h"
 
 //#include <string.h>
 #include "CallScilab.h"
 #include "stack-c.h"
 
-//internal boolean sparse functions
-static int fillBooleanSparseMatrix(int *_piAddress, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos);
 
 int getBooleanSparseMatrix(int* _piAddress, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos)
 {
@@ -50,14 +49,15 @@ int getBooleanSparseMatrix(int* _piAddress, int* _piRows, int* _piCols, int* _pi
        return 0;
 }
 
-int allocBooleanSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos, int** _piAddress)
+int allocBooleanSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos)
 {
        int iNewPos                     = Top - Rhs + _iVar;
        int iAddr                               = *Lstk(iNewPos);
        int iPos                                = 0;
+       int* piAddr                     = NULL;
 
-       getNewVarAddressFromPosition(iNewPos, _piAddress);
-       fillBooleanSparseMatrix(*_piAddress, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos);
+       getNewVarAddressFromPosition(iNewPos, &piAddr);
+       fillBooleanSparseMatrix(piAddr, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos);
 
        iPos    = iAddr + 5;//4 for header + 1 for NbItem
        iPos += _iRows + _iNbItem;
@@ -67,7 +67,7 @@ int allocBooleanSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, in
        return 0;
 }
 
-static int fillBooleanSparseMatrix(int *_piAddress, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos)
+int fillBooleanSparseMatrix(int *_piAddress, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos)
 {
        if(_piAddress == NULL)
        {
@@ -86,13 +86,12 @@ static int fillBooleanSparseMatrix(int *_piAddress, int _iRows, int _iCols, int
        return 0;
 }
 
-int createBooleanSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, int** _piAddress)
+int createBooleanSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos)
 {
        int* piNbItemRow        = NULL;
        int* piColPos                   = NULL;
-       int* piAddr                             = NULL;
 
-       int iRet = allocBooleanSparseMatrix(_iVar, _iRows, _iCols, _iNbItem, &piNbItemRow, &piColPos, &piAddr);
+       int iRet = allocBooleanSparseMatrix(_iVar, _iRows, _iCols, _iNbItem, &piNbItemRow, &piColPos);
        if(iRet)
        {
                return 1;
index 0d50f8c..e309bc1 100644 (file)
@@ -169,6 +169,23 @@ int createComplexMatrixOfDouble(int _iVar, int _iRows, int _iCols, double* _pdbl
        return 0;
 }
 
+int createComplexZMatrixOfDouble(int _iVar, int _iRows, int _iCols, doublecomplex* _pdblData)
+{
+       int iRet                                                = 0;
+       double *pdblReal                = NULL;
+       double *pdblImg                 = NULL;
+
+
+       iRet = allocComplexMatrixOfDouble(_iVar, _iRows, _iCols, &pdblReal, &pdblImg);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       vGetPointerFromDoubleComplex(_pdblData, _iRows * _iCols, pdblReal, pdblImg);
+       return 0;
+}
+
 int createNamedMatrixOfDouble(char* _pstName, int _iRows, int _iCols, double* _pdblReal)
 {
        return createCommunNamedMatrixOfDouble(_pstName, 0, _iRows, _iCols, _pdblReal, NULL);
@@ -179,6 +196,40 @@ int createNamedComplexMatrixOfDouble(char* _pstName, int _iRows, int _iCols, dou
        return createCommunNamedMatrixOfDouble(_pstName, 1, _iRows, _iCols, _pdblReal, _pdblImg);
 }
 
+int createNamedComplexZMatrixOfDouble(char* _pstName, int _iRows, int _iCols, doublecomplex* _pdblData)
+{
+       int iVarID[nsiz];
+  int iSaveRhs                 = Rhs;
+       int iSaveTop                    = Top;
+       int iSize                                       = _iRows * _iCols;
+       int iRet                                        = 0;
+       int *piAddr                             = NULL;
+       double *pdblReal        = NULL;
+       double *pdblImg         = NULL;
+
+  C2F(str2name)(_pstName, iVarID, (int)strlen(_pstName));
+  Top = Top + Nbvars + 1;
+
+       iRet = getNewVarAddressFromPosition(Top, &piAddr);
+
+       //write matrix information
+       fillCommonMatrixOfDouble(piAddr, 1, _iRows, _iCols, &pdblReal, &pdblImg);
+
+       vGetPointerFromDoubleComplex(_pdblData, _iRows * _iCols, pdblReal, pdblImg);
+
+       //update "variable index"
+       updateLstk(Top, *Lstk(Top) + sadr(4), iSize * (2) * 2);
+
+       Rhs = 0;
+       //Add name in stack reference list
+       createNamedVariable(iVarID);
+
+       Top = iSaveTop;
+  Rhs = iSaveRhs;
+
+       return 0;
+}
+
 int createCommunNamedMatrixOfDouble(char* _pstName, int _iComplex, int _iRows, int _iCols, double* _pdblReal, double* _pdblImg)
 {
        int iVarID[nsiz];
diff --git a/scilab/modules/core/src/c/api_internal_boolean_sparse.h b/scilab/modules/core/src/c/api_internal_boolean_sparse.h
new file mode 100644 (file)
index 0000000..18c2f80
--- /dev/null
@@ -0,0 +1,23 @@
+/*
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2009 - DIGITEO - Antoine ELIAS
+ *
+ * This file must be used under the terms of the CeCILL.
+ * This source file is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution.  The terms
+ * are also available at
+ * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ * Please note that piece of code will be rewrited for the Scilab 6 family
+ * However, the API (profile of the functions in the header files) will be
+ * still available and supported in Scilab 6.
+ */
+
+#ifndef __INTERNAL_BOOLEAN_SPARSE_API__
+#define __INTERNAL_BOOLEAN_SPARSE_API__
+
+//internal functions
+//internal boolean sparse functions
+int fillBooleanSparseMatrix(int *_piAddress, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos);
+
+#endif /* __INTERNAL_BOOLEAN_SPARSE_API__ */
diff --git a/scilab/modules/core/src/c/api_internal_sparse.h b/scilab/modules/core/src/c/api_internal_sparse.h
new file mode 100644 (file)
index 0000000..1afd872
--- /dev/null
@@ -0,0 +1,23 @@
+/*
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2009 - DIGITEO - Antoine ELIAS
+ *
+ * This file must be used under the terms of the CeCILL.
+ * This source file is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution.  The terms
+ * are also available at
+ * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ */
+
+#ifndef __INTERNAL_SPARSE_API__
+#define __INTERNAL_SPARSE_API__
+
+int getCommonSparseMatrix(int* _piAddress, int _iComplex, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg);
+int allocCommonSparseMatrix(int _iVar, int _iComplex, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg);
+int fillCommonSparseMatrix(int *_piAddress, int _iComplex, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg, int* _piTotalSize);
+int createCommonSparseMatrix(int _iVar, int _iComplex, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg);
+int createCommonNamedSparseMatrix(char* _pstName, int _iComplex, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg);
+int readCommonNamedSparseMatrix(char* _pstName, int _iComplex, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg);
+
+
+#endif /* __INTERNAL_SPARSE_API__ */
index 5564d4c..81681b9 100644 (file)
 #include "api_internal_boolean.h"
 #include "api_internal_poly.h"
 #include "api_internal_int.h"
+#include "api_internal_sparse.h"
+#include "api_internal_boolean_sparse.h"
 #include "api_list.h"
 #include "api_string.h"
 #include "api_boolean.h"
 #include "api_int.h"
+#include "api_boolean_sparse.h"
 
 
 //internal functions
@@ -433,6 +436,24 @@ int createComplexMatrixOfDoubleInList(int _iVar, int* _piParent, int _iItemPos,
        return createCommonMatrixOfDoubleInList(_iVar, _piParent, _iItemPos, 1, _iRows, _iCols, _pdblReal, _pdblImg);
 }
 
+int createComplexZMatrixOfDoubleInList(int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, doublecomplex* _pdblData)
+{
+       double *pdblReal        = NULL;
+       double *pdblImg         = NULL;
+
+       int iRet = 0;
+
+       iRet = allocCommonMatrixOfDoubleInList(_iVar, _piParent, _iItemPos, 1, _iRows, _iCols, &pdblReal, &pdblImg);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       vGetPointerFromDoubleComplex(_pdblData, _iRows * _iCols, pdblReal, pdblImg);
+
+       return 0;
+}
+
 int createCommonMatrixOfDoubleInList(int _iVar, int* _piParent, int _iItemPos, int _iComplex, int _iRows, int _iCols, double* _pdblReal, double* _pdblImg)
 {
        double *pdblReal        = NULL;
@@ -467,6 +488,56 @@ int createComplexMatrixOfDoubleInNamedList(char* _pstName, int* _piParent, int _
        return createCommomMatrixOfDoubleInNamedList(_pstName, _piParent, _iItemPos, 1, _iRows, _iCols, _pdblReal, _pdblImg);
 }
 
+int createComplexZMatrixOfDoubleInNamedList(char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, doublecomplex* _pdblData)
+{
+       int iVarID[nsiz];
+  int iSaveRhs                 = Rhs;
+       int iSaveTop                    = Top;
+       int iRet                                        = 0;
+       int *piAddr                             = NULL;
+       double *pdblReal        = NULL;
+       double *pdblImg         = NULL;
+       int* piEnd                              = NULL;
+       int* piChildAddr        = NULL;
+
+  C2F(str2name)(_pstName, iVarID, (unsigned long)strlen(_pstName));
+  Top = Top + Nbvars + 1;
+
+       iRet = getNewVarAddressFromPosition(Top, &piAddr);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       iRet = fillCommonMatrixOfDoubleInList(Top, _piParent, _iItemPos, 1, _iRows, _iCols, &pdblReal, &pdblImg);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       vGetPointerFromDoubleComplex(_pdblData, _iRows * _iCols, pdblReal, pdblImg);
+
+       iRet = allocCommonItemInList(_piParent, _iItemPos, &piChildAddr);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       piEnd = piChildAddr + 4 + (_iRows * _iCols * 4);//4 -> 2*2 real + img * double
+       closeList(Top, piEnd);
+
+       if(_iItemPos == _piParent[1])
+       {
+               updateNamedListOffset(Top, _piParent, _iItemPos, piEnd);
+               createNamedVariable(iVarID);
+       }
+
+       Top = iSaveTop;
+  Rhs = iSaveRhs;
+
+       return 0;
+}
+
 int createCommomMatrixOfDoubleInNamedList(char* _pstName, int* _piParent, int _iItemPos, int _iComplex, int _iRows, int _iCols, double* _pdblReal, double* _pdblImg)
 {
        int iVarID[nsiz];
@@ -506,7 +577,7 @@ int createCommomMatrixOfDoubleInNamedList(char* _pstName, int* _piParent, int _i
                return 1;
        }
 
-       piEnd = piChildAddr + 4 + (_iRows * _iCols * 2);
+       piEnd = piChildAddr + 4 + (_iRows * _iCols * 2 * (_iComplex + 1));
        closeList(Top, piEnd);
 
        if(_iItemPos == _piParent[1])
@@ -999,6 +1070,56 @@ int createMatrixOfBooleanInNamedList(char* _pstName, int* _piParent, int _iItemP
        return 0;
 }
 
+int readMatrixOfBooleanInNamedList(char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piBool)
+{
+       int iRet                                        = 0;
+       int* piAddr                             = NULL;
+       int* piRoot                             = NULL;
+       int iNbItem                             = NULL;
+       int* piBool                             = NULL;
+
+
+       if(_piParent == NULL)
+       {
+               iRet = readNamedList(_pstName, &iNbItem, &piRoot);
+               if(iRet)
+               {
+                       return 1;
+               }
+
+               iRet = getListItemAddress(piRoot, _iItemPos, &piAddr);
+       }
+       else
+       {
+               iRet = getListItemAddress(_piParent, _iItemPos, &piAddr);
+       }
+
+       if(iRet)
+       {
+               return 1;
+       }
+
+       iRet = getMatrixOfBoolean(piAddr, _piRows, _piCols, &piBool);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       if(_piBool == NULL)
+       {
+               return 0;
+       }
+
+       if(piBool == NULL)
+       {
+               return 1;
+       }
+
+       memcpy(_piBool, piBool, *_piRows * *_piCols * sizeof(int));
+       return 0;
+}
+
+
 /*************************
  * polynomials functions *
  *************************/
@@ -1221,6 +1342,10 @@ int readCommonMatrixOfPolyInNamedList(char* _pstName, int* _piParent, int _iItem
        return 0;
 }
 
+/**********************
+ * integers functions *
+ **********************/
+
 static int fillCommonMatrixOfIntegerInList(int _iVar, int* _piParent, int _iItemPos, int _iPrecision, int _iRows, int _iCols, void** _pvData)
 {
        int iRet                                        = 0;
@@ -1334,6 +1459,41 @@ int createMatrixOfInteger32InList(int _iVar, int* _piParent, int _iItemPos, int
        return createCommomMatrixOfIntegerInList(_iVar, _piParent, _iItemPos, SCI_INT32, _iRows, _iCols, _piData);
 }
 
+static int getCommonMatrixOfIntegerInList(int _iVar, int* _piParent, int _iItemPos, int _iPrecision, int* _piRows, int* _piCols, void* _pvData)
+{
+       int iRet                        = 0;
+       int* piAddr             = NULL;
+       
+       iRet = getListItemAddress(_piParent, _iItemPos, &piAddr);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       iRet = getCommonMatrixOfInteger(piAddr, _iPrecision, _piRows, _piCols, _pvData);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       return 0;
+}
+
+int getMatrixOfInteger8InList(int _iVar, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, char* _pcData)
+{
+       return getCommonMatrixOfIntegerInList(_iVar, _piParent, _iItemPos, SCI_INT8, _piRows, _piCols, _pcData);
+}
+
+int getMatrixOfInteger16InList(int _iVar, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, short* _psData)
+{
+       return getCommonMatrixOfIntegerInList(_iVar, _piParent, _iItemPos, SCI_INT16, _piRows, _piCols, _psData);
+}
+
+int getMatrixOfInteger32InList(int _iVar, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piData)
+{
+       return getCommonMatrixOfIntegerInList(_iVar, _piParent, _iItemPos, SCI_INT32, _piRows, _piCols, _piData);
+}
+
 int createCommonMatrixOfIntegerInNamedList(char* _pstName, int* _piParent, int _iItemPos, int _iPrecision, int _iRows, int _iCols, void* _pvData)
 {
        int iVarID[nsiz];
@@ -1399,86 +1559,602 @@ int createMatrixOfInteger32InNamedList(char* _pstName, int* _piParent, int _iIte
        return createCommonMatrixOfIntegerInNamedList(_pstName, _piParent, _iItemPos, SCI_INT32, _iRows, _iCols, _piData);
 }
 
+static int readCommonMatrixOfIntgerInNamedList(char* _pstName, int* _piParent, int _iItemPos, int _iPrecision, int* _piRows, int* _piCols, void* _pvData)
+{
+       int iRet                                        = 0;
+       int iNbItem                             = 0;
+       int* piAddr                             = NULL;
+       int* piRoot                             = NULL;
+       void* pvData                    = NULL;
+
+       if(_piParent == NULL)
+       {
+               iRet = readNamedList(_pstName, &iNbItem, &piRoot);
+               if(iRet)
+               {
+                       return 1;
+               }
 
+               iRet = getListItemAddress(piRoot, _iItemPos, &piAddr);
+       }
+       else
+       {
+               iRet = getListItemAddress(_piParent, _iItemPos, &piAddr);
+       }
 
+       if(iRet)
+       {
+               return 1;
+       }
 
+       iRet = getCommonMatrixOfInteger(piAddr, _iPrecision, _piRows, _piCols, &pvData);
+       if(iRet)
+       {
+               return 1;
+       }
 
+       if(_pvData == NULL)
+       {
+               return 0;
+       }
 
+       memcpy(_pvData, pvData, _iPrecision * *_piRows * *_piCols);
+       return 0;
+}
 
-static void updateNamedListOffset(int _iVar, int *_piCurrentNode, int _iItemPos, int *_piEnd)
+int readMatrixOfIntger8InNamedList(char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, char* _pcData)
 {
-       updateCommunListOffset(_iVar, _piCurrentNode, _iItemPos, _piEnd);
+       return readCommonMatrixOfIntgerInNamedList(_pstName, _piParent, _iItemPos, SCI_INT8, _piRows, _piCols, _pcData);
 }
 
-static void updateListOffset(int _iVar, int *_piCurrentNode, int _iItemPos, int *_piEnd)
+int readMatrixOfIntger16InNamedList(char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, short* _psData)
 {
-       int iNewPos                             = Top - Rhs + _iVar;
-       updateCommunListOffset(iNewPos, _piCurrentNode, _iItemPos, _piEnd);
+       return readCommonMatrixOfIntgerInNamedList(_pstName, _piParent, _iItemPos, SCI_INT16, _piRows, _piCols, _psData);
 }
 
-//internal tool functions
-static void updateCommunListOffset(int _iVar, int *_piCurrentNode, int _iItemPos, int *_piEnd)
+int readMatrixOfIntger32InNamedList(char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piData)
 {
-       //find list depth and update list offset for last item
-       int i                                                   = 0;
-       int *piRoot                             = istk(iadr(*Lstk(_iVar)));
-       int iDepth                              = 1; //we are already in a list
-       int iMaxDepth                   = 0; //we are already in a list
-       int **piParent                  = NULL;
+       return readCommonMatrixOfIntgerInNamedList(_pstName, _piParent, _iItemPos, SCI_INT32, _piRows, _piCols, _piData);
+}
 
-       getParentList(piRoot, _piCurrentNode, &iDepth, NULL);
-       piParent = (int**)MALLOC(sizeof(int*) * iDepth);
-       iMaxDepth = iDepth;
-       iDepth = 1;
-       piParent[0] = piRoot;
-       getParentList(piRoot, _piCurrentNode, &iDepth, piParent);
-       for(i = iMaxDepth - 2 ; i >= 0 ; i--)
+/*********************
+ * sparses functions *
+ *********************/
+
+static int fillCommonSparseMatrixInList(int _iVar, int* _piParent, int _iItemPos, int _iComplex, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg, int* _piTotalSize)
+{
+       int iRet                                        = 0;
+       int iNbItem                             = 0;
+       int iTotalLen                   = 0;
+       int* piOffset                   = NULL;
+       int* piNbItemRow        = NULL;
+       int* piColPos                   = NULL;
+       int* piChildAddr        = NULL;
+       double* pdblReal        = NULL;
+       double* pdblImg         = NULL;
+
+       int iItemLen                    = 0;
+
+       //Does item can be added in the list
+       getListItemNumber(_piParent, &iNbItem);
+       if(iNbItem < _iItemPos)
        {
-               int j                                   =       0;
-               int iItem                       = piParent[i][1];
-               int *piOffset = piParent[i] + 2;
-               int *piData             = piOffset + iItem + 1 + !(iItem % 2);
+               return 1;
+       }
 
-               //for all nodes
-               for(j = 0 ; j < iItem ; j++)
-               {
-                       int* piItem = piData + ((piOffset[j] - 1) * 2);
+       iRet = allocCommonItemInList(_piParent, _iItemPos, &piChildAddr);
+       if(iRet)
+       {
+               return 1;
+       }
 
-                       if(piItem == piParent[i + 1])
-                       {
-                               int iOffset = 0;
-                               iOffset         = piOffset[j] + (int)((_piEnd - piItem + 1) / 2);
-                               piOffset[j + 1] = iOffset;
-                       }
-                       //else
-                       //{
-                       //      break;
-                       //      //if this item is not the last of the parent list
-                       //      //we don't need to continue to check the uppers levels
-                       //}
-               }
+       iRet = fillCommonSparseMatrix(piChildAddr, _iComplex, _iRows, _iCols, _iNbItem, &piNbItemRow, &piColPos, &pdblReal, &pdblImg, &iTotalLen);
+       if(iRet)
+       {
+               return 1;
        }
 
-       FREE(piParent);
-}
+       piOffset                                                = _piParent + 2;
 
-static void closeList(int _iVar, int *_piEnd)
-{
-       //Get Root address;
-       int *piRoot                             = istk(iadr(*Lstk(_iVar)));
-       int iAddr                                       = *Lstk(_iVar);
+       iItemLen                                                = 5 + _iRows + _iNbItem + !((_iRows + _iNbItem) % 2);
+       iItemLen                                                += iTotalLen * 2;
+       piOffset[_iItemPos] = piOffset[_iItemPos - 1] + ((iItemLen + 1) / 2);
 
-       int iOffsetData         =       2 + piRoot[1] + 1 + !(piRoot[1] % 2);
-       int iScale                              = (int)(_piEnd - (piRoot + iOffsetData));
-       int iDoubleSclale = (iScale + 1)/ 2;
+       memcpy(piNbItemRow, _piNbItemRow, _iRows * sizeof(int));
+       memcpy(piColPos, _piColPos, _iNbItem * sizeof(int));
 
-       updateLstk(_iVar, sadr(iadr(iAddr) + iOffsetData), iDoubleSclale);
+       memcpy(pdblReal, _pdblReal, _iNbItem * sizeof(double));
+       if(_iComplex)
+       {
+               memcpy(pdblImg, _pdblImg, _iNbItem * sizeof(double));
+       }
+
+       *_piTotalSize = iTotalLen;
+       return 0;
 }
 
-static int getParentList(int* _piStart, int* _piToFind, int* _piDepth, int** _piParent)
+int createCommonSparseMatrixInList(int _iVar, int* _piParent, int _iItemPos, int _iComplex, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg)
 {
-       if(isKindOfList(_piStart))
-       {
+       int iRet                                                = 0;
+       int* piAddr                                     = NULL;
+       int *piEnd                                      = NULL;
+       int iItemLen                            = 0;
+       int iTotalLen                           = 0;
+
+       iRet = getListItemAddress(_piParent, _iItemPos, &piAddr);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       iRet = fillCommonSparseMatrixInList(_iVar, _piParent, _iItemPos, _iComplex, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg, &iTotalLen);
+       if(iRet)
+       {
+               return 1;
+       }
+       
+       iItemLen                                                = 5 + _iRows + _iNbItem + !((_iRows + _iNbItem) % 2);
+       iItemLen                                                += iTotalLen * 2;
+       piEnd                                                           =       piAddr + iItemLen;
+       if(_iItemPos == _piParent[1])
+       {
+               updateListOffset(_iVar, _piParent, _iItemPos, piEnd);
+       }
+
+       closeList(_iVar, piEnd);
+
+       return 0;
+}
+
+int createSparseMatrixInList(int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal)
+{
+       return createCommonSparseMatrixInList(_iVar, _piParent, _iItemPos, 0, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
+}
+
+int createComplexSparseMatrixInList(int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg)
+{
+       return createCommonSparseMatrixInList(_iVar, _piParent, _iItemPos, 1, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
+}
+
+int createCommonSparseMatrixInNamedList(char* _pstName, int* _piParent, int _iItemPos, int _iComplex, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg)
+{
+       int iVarID[nsiz];
+  int iSaveRhs                 = Rhs;
+       int iSaveTop                    = Top;
+       int iItemLen                    = 0;
+       int iRet                                        = 0;
+       int *piAddr                             = NULL;
+       int* piEnd                              = NULL;
+       int* piChildAddr        = NULL;
+
+  C2F(str2name)(_pstName, iVarID, (unsigned long)strlen(_pstName));
+  Top = Top + Nbvars + 1;
+
+       iRet = getNewVarAddressFromPosition(Top, &piAddr);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       iRet = createCommonSparseMatrixInList(Top, _piParent, _iItemPos, _iComplex, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       iRet = allocCommonItemInList(_piParent, _iItemPos, &piChildAddr);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       iItemLen                                                = 5 + _iRows + _iNbItem + !((_iRows + _iNbItem) % 2);
+       iItemLen                                                += _iNbItem * (_iComplex + 1) * 2;
+       piEnd                                                           =       piChildAddr + iItemLen;
+       closeList(Top, piEnd);
+
+       if(_iItemPos == _piParent[1])
+       {
+               updateNamedListOffset(Top, _piParent, _iItemPos, piEnd);
+               createNamedVariable(iVarID);
+       }
+
+       Top = iSaveTop;
+  Rhs = iSaveRhs;
+
+       return 0;
+}
+
+int createSparseMatrixInNamedList(char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal)
+{
+       return createCommonSparseMatrixInNamedList(_pstName, _piParent, _iItemPos, 0, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
+}
+
+int createComplexSparseMatrixInNamedList(char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg)
+{
+       return createCommonSparseMatrixInNamedList(_pstName, _piParent, _iItemPos, 1, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
+}
+
+static int getCommonSparseMatrixInList(int _iVar, int* _piParent, int _iItemPos, int _iComplex, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg)
+{
+       int iRet                        = 0;
+       int* piAddr             = NULL;
+       
+       iRet = getListItemAddress(_piParent, _iItemPos, &piAddr);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       iRet = getCommonSparseMatrix(piAddr, _iComplex, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       return 0;
+}
+
+int getSparseMatrixInList(int _iVar, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal)
+{
+       return getCommonSparseMatrixInList(_iVar, _piParent, _iItemPos, 0, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
+}
+
+int getComplexSparseMatrixInList(int _iVar, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg)
+{
+       return getCommonSparseMatrixInList(_iVar, _piParent, _iItemPos, 1, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
+}
+
+int readCommonSparseMatrixInNamedList(char* _pstName, int* _piParent, int _iItemPos, int _iComplex, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg)
+{
+       int iRet                                        = 0;
+       int iNbItem                             = 0;
+       int* piAddr                             = NULL;
+       int* piRoot                             = NULL;
+       int* piNbItemRow        = NULL;
+       int* piColPos                   = NULL;
+       double* pdblReal        = NULL;
+       double* pdblImg         = NULL;
+
+       if(_piParent == NULL)
+       {
+               iRet = readNamedList(_pstName, &iNbItem, &piRoot);
+               if(iRet)
+               {
+                       return 1;
+               }
+
+               iRet = getListItemAddress(piRoot, _iItemPos, &piAddr);
+       }
+       else
+       {
+               iRet = getListItemAddress(_piParent, _iItemPos, &piAddr);
+       }
+
+       if(iRet)
+       {
+               return 1;
+       }
+
+       iRet = getCommonSparseMatrix(piAddr, _iComplex, _piRows, _piCols, _piNbItem, &piNbItemRow, &piColPos, &pdblReal, &pdblImg);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       if(_piNbItemRow == NULL)
+       {
+               return 0;
+       }
+       memcpy(_piNbItemRow, piNbItemRow, *_piRows * sizeof(int));
+
+       if(_piColPos == NULL)
+       {
+               return 0;
+       }
+       memcpy(_piColPos, piColPos, *_piNbItem * sizeof(int));
+
+       if(_pdblReal == NULL || (_iComplex && _pdblImg == NULL))
+       {
+               return 0;
+       }
+
+       memcpy(_pdblReal, pdblReal, sizeof(double) * *_piNbItem);
+       if(_iComplex)
+       {
+               memcpy(_pdblImg, pdblImg, sizeof(double) * *_piNbItem);
+       }
+
+       return 0;
+}
+
+int readSparseMatrixInNamedList(char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal)
+{
+       return readCommonSparseMatrixInNamedList(_pstName, _piParent, _iItemPos, 0, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
+}
+
+int readComplexSparseMatrixInNamedList(char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg)
+{
+       return readCommonSparseMatrixInNamedList(_pstName, _piParent, _iItemPos, 1, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
+}
+
+/*****************************
+ * boolean sparses functions *
+ *****************************/
+static int fillBooleanSparseMatrixInList(int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos)
+{
+       int iRet                                        = 0;
+       int iNbItem                             = 0;
+       int iTotalLen                   = 0;
+       int* piOffset                   = NULL;
+       int* piNbItemRow        = NULL;
+       int* piColPos                   = NULL;
+       int* piChildAddr        = NULL;
+       double* pdblReal        = NULL;
+       double* pdblImg         = NULL;
+
+       int iItemLen                    = 0;
+
+       //Does item can be added in the list
+       getListItemNumber(_piParent, &iNbItem);
+       if(iNbItem < _iItemPos)
+       {
+               return 1;
+       }
+
+       iRet = allocCommonItemInList(_piParent, _iItemPos, &piChildAddr);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       iRet = fillBooleanSparseMatrix(piChildAddr, _iRows, _iCols, _iNbItem, &piNbItemRow, &piColPos);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       piOffset                                                = _piParent + 2;
+
+       iItemLen                                                = 5 + _iRows + _iNbItem + !((_iRows + _iNbItem) % 2);
+       piOffset[_iItemPos] = piOffset[_iItemPos - 1] + ((iItemLen + 1) / 2);
+
+       memcpy(piNbItemRow, _piNbItemRow, _iRows * sizeof(int));
+       memcpy(piColPos, _piColPos, _iNbItem * sizeof(int));
+
+       return 0;
+}
+
+int createBooleanSparseMatrixInList(int _iVar, int* _piParent, int _iItemPos, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos)
+{
+       int iRet                                                = 0;
+       int* piAddr                                     = NULL;
+       int *piEnd                                      = NULL;
+       int iItemLen                            = 0;
+       int iTotalLen                           = 0;
+
+       iRet = getListItemAddress(_piParent, _iItemPos, &piAddr);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       iRet = fillBooleanSparseMatrixInList(_iVar, _piParent, _iItemPos, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos);
+       if(iRet)
+       {
+               return 1;
+       }
+       
+       iItemLen                                                = 5 + _iRows + _iNbItem + !((_iRows + _iNbItem) % 2);
+       piEnd                                                           =       piAddr + iItemLen;
+       if(_iItemPos == _piParent[1])
+       {
+               updateListOffset(_iVar, _piParent, _iItemPos, piEnd);
+       }
+
+       closeList(_iVar, piEnd);
+
+       return 0;
+}
+
+int createBooleanSparseMatrixInNamedList(char* _pstName, int* _piParent, int _iItemPos, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos)
+{
+       int iVarID[nsiz];
+  int iSaveRhs                 = Rhs;
+       int iSaveTop                    = Top;
+       int iItemLen                    = 0;
+       int iRet                                        = 0;
+       int *piAddr                             = NULL;
+       int* piEnd                              = NULL;
+       int* piChildAddr        = NULL;
+
+  C2F(str2name)(_pstName, iVarID, (unsigned long)strlen(_pstName));
+  Top = Top + Nbvars + 1;
+
+       iRet = getNewVarAddressFromPosition(Top, &piAddr);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       iRet = createBooleanSparseMatrixInList(Top, _piParent, _iItemPos, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       iRet = allocCommonItemInList(_piParent, _iItemPos, &piChildAddr);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       iItemLen                                                = 5 + _iRows + _iNbItem + !((_iRows + _iNbItem) % 2);
+       piEnd                                                           =       piChildAddr + iItemLen;
+       closeList(Top, piEnd);
+
+       if(_iItemPos == _piParent[1])
+       {
+               updateNamedListOffset(Top, _piParent, _iItemPos, piEnd);
+               createNamedVariable(iVarID);
+       }
+
+       Top = iSaveTop;
+  Rhs = iSaveRhs;
+
+       return 0;
+}
+
+int getBooleanSparseMatrixInList(int _iVar, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos)
+{
+       int iRet                        = 0;
+       int* piAddr             = NULL;
+       
+       iRet = getListItemAddress(_piParent, _iItemPos, &piAddr);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       iRet = getBooleanSparseMatrix(piAddr, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       return 0;
+}
+
+int readBooleanSparseMatrixInNamedList(char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos)
+{
+       int iRet                                        = 0;
+       int iNbItem                             = 0;
+       int* piAddr                             = NULL;
+       int* piRoot                             = NULL;
+       int* piNbItemRow        = NULL;
+       int* piColPos                   = NULL;
+
+       if(_piParent == NULL)
+       {
+               iRet = readNamedList(_pstName, &iNbItem, &piRoot);
+               if(iRet)
+               {
+                       return 1;
+               }
+
+               iRet = getListItemAddress(piRoot, _iItemPos, &piAddr);
+       }
+       else
+       {
+               iRet = getListItemAddress(_piParent, _iItemPos, &piAddr);
+       }
+
+       if(iRet)
+       {
+               return 1;
+       }
+
+       iRet = getBooleanSparseMatrix(piAddr, _piRows, _piCols, _piNbItem, &piNbItemRow, &piColPos);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       if(_piNbItemRow == NULL)
+       {
+               return 0;
+       }
+       memcpy(_piNbItemRow, piNbItemRow, *_piRows * sizeof(int));
+
+       if(_piColPos == NULL)
+       {
+               return 0;
+       }
+       memcpy(_piColPos, piColPos, *_piNbItem * sizeof(int));
+
+       return 0;
+}
+
+
+
+/********************
+ * tools  functions *
+ ********************/
+
+static void updateNamedListOffset(int _iVar, int *_piCurrentNode, int _iItemPos, int *_piEnd)
+{
+       updateCommunListOffset(_iVar, _piCurrentNode, _iItemPos, _piEnd);
+}
+
+static void updateListOffset(int _iVar, int *_piCurrentNode, int _iItemPos, int *_piEnd)
+{
+       int iNewPos                             = Top - Rhs + _iVar;
+       updateCommunListOffset(iNewPos, _piCurrentNode, _iItemPos, _piEnd);
+}
+
+//internal tool functions
+static void updateCommunListOffset(int _iVar, int *_piCurrentNode, int _iItemPos, int *_piEnd)
+{
+       //find list depth and update list offset for last item
+       int i                                                   = 0;
+       int *piRoot                             = istk(iadr(*Lstk(_iVar)));
+       int iDepth                              = 1; //we are already in a list
+       int iMaxDepth                   = 0; //we are already in a list
+       int **piParent                  = NULL;
+
+       getParentList(piRoot, _piCurrentNode, &iDepth, NULL);
+       piParent = (int**)MALLOC(sizeof(int*) * iDepth);
+       iMaxDepth = iDepth;
+       iDepth = 1;
+       piParent[0] = piRoot;
+       getParentList(piRoot, _piCurrentNode, &iDepth, piParent);
+       for(i = iMaxDepth - 2 ; i >= 0 ; i--)
+       {
+               int j                                   =       0;
+               int iItem                       = piParent[i][1];
+               int *piOffset = piParent[i] + 2;
+               int *piData             = piOffset + iItem + 1 + !(iItem % 2);
+
+               //for all nodes
+               for(j = 0 ; j < iItem ; j++)
+               {
+                       int* piItem = piData + ((piOffset[j] - 1) * 2);
+
+                       if(piItem == piParent[i + 1])
+                       {
+                               int iOffset = 0;
+                               iOffset         = piOffset[j] + (int)((_piEnd - piItem + 1) / 2);
+                               piOffset[j + 1] = iOffset;
+                       }
+                       //else
+                       //{
+                       //      break;
+                       //      //if this item is not the last of the parent list
+                       //      //we don't need to continue to check the uppers levels
+                       //}
+               }
+       }
+
+       FREE(piParent);
+}
+
+static void closeList(int _iVar, int *_piEnd)
+{
+       //Get Root address;
+       int *piRoot                             = istk(iadr(*Lstk(_iVar)));
+       int iAddr                                       = *Lstk(_iVar);
+
+       int iOffsetData         =       2 + piRoot[1] + 1 + !(piRoot[1] % 2);
+       int iScale                              = (int)(_piEnd - (piRoot + iOffsetData));
+       int iDoubleSclale = (iScale + 1)/ 2;
+
+       updateLstk(_iVar, sadr(iadr(iAddr) + iOffsetData), iDoubleSclale);
+}
+
+static int getParentList(int* _piStart, int* _piToFind, int* _piDepth, int** _piParent)
+{
+       if(isKindOfList(_piStart))
+       {
                int iItem       = _piStart[1];
                int iIndex      = 0;
                *_piDepth += 1;
@@ -1521,4 +2197,5 @@ static int isKindOfList(int* _piNode)
        else
                return 0;
 }
+
 /*--------------------------------------------------------------------------*/
index 33df997..bf81b28 100644 (file)
@@ -15,6 +15,7 @@
 
 #include "api_common.h"
 #include "api_internal_common.h"
+#include "api_internal_sparse.h"
 #include "api_sparse.h"
 
 #include "MALLOC.h"
 #include "stack-c.h"
 
 //internal sparse functions
-static int getCommonSparseMatrix(int* _piAddress, int _iComplex, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg);
-static int allocCommonSparseMatrix(int _iVar, int _iComplex, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg, int** _piAddress);
-static int fillCommonSparseMatrix(int *_piAddress, int _iComplex, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg, int* _piTotalSize);
-static int createCommonSparseMatrix(int _iVar, int _iComplex, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg, int** _piAddress);
-static int createCommonNamedSparseMatrix(char* _pstName, int _iComplex, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg);
-static int readCommonNamedSparseMatrix(char* _pstName, int _iComplex, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg);
-
 int getSparseMatrix(int* _piAddress, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal)
 {
        return getCommonSparseMatrix(_piAddress, 0, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
@@ -39,7 +33,7 @@ int getComplexSparseMatrix(int* _piAddress, int* _piRows, int* _piCols, int* _pi
        return getCommonSparseMatrix(_piAddress, 1, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
 }
 
-static int getCommonSparseMatrix(int* _piAddress, int _iComplex, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg)
+int getCommonSparseMatrix(int* _piAddress, int _iComplex, int* _piRows, int* _piCols, int* _piNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg)
 {
        int iPos                                        = 0;
 
@@ -80,25 +74,26 @@ static int getCommonSparseMatrix(int* _piAddress, int _iComplex, int* _piRows, i
        return 0;
 }
 
-int allocSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, int** _piAddress)
+int allocSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal)
 {
-       return allocCommonSparseMatrix(_iVar, 0, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL, _piAddress);
+       return allocCommonSparseMatrix(_iVar, 0, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
 }
 
-int allocComplexSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg, int** _piAddress)
+int allocComplexSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg)
 {
-       return allocCommonSparseMatrix(_iVar, 1, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg, _piAddress);
+       return allocCommonSparseMatrix(_iVar, 1, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
 }
 
-static int allocCommonSparseMatrix(int _iVar, int _iComplex, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg, int** _piAddress)
+int allocCommonSparseMatrix(int _iVar, int _iComplex, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg)
 {
        int iNewPos                     = Top - Rhs + _iVar;
        int iAddr                               = *Lstk(iNewPos);
        int     iTotalSize      = 0;
        int iOffset                     = 0;
+       int* piAddr                     = NULL;
 
-       getNewVarAddressFromPosition(iNewPos, _piAddress);
-       fillCommonSparseMatrix(*_piAddress, _iComplex, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg, &iTotalSize);
+       getNewVarAddressFromPosition(iNewPos, &piAddr);
+       fillCommonSparseMatrix(piAddr, _iComplex, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg, &iTotalSize);
 
        iOffset = 5;//4 for header + 1 for NbItem
        iOffset         += _iRows + _iNbItem + !((_iRows + _iNbItem) % 2);
@@ -108,7 +103,7 @@ static int allocCommonSparseMatrix(int _iVar, int _iComplex, int _iRows, int _iC
        return 0;
 }
 
-static int fillCommonSparseMatrix(int *_piAddress, int _iComplex, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg, int* _piTotalSize)
+int fillCommonSparseMatrix(int *_piAddress, int _iComplex, int _iRows, int _iCols, int _iNbItem, int** _piNbItemRow, int** _piColPos, double** _pdblReal, double** _pdblImg, int* _piTotalSize)
 {
        if(_piAddress == NULL)
        {
@@ -135,25 +130,24 @@ static int fillCommonSparseMatrix(int *_piAddress, int _iComplex, int _iRows, in
        return 0;
 }
 
-int createSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, int** _piAddress)
+int createSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal)
 {
-       return createCommonSparseMatrix(_iVar, 0, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL, _piAddress);
+       return createCommonSparseMatrix(_iVar, 0, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, NULL);
 }
 
-int createComplexSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg, int** _piAddress)
+int createComplexSparseMatrix(int _iVar, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg)
 {
-       return createCommonSparseMatrix(_iVar, 1, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg, _piAddress);
+       return createCommonSparseMatrix(_iVar, 1, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
 }
 
-static int createCommonSparseMatrix(int _iVar, int _iComplex, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg, int** _piAddress)
+int createCommonSparseMatrix(int _iVar, int _iComplex, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg)
 {
        int* piNbItemRow        = NULL;
        int* piColPos                   = NULL;
-       int* piAddr                             = NULL;
        double* pdblReal        = NULL;
        double* pdblImg         = NULL;
 
-       int iRet = allocCommonSparseMatrix(_iVar, _iComplex, _iRows, _iCols, _iNbItem, &piNbItemRow, &piColPos, &pdblReal, &pdblImg, &piAddr);
+       int iRet = allocCommonSparseMatrix(_iVar, _iComplex, _iRows, _iCols, _iNbItem, &piNbItemRow, &piColPos, &pdblReal, &pdblImg);
        if(iRet)
        {
                return 1;
@@ -179,7 +173,7 @@ int createNamedComplexSparseMatrix(char* _pstName, int _iRows, int _iCols, int _
        return createCommonNamedSparseMatrix(_pstName, 1, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
 }
 
-static int createCommonNamedSparseMatrix(char* _pstName, int _iComplex, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg)
+int createCommonNamedSparseMatrix(char* _pstName, int _iComplex, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg)
 {
        int iVarID[nsiz];
   int iSaveRhs                 = Rhs;
@@ -237,7 +231,7 @@ int readNamedComplexSparseMatrix(char* _pstName, int* _piRows, int* _piCols, int
        return readCommonNamedSparseMatrix(_pstName, 1, _piRows, _piCols, _piNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
 }
 
-static int readCommonNamedSparseMatrix(char* _pstName, int _iComplex, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg)
+int readCommonNamedSparseMatrix(char* _pstName, int _iComplex, int* _piRows, int* _piCols, int* _piNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg)
 {
        int iRet                                        = 0;
        int* piAddr                             = NULL;
index 74a7b61..ac06da4 100644 (file)
@@ -29,6 +29,8 @@ int getScilabTypeFromDataSet(int _iDatasetId);
 
 int getDatasetPrecision(int _iDatasetId, int* _piPrec);
 
+int getSparseDimension(int _iDatasetId, int* _piRows, int * _piCols, int* _piNbItem);
+
 int readDoubleMatrix(int _iDatasetId, int _iRows, int _iCols, double *_pdblData);
 int readDoubleComplexMatrix(int _iDatasetId, int _iRows, int _iCols, double *_pdblReal, double *_pdblImg);
 
@@ -44,6 +46,11 @@ int readInterger16Matrix(int _iDatasetId, int _iRows, int _iCols, short* _psData
 int readInterger32Matrix(int _iDatasetId, int _iRows, int _iCols, int* _piData);
 int readInterger64Matrix(int _iDatasetId, int _iRows, int _iCols, long long* _pllData);
 
+int readSparseComplexMatrix(int _iDatasetId, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow,  int* _piColPos, double *_pdblReal, double *_pdblImg);
+int readSparseMatrix(int _iDatasetId, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double *_pdblReal);
+
+int readBooleanSparseMatrix(int _iDatasetId, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow,  int* _piColPos);
+
 int getListItemReferences(int _iDatasetId, hobj_ref_t** _piItemRef);
 
 int getListItemDataset(int _iDatasetId, void* _piItemRef, int _iItemPos, int* _piItemDataset);
index f0dca67..7945879 100644 (file)
@@ -35,6 +35,8 @@ int writeInterger64Matrix(int _iFile, char* _pstDatasetName, int _iRows, int _iC
 int writeSparseMatrix(int _iFile, char* _pstDatasetName, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal);
 int writeSparseComplexMatrix(int _iFile, char* _pstDatasetName, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double* _pdblReal, double* _pdblImg);
 
+int writeBooleanSparseMatrix(int _iFile, char* _pstDatasetName, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos);
+
 void* openList(int _iFile, char* pstDatasetName, int _iNbItem);
 int addItemInList(int _iFile, void* _pvList, int _iPos, char* _pstItemName);
 int closeList(int _iFile,  void* _pvList, char* _pstListName, int _iNbItem, int _iVarType);
index ab83b04..841879d 100644 (file)
@@ -35,7 +35,7 @@ bool export_double(int _iH5File, int *_piVar, char* _pstName);
 bool export_poly(int _iH5File, int *_piVar, char* _pstName);
 bool export_boolean(int _iH5File, int *_piVar, char* _pstName);
 bool export_sparse(int _iH5File, int *_piVar, char* _pstName);
-bool export_boolean_sparse(int *_piVar, char* _pstName);
+bool export_boolean_sparse(int _iH5File, int *_piVar, char* _pstName);
 bool export_matlab_sparse(int *_piVar, char* _pstName);
 bool export_ints(int _iH5File, int *_piVar, char* _pstName);
 bool export_handles(int *_piVar, char* _pstName);
@@ -144,7 +144,7 @@ bool export_data(int _iH5File, int* _piVar, char* _pstName)
                }
        case sci_boolean_sparse :
                {
-                       bReturn = export_boolean_sparse(_piVar, _pstName);
+                       bReturn = export_boolean_sparse(_iH5File, _piVar, _pstName);
                        break;
                }
        case sci_matlab_sparse :
@@ -355,6 +355,34 @@ bool export_boolean(int _iH5File, int *_piVar, char* _pstName)
        return true;
 }
 
+bool export_boolean_sparse(int _iH5File, int *_piVar, char* _pstName)
+{
+       int iRet                                                = 0;
+       int iRows                                               = 0;
+       int iCols                                               = 0;
+       int iNbItem                                     = 0;
+       int* piNbCoef                           = NULL;
+       int* piNbItemRow                = NULL;
+       int* piColPos                           = NULL;
+
+       iRet = getBooleanSparseMatrix(_piVar, &iRows, &iCols, &iNbItem, &piNbItemRow, &piColPos);
+       if(iRet)
+       {
+               return false;
+       }
+
+       iRet = writeBooleanSparseMatrix(_iH5File, _pstName, iRows, iCols, iNbItem, piNbItemRow, piColPos);
+       if(iRet)
+       {
+               return false;
+       }
+
+       char pstMsg[512];
+       sprintf(pstMsg, "boolean sparse (%d x %d)", iRows, iCols);
+       print_type(pstMsg);
+       return true;
+}
+
 bool export_sparse(int _iH5File, int *_piVar, char* _pstName)
 {
        int iRet                                                = 0;
index 2472f7e..99a587b 100644 (file)
@@ -40,6 +40,8 @@ bool import_double(int _iDatasetId, int _iItemPos, int* _piAddress, char* _pstVa
 bool import_string(int _iDatasetId, int _iItemPos, int* _piAddress, char* _pstVarname);
 bool import_boolean(int _iDatasetId, int _iItemPos, int* _piAddress, char* _pstVarname);
 bool import_integer(int _iDatasetId, int _iItemPos, int* _piAddress, char* _pstVarname);
+bool import_sparse(int _iDatasetId, int _iItemPos, int* _piAddress, char* _pstVarname);
+bool import_boolean_sparse(int _iDatasetId, int _iItemPos, int* _piAddress, char* _pstVarname);
 bool import_poly(int _iDatasetId, int _iItemPos, int* _piAddress, char* _pstVarname);
 bool import_list(int _iDatasetId, int _iVarType, int _iItemPos, int* _piAddress, char* _pstVarname);
 
@@ -168,6 +170,16 @@ bool import_data(int _iDatasetId, int _iItemPos, int* _piAddress, char* _pstVarn
                        bRet = import_integer(_iDatasetId, _iItemPos, _piAddress, _pstVarname);
                        break;
                }
+       case sci_sparse :
+               {
+                       bRet = import_sparse(_iDatasetId, _iItemPos, _piAddress, _pstVarname);
+                       break;
+               }
+       case sci_boolean_sparse :
+               {
+                       bRet = import_boolean_sparse(_iDatasetId, _iItemPos, _piAddress, _pstVarname);
+                       break;
+               }
        default : 
                {
                        char pstMsg[512];
@@ -550,6 +562,143 @@ bool import_poly(int _iDatasetId, int _iItemPos, int* _piAddress, char* _pstVarn
        return true;
 }
 
+bool import_sparse(int _iDatasetId, int _iItemPos, int* _piAddress, char* _pstVarname)
+{
+       int iRet                                                = 0;
+       int i                                                           = 0;
+       int     iRows                                           = 0;
+       int iCols                                               = 0;
+       int iComplex                            = 0;
+       double *pdblReal                = NULL;
+       double *pdblImg                 = NULL;
+       int iNbItem                                     = 0;
+       int* piNbItemRow                = NULL;
+       int* piColPos                           = NULL;
+
+       iRet                                                            = getSparseDimension(_iDatasetId, &iRows, &iCols, &iNbItem);
+       if(iRet)
+       {
+               return false;
+       }
+
+       iComplex                                                = isComplexData(_iDatasetId);
+
+
+       if(iComplex)
+       {
+               piNbItemRow                             = (int*)malloc(iRows * sizeof(int));
+               piColPos                                        = (int*)malloc(iNbItem * sizeof(int));
+               pdblReal                                        = (double*)malloc(iNbItem * sizeof(double));
+               pdblImg                                         = (double*)malloc(iNbItem * sizeof(double));
+               iRet                                                    = readSparseComplexMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
+       }
+       else
+       {
+               piNbItemRow                             = (int*)malloc(iRows * sizeof(int));
+               piColPos                                        = (int*)malloc(iNbItem * sizeof(int));
+               pdblReal                                        = (double*)malloc(iNbItem * sizeof(double));
+               iRet                                                    = readSparseMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
+       }
+
+       if(iRet)
+       {
+               return false;
+       }
+
+       if(_piAddress == NULL)
+       {
+               if(iComplex)
+               {
+                       iRet                    =       createNamedComplexSparseMatrix(_pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
+               }
+               else
+               {
+                       iRet                    =       createNamedSparseMatrix(_pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
+               }
+       }
+       else //if not null this variable is in a list
+       {
+               if(iComplex)
+               {
+                       iRet                    = createComplexSparseMatrixInNamedList(_pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal, pdblImg);
+               }
+               else
+               {
+                       iRet                    = createSparseMatrixInNamedList(_pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos, pdblReal);
+               }
+       }
+
+       char pstMsg[512];
+       sprintf(pstMsg, "sparse (%d x %d)", iRows, iCols);
+       print_tree(pstMsg);
+
+       free(piNbItemRow);
+       free(piColPos);
+       free(pdblReal);
+       if(iComplex)
+       {
+               free(pdblImg);
+       }
+
+
+       if(iRet)
+       {
+               return false;
+       }
+
+       return true;
+}
+
+bool import_boolean_sparse(int _iDatasetId, int _iItemPos, int* _piAddress, char* _pstVarname)
+{
+       int iRet                                                = 0;
+       int i                                                           = 0;
+       int     iRows                                           = 0;
+       int iCols                                               = 0;
+       int iNbItem                                     = 0;
+       int* piNbItemRow                = NULL;
+       int* piColPos                           = NULL;
+
+       iRet                                                            = getSparseDimension(_iDatasetId, &iRows, &iCols, &iNbItem);
+       if(iRet)
+       {
+               return false;
+       }
+
+
+       piNbItemRow                             = (int*)malloc(iRows * sizeof(int));
+       piColPos                                        = (int*)malloc(iNbItem * sizeof(int));
+       iRet                                                    = readBooleanSparseMatrix(_iDatasetId, iRows, iCols, iNbItem, piNbItemRow, piColPos);
+       if(iRet)
+       {
+               return false;
+       }
+
+       if(_piAddress == NULL)
+       {
+               iRet                    =       createNamedBooleanSparseMatrix(_pstVarname, iRows, iCols, iNbItem, piNbItemRow, piColPos);
+       }
+       else //if not null this variable is in a list
+       {
+               iRet                    = createBooleanSparseMatrixInNamedList(_pstVarname, _piAddress, _iItemPos, iRows, iCols, iNbItem, piNbItemRow, piColPos);
+       }
+
+       char pstMsg[512];
+       sprintf(pstMsg, "boolean sparse (%d x %d)", iRows, iCols);
+       print_tree(pstMsg);
+
+       free(piNbItemRow);
+       free(piColPos);
+
+
+       if(iRet)
+       {
+               return false;
+       }
+
+       return true;
+}
+
 bool import_list(int _iDatasetId, int _iVarType, int _iItemPos, int* _piAddress, char* _pstVarname)
 {
        int iRet                                                                = 0;
index bddafb4..912c1d2 100644 (file)
@@ -131,6 +131,44 @@ static int checkAttribute(int _iDatasetId, char* _pstAttribute, char* _pstValue)
        return iRet;
 }
 
+int getSparseDimension(int _iDatasetId, int* _piRows, int * _piCols, int* _piNbItem)
+{
+       int iRet                                                        = 0;
+       int iDummy                                              = 0;
+       char *pstScilabClass    = NULL;
+
+       //get number of item in the sparse matrix
+
+       iRet = getDataSetDims(_iDatasetId, &iDummy, _piNbItem);
+       if(iRet)
+       {
+               return 1;
+       }
+
+       pstScilabClass = readAttribute(_iDatasetId, g_SCILAB_CLASS_ROWS);
+       if(pstScilabClass != NULL)
+       {
+               *_piRows = atoi(pstScilabClass);
+       }
+       
+       if(pstScilabClass)
+       {
+               free(pstScilabClass);
+       }
+
+       pstScilabClass = readAttribute(_iDatasetId, g_SCILAB_CLASS_COLS);
+       if(pstScilabClass != NULL)
+       {
+               *_piCols = atoi(pstScilabClass);
+       }
+       
+       if(pstScilabClass)
+       {
+               free(pstScilabClass);
+       }
+       return iRet;
+}
+
 static int isEmptyDataset(int _iDatasetId)
 {
        return checkAttribute(_iDatasetId, (char*)g_SCILAB_CLASS_EMPTY, "true");
@@ -244,7 +282,7 @@ int getDataSetDims(int _iDatasetId, int *_piRows, int *_piCols)
                *_piRows = (int)lDims[0];
                if (ndims == 1)
                {
-                       //check if double in this case read chid size
+                       //check if double in this case read child size
                        if(getScilabTypeFromDataSet(_iDatasetId) == sci_matrix)
                        {
                                int iItemDataset                                = 0;
@@ -257,6 +295,18 @@ int getDataSetDims(int _iDatasetId, int *_piRows, int *_piCols)
                                getDataSetDims(iItemDataset, _piRows, _piCols);
                                free(piItemRef);
                        }
+                       else if(getScilabTypeFromDataSet(_iDatasetId) == sci_sparse || getScilabTypeFromDataSet(_iDatasetId) == sci_boolean_sparse)
+                       {
+                               int iItemDataset                                = 0;
+                               hobj_ref_t* piItemRef           = NULL;
+
+                               piItemRef = (hobj_ref_t *) malloc (*_piRows * sizeof (hobj_ref_t));
+                               H5Dread (_iDatasetId, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, piItemRef);
+
+                               getListItemDataset(_iDatasetId, piItemRef, 1, &iItemDataset);
+                               getDataSetDims(iItemDataset, _piRows, _piCols);
+                               free(piItemRef);
+                       }
                        else
                        {
                                *_piCols = 1;
@@ -456,31 +506,12 @@ static int readComplexPoly(int _iDatasetId, int* _piNbCoef, double** _pdblReal,
 
 static int readPoly(int _iDatasetId, int* _piNbCoef, double** _pdblData)
 {
-       //hid_t iFileType                       = 0;
-       //hid_t iSpace                          = 0;
-       //herr_t status                         = 0;
-       //size_t iDim                                   = 0;
-       //hsize_t dims[1];
        int iRows                                                       = 0;
        int iCols                                                       = 0;
 
        //Get the datatype and its size.
        getDataSetDims(_iDatasetId, &iRows, &iCols);
 
-       //iFileType = H5Dget_type (_iDatasetId);
-       //iDim = H5Tget_size (iFileType);
-       //iDim++;                         // Make room for null terminator
-
-       ////Get dataspace and allocate memory for read buffer.  This is a
-       ////two dimensional attribute so the dynamic allocation must be done
-       ////in steps.
-
-       //iSpace = H5Dget_space (_iDatasetId);
-       //H5Sget_simple_extent_dims (iSpace, dims, NULL);
-
-       //Allocate space for string data.
-       //*_piNbCoef = (int)dims[0];
-       //*_pdblData = (double*)malloc((int)dims[0] * sizeof(double));
        *_piNbCoef = iRows * iCols;
        *_pdblData = (double*)malloc(*_piNbCoef * sizeof(double));
 
@@ -669,6 +700,109 @@ int readInterger64Matrix(int _iDatasetId, int _iRows, int _iCols, long long* _pl
        return status;
 }
 
+int readCommonSparseComplexMatrix(int _iDatasetId, int _iComplex, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow,     int* _piColPos, double *_pdblReal, double *_pdblImg)
+{
+       int     i                                                               = 0;
+       int j                                                           = 0;
+       hid_t obj                                               = 0;
+       hobj_ref_t *pRef                = (hobj_ref_t *)malloc(3 * sizeof (hobj_ref_t));
+       herr_t status;
+
+       /*
+       * Read the data.
+       */
+       status = H5Dread (_iDatasetId, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pRef);
+       if(status)
+       {
+               return 1;
+       }
+
+       //read Row data
+       obj = H5Rdereference (_iDatasetId, H5R_OBJECT, &pRef[0]);
+       status = readInterger32Matrix(obj, 1, _iRows, _piNbItemRow);
+       if(status)
+       {
+               return 1;
+       }
+
+       //read cols data
+       obj = H5Rdereference (_iDatasetId, H5R_OBJECT, &pRef[1]);
+       status = readInterger32Matrix(obj, 1, _iNbItem, _piColPos);
+       if(status)
+       {
+               return 1;
+       }
+
+       //read sparse data
+       obj = H5Rdereference (_iDatasetId, H5R_OBJECT, &pRef[2]);
+
+       if(_iComplex)
+       {
+               status = readDoubleComplexMatrix(obj, 1, _iNbItem, _pdblReal, _pdblImg);
+       }
+       else
+       {
+               status = readDoubleMatrix(obj, 1, _iNbItem, _pdblReal);
+       }
+
+       if(status)
+       {
+               return 1;
+       }
+
+       free(pRef);
+
+       return status;
+}
+
+int readSparseMatrix(int _iDatasetId, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos, double *_pdblReal)
+{
+       return readCommonSparseComplexMatrix(_iDatasetId, 0, _iRows, _iCols, _iNbItem, _piNbItemRow,    _piColPos, _pdblReal, NULL);
+}
+
+int readSparseComplexMatrix(int _iDatasetId, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow,  int* _piColPos, double *_pdblReal, double *_pdblImg)
+{
+       return readCommonSparseComplexMatrix(_iDatasetId, 1, _iRows, _iCols, _iNbItem, _piNbItemRow,    _piColPos, _pdblReal, _pdblImg);
+}
+
+int readBooleanSparseMatrix(int _iDatasetId, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow,  int* _piColPos)
+{
+       int     i                                                               = 0;
+       int j                                                           = 0;
+       hid_t obj                                               = 0;
+       hobj_ref_t *pRef                = (hobj_ref_t *)malloc(2 * sizeof (hobj_ref_t));
+       herr_t status;
+
+       /*
+       * Read the data.
+       */
+       status = H5Dread (_iDatasetId, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pRef);
+       if(status)
+       {
+               return 1;
+       }
+
+       //read Row data
+       obj = H5Rdereference (_iDatasetId, H5R_OBJECT, &pRef[0]);
+       status = readInterger32Matrix(obj, 1, _iRows, _piNbItemRow);
+       if(status)
+       {
+               return 1;
+       }
+
+       //read cols data
+       obj = H5Rdereference (_iDatasetId, H5R_OBJECT, &pRef[1]);
+       status = readInterger32Matrix(obj, 1, _iNbItem, _piColPos);
+       if(status)
+       {
+               return 1;
+       }
+
+       free(pRef);
+
+       return status;
+}
+
 int getScilabTypeFromDataSet(int _iDatasetId)
 {
        int iVarType                                    = 0;
@@ -699,6 +833,14 @@ int getScilabTypeFromDataSet(int _iDatasetId)
        {
                iVarType = sci_ints;
        }
+       else if(strcmp(pstScilabClass, g_SCILAB_CLASS_SPARSE) == 0)
+       {
+               iVarType = sci_sparse;
+       }
+       else if(strcmp(pstScilabClass, g_SCILAB_CLASS_BSPARSE) == 0)
+       {
+               iVarType = sci_boolean_sparse;
+       }
        else if(strcmp(pstScilabClass, g_SCILAB_CLASS_LIST) == 0)
        {
                iVarType = sci_list;
index db725d8..74b107e 100644 (file)
@@ -840,7 +840,7 @@ int writeCommonSparseComplexMatrix(int _iFile, char* _pstDatasetName, int _iComp
        space                                                           = H5Screate_simple(1, dims, NULL);
 
        //Create the dataset and write the array data to it.
-       iCompress                                               = enableCompression(9, 2, dims);
+       iCompress                                               = enableCompression(9, 1, dims);
        dset                                                            = H5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress);
        status                                                  = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pDataRef);
        if(status)
@@ -880,6 +880,99 @@ int writeSparseComplexMatrix(int _iFile, char* _pstDatasetName, int _iRows, int
        return writeCommonSparseComplexMatrix(_iFile, _pstDatasetName, 1, _iRows, _iCols, _iNbItem, _piNbItemRow, _piColPos, _pdblReal, _pdblImg);
 }
 
+int writeBooleanSparseMatrix(int _iFile, char* _pstDatasetName, int _iRows, int _iCols, int _iNbItem, int* _piNbItemRow, int* _piColPos)
+{
+       int iRet                                                        = 0;
+       int i                                                                   = 0;
+       int j                                                                   = 0;
+       hsize_t dims[1]                         = {2};
+       herr_t status                                   = 0;
+       hid_t   space                                           = 0;
+       hid_t   dset                                            = 0;
+       hid_t   group                                           = 0;
+       hid_t iCompress                         = 0;
+       hobj_ref_t* pDataRef    = 0; 
+       char pstRow[10]                         = {0};
+       char pstCol[10]                         = {0};
+
+
+       char* pstRowPath                        = NULL;
+       char* pstColPath                        = NULL;
+
+       char* pstGroupName              = NULL;
+
+
+       // Create ref matrix
+       //3 refs : 1 for data, 1 for Number Item by row ( row size ) and 1 for column position
+       pDataRef                                                = (hobj_ref_t *)malloc(23 * sizeof(hobj_ref_t));
+
+       // Generate groupname #<dataSetName>#
+       pstGroupName = createGroupName(_pstDatasetName);
+
+       //First create a group to store all referenced objects.
+       group                                                           = H5Gcreate(_iFile, pstGroupName, H5P_DEFAULT);
+       status                                                  = H5Gclose(group);
+
+       //Create each sub dataset and insert data
+       pstRowPath = createPathName(pstGroupName, 0);
+       status = writeInterger32Matrix(_iFile, pstRowPath, 1, _iRows, _piNbItemRow);
+       if(status)
+       {
+               return 1;
+       }
+
+       status = H5Rcreate(&pDataRef[0], _iFile, pstRowPath, H5R_OBJECT, -1);
+       if(status)
+       {
+               return 1;
+       }
+
+       pstColPath = createPathName(pstGroupName, 1);
+       status = writeInterger32Matrix(_iFile, pstColPath, 1, _iNbItem, _piColPos);
+       if(status)
+       {
+               return 1;
+       }
+
+       status = H5Rcreate(&pDataRef[1], _iFile, pstColPath, H5R_OBJECT, -1);
+       if(status)
+       {
+               return 1;
+       }
+
+
+       //free group names
+       free(pstRowPath);
+       free(pstColPath);
+
+       //Create dataspace.  Setting maximum size to NULL sets the maximum size to be the current size.
+       space                                                           = H5Screate_simple(1, dims, NULL);
+
+       //Create the dataset and write the array data to it.
+       iCompress                                               = enableCompression(9, 1, dims);
+       dset                                                            = H5Dcreate(_iFile, _pstDatasetName, H5T_STD_REF_OBJ, space, iCompress);
+       status                                                  = H5Dwrite(dset, H5T_STD_REF_OBJ, H5S_ALL, H5S_ALL, H5P_DEFAULT, pDataRef);
+       if(status)
+       {
+               return 1;
+       }
+       //Add attribute SCILAB_Class = poly to dataset
+       sprintf(pstRow, "%d", _iRows);
+       sprintf(pstCol, "%d", _iCols);
+       addAttribute(dset, g_SCILAB_CLASS                                       , g_SCILAB_CLASS_BSPARSE);
+       addAttribute(dset, g_SCILAB_CLASS_ROWS          , pstRow);
+       addAttribute(dset, g_SCILAB_CLASS_COLS          , pstCol);
+
+       //Close and release resources.
+       status                                                  = H5Dclose(dset);
+       status                                                  = H5Sclose(space);
+
+       free(pstGroupName);
+
+       return status;
+}
+
+
 //create a group and create hobj_ref_t array
 void* openList(int _iFile, char* pstDatasetName, int _iNbItem)
 {