BinaryFile.cpp

Go to the documentation of this file.
00001 /*
00002  * This program is free software; you can redistribute it and/or modify
00003  * it under the terms of the GNU General Public License as published by
00004  * the Free Software Foundation; either version 3 of the License, or
00005  * (at your option) any later version.
00006  *
00007  * Written (W) 2010 Soeren Sonnenburg
00008  * Copyright (C) 2010 Berlin Institute of Technology
00009  */
00010 
00011 #include <shogun/io/File.h>
00012 #include <shogun/features/SparseFeatures.h>
00013 #include <shogun/io/BinaryFile.h>
00014 
00015 using namespace shogun;
00016 
00017 CBinaryFile::CBinaryFile()
00018 {
00019     SG_UNSTABLE("CBinaryFile::CBinaryFile()", "\n");
00020 }
00021 
00022 CBinaryFile::CBinaryFile(FILE* f, const char* name) : CFile(f, name)
00023 {
00024 }
00025 
00026 CBinaryFile::CBinaryFile(const char* fname, char rw, const char* name) : CFile(fname, rw, name)
00027 {
00028 }
00029 
00030 CBinaryFile::~CBinaryFile()
00031 {
00032 }
00033 
00034 #define GET_VECTOR(fname, sg_type, datatype)                                        \
00035 void CBinaryFile::fname(sg_type*& vec, int32_t& len)                                \
00036 {                                                                                   \
00037     if (!file)                                                                      \
00038         SG_ERROR("File invalid.\n");                                                \
00039     TSGDataType dtype(CT_SCALAR, ST_NONE, PT_BOOL); read_header(&dtype);                        \
00040     if (dtype!=datatype)                                                            \
00041         SG_ERROR("Datatype mismatch\n");                                            \
00042                                                                                     \
00043     if (fread(&len, sizeof(int32_t), 1, file)!=1)                                   \
00044         SG_ERROR("Failed to read vector length\n");                                 \
00045     vec=SG_MALLOC(sg_type, len);                                                            \
00046     if (fread(vec, sizeof(sg_type), len, file)!=(size_t) len)                       \
00047         SG_ERROR("Failed to read Matrix\n");                                        \
00048 }
00049 
00050 GET_VECTOR(get_vector, int8_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT8))
00051 GET_VECTOR(get_vector, uint8_t, TSGDataType(CT_VECTOR, ST_NONE, PT_UINT8))
00052 GET_VECTOR(get_vector, char, TSGDataType(CT_VECTOR, ST_NONE, PT_CHAR))
00053 GET_VECTOR(get_vector, int32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT32))
00054 GET_VECTOR(get_vector, uint32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_UINT32))
00055 GET_VECTOR(get_vector, float32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOAT32))
00056 GET_VECTOR(get_vector, float64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOAT64))
00057 GET_VECTOR(get_vector, floatmax_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOATMAX))
00058 GET_VECTOR(get_vector, int16_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT16))
00059 GET_VECTOR(get_vector, uint16_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT16))
00060 GET_VECTOR(get_vector, int64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT64))
00061 GET_VECTOR(get_vector, uint64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_UINT64))
00062 #undef GET_VECTOR
00063 
00064 #define GET_MATRIX(fname, sg_type, datatype)                                        \
00065 void CBinaryFile::fname(sg_type*& matrix, int32_t& num_feat, int32_t& num_vec)      \
00066 {                                                                                   \
00067     if (!file)                                                                      \
00068         SG_ERROR("File invalid.\n");                                                \
00069     TSGDataType dtype(CT_SCALAR, ST_NONE, PT_BOOL); read_header(&dtype);                        \
00070     if (dtype!=datatype)                                                            \
00071         SG_ERROR("Datatype mismatch\n");                                            \
00072                                                                                     \
00073     if (fread(&num_feat, sizeof(int32_t), 1, file)!=1 ||                            \
00074             fread(&num_vec, sizeof(int32_t), 1, file)!=1)                           \
00075         SG_ERROR("Failed to read Matrix dimensions\n");                             \
00076     matrix=SG_MALLOC(sg_type, int64_t(num_feat)*num_vec);                                   \
00077     if (fread(matrix, sizeof(sg_type)*num_feat, num_vec, file)!=(size_t) num_vec)   \
00078         SG_ERROR("Failed to read Matrix\n");                                        \
00079 }
00080 
00081 GET_MATRIX(get_matrix, char, TSGDataType(CT_MATRIX, ST_NONE, PT_CHAR))
00082 GET_MATRIX(get_matrix, uint8_t, TSGDataType(CT_MATRIX, ST_NONE, PT_UINT8))
00083 GET_MATRIX(get_int8_matrix, int8_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT8))
00084 GET_MATRIX(get_matrix, int32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT32))
00085 GET_MATRIX(get_uint_matrix, uint32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT32))
00086 GET_MATRIX(get_long_matrix, int64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT64))
00087 GET_MATRIX(get_ulong_matrix, uint64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT64))
00088 GET_MATRIX(get_matrix, int16_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT16))
00089 GET_MATRIX(get_matrix, uint16_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT16))
00090 GET_MATRIX(get_matrix, float32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOAT32))
00091 GET_MATRIX(get_matrix, float64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOAT64))
00092 GET_MATRIX(get_longreal_matrix, floatmax_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOATMAX))
00093 #undef GET_MATRIX
00094 
00095 #define GET_NDARRAY(fname,sg_type,datatype)                                 \
00096 void CBinaryFile::fname(sg_type *& array, int32_t *& dims,int32_t & num_dims)\
00097 {                                                                           \
00098     size_t total = 1;                                                       \
00099                                                                             \
00100     if (!file)                                                              \
00101         SG_ERROR("File invalid.\n");                                        \
00102                                                                             \
00103     TSGDataType dtype(CT_SCALAR, ST_NONE, PT_BOOL);                         \
00104     read_header(&dtype);                                                    \
00105                                                                             \
00106     if (dtype!=datatype)                                                    \
00107         SG_ERROR("Datatype mismatch\n");                                    \
00108                                                                             \
00109     if (fread(&num_dims,sizeof(int32_t),1,file) != 1)                       \
00110         SG_ERROR("Failed to read number of dimensions");                    \
00111                                                                             \
00112     dims = SG_MALLOC(int32_t, num_dims);                                            \
00113     if (fread(dims,sizeof(int32_t),num_dims,file) != (size_t)num_dims)      \
00114         SG_ERROR("Failed to read sizes of dimensions!");                    \
00115                                                                             \
00116     for (int32_t i = 0;i < num_dims;i++)                                    \
00117         total *= dims[i];                                                   \
00118                                                                             \
00119     array = SG_MALLOC(sg_type, total);                                              \
00120     if (fread(array,sizeof(sg_type),total,file) != (size_t)total)           \
00121         SG_ERROR("Failed to read array data!");                             \
00122 }
00123 
00124 GET_NDARRAY(get_ndarray,uint8_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_UINT8));
00125 GET_NDARRAY(get_ndarray,char,TSGDataType(CT_NDARRAY, ST_NONE, PT_CHAR));
00126 GET_NDARRAY(get_ndarray,int32_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_INT32));
00127 GET_NDARRAY(get_ndarray,int16_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_INT16));
00128 GET_NDARRAY(get_ndarray,uint16_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_UINT16));
00129 GET_NDARRAY(get_ndarray,float32_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_FLOAT32));
00130 GET_NDARRAY(get_ndarray,float64_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_FLOAT64));
00131 #undef GET_NDARRAY
00132 
00133 #define GET_SPARSEMATRIX(fname, sg_type, datatype)                                      \
00134 void CBinaryFile::fname(SGSparseVector<sg_type>*& matrix, int32_t& num_feat, int32_t& num_vec)  \
00135 {                                                                                       \
00136     if (!(file))                                                                        \
00137         SG_ERROR("File invalid.\n");                                                    \
00138                                                                                         \
00139     TSGDataType dtype(CT_SCALAR, ST_NONE, PT_BOOL); read_header(&dtype);                            \
00140     if (dtype!=datatype)                                                                \
00141         SG_ERROR("Datatype mismatch\n");                                                \
00142                                                                                         \
00143     if (fread(&num_vec, sizeof(int32_t), 1, file)!=1)                                   \
00144         SG_ERROR("Failed to read number of vectors\n");                                 \
00145                                                                                         \
00146     matrix=SG_MALLOC(SGSparseVector<sg_type>, num_vec);                                             \
00147                                                                                         \
00148     for (int32_t i=0; i<num_vec; i++)                                                   \
00149     {                                                                                   \
00150         new (&matrix[i]) SGSparseVector<sg_type>();                                     \
00151         int32_t len=0;                                                                  \
00152         if (fread(&len, sizeof(int32_t), 1, file)!=1)                                   \
00153             SG_ERROR("Failed to read sparse vector length of vector idx=%d\n", i);      \
00154         matrix[i].num_feat_entries=len;                                                 \
00155         SGSparseVectorEntry<sg_type>* vec = SG_MALLOC(SGSparseVectorEntry<sg_type>, len);                   \
00156         if (fread(vec, sizeof(SGSparseVectorEntry<sg_type>), len, file)!= (size_t) len)     \
00157             SG_ERROR("Failed to read sparse vector %d\n", i);                           \
00158         matrix[i].features=vec;                                                         \
00159     }                                                                                   \
00160 }
00161 GET_SPARSEMATRIX(get_sparse_matrix, bool, TSGDataType(CT_MATRIX, ST_NONE, PT_BOOL))
00162 GET_SPARSEMATRIX(get_sparse_matrix, char, TSGDataType(CT_MATRIX, ST_NONE, PT_CHAR))
00163 GET_SPARSEMATRIX(get_sparse_matrix, uint8_t, TSGDataType(CT_MATRIX, ST_NONE, PT_UINT8))
00164 GET_SPARSEMATRIX(get_int8_sparsematrix, int8_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT8))
00165 GET_SPARSEMATRIX(get_sparse_matrix, int32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT32))
00166 GET_SPARSEMATRIX(get_uint_sparsematrix, uint32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT32))
00167 GET_SPARSEMATRIX(get_long_sparsematrix, int64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT64))
00168 GET_SPARSEMATRIX(get_ulong_sparsematrix, uint64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT64))
00169 GET_SPARSEMATRIX(get_sparse_matrix, int16_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT16))
00170 GET_SPARSEMATRIX(get_sparse_matrix, uint16_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT16))
00171 GET_SPARSEMATRIX(get_sparse_matrix, float32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOAT32))
00172 GET_SPARSEMATRIX(get_sparse_matrix, float64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOAT64))
00173 GET_SPARSEMATRIX(get_longreal_sparsematrix, floatmax_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOATMAX))
00174 #undef GET_SPARSEMATRIX
00175 
00176 
00177 #define GET_STRING_LIST(fname, sg_type, datatype)                                               \
00178 void CBinaryFile::fname(SGString<sg_type>*& strings, int32_t& num_str, int32_t& max_string_len) \
00179 {                                                                                               \
00180     strings=NULL;                                                                               \
00181     num_str=0;                                                                                  \
00182     max_string_len=0;                                                                           \
00183                                                                                                 \
00184     if (!file)                                                                                  \
00185         SG_ERROR("File invalid.\n");                                                            \
00186                                                                                                 \
00187     TSGDataType dtype(CT_SCALAR, ST_NONE, PT_BOOL); read_header(&dtype);                                    \
00188     if (dtype!=datatype)                                                                        \
00189         SG_ERROR("Datatype mismatch\n");                                                        \
00190                                                                                                 \
00191     if (fread(&num_str, sizeof(int32_t), 1, file)!=1)                                           \
00192         SG_ERROR("Failed to read number of strings\n");                                         \
00193                                                                                                 \
00194     strings=SG_MALLOC(SGString<sg_type>, num_str);                                                      \
00195                                                                                                 \
00196     for (int32_t i=0; i<num_str; i++)                                                           \
00197     {                                                                                           \
00198         int32_t len=0;                                                                          \
00199         if (fread(&len, sizeof(int32_t), 1, file)!=1)                                           \
00200             SG_ERROR("Failed to read string length of string with idx=%d\n", i);                \
00201         strings[i].slen=len;                                                                    \
00202         sg_type* str = SG_MALLOC(sg_type, len);                                                     \
00203         if (fread(str, sizeof(sg_type), len, file)!= (size_t) len)                              \
00204             SG_ERROR("Failed to read string %d\n", i);                                          \
00205         strings[i].string=str;                                                                  \
00206     }                                                                                           \
00207 }
00208 
00209 GET_STRING_LIST(get_string_list, char, TSGDataType(CT_VECTOR, ST_NONE, PT_CHAR))
00210 GET_STRING_LIST(get_string_list, uint8_t, TSGDataType(CT_VECTOR, ST_NONE, PT_UINT8))
00211 GET_STRING_LIST(get_int8_string_list, int8_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT8))
00212 GET_STRING_LIST(get_string_list, int32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT32))
00213 GET_STRING_LIST(get_uint_string_list, uint32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT32))
00214 GET_STRING_LIST(get_long_string_list, int64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT64))
00215 GET_STRING_LIST(get_ulong_string_list, uint64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT64))
00216 GET_STRING_LIST(get_string_list, int16_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT16))
00217 GET_STRING_LIST(get_string_list, uint16_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT16))
00218 GET_STRING_LIST(get_string_list, float32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOAT32))
00219 GET_STRING_LIST(get_string_list, float64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOAT64))
00220 GET_STRING_LIST(get_longreal_string_list, floatmax_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOATMAX))
00221 #undef GET_STRING_LIST
00222 
00225 #define SET_VECTOR(fname, sg_type, dtype)                           \
00226 void CBinaryFile::fname(const sg_type* vec, int32_t len)            \
00227 {                                                                   \
00228     if (!(file && vec))                                             \
00229         SG_ERROR("File or vector invalid.\n");                      \
00230                                                                     \
00231     TSGDataType t dtype; write_header(&t);                          \
00232                                                                     \
00233     if (fwrite(&len, sizeof(int32_t), 1, file)!=1 ||                \
00234             fwrite(vec, sizeof(sg_type), len, file)!=(size_t) len)  \
00235         SG_ERROR("Failed to write vector\n");                       \
00236 }
00237 SET_VECTOR(set_vector, int8_t, (CT_VECTOR, ST_NONE, PT_INT8))
00238 SET_VECTOR(set_vector, uint8_t, (CT_VECTOR, ST_NONE, PT_UINT8))
00239 SET_VECTOR(set_vector, char, (CT_VECTOR, ST_NONE, PT_CHAR))
00240 SET_VECTOR(set_vector, int32_t, (CT_VECTOR, ST_NONE, PT_INT32))
00241 SET_VECTOR(set_vector, uint32_t, (CT_VECTOR, ST_NONE, PT_UINT32))
00242 SET_VECTOR(set_vector, float32_t, (CT_VECTOR, ST_NONE, PT_FLOAT32))
00243 SET_VECTOR(set_vector, float64_t, (CT_VECTOR, ST_NONE, PT_FLOAT64))
00244 SET_VECTOR(set_vector, floatmax_t, (CT_VECTOR, ST_NONE, PT_FLOATMAX))
00245 SET_VECTOR(set_vector, int16_t, (CT_VECTOR, ST_NONE, PT_INT16))
00246 SET_VECTOR(set_vector, uint16_t, (CT_VECTOR, ST_NONE, PT_INT16))
00247 SET_VECTOR(set_vector, int64_t, (CT_VECTOR, ST_NONE, PT_INT64))
00248 SET_VECTOR(set_vector, uint64_t, (CT_VECTOR, ST_NONE, PT_UINT64))
00249 #undef SET_VECTOR
00250 
00251 #define SET_MATRIX(fname, sg_type, dtype) \
00252 void CBinaryFile::fname(const sg_type* matrix, int32_t num_feat, int32_t num_vec)   \
00253 {                                                                                   \
00254     if (!(file && matrix))                                                          \
00255         SG_ERROR("File or matrix invalid.\n");                                      \
00256                                                                                     \
00257     TSGDataType t dtype; write_header(&t);                                          \
00258                                                                                     \
00259     if (fwrite(&num_feat, sizeof(int32_t), 1, file)!=1 ||                           \
00260             fwrite(&num_vec, sizeof(int32_t), 1, file)!=1 ||                        \
00261             fwrite(matrix, sizeof(sg_type)*num_feat, num_vec, file)!=(size_t) num_vec)  \
00262         SG_ERROR("Failed to write Matrix\n");                                       \
00263 }
00264 SET_MATRIX(set_matrix, char, (CT_MATRIX, ST_NONE, PT_CHAR))
00265 SET_MATRIX(set_matrix, uint8_t, (CT_MATRIX, ST_NONE, PT_UINT8))
00266 SET_MATRIX(set_int8_matrix, int8_t, (CT_MATRIX, ST_NONE, PT_INT8))
00267 SET_MATRIX(set_matrix, int32_t, (CT_MATRIX, ST_NONE, PT_INT32))
00268 SET_MATRIX(set_uint_matrix, uint32_t, (CT_MATRIX, ST_NONE, PT_INT32))
00269 SET_MATRIX(set_long_matrix, int64_t, (CT_MATRIX, ST_NONE, PT_INT64))
00270 SET_MATRIX(set_ulong_matrix, uint64_t, (CT_MATRIX, ST_NONE, PT_INT64))
00271 SET_MATRIX(set_matrix, int16_t, (CT_MATRIX, ST_NONE, PT_INT16))
00272 SET_MATRIX(set_matrix, uint16_t, (CT_MATRIX, ST_NONE, PT_INT16))
00273 SET_MATRIX(set_matrix, float32_t, (CT_MATRIX, ST_NONE, PT_FLOAT32))
00274 SET_MATRIX(set_matrix, float64_t, (CT_MATRIX, ST_NONE, PT_FLOAT64))
00275 SET_MATRIX(set_longreal_matrix, floatmax_t, (CT_MATRIX, ST_NONE, PT_FLOATMAX))
00276 #undef SET_MATRIX
00277 
00278 #define SET_NDARRAY(fname,sg_type,datatype)                                 \
00279 void CBinaryFile::fname(const sg_type * array, int32_t * dims,int32_t num_dims) \
00280 {                                                                           \
00281     size_t total = 1;                                                       \
00282                                                                             \
00283     if (!file)                                                              \
00284         SG_ERROR("File invalid.\n");                                        \
00285                                                                             \
00286     if (!array)                                                             \
00287         SG_ERROR("Invalid array!\n");                                       \
00288                                                                             \
00289     TSGDataType t datatype;                                                 \
00290     write_header(&t);                                                       \
00291                                                                             \
00292     if (fwrite(&num_dims,sizeof(int32_t),1,file) != 1)                      \
00293         SG_ERROR("Failed to write number of dimensions!\n");                \
00294                                                                             \
00295     if (fwrite(dims,sizeof(int32_t),num_dims,file) != (size_t)num_dims)     \
00296         SG_ERROR("Failed to write sizes of dimensions!\n");                 \
00297                                                                             \
00298     for (int32_t i = 0;i < num_dims;i++)                                        \
00299         total *= dims[i];                                                   \
00300                                                                             \
00301     if (fwrite(array,sizeof(sg_type),total,file) != (size_t)total)          \
00302         SG_ERROR("Failed to write array data!\n");                          \
00303 }
00304 
00305 SET_NDARRAY(set_ndarray,uint8_t,(CT_NDARRAY, ST_NONE, PT_UINT8));
00306 SET_NDARRAY(set_ndarray,char,(CT_NDARRAY, ST_NONE, PT_CHAR));
00307 SET_NDARRAY(set_ndarray,int32_t,(CT_NDARRAY, ST_NONE, PT_INT32));
00308 SET_NDARRAY(set_ndarray,int16_t,(CT_NDARRAY, ST_NONE, PT_INT16));
00309 SET_NDARRAY(set_ndarray,uint16_t,(CT_NDARRAY, ST_NONE, PT_UINT16));
00310 SET_NDARRAY(set_ndarray,float32_t,(CT_NDARRAY, ST_NONE, PT_FLOAT32));
00311 SET_NDARRAY(set_ndarray,float64_t,(CT_NDARRAY, ST_NONE, PT_FLOAT64));
00312 #undef SET_NDARRAY
00313 
00314 #define SET_SPARSEMATRIX(fname, sg_type, dtype)             \
00315 void CBinaryFile::fname(const SGSparseVector<sg_type>* matrix,  \
00316         int32_t num_feat, int32_t num_vec)                  \
00317 {                                                           \
00318     if (!(file && matrix))                                  \
00319         SG_ERROR("File or matrix invalid.\n");              \
00320                                                             \
00321     TSGDataType t dtype; write_header(&t);                  \
00322                                                             \
00323     if (fwrite(&num_vec, sizeof(int32_t), 1, file)!=1)      \
00324         SG_ERROR("Failed to write Sparse Matrix\n");        \
00325                                                             \
00326     for (int32_t i=0; i<num_vec; i++)                       \
00327     {                                                       \
00328         SGSparseVectorEntry<sg_type>* vec = matrix[i].features; \
00329         int32_t len=matrix[i].num_feat_entries;             \
00330         if ((fwrite(&len, sizeof(int32_t), 1, file)!=1) ||  \
00331                 (fwrite(vec, sizeof(SGSparseVectorEntry<sg_type>), len, file)!= (size_t) len))      \
00332             SG_ERROR("Failed to write Sparse Matrix\n");    \
00333     }                                                       \
00334 }
00335 SET_SPARSEMATRIX(set_sparse_matrix, bool, (CT_MATRIX, ST_NONE, PT_BOOL))
00336 SET_SPARSEMATRIX(set_sparse_matrix, char, (CT_MATRIX, ST_NONE, PT_CHAR))
00337 SET_SPARSEMATRIX(set_sparse_matrix, uint8_t, (CT_MATRIX, ST_NONE, PT_UINT8))
00338 SET_SPARSEMATRIX(set_int8_sparsematrix, int8_t, (CT_MATRIX, ST_NONE, PT_INT8))
00339 SET_SPARSEMATRIX(set_sparse_matrix, int32_t, (CT_MATRIX, ST_NONE, PT_INT32))
00340 SET_SPARSEMATRIX(set_uint_sparsematrix, uint32_t, (CT_MATRIX, ST_NONE, PT_INT32))
00341 SET_SPARSEMATRIX(set_long_sparsematrix, int64_t, (CT_MATRIX, ST_NONE, PT_INT64))
00342 SET_SPARSEMATRIX(set_ulong_sparsematrix, uint64_t, (CT_MATRIX, ST_NONE, PT_INT64))
00343 SET_SPARSEMATRIX(set_sparse_matrix, int16_t, (CT_MATRIX, ST_NONE, PT_INT16))
00344 SET_SPARSEMATRIX(set_sparse_matrix, uint16_t, (CT_MATRIX, ST_NONE, PT_INT16))
00345 SET_SPARSEMATRIX(set_sparse_matrix, float32_t, (CT_MATRIX, ST_NONE, PT_FLOAT32))
00346 SET_SPARSEMATRIX(set_sparse_matrix, float64_t, (CT_MATRIX, ST_NONE, PT_FLOAT64))
00347 SET_SPARSEMATRIX(set_longreal_sparsematrix, floatmax_t, (CT_MATRIX, ST_NONE, PT_FLOATMAX))
00348 #undef SET_SPARSEMATRIX
00349 
00350 #define SET_STRING_LIST(fname, sg_type, dtype) \
00351 void CBinaryFile::fname(const SGString<sg_type>* strings, int32_t num_str)  \
00352 {                                                                                       \
00353     if (!(file && strings))                                                             \
00354         SG_ERROR("File or strings invalid.\n");                                         \
00355                                                                                         \
00356     TSGDataType t dtype; write_header(&t);                                              \
00357     for (int32_t i=0; i<num_str; i++)                                                   \
00358     {                                                                                   \
00359         int32_t len = strings[i].slen;                                              \
00360         if ((fwrite(&len, sizeof(int32_t), 1, file)!=1) ||                              \
00361                 (fwrite(strings[i].string, sizeof(sg_type), len, file)!= (size_t) len)) \
00362             SG_ERROR("Failed to write Sparse Matrix\n");                                \
00363     }                                                                                   \
00364 }
00365 SET_STRING_LIST(set_string_list, char, (CT_VECTOR, ST_NONE, PT_CHAR))
00366 SET_STRING_LIST(set_string_list, uint8_t, (CT_VECTOR, ST_NONE, PT_UINT8))
00367 SET_STRING_LIST(set_int8_string_list, int8_t, (CT_VECTOR, ST_NONE, PT_INT8))
00368 SET_STRING_LIST(set_string_list, int32_t, (CT_VECTOR, ST_NONE, PT_INT32))
00369 SET_STRING_LIST(set_uint_string_list, uint32_t, (CT_VECTOR, ST_NONE, PT_INT32))
00370 SET_STRING_LIST(set_long_string_list, int64_t, (CT_VECTOR, ST_NONE, PT_INT64))
00371 SET_STRING_LIST(set_ulong_string_list, uint64_t, (CT_VECTOR, ST_NONE, PT_INT64))
00372 SET_STRING_LIST(set_string_list, int16_t, (CT_VECTOR, ST_NONE, PT_INT16))
00373 SET_STRING_LIST(set_string_list, uint16_t, (CT_VECTOR, ST_NONE, PT_INT16))
00374 SET_STRING_LIST(set_string_list, float32_t, (CT_VECTOR, ST_NONE, PT_FLOAT32))
00375 SET_STRING_LIST(set_string_list, float64_t, (CT_VECTOR, ST_NONE, PT_FLOAT64))
00376 SET_STRING_LIST(set_longreal_string_list, floatmax_t, (CT_VECTOR, ST_NONE, PT_FLOATMAX))
00377 #undef SET_STRING_LIST
00378 
00379 
00380 int32_t CBinaryFile::parse_first_header(TSGDataType& type)
00381 {
00382         return -1;
00383 }
00384 
00385 int32_t CBinaryFile::parse_next_header(TSGDataType& type)
00386 {
00387         return -1;
00388 }
00389 
00390 void
00391 CBinaryFile::read_header(TSGDataType* dest)
00392 {
00393     ASSERT(file);
00394     ASSERT(dest);
00395 
00396     if (fseek(file, 0L, SEEK_SET)!=0)
00397         SG_ERROR("Error seeking file '%s' to the beginning.\n", filename);
00398 
00399     char fourcc[4];
00400     uint16_t endian=0;
00401 
00402     if (fread(&fourcc, sizeof(char), 4, file)!=4)
00403         SG_ERROR("Error reading fourcc header in file '%s'\n", filename);
00404 
00405     if (fread(&endian, sizeof(uint16_t), 1, file)!=1)
00406         SG_ERROR("Error reading endian header in file '%s'\n", filename);
00407 
00408     if ((fread(&dest->m_ctype, sizeof(dest->m_ctype), 1, file)!=1) ||
00409             (fread(&dest->m_ptype, sizeof(dest->m_ptype), 1, file)!=1))
00410         SG_ERROR("Error reading datatype header in file '%s'\n", filename);
00411 
00412     if (strncmp(fourcc, "SG01", 4))
00413         SG_ERROR("Header mismatch, expected SG01 in file '%s'\n", filename);
00414 }
00415 
00416 void
00417 CBinaryFile::write_header(const TSGDataType* datatype)
00418 {
00419     ASSERT(file);
00420 
00421     const char* fourcc="SG01";
00422     uint16_t endian=0x1234;
00423 
00424     if (!((fwrite(fourcc, sizeof(char), 4, file)==4) &&
00425           (fwrite(&endian, sizeof(uint16_t), 1, file)==1) &&
00426           (fwrite(&datatype->m_ctype, sizeof(datatype->m_ctype), 1,
00427                   file)==1)
00428           && (fwrite(&datatype->m_ptype, sizeof(datatype->m_ptype), 1,
00429                      file)==1)
00430             ))
00431         SG_ERROR("Error writing header\n");
00432 }
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines

SHOGUN Machine Learning Toolbox - Documentation