sort

#include "sys/types.h"
#include "assert.h"
#include "memory.h"

template <typename T>
int bits(const T& a) {
    unsigned int l, h;
    switch (sizeof(T)) {
        case 8:
            h = a >> 32;
            if (h)
                return 64 - __builtin_clz(h);
        case 4:
        case 2:
        case 1:
            l = a;
            if (l)
                return 32 - __builtin_clz(l);
            return 0;
        default:
            assert(0);
    }
}


template<typename _Tp>
static inline  void  swap(_Tp& __a, _Tp& __b)
{
    _Tp __tmp = (__a);
    __a = (__b);
    __b = (__tmp);
}

template<typename _Tp, size_t _Nm>
static inline void swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
{
    for (size_t __n = 0; __n < _Nm; ++__n)
        swap(__a[__n], __b[__n]);
}

template <typename T>
void assign(T &p, const T& e){
    p = e; //Forward()
}

template <typename T>
static inline int compare(const T& a, const T& b){
    if (a < b)
        return -1;
    else if (a == b)
        return 0;
    else
        return 1;
}

template <typename T>
static inline int pcompare(const T* a, const T* b){
    return compare(*a, *b);
}

template <typename T, size_t trun = 0, size_t bits = (sizeof(T) * 8)>
static inline size_t bucketstep(const T& t){
    return (t >> trun) & (((1 << (bits - 1)) - 1) | (1 << (bits - 1)));
}


template <size_t size, typename T,  //if max=255 then size = 256;
        size_t (*bucket)(const T& t) = bucketstep<T>,
        int(*comp)(const T *e1, const T *e2) = pcompare>
void  CountSort(T* const d, const T* const s, size_t n){ //d, s cant be same
    size_t buckets[size] = {};
    for (size_t i = 0; i < n; i++){
        ++buckets[bucket(s[i])];
    }

    for (size_t i = 1; i < size; i++){
        buckets[i] += buckets[i - 1];
    }

    for (size_t i = n - 1; i != -1; i--){
        assign(d[--buckets[bucket(s[i])]], s[i]);
    }
}

template <typename T,
        int(*comp)(const T *e1, const T *e2) = pcompare, size_t radix = 8>
void  RadixSort(T* d, T* s, size_t n) //d, s cant be same
{
    size_t step = sizeof(T);
    switch (step) {
        case 8:
            CountSort<1 << radix, T, bucketstep<T, radix * 7, radix>, comp>(d, s, n);
            swap(d, s);
        case 7:
            CountSort<1 << radix, T, bucketstep<T, radix * 6, radix>, comp>(d, s, n);
            swap(d, s);
        case 6:
            CountSort<1 << radix, T, bucketstep<T, radix * 5, radix>, comp>(d, s, n);
            swap(d, s);
        case 5:
            CountSort<1 << radix, T, bucketstep<T, radix * 4, radix>, comp>(d, s, n);
            swap(d, s);
        case 4:
            CountSort<1 << radix, T, bucketstep<T, radix * 3, radix>, comp>(d, s, n);
            swap(d, s);
        case 3:
            CountSort<1 << radix, T, bucketstep<T, radix * 2, radix>, comp>(d, s, n);
            swap(d, s);
        case 2:
            CountSort<1 << radix, T, bucketstep<T, radix * 1, radix>, comp>(d, s, n);
            swap(d, s);
        case 1:
            CountSort<1 << radix, T, bucketstep<T, 0, radix>, comp>(d, s, n);
            swap(d, s);
            break;
        default:
            assert(0);
    }
    if (!(step & 01))
        memcpy(d, s, sizeof(T) * n);
}



template <typename T>
const T& FindMax(const T* a, size_t n){
    const T* max = &a[0];
    for (size_t i = 1; i < n; i++){
        if (a[i] > *max)
            max = &a[i];
    }
    return *max;
}





template <typename T>
bool isSorted(const T* a, size_t n){
    for (size_t i = 1; i < n; i++){
        if (a[i] < a[i - 1])
            return false;
    }
    return true;
}

int f(){
#define N 5
    size_t s[N] = {0x783, 0x343, 32, 8, 9}, d[N];
    RadixSort(d, s, N);
    return  1;
}

template <typename T,
        int(*comp)(const T *e1, const T *e2) = pcompare, size_t radix = 8>
void  RadixSort(T* dst, T* src, size_t n) //d, s cant be same
{
    T *s = src;
    T* d = dst;
    for (int j = 0; j < 8; j++){
        const int size = 1 << 8;
        size_t buckets[size] = {};
        for (size_t i = 0; i < n; i++){
            ++buckets[(s[i] >> j * 8) & 0xff];
        }

        for (size_t i = 1; i < size; i++){
            buckets[i] += buckets[i - 1];
        }

        for (size_t i = n - 1; i != -1; i--){
            assign(d[--buckets[(s[i] >> j * 8) & 0xff]], s[i]);
        }
        swap(s, d);
    }
    memmove(dst, s, sizeof(T) * n);
}

#include "sys/types.h"
#include "assert.h"
#include "memory.h"

template <typename T>
int bits(const T& a) {
    unsigned int l, h;
    switch (sizeof(T)) {
        case 8:
            h = a >> 32;
            if (h)
                return 64 - __builtin_clz(h);
        case 4:
        case 2:
        case 1:
            l = a;
            if (l)
                return 32 - __builtin_clz(l);
            return 0;
        default:
            assert(0);
    }
}


