// main.cpp
    #include <iostream>
    #include <ctime> // For seeding with time(NULL)
    #include <cuda.h>
    #include <curand.h>  // CURAND host API header

    using namespace std;

    int main() {
    // Count of numbers to generate
    const int count = 20;

    // Device generator stores in device global memory
    curandGenerator_t deviceGenerator;

    // Host generators store in system RAM
    curandGenerator_t hostGenerator;

    // Define device pointer for storing deviceGenerator results
    float *d_deviceOutput;

    // Define host arrays for storing hostGenerator's results
    float h_deviceOutput[count], hostOutput[count];

    // Allocate memory on device for deviceGenerator
    cudaMalloc(&d_deviceOutput, sizeof(float)*count);

    // Initialize the two generators
    curandCreateGenerator(&deviceGenerator, CURAND_RNG_PSEUDO_DEFAULT);
    curandCreateGeneratorHost(&hostGenerator, CURAND_RNG_PSEUDO_DEFAULT);

    // Set the seed for both generators to 0\. Using the same seed will
    // cause both generators create exactly the same sequence.
    curandSetPseudoRandomGeneratorSeed(deviceGenerator, 0);
    curandSetPseudoRandomGeneratorSeed(hostGenerator, 0);

    // If you would like the generators to use an unpredictable seed and
    // create different sequences, you can use time(NULL) as the seed.
    // Alter the value in some way (I've multiplied my hostGenerators by 10
    // in the following) otherwise time(NULL) will be exactly the same when
    // you seed them.
    // curandSetPseudoRandomGeneratorSeed(deviceGenerator, time(NULL));
    // curandSetPseudoRandomGeneratorSeed(hostGenerator, time(NULL)*10);

    // Generate a random block of uniform floats with both generators:
    // The deviceGenerator outputs to global memory:
    curandGenerateUniform(deviceGenerator, d_deviceOutput, count);
    // The hostGenerator's output is in system RAM
    curandGenerateUniform(hostGenerator, hostOutput, count);

    // Copy the device results to the host
    cudaMemcpy(h_deviceOutput, d_deviceOutput,
           sizeof(float)*count, cudaMemcpyDeviceToHost);

    // Free device and CURAND resources
    cudaFree(d_deviceOutput);
    curandDestroyGenerator(deviceGenerator);
    curandDestroyGenerator(hostGenerator);

    // Print out the generator sequences for comparison
    for(int i = 0; i < count; i++) {
           cout<<i<<". Device generated "<<h_deviceOutput[i]<<
                  " Host generated "<<hostOutput[i]<<endl;
           }

    return 0;
    }

    // Generate a random block of floats from normal curves
    curandGenerateNormal(deviceGenerator, d_deviceOutput, count, 0.0f, 1.0f);
    curandGenerateNormal(hostGenerator, hostOutput, count, 0.0f, 1.0f);

    // main.cu
    #include <iostream>
    #include <cuda.h>
    #include <curand_kernel.h>
    #include <device_launch_parameters.h>

    using namespace std;

    // Kernel to init random generator states
    __global__ void InitRandGenerator(curandStateMRG32k3a *state) {
    int id = threadIdx.x + blockIdx.x * blockDim.x;

    // Init the seed for this thread
    curand_init(0, id, 0, &state[id]);
    }

    // Generate random numbers using the device API
    __global__ void Generate(unsigned int *result, int count, curandStateMRG32k3a *state) {
    int idx = threadIdx.x + blockIdx.x * blockDim.x;

    // Make a local copy of the state
    curandStateMRG32k3a localState = state[idx];

    // Generate one number per thread
    if(idx < count) {
           // The numbers generated will be integers between 0 and 100
           result[idx] = (unsigned int) curand(&localState)%100;
           }
    }

    int main() {
    // How many numbers to generate
    const int count = 100;

    // Declare the arrays to hold the results
    unsigned int* h_a = new unsigned int[count];
    unsigned int* d_a;
    cudaMalloc(&d_a, sizeof(unsigned int)*count);

    // Declare the array to hold the state of the generator
    curandStateMRG32k3a *generatorState;
    cudaMalloc(&generatorState, sizeof(curandStateMRG32k3a) * count);

    // Call an init kernel to set up the state
    InitRandGenerator<<<(count/64)+1, 64>>>(generatorState);

    // Call a kernel to generate the random numbers
    Generate<<<(count/64)+1, 64>>>(d_a, count, generatorState);

    // Copy the results back to the host
    cudaMemcpy(h_a, d_a, sizeof(unsigned int)*count, cudaMemcpyDeviceToHost);

    // Print the results to the screen
    for(int i = 0; i < count; i++)
           cout<<i<<". "<<h_a[i]<<endl;

    // Free resources
    cudaFree(d_a);
    cudaFree(generatorState);
    delete[] h_a;

    return 0;
    }

    // main.cu
    #include <iostream>
    #include <thrust\host_vector.h>
    #include <thrust\device_vector.h>
    #include <vector>    // STL vector header

    int main() {
    // Defining vectors

    // STL vector, 100 ints set to 18
    std::vector<int> stdV(100, 18);

    // Host vector of 100 floats
    thrust::host_vector<float> h(100);

    // Host vector, 100 ints set to 67
    thrust::host_vector<int> hi(100, 67);

    // Empty device vector of doubles
    thrust::device_vector<double> dbv;

    // Device vector, 100 ints set to 0
    thrust::device_vector<int> di(100, 0);

    //
    // Adding and removing elements
    //

    // Print initial element count for h
    std::cout<<"H contains "<<h.size()<<" elements"<<std::endl;

    // Remove last element
    h.pop_back();
    std::cout<<"H contains "<<h.size()<<" elements"<<std::endl;

    // Adding and removing elements from device vector is the same
    dbv.push_back(0.5);
    std::cout<<"Final elements of dbv is "<<dbv.back()<<std::endl;
    dbv.pop_back();

    //
    // Copying data between vectors
    //

    // Print out the first element of h
    std::cout<<"First element of hi is "<<hi[0]<<std::endl;

    // Copying host vector to device vector
    di = hi;
    std::cout<<"First element of di is "<<di[0]<<std::endl;

    // Copy from STD vector to device vector
    di = stdV;
    std::cout<<"First element of di is "<<di[0]<<std::endl;

    return 0;
    }

    // main.cu
    // Standard headers
    #include <iostream>
    #include <ctime>

    // CUDA and Thrust headers
    #include <thrust\host_vector.h>
    #include <thrust\device_vector.h>
    #include <thrust\sort.h>

    // STL headers
    #include <vector>
    #include <algorithm>

    // Helper defines and variable for timing
    long startTime;
    #define StartTimer() startTime=clock()
    #define ElapsedTime (clock()-startTime)

    int main() {
    int count = 20000000; // 20 million elements to sort

    // Vectors
    std::vector<int> stlVec(count); // STL vector
    thrust::host_vector<int> hostVec(count); // Thrust host vector
    thrust::device_vector<int> devVec(count); // Thrust device vector

    std::cout<<"Comparison of Thrust and STL sort times on vectors of size "<<
           count<<"\n\n";

    // Sort 5 times using STL vector
    std::cout<<"STL vector:"<<std::endl;
    for(int i = 0; i < 5; i++) {
           std::generate(stlVec.begin(), stlVec.end(), rand);
           StartTimer();
           std::sort(stlVec.begin(), stlVec.end());
           std::cout<<"Run["<<i<<"] Sorted in "<<ElapsedTime<<" millis"<<
                  std::endl;
           }

    // Sort 5 times using Thrust host vector
    std::cout<<"\nThrust host vector:"<<std::endl;
    for(int i = 0; i < 5; i++) {
           thrust::generate(hostVec.begin(), hostVec.end(), rand);
           StartTimer();
           thrust::sort(hostVec.begin(), hostVec.end());
           std::cout<<"Run["<<i<<"] Sorted in "<<ElapsedTime<<" millis"<<
                  std::endl;
           }

    // Sort 5 times using Thrust device vector
    std::cout<<"\nThrust device vector:"<<std::endl;
    for(int i = 0; i < 5; i++) {
           // Host generates values for devVec
           thrust::generate(hostVec.begin(),hostVec.end(),rand);
           devVec = hostVec; // Copy from host since there's no rand()

           StartTimer();
           thrust::sort(devVec.begin(), devVec.end());
           std::cout<<"Run["<<i<<"] Sorted in "<<ElapsedTime<<" millis"<<
                  std::endl;
           }
    std::cout<<"All tests complete!"<<std::endl;
    return 0;
    }

    // main.cu

    #include <iostream>

    // Thrust headers
    #include <thrust\device_vector.h>
    #include <thrust\transform.h>
    #include <thrust\sequence.h>
    #include <thrust\copy.h>

    // Helper function, returns true if x is zero
    // else return false
    struct isZero {
           __device__ bool operator()(const int x) {
           return x == 0;
           }
    };

    int main() {

    int x = 600; // The integer to factorize

    //
    // Define Thrust device vectors
    //
    // dx vector will be filled with multiple copies of x
    thrust::device_vector<int> dx((int)(std::sqrt((double)x)+1));
    // dy vector will be filled with sequence (2, 3, 4... etc.)
    thrust::device_vector<int> dy((int)(std::sqrt((double)x)+1));
    // factors vector is used to store up to 20 factors
    thrust::device_vector<int> factors(20);

    // Fill dx with multiple copies of x
    thrust::fill(dx.begin(), dx.end(), x);

    // Fill dy with a sequence of integers from 2 up to
    // the square root of x
    thrust::sequence(dy.begin(), dy.end(), 2, 1);

    // Set elements of dx[] to remainders after division
    // of dx[] and dy[]
    thrust::transform(dx.begin(), dx.end(), dy.begin(), dx.begin(),
           thrust::modulus<int>());

    // Multiply all remainders together
    int product = thrust::reduce(dx.begin(), dx.end(), 1,
           thrust::multiplies<int>());

    // If this product is 0 we found factors!
    if(!product && x >= 4) {
           std::cout<<"Factors found!"<<std::endl;

           // Compact dx to factors where dy is 0
           thrust::copy_if(dy.begin(), dy.end(), dx.begin(),
                  factors.begin(), isZero());

           // Print out the results
           for(int i = 0; i < factors.size(); i++) {
                  if(factors[i] != 0)
                         std::cout<<factors[i]<<" is a factor of "<<
                               x<<std::endl;
                  }
           }
    else { // Otherwise x is prime
           std::cout<<x<<" is prime, factors are 1 and "<<x<<std::endl;
           }

    return 0;
    }