|| || || || || || || ||

---

Sort.h

Go to the documentation of this file.

#ifndef Impala_Core_Column_Sort_h
#define Impala_Core_Column_Sort_h

#include <iostream>
#include "Core/Column/ColumnTem.h"
#include "Util/QuickSort.h"

namespace Impala
{
namespace Core
{
namespace Column
{


template <class C1, class C2>
inline void
SortAscending(C1* first, C2* second, int nrElem)
{
    ILOG_VAR(Impala.Core.Column.SortAscending);
    if (first->Capacity() == 0 || second->Capacity() == 0)
    {
        // no warning in case of empty column
        return;
    }
    if ((nrElem > first->Capacity()) || (nrElem > second->Capacity()))
    {
        ILOG_ERROR("Incompatible sizes");
        return;
    }

    // for some reason Dennis and Michiel chose different calling order for
    // the sorted and unsorted parameter
    Util::QuickSortCo(second->GetData(), first->GetData(), 0, nrElem - 1);
}

template <class C1, class C2>
inline void
SortAscendingTopN(C1* first, C2* second, C1* result, C2* resultSecond)
{
    ILOG_VAR(Impala.Core.Column.SortAscendingTopN);
    if (first->Capacity() != second->Capacity())
    {
        ILOG_ERROR("Incompatible sizes");
        return;
    }
    if (result->Capacity() != resultSecond->Capacity())
    {
        ILOG_ERROR("Incompatible sizes");
        return;
    }

    int nrElem = first->Capacity();
    int topN = result->Capacity();
    result->Set(0, first->Get(0));
    resultSecond->Set(0, second->Get(0));
    int curNr = 1;
    for (int i=1 ; i<nrElem ; i++)
    {
        int j=0;
        while ((j<curNr) && (second->Get(i) > resultSecond->Get(j)))
        {
            j++;
        }
        if (j == curNr)
        { // is larger than result
            if (curNr < topN)
            { // insert only when topN is not filled yet
                result->Set(curNr, first->Get(i));
                resultSecond->Set(curNr, second->Get(i));
                curNr++;
            }
        }
        else
        { // insert at current position
            if (curNr < topN)
            { // room left, so expand
                curNr++;
            }
            for (int k=curNr-1 ; k>j ; k--)
            { // move larger value towards end
                result->Set(k, result->Get(k-1));
                resultSecond->Set(k, resultSecond->Get(k-1));
            }
            result->Set(j, first->Get(i));
            resultSecond->Set(j, second->Get(i));
        }
    }
}

template <class C1, class C2>
inline void
SortDescending(C1* first, C2* second, int nrElem)
{
    ILOG_VAR(Impala.Core.Column.SortDescending);
    if ((nrElem > first->Capacity()) || (nrElem > second->Capacity()))
    {
        ILOG_ERROR("Incompatible sizes");
        return;
    }

    // for some reason Dennis and Michiel chose different calling order for
    // the sorted and unsorted parameter
    Util::QuickSortDescCo(second->GetData(), first->GetData(), 0, nrElem - 1);
}

template <class C1, class C2>
inline void
SortDescendingTopN(C1* first, C2* second, C1* result, C2* resultSecond)
{
    ILOG_VAR(Impala.Core.Column.SortDescendingTopN);
    if (first->Capacity() != second->Capacity())
    {
        ILOG_ERROR("Incompatible sizes");
        return;
    }
    if (result->Capacity() != resultSecond->Capacity())
    {
        ILOG_ERROR("Incompatible sizes");
        return;
    }

    int nrElem = first->Capacity();
    int topN = result->Capacity();
    result->Set(0, first->Get(0));
    resultSecond->Set(0, second->Get(0));
    int curNr = 1;
    for (int i=1 ; i<nrElem ; i++)
    {
        int j=0;
        while ((j<curNr) && (second->Get(i) < resultSecond->Get(j)))
        {
            j++;
        }
        if (j == curNr)
        { // is smaller than result
            if (curNr < topN)
            { // insert only when topN is not filled yet
                result->Set(curNr, first->Get(i));
                resultSecond->Set(curNr, second->Get(i));
                curNr++;
            }
        }
        else
        { // insert at current position
            if (curNr < topN)
            { // room left, so expand
                curNr++;
            }
            for (int k=curNr-1 ; k>j ; k--)
            { // move larger value towards end
                result->Set(k, result->Get(k-1));
                resultSecond->Set(k, resultSecond->Get(k-1));
            }
            result->Set(j, first->Get(i));
            resultSecond->Set(j, second->Get(i));
        }
    }
}

} // namespace Column
} // namespace Core
} // namespace Impala

#endif

---