itkMath.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkMath.h,v $
  Language:  C++
  Date:      $Date: 2010-04-07 17:25:21 $
  Version:   $Revision: 1.16 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

  Portions of this code are covered under the VTK copyright.
  See VTKCopyright.txt or http://www.kitware.com/VTKCopyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/

#ifndef __itkMath_h
#define __itkMath_h


#include "itkConfigure.h"
#include "itkIntTypes.h"
#include "itkMathDetail.h"
#include "itkConceptChecking.h"


namespace itk 
{
namespace Math 
{

// These constants originate from VXL's vnl_math.h. They have been
// moved here to improve visibility, and to ensure that the constants
// are available during compile time ( as opposed to static const
// member vaiables ).

static const double e                = 2.7182818284590452354;
static const double log2e            = 1.4426950408889634074;
static const double log10e           = 0.43429448190325182765;
static const double ln2              = 0.69314718055994530942;
static const double ln10             = 2.30258509299404568402;
static const double pi               = 3.14159265358979323846;
static const double pi_over_2        = 1.57079632679489661923;
static const double pi_over_4        = 0.78539816339744830962;
static const double one_over_pi      = 0.31830988618379067154;
static const double two_over_pi      = 0.63661977236758134308;
static const double two_over_sqrtpi  = 1.12837916709551257390;
static const double one_over_sqrt2pi = 0.39894228040143267794;
static const double sqrt2            = 1.41421356237309504880;
static const double sqrt1_2          = 0.70710678118654752440;


#ifdef ITK_HAS_INT_64

#define itkTemplateFloatingToIntegerMacro(name)                         \
  template <typename TReturn,typename TInput>                           \
  inline TReturn name(TInput x)                                         \
  {                                                                     \
                                                                        \
    if (sizeof(TReturn) <= 4)                                           \
      {                                                                 \
      return static_cast<TReturn>(Detail::name##_32(x));                \
      }                                                                 \
    else if (sizeof(TReturn) <= 8)                                      \
      {                                                                 \
      return static_cast<TReturn>(Detail::name##_64(x));                \
      }                                                                 \
    else                                                                \
      {                                                                 \
      return static_cast<TReturn>(Detail::name##_base<TReturn,TInput>(x)); \
      }                                                                 \
   }
#else
#define itkTemplateFloatingToIntegerMacro(name)                         \
  template <typename TReturn,typename TInput>                           \
  inline TReturn name(TInput x)                                         \
  {                                                                     \
    if (sizeof(TReturn) <= 4)                                           \
      {                                                                 \
      return static_cast<TReturn>(Detail::name##_32(x));                \
      }                                                                 \
    else                                                                \
      {                                                                 \
      return static_cast<TReturn>(Detail::name##_base<TReturn,TInput>(x)); \
      }                                                                 \
   }
#endif // end ITK_HAS_INT_64


itkTemplateFloatingToIntegerMacro(RoundHalfIntegerToEven);

itkTemplateFloatingToIntegerMacro(RoundHalfIntegerUp);

template <typename TReturn, typename TInput>
inline TReturn Round(TInput x) { return RoundHalfIntegerUp<TReturn,TInput>(x); }

itkTemplateFloatingToIntegerMacro(Floor);

itkTemplateFloatingToIntegerMacro(Ceil);


#undef  itkTemplateFloatingToIntegerMacro


#if !defined(ITK_LEGACY_REMOVE) &&  !VCL_TEMPLATE_MATCHES_TOO_OFTEN
// VCL_TEMPLATE_MATCHES_TOO_OFTEN is used here because some compilers
// can not handle function overloading with templated and
// non-templated methods, ie the templated functions matches too often


inline int RoundHalfIntegerToEven(double x) { return Detail::RoundHalfIntegerToEven_32(x); }
inline int RoundHalfIntegerToEven(float  x) { return Detail::RoundHalfIntegerToEven_32(x); }

inline int RoundHalfIntegerUp(double x) { return Detail::RoundHalfIntegerUp_32(x); }
inline int RoundHalfIntegerUp(float  x) { return Detail::RoundHalfIntegerUp_32(x); }

inline int Round(double x) { return Detail::RoundHalfIntegerUp_32(x); }
inline int Round(float  x) { return Detail::RoundHalfIntegerUp_32(x); }

inline int Floor(double x) { return Detail::Floor_32(x); }
inline int Floor(float  x) { return Detail::Floor_32(x); }

inline int Ceil(double x) { return Detail::Ceil_32(x); }
inline int Ceil(float  x) { return Detail::Ceil_32(x); }
#endif // end of ITK_LEGACY_REMOVE

template <typename TReturn,typename TInput>
inline TReturn CastWithRangeCheck(TInput x)
{

#ifdef ITK_USE_CONCEPT_CHECKING
  itkConceptMacro( OnlyDefinedForIntegerTypes1, (itk::Concept::IsInteger<TReturn>) );
  itkConceptMacro( OnlyDefinedForIntegerTypes2, (itk::Concept::IsInteger<TInput>) );
#endif // ITK_USE_CONCEPT_CHECKING

  TReturn ret = static_cast<TReturn>(x);
  if ( sizeof (TReturn) > sizeof(TInput) && 
       !( !itk::NumericTraits<TReturn>::is_signed &&  itk::NumericTraits<TInput>::is_signed ) )
    { 
    // if the output type is bigger and we are not converting a signed
    // interger to an unsigned interger then we have no problems
    return ret;
    }
  else if ( sizeof (TReturn) >= sizeof(TInput) )
    {
    if ( itk::NumericTraits<TInput>::IsPositive(x) != itk::NumericTraits<TReturn>::IsPositive(ret) )
     {
     itk::RangeError _e(__FILE__, __LINE__);
     throw _e;
     }
    }
  else if ( static_cast<TInput>(ret) != x ||
            ( itk::NumericTraits<TInput>::IsPositive(x) != itk::NumericTraits<TReturn>::IsPositive(ret) ) )
    {
    itk::RangeError _e(__FILE__, __LINE__);
    throw _e;
    }
  return ret;
}

} // end namespace Math
} // end namespace itk
#endif // end of itkMath.h