KernelMath.h

Go to the documentation of this file.

// this is a -*- C++ -*- file

// -- BEGIN LICENSE BLOCK ----------------------------------------------
//
// You received this file as part of MCA2
// Modular Controller Architecture Version 2
//
// Copyright (C) FZI Forschungszentrum Informatik Karlsruhe
//
// This program is free software; you mild_base_driving redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//
// -- END LICENSE BLOCK ------------------------------------------------

//----------------------------------------------------------------------
//----------------------------------------------------------------------
#ifndef _KernelMath_h_
#define _KernelMath_h_

//----------------------------------------------------------------------
// non MCA Includes - include with <>
// MCA Includes - include with ""
//----------------------------------------------------------------------
#include <limits.h>

//----------------------------------------------------------------------
//                                Mathematical Function
//----------------------------------------------------------------------

template <class T>
inline T Max(T a, T b)
{
    return a > b ? a : b;
}


inline double Max(double a, double b)
{
    return a > b ? a : b;
}

inline double Max(double a, long b)
{
    return a > b ? a : b;
}

inline double Max(double a, unsigned long b)
{
    return a > b ? a : b;
}

inline double Max(double a, int b)
{
    return a > b ? a : b;
}

inline double Max(double a, unsigned b)
{
    return a > b ? a : b;
}

inline double Max(long a, double b)
{
    return a > b ? a : b;
}

inline double Max(unsigned long a, double b)
{
    return a > b ? a : b;
}

inline double Max(int a, double b)
{
    return a > b ? a : b;
}

inline double Max(unsigned a, double b)
{
    return a > b ? a : b;
}

inline int Max(int a, int b)
{
    return a > b ? a : b;
}

#if 1
//#ifdef _SYSTEM_DARWIN_
inline unsigned long Max(unsigned long a, int b)
{
    // !!!Be Carefull size_t will be casted to unsigned!!!
    return b < 0 ? a : Max(unsigned(a), unsigned(b));
}

inline unsigned long Max(int a, unsigned long b)
{
    // !!!Be Carefull size_t will be casted to unsigned!!!
    return a < 0 ? b : Max(unsigned(a), unsigned(b));
}

inline unsigned long Max(unsigned a, unsigned long b)
{
    return a > b ? a : b;
}
#endif

inline unsigned Max(unsigned a, unsigned b)
{
    return a > b ? a : b;
}

inline unsigned Max(int a, unsigned b)
{
    return a < 0 ? b : Max(unsigned(a), b);
}

inline unsigned Max(unsigned a, int b)
{
    return Max(b, a);
}

inline double Max(double a, double b, double c)
{
    return Max(a, Max(b, c));
}

template<typename A, typename B, typename C, typename D, typename R>
inline R Max(A a, B b, C c, D d)
{
    return Max(a, Max(b, Max(c, d)));
}

template <class T>
inline T Min(T a, T b)
{
    return a < b ? a : b;
}

inline double Min(double a, double b)
{
    return a < b ? a : b;
}

inline double Min(double a, long b)
{
    return a < b ? a : b;
}

inline double Min(double a, int b)
{
    return a < b ? a : b;
}

inline double Min(double a, unsigned long b)
{
    return a < b ? a : b;
}

inline double Min(double a, unsigned b)
{
    return a < b ? a : b;
}

inline double Min(long a, double b)
{
    return a < b ? a : b;
}

inline double Min(int a, double b)
{
    return a < b ? a : b;
}

inline double Min(unsigned long a, double b)
{
    return a < b ? a : b;
}

inline double Min(unsigned a, double b)
{
    return a < b ? a : b;
}

inline int Min(int a, int b)
{
    return a < b ? a : b;
}

inline void* Min(void* a, void* b)
{
    return a < b ? a : b;
}

inline unsigned Min(unsigned a, unsigned b)
{
    return a < b ? a : b;
}

inline int Min(int a, unsigned int b)
{
    return b > INT_MAX ? a : (Min(int(b), a));
}

inline int Min(unsigned int a, int b)
{
    return Min(b, a);
}

inline double Min(double a, double b, double c)
{
    return Min(a, Min(b, c));
}

template<typename A, typename B, typename C, typename D, typename R>
inline R Min(A a, B b, C c, D d)
{
    return Min(a, Min(b, Min(c, d)));
}

template<typename T>
inline T Abs(T x)
{
    return (x > 0 ? x : -x);
}

#endif