NumericInfo.h

Go to the documentation of this file.

#ifndef __NUMERICINFO_H_
#define __NUMERICINFO_H_
//
//
/*
    Copyright (C) 2000 PARAPET partners
    Copyright (C) 2000- 2009, Hammersmith Imanet Ltd
    This file is part of STIR.
 
    SPDX-License-Identifier: Apache-2.0 AND License-ref-PARAPET-license
 
    See STIR/LICENSE.txt for details
*/
// TODO some of these members could be made static
 
/*
  History :
  first version by Kris Thielemans
 
  KT 15/12/99
  reordered member function declarations to allow easier inlining
  moved NumericType and ByteOrder to separate files
 
  KT 18/02/2000 use new syntax for template specialisations: template<> {class blabla};
 */
 
#include "stir/NumericType.h"
 
// this code uses #define's  as specified by the ANSI C standard
#include <climits>
#include <cfloat>
#ifndef __MSL__
#  include <sys/types.h>
#else
#  include <size_t.h>
#endif
 
START_NAMESPACE_STIR

template <class NUMBER>
class NumericInfo
{
public:
  inline bool signed_type() const;
 
  inline bool integer_type() const;
  inline size_t size_in_bytes() const;
  inline size_t size_in_bits() const;
 
  inline NUMBER max_value() const;
  inline NUMBER min_value() const;
 
  inline NumericType type_id() const;
};
 
// Below are the actual details filled in.

template <>
class NumericInfo<signed char>
{
  typedef signed char type;
 
public:
  bool signed_type() const { return true; }
  bool integer_type() const { return true; }
  size_t size_in_bytes() const { return sizeof(type); }
  size_t size_in_bits() { return CHAR_BIT * size_in_bytes(); }
  type max_value() const { return SCHAR_MAX; }
  type min_value() const { return SCHAR_MIN; }
  NumericType type_id() const { return NumericType::SCHAR; }
};

template <>
class NumericInfo<unsigned char>
{
  typedef unsigned char type;
 
public:
  bool signed_type() const { return false; }
  bool integer_type() const { return true; }
  size_t size_in_bytes() const { return sizeof(type); }
  size_t size_in_bits() { return CHAR_BIT * size_in_bytes(); }
  type max_value() const { return UCHAR_MAX; }
  type min_value() const { return 0; }
  NumericType type_id() const { return NumericType::UCHAR; }
};

template <>
class NumericInfo<signed short>
{
  typedef signed short type;
 
public:
  bool signed_type() const { return true; }
  bool integer_type() const { return true; }
  size_t size_in_bytes() const { return sizeof(type); }
  size_t size_in_bits() { return CHAR_BIT * size_in_bytes(); }
  type max_value() const { return SHRT_MAX; }
  type min_value() const { return SHRT_MIN; }
  NumericType type_id() const { return NumericType::SHORT; }
};

template <>
class NumericInfo<unsigned short>
{
  typedef unsigned short type;
 
public:
  bool signed_type() const { return false; }
  bool integer_type() const { return true; }
  size_t size_in_bytes() const { return sizeof(type); }
  size_t size_in_bits() { return CHAR_BIT * size_in_bytes(); }
  type max_value() const { return USHRT_MAX; }
  type min_value() const { return 0; }
  NumericType type_id() const { return NumericType::USHORT; }
};

template <>
class NumericInfo<signed int>
{
  typedef signed int type;
 
public:
  bool signed_type() const { return true; }
  bool integer_type() const { return true; }
  size_t size_in_bytes() const { return sizeof(type); }
  size_t size_in_bits() { return CHAR_BIT * size_in_bytes(); }
  type max_value() const { return INT_MAX; }
  type min_value() const { return INT_MIN; }
  NumericType type_id() const { return NumericType::INT; }
};

template <>
class NumericInfo<unsigned int>
{
  typedef unsigned int type;
 
public:
  bool signed_type() const { return false; }
  bool integer_type() const { return true; }
  size_t size_in_bytes() const { return sizeof(type); }
  size_t size_in_bits() { return CHAR_BIT * size_in_bytes(); }
  type max_value() const { return UINT_MAX; }
  type min_value() const { return 0; }
  NumericType type_id() const { return NumericType::UINT; }
};

template <>
class NumericInfo<signed long>
{
  typedef signed long type;
 
public:
  bool signed_type() const { return true; }
  bool integer_type() const { return true; }
  size_t size_in_bytes() const { return sizeof(type); }
  size_t size_in_bits() { return CHAR_BIT * size_in_bytes(); }
  type max_value() const { return LONG_MAX; }
  type min_value() const { return LONG_MIN; }
  NumericType type_id() const { return NumericType::LONG; }
};

template <>
class NumericInfo<unsigned long>
{
  typedef unsigned long type;
 
public:
  bool signed_type() const { return false; }
  bool integer_type() const { return true; }
  size_t size_in_bytes() const { return sizeof(type); }
  size_t size_in_bits() { return CHAR_BIT * size_in_bytes(); }
  type max_value() const { return ULONG_MAX; }
  type min_value() const { return 0; }
  NumericType type_id() const { return NumericType::ULONG; }
};

template <>
class NumericInfo<float>
{
  typedef float type;
 
public:
  bool signed_type() const { return true; }
  bool integer_type() const { return false; }
  size_t size_in_bytes() const { return sizeof(type); }
  size_t size_in_bits() { return CHAR_BIT * size_in_bytes(); }
  type max_value() const { return FLT_MAX; }
  type min_value() const { return -FLT_MAX; }
  NumericType type_id() const { return NumericType::FLOAT; }
};

template <>
class NumericInfo<double>
{
  typedef double type;
 
public:
  bool signed_type() const { return true; }
  bool integer_type() const { return false; }
  size_t size_in_bytes() const { return sizeof(type); }
  size_t size_in_bits() { return CHAR_BIT * size_in_bytes(); }
  type max_value() const { return DBL_MAX; }
  type min_value() const { return -DBL_MAX; }
  NumericType type_id() const { return NumericType::DOUBLE; }
};
 
END_NAMESPACE_STIR
 
#endif