SHOGUN  v1.1.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
BinaryFile.cpp
Go to the documentation of this file.
1 /*
2  * This program is free software; you can redistribute it and/or modify
3  * it under the terms of the GNU General Public License as published by
4  * the Free Software Foundation; either version 3 of the License, or
5  * (at your option) any later version.
6  *
7  * Written (W) 2010 Soeren Sonnenburg
8  * Copyright (C) 2010 Berlin Institute of Technology
9  */
10 
11 #include <shogun/io/File.h>
13 #include <shogun/io/BinaryFile.h>
14 
15 using namespace shogun;
16 
18 {
19  SG_UNSTABLE("CBinaryFile::CBinaryFile()", "\n");
20 }
21 
22 CBinaryFile::CBinaryFile(FILE* f, const char* name) : CFile(f, name)
23 {
24 }
25 
26 CBinaryFile::CBinaryFile(char* fname, char rw, const char* name) : CFile(fname, rw, name)
27 {
28 }
29 
31 {
32 }
33 
34 #define GET_VECTOR(fname, sg_type, datatype) \
35 void CBinaryFile::fname(sg_type*& vec, int32_t& len) \
36 { \
37  if (!file) \
38  SG_ERROR("File invalid.\n"); \
39  TSGDataType dtype(CT_SCALAR, ST_NONE, PT_BOOL); read_header(&dtype); \
40  if (dtype!=datatype) \
41  SG_ERROR("Datatype mismatch\n"); \
42  \
43  if (fread(&len, sizeof(int32_t), 1, file)!=1) \
44  SG_ERROR("Failed to read vector length\n"); \
45  vec=SG_MALLOC(sg_type, len); \
46  if (fread(vec, sizeof(sg_type), len, file)!=(size_t) len) \
47  SG_ERROR("Failed to read Matrix\n"); \
48 }
49 
50 GET_VECTOR(get_vector, uint8_t, TSGDataType(CT_VECTOR, ST_NONE, PT_UINT8))
51 GET_VECTOR(get_vector, char, TSGDataType(CT_VECTOR, ST_NONE, PT_CHAR))
52 GET_VECTOR(get_vector, int32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT32))
53 GET_VECTOR(get_vector, float32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOAT32))
54 GET_VECTOR(get_vector, float64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOAT64))
55 GET_VECTOR(get_vector, int16_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT16))
56 GET_VECTOR(get_vector, uint16_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT16))
57 #undef GET_VECTOR
58 
59 #define GET_MATRIX(fname, sg_type, datatype) \
60 void CBinaryFile::fname(sg_type*& matrix, int32_t& num_feat, int32_t& num_vec) \
61 { \
62  if (!file) \
63  SG_ERROR("File invalid.\n"); \
64  TSGDataType dtype(CT_SCALAR, ST_NONE, PT_BOOL); read_header(&dtype); \
65  if (dtype!=datatype) \
66  SG_ERROR("Datatype mismatch\n"); \
67  \
68  if (fread(&num_feat, sizeof(int32_t), 1, file)!=1 || \
69  fread(&num_vec, sizeof(int32_t), 1, file)!=1) \
70  SG_ERROR("Failed to read Matrix dimensions\n"); \
71  matrix=SG_MALLOC(sg_type, int64_t(num_feat)*num_vec); \
72  if (fread(matrix, sizeof(sg_type)*num_feat, num_vec, file)!=(size_t) num_vec) \
73  SG_ERROR("Failed to read Matrix\n"); \
74 }
75 
76 GET_MATRIX(get_matrix, char, TSGDataType(CT_MATRIX, ST_NONE, PT_CHAR))
77 GET_MATRIX(get_matrix, uint8_t, TSGDataType(CT_MATRIX, ST_NONE, PT_UINT8))
78 GET_MATRIX(get_int8_matrix, int8_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT8))
79 GET_MATRIX(get_matrix, int32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT32))
80 GET_MATRIX(get_uint_matrix, uint32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT32))
81 GET_MATRIX(get_long_matrix, int64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT64))
82 GET_MATRIX(get_ulong_matrix, uint64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT64))
83 GET_MATRIX(get_matrix, int16_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT16))
84 GET_MATRIX(get_matrix, uint16_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT16))
85 GET_MATRIX(get_matrix, float32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOAT32))
86 GET_MATRIX(get_matrix, float64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOAT64))
87 GET_MATRIX(get_longreal_matrix, floatmax_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOATMAX))
88 #undef GET_MATRIX
89 
90 #define GET_NDARRAY(fname,sg_type,datatype) \
91 void CBinaryFile::fname(sg_type *& array, int32_t *& dims,int32_t & num_dims)\
92 { \
93  size_t total = 1; \
94  \
95  if (!file) \
96  SG_ERROR("File invalid.\n"); \
97  \
98  TSGDataType dtype(CT_SCALAR, ST_NONE, PT_BOOL); \
99  read_header(&dtype); \
100  \
101  if (dtype!=datatype) \
102  SG_ERROR("Datatype mismatch\n"); \
103  \
104  if (fread(&num_dims,sizeof(int32_t),1,file) != 1) \
105  SG_ERROR("Failed to read number of dimensions"); \
106  \
107  dims = SG_MALLOC(int32_t, num_dims); \
108  if (fread(dims,sizeof(int32_t),num_dims,file) != (size_t)num_dims) \
109  SG_ERROR("Failed to read sizes of dimensions!"); \
110  \
111  for (int32_t i = 0;i < num_dims;i++) \
112  total *= dims[i]; \
113  \
114  array = SG_MALLOC(sg_type, total); \
115  if (fread(array,sizeof(sg_type),total,file) != (size_t)total) \
116  SG_ERROR("Failed to read array data!"); \
117 }
118 
119 GET_NDARRAY(get_ndarray,uint8_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_UINT8));
120 GET_NDARRAY(get_ndarray,char,TSGDataType(CT_NDARRAY, ST_NONE, PT_CHAR));
121 GET_NDARRAY(get_ndarray,int32_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_INT32));
122 GET_NDARRAY(get_ndarray,int16_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_INT16));
123 GET_NDARRAY(get_ndarray,uint16_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_UINT16));
124 GET_NDARRAY(get_ndarray,float32_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_FLOAT32));
125 GET_NDARRAY(get_ndarray,float64_t,TSGDataType(CT_NDARRAY, ST_NONE, PT_FLOAT64));
126 #undef GET_NDARRAY
127 
128 #define GET_SPARSEMATRIX(fname, sg_type, datatype) \
129 void CBinaryFile::fname(SGSparseVector<sg_type>*& matrix, int32_t& num_feat, int32_t& num_vec) \
130 { \
131  if (!(file)) \
132  SG_ERROR("File invalid.\n"); \
133  \
134  TSGDataType dtype(CT_SCALAR, ST_NONE, PT_BOOL); read_header(&dtype); \
135  if (dtype!=datatype) \
136  SG_ERROR("Datatype mismatch\n"); \
137  \
138  if (fread(&num_vec, sizeof(int32_t), 1, file)!=1) \
139  SG_ERROR("Failed to read number of vectors\n"); \
140  \
141  matrix=SG_MALLOC(SGSparseVector<sg_type>, num_vec); \
142  \
143  for (int32_t i=0; i<num_vec; i++) \
144  { \
145  int32_t len=0; \
146  if (fread(&len, sizeof(int32_t), 1, file)!=1) \
147  SG_ERROR("Failed to read sparse vector length of vector idx=%d\n", i); \
148  matrix[i].num_feat_entries=len; \
149  SGSparseVectorEntry<sg_type>* vec = SG_MALLOC(SGSparseVectorEntry<sg_type>, len); \
150  if (fread(vec, sizeof(SGSparseVectorEntry<sg_type>), len, file)!= (size_t) len) \
151  SG_ERROR("Failed to read sparse vector %d\n", i); \
152  matrix[i].features=vec; \
153  } \
154 }
155 GET_SPARSEMATRIX(get_sparse_matrix, bool, TSGDataType(CT_MATRIX, ST_NONE, PT_BOOL))
156 GET_SPARSEMATRIX(get_sparse_matrix, char, TSGDataType(CT_MATRIX, ST_NONE, PT_CHAR))
157 GET_SPARSEMATRIX(get_sparse_matrix, uint8_t, TSGDataType(CT_MATRIX, ST_NONE, PT_UINT8))
158 GET_SPARSEMATRIX(get_int8_sparsematrix, int8_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT8))
159 GET_SPARSEMATRIX(get_sparse_matrix, int32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT32))
160 GET_SPARSEMATRIX(get_uint_sparsematrix, uint32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT32))
161 GET_SPARSEMATRIX(get_long_sparsematrix, int64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT64))
162 GET_SPARSEMATRIX(get_ulong_sparsematrix, uint64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT64))
163 GET_SPARSEMATRIX(get_sparse_matrix, int16_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT16))
164 GET_SPARSEMATRIX(get_sparse_matrix, uint16_t, TSGDataType(CT_MATRIX, ST_NONE, PT_INT16))
165 GET_SPARSEMATRIX(get_sparse_matrix, float32_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOAT32))
166 GET_SPARSEMATRIX(get_sparse_matrix, float64_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOAT64))
167 GET_SPARSEMATRIX(get_longreal_sparsematrix, floatmax_t, TSGDataType(CT_MATRIX, ST_NONE, PT_FLOATMAX))
168 #undef GET_SPARSEMATRIX
169 
170 
171 #define GET_STRING_LIST(fname, sg_type, datatype) \
172 void CBinaryFile::fname(SGString<sg_type>*& strings, int32_t& num_str, int32_t& max_string_len) \
173 { \
174  strings=NULL; \
175  num_str=0; \
176  max_string_len=0; \
177  \
178  if (!file) \
179  SG_ERROR("File invalid.\n"); \
180  \
181  TSGDataType dtype(CT_SCALAR, ST_NONE, PT_BOOL); read_header(&dtype); \
182  if (dtype!=datatype) \
183  SG_ERROR("Datatype mismatch\n"); \
184  \
185  if (fread(&num_str, sizeof(int32_t), 1, file)!=1) \
186  SG_ERROR("Failed to read number of strings\n"); \
187  \
188  strings=SG_MALLOC(SGString<sg_type>, num_str); \
189  \
190  for (int32_t i=0; i<num_str; i++) \
191  { \
192  int32_t len=0; \
193  if (fread(&len, sizeof(int32_t), 1, file)!=1) \
194  SG_ERROR("Failed to read string length of string with idx=%d\n", i); \
195  strings[i].slen=len; \
196  sg_type* str = SG_MALLOC(sg_type, len); \
197  if (fread(str, sizeof(sg_type), len, file)!= (size_t) len) \
198  SG_ERROR("Failed to read string %d\n", i); \
199  strings[i].string=str; \
200  } \
201 }
202 
203 GET_STRING_LIST(get_string_list, char, TSGDataType(CT_VECTOR, ST_NONE, PT_CHAR))
204 GET_STRING_LIST(get_string_list, uint8_t, TSGDataType(CT_VECTOR, ST_NONE, PT_UINT8))
205 GET_STRING_LIST(get_int8_string_list, int8_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT8))
206 GET_STRING_LIST(get_string_list, int32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT32))
207 GET_STRING_LIST(get_uint_string_list, uint32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT32))
208 GET_STRING_LIST(get_long_string_list, int64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT64))
209 GET_STRING_LIST(get_ulong_string_list, uint64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT64))
210 GET_STRING_LIST(get_string_list, int16_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT16))
211 GET_STRING_LIST(get_string_list, uint16_t, TSGDataType(CT_VECTOR, ST_NONE, PT_INT16))
212 GET_STRING_LIST(get_string_list, float32_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOAT32))
213 GET_STRING_LIST(get_string_list, float64_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOAT64))
214 GET_STRING_LIST(get_longreal_string_list, floatmax_t, TSGDataType(CT_VECTOR, ST_NONE, PT_FLOATMAX))
215 #undef GET_STRING_LIST
216 
219 #define SET_VECTOR(fname, sg_type, dtype) \
220 void CBinaryFile::fname(const sg_type* vec, int32_t len) \
221 { \
222  if (!(file && vec)) \
223  SG_ERROR("File or vector invalid.\n"); \
224  \
225  TSGDataType t dtype; write_header(&t); \
226  \
227  if (fwrite(&len, sizeof(int32_t), 1, file)!=1 || \
228  fwrite(vec, sizeof(sg_type), len, file)!=(size_t) len) \
229  SG_ERROR("Failed to write vector\n"); \
230 }
231 SET_VECTOR(set_vector, uint8_t, (CT_VECTOR, ST_NONE, PT_UINT8))
232 SET_VECTOR(set_vector, char, (CT_VECTOR, ST_NONE, PT_CHAR))
233 SET_VECTOR(set_vector, int32_t, (CT_VECTOR, ST_NONE, PT_INT32))
234 SET_VECTOR(set_vector, float32_t, (CT_VECTOR, ST_NONE, PT_FLOAT32))
235 SET_VECTOR(set_vector, float64_t, (CT_VECTOR, ST_NONE, PT_FLOAT64))
236 SET_VECTOR(set_vector, int16_t, (CT_VECTOR, ST_NONE, PT_INT16))
237 SET_VECTOR(set_vector, uint16_t, (CT_VECTOR, ST_NONE, PT_INT16))
238 #undef SET_VECTOR
239 
240 #define SET_MATRIX(fname, sg_type, dtype) \
241 void CBinaryFile::fname(const sg_type* matrix, int32_t num_feat, int32_t num_vec) \
242 { \
243  if (!(file && matrix)) \
244  SG_ERROR("File or matrix invalid.\n"); \
245  \
246  TSGDataType t dtype; write_header(&t); \
247  \
248  if (fwrite(&num_feat, sizeof(int32_t), 1, file)!=1 || \
249  fwrite(&num_vec, sizeof(int32_t), 1, file)!=1 || \
250  fwrite(matrix, sizeof(sg_type)*num_feat, num_vec, file)!=(size_t) num_vec) \
251  SG_ERROR("Failed to write Matrix\n"); \
252 }
253 SET_MATRIX(set_matrix, char, (CT_MATRIX, ST_NONE, PT_CHAR))
254 SET_MATRIX(set_matrix, uint8_t, (CT_MATRIX, ST_NONE, PT_UINT8))
255 SET_MATRIX(set_int8_matrix, int8_t, (CT_MATRIX, ST_NONE, PT_INT8))
256 SET_MATRIX(set_matrix, int32_t, (CT_MATRIX, ST_NONE, PT_INT32))
257 SET_MATRIX(set_uint_matrix, uint32_t, (CT_MATRIX, ST_NONE, PT_INT32))
258 SET_MATRIX(set_long_matrix, int64_t, (CT_MATRIX, ST_NONE, PT_INT64))
259 SET_MATRIX(set_ulong_matrix, uint64_t, (CT_MATRIX, ST_NONE, PT_INT64))
260 SET_MATRIX(set_matrix, int16_t, (CT_MATRIX, ST_NONE, PT_INT16))
261 SET_MATRIX(set_matrix, uint16_t, (CT_MATRIX, ST_NONE, PT_INT16))
262 SET_MATRIX(set_matrix, float32_t, (CT_MATRIX, ST_NONE, PT_FLOAT32))
263 SET_MATRIX(set_matrix, float64_t, (CT_MATRIX, ST_NONE, PT_FLOAT64))
264 SET_MATRIX(set_longreal_matrix, floatmax_t, (CT_MATRIX, ST_NONE, PT_FLOATMAX))
265 #undef SET_MATRIX
266 
267 #define SET_NDARRAY(fname,sg_type,datatype) \
268 void CBinaryFile::fname(const sg_type * array, int32_t * dims,int32_t num_dims) \
269 { \
270  size_t total = 1; \
271  \
272  if (!file) \
273  SG_ERROR("File invalid.\n"); \
274  \
275  if (!array) \
276  SG_ERROR("Invalid array!\n"); \
277  \
278  TSGDataType t datatype; \
279  write_header(&t); \
280  \
281  if (fwrite(&num_dims,sizeof(int32_t),1,file) != 1) \
282  SG_ERROR("Failed to write number of dimensions!\n"); \
283  \
284  if (fwrite(dims,sizeof(int32_t),num_dims,file) != (size_t)num_dims) \
285  SG_ERROR("Failed to write sizes of dimensions!\n"); \
286  \
287  for (int32_t i = 0;i < num_dims;i++) \
288  total *= dims[i]; \
289  \
290  if (fwrite(array,sizeof(sg_type),total,file) != (size_t)total) \
291  SG_ERROR("Failed to write array data!\n"); \
292 }
293 
294 SET_NDARRAY(set_ndarray,uint8_t,(CT_NDARRAY, ST_NONE, PT_UINT8));
295 SET_NDARRAY(set_ndarray,char,(CT_NDARRAY, ST_NONE, PT_CHAR));
296 SET_NDARRAY(set_ndarray,int32_t,(CT_NDARRAY, ST_NONE, PT_INT32));
297 SET_NDARRAY(set_ndarray,int16_t,(CT_NDARRAY, ST_NONE, PT_INT16));
298 SET_NDARRAY(set_ndarray,uint16_t,(CT_NDARRAY, ST_NONE, PT_UINT16));
299 SET_NDARRAY(set_ndarray,float32_t,(CT_NDARRAY, ST_NONE, PT_FLOAT32));
300 SET_NDARRAY(set_ndarray,float64_t,(CT_NDARRAY, ST_NONE, PT_FLOAT64));
301 #undef SET_NDARRAY
302 
303 #define SET_SPARSEMATRIX(fname, sg_type, dtype) \
304 void CBinaryFile::fname(const SGSparseVector<sg_type>* matrix, \
305  int32_t num_feat, int32_t num_vec) \
306 { \
307  if (!(file && matrix)) \
308  SG_ERROR("File or matrix invalid.\n"); \
309  \
310  TSGDataType t dtype; write_header(&t); \
311  \
312  if (fwrite(&num_vec, sizeof(int32_t), 1, file)!=1) \
313  SG_ERROR("Failed to write Sparse Matrix\n"); \
314  \
315  for (int32_t i=0; i<num_vec; i++) \
316  { \
317  SGSparseVectorEntry<sg_type>* vec = matrix[i].features; \
318  int32_t len=matrix[i].num_feat_entries; \
319  if ((fwrite(&len, sizeof(int32_t), 1, file)!=1) || \
320  (fwrite(vec, sizeof(SGSparseVectorEntry<sg_type>), len, file)!= (size_t) len)) \
321  SG_ERROR("Failed to write Sparse Matrix\n"); \
322  } \
323 }
324 SET_SPARSEMATRIX(set_sparse_matrix, bool, (CT_MATRIX, ST_NONE, PT_BOOL))
325 SET_SPARSEMATRIX(set_sparse_matrix, char, (CT_MATRIX, ST_NONE, PT_CHAR))
326 SET_SPARSEMATRIX(set_sparse_matrix, uint8_t, (CT_MATRIX, ST_NONE, PT_UINT8))
327 SET_SPARSEMATRIX(set_int8_sparsematrix, int8_t, (CT_MATRIX, ST_NONE, PT_INT8))
328 SET_SPARSEMATRIX(set_sparse_matrix, int32_t, (CT_MATRIX, ST_NONE, PT_INT32))
329 SET_SPARSEMATRIX(set_uint_sparsematrix, uint32_t, (CT_MATRIX, ST_NONE, PT_INT32))
330 SET_SPARSEMATRIX(set_long_sparsematrix, int64_t, (CT_MATRIX, ST_NONE, PT_INT64))
331 SET_SPARSEMATRIX(set_ulong_sparsematrix, uint64_t, (CT_MATRIX, ST_NONE, PT_INT64))
332 SET_SPARSEMATRIX(set_sparse_matrix, int16_t, (CT_MATRIX, ST_NONE, PT_INT16))
333 SET_SPARSEMATRIX(set_sparse_matrix, uint16_t, (CT_MATRIX, ST_NONE, PT_INT16))
334 SET_SPARSEMATRIX(set_sparse_matrix, float32_t, (CT_MATRIX, ST_NONE, PT_FLOAT32))
335 SET_SPARSEMATRIX(set_sparse_matrix, float64_t, (CT_MATRIX, ST_NONE, PT_FLOAT64))
336 SET_SPARSEMATRIX(set_longreal_sparsematrix, floatmax_t, (CT_MATRIX, ST_NONE, PT_FLOATMAX))
337 #undef SET_SPARSEMATRIX
338 
339 #define SET_STRING_LIST(fname, sg_type, dtype) \
340 void CBinaryFile::fname(const SGString<sg_type>* strings, int32_t num_str) \
341 { \
342  if (!(file && strings)) \
343  SG_ERROR("File or strings invalid.\n"); \
344  \
345  TSGDataType t dtype; write_header(&t); \
346  for (int32_t i=0; i<num_str; i++) \
347  { \
348  int32_t len = strings[i].slen; \
349  if ((fwrite(&len, sizeof(int32_t), 1, file)!=1) || \
350  (fwrite(strings[i].string, sizeof(sg_type), len, file)!= (size_t) len)) \
351  SG_ERROR("Failed to write Sparse Matrix\n"); \
352  } \
353 }
354 SET_STRING_LIST(set_string_list, char, (CT_VECTOR, ST_NONE, PT_CHAR))
355 SET_STRING_LIST(set_string_list, uint8_t, (CT_VECTOR, ST_NONE, PT_UINT8))
356 SET_STRING_LIST(set_int8_string_list, int8_t, (CT_VECTOR, ST_NONE, PT_INT8))
357 SET_STRING_LIST(set_string_list, int32_t, (CT_VECTOR, ST_NONE, PT_INT32))
358 SET_STRING_LIST(set_uint_string_list, uint32_t, (CT_VECTOR, ST_NONE, PT_INT32))
359 SET_STRING_LIST(set_long_string_list, int64_t, (CT_VECTOR, ST_NONE, PT_INT64))
360 SET_STRING_LIST(set_ulong_string_list, uint64_t, (CT_VECTOR, ST_NONE, PT_INT64))
361 SET_STRING_LIST(set_string_list, int16_t, (CT_VECTOR, ST_NONE, PT_INT16))
362 SET_STRING_LIST(set_string_list, uint16_t, (CT_VECTOR, ST_NONE, PT_INT16))
363 SET_STRING_LIST(set_string_list, float32_t, (CT_VECTOR, ST_NONE, PT_FLOAT32))
364 SET_STRING_LIST(set_string_list, float64_t, (CT_VECTOR, ST_NONE, PT_FLOAT64))
365 SET_STRING_LIST(set_longreal_string_list, floatmax_t, (CT_VECTOR, ST_NONE, PT_FLOATMAX))
366 #undef SET_STRING_LIST
367 
368 
370 {
371  return -1;
372 }
373 
375 {
376  return -1;
377 }
378 
379 void
381 {
382  ASSERT(file);
383  ASSERT(dest);
384 
385  if (fseek(file, 0L, SEEK_SET)!=0)
386  SG_ERROR("Error seeking file '%s' to the beginning.\n", filename);
387 
388  char fourcc[4];
389  uint16_t endian=0;
390 
391  if (fread(&fourcc, sizeof(char), 4, file)!=4)
392  SG_ERROR("Error reading fourcc header in file '%s'\n", filename);
393 
394  if (fread(&endian, sizeof(uint16_t), 1, file)!=1)
395  SG_ERROR("Error reading endian header in file '%s'\n", filename);
396 
397  if ((fread(&dest->m_ctype, sizeof(dest->m_ctype), 1, file)!=1) ||
398  (fread(&dest->m_ptype, sizeof(dest->m_ptype), 1, file)!=1))
399  SG_ERROR("Error reading datatype header in file '%s'\n", filename);
400 
401  if (strncmp(fourcc, "SG01", 4))
402  SG_ERROR("Header mismatch, expected SG01 in file '%s'\n", filename);
403 }
404 
405 void
407 {
408  ASSERT(file);
409 
410  const char* fourcc="SG01";
411  uint16_t endian=0x1234;
412 
413  if (!((fwrite(fourcc, sizeof(char), 4, file)==4) &&
414  (fwrite(&endian, sizeof(uint16_t), 1, file)==1) &&
415  (fwrite(&datatype->m_ctype, sizeof(datatype->m_ctype), 1,
416  file)==1)
417  && (fwrite(&datatype->m_ptype, sizeof(datatype->m_ptype), 1,
418  file)==1)
419  ))
420  SG_ERROR("Error writing header\n");
421 }

SHOGUN Machine Learning Toolbox - Documentation