average.cpp

Go to the documentation of this file.

 
#include <semf/utils/processing/average.h>
 
namespace semf
{
template <typename T>
T Average<T>::value(const T data[], size_t dataSize)
{
    const Buffer<T> buffer(const_cast<T*>(data), dataSize);
    return value(buffer);
}
 
template <typename T>
T Average<T>::value(const Buffer<T>& data)
{
    T sumLow = 0;
    T sumLowLast = 0;
    size_t sumHigh = 0;
    size_t sumHighLast = 0;
    size_t nValuesSummed = 0;
 
    if (data.data() == nullptr)
    {
        return 0;
    }
 
    // summing up the values
    for (size_t i = 0; i < data.count(); i++)
    {
        sumLow += data[i];
        if (sumLowLast > sumLow)
        {
            sumHigh++;
 
            // prevent overflow from sumHigh
            if (sumHighLast > sumHigh)
            {
                sumLow = sumLowLast;
                sumHigh = sumHighLast;
                break;
            }
        }
        sumLowLast = sumLow;
        sumHighLast = sumHigh;
        nValuesSummed++;
    }
 
    return divide(sumHigh, sumLow, nValuesSummed);
}
 
template <typename T>
T Average<T>::divide(size_t highValue, T lowValue, size_t divider)
{
    uint32_t binPlacesDivider = 0;  // for counting the binary places of the divider
    T mask = 0;
    size_t divideHelper = 0;  // for saving the intermediate steps by the division
    T result = 0;
 
    // counting the binaryplaces of the divider
    for (uint32_t i = 0; i < static_cast<uint32_t>(sizeof(divider)) * 8; i++)
    {
        if (!(divider >> i))
        {
            binPlacesDivider = i;
            break;
        }
    }
    // Make a mask that has as many ones as the divider has binary places
    for (uint32_t i = 0; i < binPlacesDivider; i++)
    {
        mask = mask << 1;
        mask += 1;
    }
 
    divideHelper = highValue >> static_cast<T>(((sizeof(std::size_t) * 8) - binPlacesDivider) & mask);
 
    // do division
    for (int i = ((sizeof(T) + sizeof(std::size_t)) * 8) - binPlacesDivider; i >= 0; i--)
    {
        result <<= 1;
        if (divideHelper >= divider)
        {
            result++;
            divideHelper = divideHelper - divider;
        }
        divideHelper = divideHelper << 1;
 
        if (i > static_cast<int>(sizeof(T)) * 8)
            divideHelper = divideHelper + static_cast<T>((highValue >> (i - (sizeof(T) * 8) - 1)) & 1);
        else
            divideHelper = divideHelper + static_cast<T>((lowValue >> (i - 1)) & 1);
    }
    return result;
}
} /* namespace semf */