std::radix_sorter< T > Template-Klassenreferenz

#include <radix_sorter.hpp>

Öffentliche Typen
enum	data_type { data_unsigned = false, data_signed }

Öffentliche Methoden
template<data_type TDataType, typename TFunc >
void	sort (T *src, int num, const TFunc &func, T *help_buffer)
template<data_type TDataType, typename TFunc >
void	sort (T *src, int num, const TFunc &func)

Statische öffentliche Attribute
static const size_t	kHistogramSize = 256

Ausführliche Beschreibung

template<typename T>
class std::radix_sorter< T >

Dokumentation der Aufzählungstypen

data_type

template<typename T >

enum std::radix_sorter::data_type

Aufzählungswerte
data_unsigned
data_signed

        {
            data_unsigned = false,
            data_signed,
        };

Dokumentation der Elementfunktionen

sort() [1/2]

template<typename T >

template<data_type TDataType, typename TFunc >

void std::radix_sorter< T >::sort ( T *  src, int  num, const TFunc &  func, T *  help_buffer  )

inline

        {
            if (num == 0) return;

            uint32_t histogram[kHistogramSize * 4];
            Sys::MemSet(histogram, 0, sizeof(histogram));

            uint32_t* h1 = &histogram[0] + kHistogramSize;
            uint32_t* h2 = h1 + kHistogramSize;
            uint32_t* h3 = h2 + kHistogramSize;

            bool alreadySorted(true);
            uint32_t prevValue = func(src[0]);

            int k(0);
            for (int i = 0; i < num; ++i)
            {
                k = i;
                const uint32_t x = func(src[i]);
                if (alreadySorted && x < prevValue)
                {
                        alreadySorted = false;
                        break;
                }
                const uint8_t* px = (const uint8_t*)&x;

                ++histogram[*px];
                ++h1[px[1]];
                ++h2[px[2]];
                ++h3[px[3]];

                prevValue = x;
            }
            if (alreadySorted)
                    return;

            for (; k < num; ++k)
            {
                const uint32_t x = func(src[k]);
                const uint8_t* px = (const uint8_t*)&x;

                ++histogram[*px];
                ++h1[px[1]];
                ++h2[px[2]];
                ++h3[px[3]];
            }
            
            const bool canBreakAfter16Bits = (h2[0] == (uint32_t)num && h3[0] == (uint32_t)num);
            (void)canBreakAfter16Bits;

            if (TDataType == data_signed)
                calculate_offsets_signed(histogram);
            else
                calculate_offsets(histogram);

            for (int i = 0; i < num; ++i)
            {
                const uint32_t pos = func(src[i]) & 0xFF;
                help_buffer[histogram[pos]++] = src[i];
            }
            
            for (int i = 0; i < num; ++i)
            {
                const uint32_t pos = (func(m_dst[i]) >> 8) & 0xFF;
                src[h1[pos]++] = help_buffer[i];
            }
            
            if (TDataType == data_unsigned && canBreakAfter16Bits)
                return;
                    
            for (int i = 0; i < num; ++i)
            {
                const uint32_t pos = (func(src[i]) >> 16) & 0xFF;
                help_buffer[h2[pos]++] = src[i];
            }
            
            for (int i = 0; i < num; ++i)
            {
                const uint32_t pos = (func(m_dst[i]) >> 24) & 0xFF;
                src[h3[pos]++] = help_buffer[i];
            }
        }

sort() [2/2]

template<typename T >

template<data_type TDataType, typename TFunc >

void std::radix_sorter< T >::sort ( T *  src, int  num, const TFunc &  func  )

inline

        {
            if (num > m_dst.size())
                    resize(num);
            sort<TDataType, TFunc>(src, num, func, m_dst.begin());
        }               

Dokumentation der Datenelemente

kHistogramSize

template<typename T >

const size_t std::radix_sorter< T >::kHistogramSize = 256

static

---

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:

• include/radix_sorter.hpp