19 using namespace shogun;
29 EPrimitiveType ptype,
index_t* length)
36 EPrimitiveType ptype,
index_t* length_y,
47 bool ctype_equal=
false;
70 SG_SDEBUG(
"leaving TSGDataType::equals_without_length(): container types are "
77 SG_SDEBUG(
"leaving TSGDataType::equals_without_length(): struct types are "
84 SG_SDEBUG(
"leaving TSGDataType::equals_without_length(): primitive types are "
89 SG_SDEBUG(
"leaving TSGDataType::equals_without_length(): data types "
90 "without lengths are equal\n");
96 SG_SDEBUG(
"entering TSGDataType::equals()\n");
100 SG_SDEBUG(
"leaving TSGDataType::equals(): Data types without lengths "
107 SG_SDEBUG(
"leaving TSGDataType::equals(): length_y is at %p while "
116 SG_SDEBUG(
"leaving TSGDataType::equals(): length_y=%d while "
124 SG_SDEBUG(
"leaving TSGDataType::equals(): m_length_x is at %p while "
133 SG_SDEBUG(
"leaving TSGDataType::equals(): m_length_x=%d while "
139 SG_SDEBUG(
"leaving TSGDataType::equals(): datatypes are equal\n");
149 case CT_SCALAR: strncpy(p,
"", n);
break;
150 case CT_VECTOR: strncpy(p,
"Vector<", n);
break;
151 case CT_SGVECTOR: strncpy(p,
"SGVector<", n);
break;
152 case CT_MATRIX: strncpy(p,
"Matrix<", n);
break;
153 case CT_SGMATRIX: strncpy(p,
"SGMatrix<", n);
break;
154 case CT_NDARRAY: strncpy(p,
"N-Dimensional Array<", n);
break;
155 case CT_UNDEFINED:
default: strncpy(p,
"Undefined", n);
break;
160 size_t np = strlen(p);
165 case CT_SCALAR:
break;
170 case CT_NDARRAY: strcat(p,
">");
break;
171 case CT_UNDEFINED:
default:
break;
208 SG_SWARNING(
"TGSDataType::sizeof_stype(): Strings are"
209 " not supported for complex128_t\n");
212 SG_SWARNING(
"TGSDataType::sizeof_stype(): Strings are"
213 " not supported for SGObject\n");
215 case PT_UNDEFINED:
default:
216 SG_SERROR(
"Implementation error: undefined primitive type\n");
236 case PT_SGOBJECT:
return -1;
237 case PT_UNDEFINED:
default:
238 SG_SERROR(
"Implementation error: undefined primitive type\n");
242 case ST_UNDEFINED:
default:
243 SG_SERROR(
"Implementation error: undefined structure type\n");
254 case PT_BOOL:
return sizeof (bool);
255 case PT_CHAR:
return sizeof (char);
256 case PT_INT8:
return sizeof (int8_t);
257 case PT_UINT8:
return sizeof (uint8_t);
258 case PT_INT16:
return sizeof (int16_t);
259 case PT_UINT16:
return sizeof (uint16_t);
260 case PT_INT32:
return sizeof (int32_t);
261 case PT_UINT32:
return sizeof (uint32_t);
262 case PT_INT64:
return sizeof (int64_t);
263 case PT_UINT64:
return sizeof (uint64_t);
264 case PT_FLOAT32:
return sizeof (
float32_t);
265 case PT_FLOAT64:
return sizeof (
float64_t);
268 case PT_SGOBJECT:
return sizeof (
CSGObject*);
269 case PT_UNDEFINED:
default:
270 SG_SERROR(
"Implementation error: undefined primitive type\n");
295 case PT_SGOBJECT:
return -1;
296 case PT_UNDEFINED:
default:
297 SG_SERROR(
"Implementation error: undefined primitive type\n");
304 #define ENTRY_OFFSET(k, type) \
305 ((char*) &((SGSparseVectorEntry<type>*) (k))->entry - (char*) (k))
309 size_t result = -1;
void* x = &result;
315 case PT_UINT8: result =
ENTRY_OFFSET(x, uint8_t);
break;
316 case PT_INT16: result =
ENTRY_OFFSET(x, int16_t);
break;
317 case PT_UINT16: result =
ENTRY_OFFSET(x, uint16_t);
break;
318 case PT_INT32: result =
ENTRY_OFFSET(x, int32_t);
break;
319 case PT_UINT32: result =
ENTRY_OFFSET(x, uint32_t);
break;
320 case PT_INT64: result =
ENTRY_OFFSET(x, int64_t);
break;
321 case PT_UINT64: result =
ENTRY_OFFSET(x, uint64_t);
break;
326 case PT_SGOBJECT:
return -1;
327 case PT_UNDEFINED:
default:
328 SG_SERROR(
"Implementation error: undefined primitive type\n");
337 EPrimitiveType ptype,
size_t n)
342 case ST_NONE: strncpy(p,
"", n);
break;
343 case ST_STRING: strncpy(p,
"String<", n);
break;
344 case ST_SPARSE: strncpy(p,
"Sparse<", n);
break;
345 case ST_UNDEFINED:
default:
346 SG_SERROR(
"Implementation error: undefined structure type\n");
350 size_t np = strlen(p);
355 case ST_STRING:
case ST_SPARSE:
356 strcat(p,
">");
break;
357 case ST_UNDEFINED:
default:
358 SG_SERROR(
"Implementation error: undefined structure type\n");
370 case PT_BOOL: strncpy(p,
"bool", n);
break;
371 case PT_CHAR: strncpy(p,
"char", n);
break;
372 case PT_INT8: strncpy(p,
"int8", n);
break;
373 case PT_UINT8: strncpy(p,
"uint8", n);
break;
374 case PT_INT16: strncpy(p,
"int16", n);
break;
375 case PT_UINT16: strncpy(p,
"uint16", n);
break;
376 case PT_INT32: strncpy(p,
"int32", n);
break;
377 case PT_UINT32: strncpy(p,
"uint32", n);
break;
378 case PT_INT64: strncpy(p,
"int64", n);
break;
379 case PT_UINT64: strncpy(p,
"uint64", n);
break;
380 case PT_FLOAT32: strncpy(p,
"float32", n);
break;
381 case PT_FLOAT64: strncpy(p,
"float64", n);
break;
382 case PT_FLOATMAX: strncpy(p,
"floatmax", n);
break;
383 case PT_COMPLEX128: strncpy(p,
"complex128", n);
break;
384 case PT_SGOBJECT: strncpy(p,
"SGSerializable*", n);
break;
385 case PT_UNDEFINED:
default:
386 SG_SERROR(
"Implementation error: undefined primitive type\n");
394 if (strcmp(str,
"bool") == 0) {
395 *ptype = PT_BOOL;
return true; }
396 if (strcmp(str,
"char") == 0) {
397 *ptype = PT_CHAR;
return true; }
398 if (strcmp(str,
"int8") == 0) {
399 *ptype = PT_INT8;
return true; }
400 if (strcmp(str,
"uint8") == 0) {
401 *ptype = PT_UINT8;
return true; }
402 if (strcmp(str,
"int16") == 0) {
403 *ptype = PT_INT16;
return true; }
404 if (strcmp(str,
"uint16") == 0) {
405 *ptype = PT_UINT16;
return true; }
406 if (strcmp(str,
"int32") == 0) {
407 *ptype = PT_INT32;
return true; }
408 if (strcmp(str,
"uint32") == 0) {
409 *ptype = PT_UINT32;
return true; }
410 if (strcmp(str,
"int64") == 0) {
411 *ptype = PT_INT64;
return true; }
412 if (strcmp(str,
"uint64") == 0) {
413 *ptype = PT_UINT64;
return true; }
414 if (strcmp(str,
"float32") == 0) {
415 *ptype = PT_FLOAT32;
return true; }
416 if (strcmp(str,
"float64") == 0) {
417 *ptype = PT_FLOAT64;
return true; }
418 if (strcmp(str,
"floatmax") == 0) {
419 *ptype = PT_FLOATMAX;
return true; }
420 if (strcmp(str,
"complex128") == 0) {
421 *ptype = PT_COMPLEX128;
return true; }
422 if (strcmp(str,
"SGSerializable*") == 0) {
423 *ptype = PT_SGOBJECT;
return true; }
427 case PT_BOOL:
case PT_CHAR:
case PT_INT8:
case PT_UINT8:
428 case PT_INT16:
case PT_UINT16:
case PT_INT32:
case PT_UINT32:
429 case PT_INT64:
case PT_UINT64:
case PT_FLOAT32:
case PT_FLOAT64:
430 case PT_FLOATMAX:
case PT_COMPLEX128:
case PT_SGOBJECT:
break;
431 case PT_UNDEFINED:
default:
432 SG_SERROR(
"Implementation error: undefined primitive type\n");
455 case ST_UNDEFINED:
default:
456 SG_SERROR(
"Implementation error: undefined structure type\n");
469 case CT_VECTOR:
case CT_SGVECTOR:
472 case CT_MATRIX:
case CT_SGMATRIX:
476 case CT_UNDEFINED:
default:
477 SG_SERROR(
"Implementation error: undefined container type\n");
std::complex< float64_t > complex128_t
static bool string_to_ptype(EPrimitiveType *ptype, const char *str)
static size_t offset_sparseentry(EPrimitiveType ptype)
size_t sizeof_ptype() const
int64_t get_num_elements()
#define SG_SNOTIMPLEMENTED
static void ptype_to_string(char *dest, EPrimitiveType ptype, size_t n)
TSGDataType(EContainerType ctype, EStructType stype, EPrimitiveType ptype)
Datatypes that shogun supports.
template class SGSparseVector The assumtion is that the stored SGSparseVectorEntry<T>* vector is orde...
bool equals_without_length(TSGDataType other)
Class SGObject is the base class of all shogun objects.
static void stype_to_string(char *dest, EStructType stype, EPrimitiveType ptype, size_t n)
size_t sizeof_stype() const
bool operator==(const TSGDataType &a)
void to_string(char *dest, size_t n) const
#define ENTRY_OFFSET(k, type)
template class SGSparseVectorEntry
bool equals(TSGDataType other)
static size_t sizeof_sparseentry(EPrimitiveType ptype)