#include <thrust/device_vector.h>
#include <thrust/sort.h>
#include <thrust/extrema.h>
#include <iostream>

extern "C" {

// ------ Sort algorithms ------ //

// Sort for integer arrays
void sort_int_wrapper( int *data, int N)
{
// Wrap raw pointer with a device_ptr
thrust::device_ptr <int> dev_ptr(data);
// Use device_ptr in Thrust sort algorithm
thrust::sort(dev_ptr, dev_ptr+N);
}

// Sort for float arrays
void sort_float_wrapper( float *data, int N)
{
thrust::device_ptr <float> dev_ptr(data);
thrust::sort(dev_ptr, dev_ptr+N);
}

// Sort for double arrays
void sort_double_wrapper( double *data, int N)
{

thrust::device_ptr <double> dev_ptr(data);
thrust::sort(dev_ptr, dev_ptr+N);
}

// ------ Min/Max algorithms ------ //

// Min for integer arrays
int min_int_wrapper( int *data, int N)
{
thrust::device_ptr <int> dev_ptr(data);
// Return index of minimum element:
return thrust::min_element(dev_ptr, dev_ptr + N) - dev_ptr;
}

int min_float_wrapper( float *data, int N)
{
thrust::device_ptr <float> dev_ptr(data);
return thrust::min_element(dev_ptr, dev_ptr + N) - dev_ptr;
}

int min_double_wrapper( double *data, int N)
{
thrust::device_ptr <double> dev_ptr(data);
return thrust::min_element(dev_ptr, dev_ptr + N) - dev_ptr;
}

// Max for integer arrays
int max_int_wrapper( int *data, int N)
{
thrust::device_ptr <int> dev_ptr(data);
// Return index of maximum element:
return thrust::max_element(dev_ptr, dev_ptr + N) - dev_ptr;
}

int max_float_wrapper( float *data, int N)
{
thrust::device_ptr <float> dev_ptr(data);
return thrust::max_element(dev_ptr, dev_ptr + N) - dev_ptr;
}

int max_double_wrapper( double *data, int N)
{
thrust::device_ptr <double> dev_ptr(data);
return thrust::max_element(dev_ptr, dev_ptr + N) - dev_ptr;
}

// ------ Reduction (sum) algorithms ------ //

// Sum for integer arrays
int reduce_int_wrapper( int *data, int N)
{
// Wrap raw pointer with a device_ptr
thrust::device_ptr <int> dev_ptr(data);
// Use device_ptr in Thrust reduce algorithm
return thrust::reduce(dev_ptr, dev_ptr+N);
}

float reduce_float_wrapper( float *data, int N)
{
thrust::device_ptr <float> dev_ptr(data);
return thrust::reduce(dev_ptr, dev_ptr+N);
}

double reduce_double_wrapper( double *data, int N)
{

thrust::device_ptr <double> dev_ptr(data);
return thrust::reduce(dev_ptr, dev_ptr+N);
}

}