Math.h

Go to the documentation of this file.

 
#ifndef _LIMBO_MATH_MATH
#define _LIMBO_MATH_MATH
 
#include <iterator>
#include <limits>

namespace limbo 
{

template <typename T>
inline T abs(T const& t)
{
    return (t > 0)? t : -t;
}

template <typename Iterator>
inline typename std::iterator_traits<Iterator>::value_type sum(Iterator first, Iterator last)
{
    typename std::iterator_traits<Iterator>::value_type v = 0;
    for (; first != last; ++first)
        v += *first;
    return v;
}

template <typename Iterator>
inline typename std::iterator_traits<Iterator>::value_type average(Iterator first, Iterator last)
{
    typename std::iterator_traits<Iterator>::value_type v = 0;
    size_t cnt = 0;
    for (; first != last; ++first)
    {
        v += *first;
        cnt += 1;
    }
    return v/cnt;
}

template <typename Iterator>
inline typename std::iterator_traits<Iterator>::value_type max(Iterator first, Iterator last)
{
    typename std::iterator_traits<Iterator>::value_type v = *first;
    for (; first != last; ++first)
    {
        if (v < *first)
            v = *first;
    }
    return v;
}

template <typename Iterator>
inline typename std::iterator_traits<Iterator>::value_type min(Iterator first, Iterator last)
{
    typename std::iterator_traits<Iterator>::value_type v = *first;
    for (; first != last; ++first)
    {
        if (v > *first)
            v = *first;
    }
    return v;
}

template <typename T>
inline T lowest(); 

template <>
inline char lowest<char>()
{
    return std::numeric_limits<char>::min();
}

template <>
inline unsigned char lowest<unsigned char>()
{
    return std::numeric_limits<unsigned char>::min();
}

template <>
inline short lowest<short>()
{
    return std::numeric_limits<short>::min();
}

template <>
inline unsigned short lowest<unsigned short>()
{
    return std::numeric_limits<unsigned short>::min();
}

template <>
inline int lowest<int>()
{
    return std::numeric_limits<int>::min();
}

template <>
inline unsigned int lowest<unsigned int>()
{
    return std::numeric_limits<unsigned int>::min();
}

template <>
inline long lowest<long>()
{
    return std::numeric_limits<long>::min();
}

template <>
inline unsigned long lowest<unsigned long>()
{
    return std::numeric_limits<unsigned long>::min();
}

template <>
inline long long lowest<long long>()
{
    return std::numeric_limits<long long>::min();
}

template <>
inline unsigned long long lowest<unsigned long long>()
{
    return std::numeric_limits<unsigned long long>::min();
}

template <>
inline float lowest<float>()
{
    return -std::numeric_limits<float>::max();
}

template <>
inline double lowest<double>()
{
    return -std::numeric_limits<double>::max();
}

template <>
inline long double lowest<long double>()
{
    return -std::numeric_limits<long double>::max();
}

 
} // namespace limbo 
 
#endif