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