template<typename _Tp>
static inline  void  swap(_Tp& __a, _Tp& __b)
{
    _Tp __tmp = (__a);
    __a = (__b);
    __b = (__tmp);
}

template<typename _Tp, size_t _Nm>
static inline void swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
{
    for (size_t __n = 0; __n < _Nm; ++__n)
        swap(__a[__n], __b[__n]);
}


#define swap_ swap
//template <typename T>
//void assign(T &p, const T& e){
//    p = e; //Forward()
//}

//template <typename T>
//static inline int compare(const T& a, const T& b){
//    if (a < b)
//        return -1;
//    else if (a == b)
//        return 0;
//    else
//        return 1;
//}

#include "3.h"


template <typename T>
static inline int pcompare(const T* a, const T* b){
    return compare(*a, *b);
}

template <typename T, size_t trun = 0, size_t bits = (sizeof(T) * 8)>
static inline size_t bucketstep(const T& t){
    return (t >> trun) & (((1 << (bits - 1)) - 1) | (1 << (bits - 1)));
}


template <size_t size, typename T,  //if max=255 then size = 256;
        size_t (*bucket)(const T& t) = bucketstep<T>,
        int(*comp)(const T *e1, const T *e2) = pcompare>
void  CountSort(T* const d, const T* const s, size_t n){ //d, s cant be same
    size_t buckets[size] = {};
    for (size_t i = 0; i < n; i++){
        ++buckets[bucket(s[i])];
    }

    for (size_t i = 1; i < size; i++){
        buckets[i] += buckets[i - 1];
    }

    for (size_t i = n - 1; i != -1; i--){
        assign(d[--buckets[bucket(s[i])]], s[i]);
    }
}

template <typename T,
        int(*comp)(const T *e1, const T *e2) = pcompare, size_t radix = 8>
void  RadixSort(T* dst, T* src, size_t n) //d, s cant be same
{
    T *s = src;
    T* d = dst;
    for (int j = 0; j < 8; j++){
        const int size = 1 << 8;
        size_t buckets[size] = {};
        for (size_t i = 0; i < n; i++){
            ++buckets[(s[i] >> j * 8) & 0xff];
        }

        for (size_t i = 1; i < size; i++){
            buckets[i] += buckets[i - 1];
        }

        for (size_t i = n - 1; i != -1; i--){
            assign(d[--buckets[(s[i] >> j * 8) & 0xff]], s[i]);
        }
        swap(s, d);
    }
    memmove(dst, s, sizeof(T) * n);
}



template <typename T>
const T& FindMax(const T* a, size_t n){
    const T* max = &a[0];
    for (size_t i = 1; i < n; i++){
        if (a[i] > *max)
            max = &a[i];
    }
    return *max;
}





template <typename T>
bool isSorted(const T* a, size_t n){
    for (size_t i = 1; i < n; i++){
        if (a[i] < a[i - 1])
            return false;
    }
    return true;
}


#include "stdio.h"
#include "time.h"
struct Clock
{
public:
    Clock() {Start();}
    void Start() {beg = clock();}
    void Finished() {end = clock();}
    clock_t Elapsed() {return Finished(), end - beg;}
    double ElapsedToSec() {return (double)Elapsed()/CLOCKS_PER_SEC;}
    double ElapsedToMin() {return ElapsedToSec() / 60;}
    double ElapsedToHor() {return ElapsedToMin() / 60;}

private:
    clock_t beg, end;
};


#include "stdlib.h"
template <typename T>
int cmps(const void *a, const void *b){
    return compare(*(const T*)a, *(const T*)b);
}

int f(){
#define N 0xffff5
    //size_t s[N] = {14, 13, 3, 8, 9}, d[N];
    size_t *d = (size_t *)malloc(N * sizeof(size_t));
    size_t *dq = (size_t *)malloc(N * sizeof(size_t));
    size_t *di = (size_t *)malloc(N * sizeof(size_t));
    size_t *s = (size_t *)malloc(N * sizeof(size_t));
    for (int i = 0; i < N; i++){
        s[i] = rand();
        s[i] = (s[i] << 32) | rand();
    }
    Clock t1;
    RadixSort(d, s, N);
    auto e1 = t1.ElapsedToSec();

    memcpy(di, s, N * sizeof(size_t));
    Clock t2;
    //InsertSort<size_t>(&di[0], &di[N-1]);
    qsort(di, N, sizeof(size_t), cmps<size_t>);
    auto e2 = t2.ElapsedToSec();

    memcpy(dq, s, N * sizeof(size_t));
    Clock t3;
    QuickSort<size_t>(&dq[0], &dq[N-1]);
    //QuickSort(dq, N);

    auto e3 = t3.ElapsedToSec();

    printf("%lf\n", e1);
    printf("%lf\n", e2);
    printf("%lf\n", e3);
//    auto b1 = isSorted(d, N);
//    auto b2 = isSorted(dq, N);
    int k = /*memcmp(dq, d, N * sizeof(size_t)) |*/  memcmp(dq, di, N * sizeof(size_t));
    printf("%d\n", k);
    return  0;
}

int main(){
    return f();
}