Add nosy config file
Add basic code structure for PyCUDA implementation

Note that the current CUDA kernel is NOT complete.  Currently, it simply
prints out the block ID, thread ID, etc.

The main kernel code is contained in:
        scatter_gather/pycuda_include/scatter_gather.hpp

The file scatter_gather/pycuda_templates/scatter_gather.cu contains a
templated test function to run the k_scatter function (from the
header file, scatter_gather.hpp) using either float or int data types.
Add scatter_lists and scatter_count args
Perform scatter to shared memory, add empty_ind...

Perform scatter to shared memory
Add `empty_index` template arg to `k_scatter` function
Add `empty_value` arg to k_scatter function.  An overloaded version of
`k_scatter` defaults `empty_value` to zero.

Using `empty_index` and `empty_value`, interpret any entry in
`scatter_lists` with the value `empty_index` as an indication that the
corresponding entry in the `block_data` array should be set to the
value `empty_value`.

e.g., Consider the following:

        k = 2
        data = [11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
        scatter_lists = [[4, -1], [3, 7], [-1, 2]]
        scatter_count = 3

    Note that some of the entries in `scatter_lists` have a value of -1.
    This is the default `empty_index` value.  Therefore, in the
    `block_data` array, any entries corresponding to these -1 indices
    should be set to `empty_value` (in this case `empty_value` is zero).
    The resulting `block_data` array is then:

        block_data = [7, 0, 8, 4, 0, 9]
Validate CUDA results against CPU

Note that the current implementation only supports the use of a single
CUDA thread block.
Refactor k_scatter() into ScatterManager class
Fix PyCUDA test comparison.
Add local_scatter_list_index(), local_block_dat...

Add local_scatter_list_index() and local_block_data_base_index() to
ScatterManager class:
    \->local_scatter_list_index()
        Given the index of the current pass of execution, return the
        `scatter_lists` index corresponding to the scatter list array to
        be processed by the current CUDA thread.
    \->local_block_data_base_index()
        Given the index of the current pass of execution, return the
        `block_data` index where the value corresponding to the first
        entry of the scatter list array being processed by the current
        CUDA thread should be written to.  The subsequent values for the
        current scatter list can then be written relative to this "base"
        index.

Fix `scatter` and `k_gather` functions to be thread count invariant.
Refactor `empty_index` to be a method

Previously, `empty_index` was a template argument to the ScatterManager
class.  However, it is more generalized to implement `empty_index` as a
method instead.  This allows arbitrary rules to be implemented for
determining which `data` indices should be considered as empty
(resulting in `empty_value` to be used instead).  By default, the
`empty_index()` method returns `true` for any value less than zero, and
`empty_value` is set to zero.
Modify Python k_scatter to handle `empty` indices
Refactor Python `k_scatter` into `ScatterManager`

Refactor Python `k_scatter` function into `ScatterManager` class
(mirroring the CUDA `ScatterManager` class).

Update scatter doctest.
Add scatter_gather doctests to nosy test config.
Add scatter_list_index() to Python ScatterManager

Add `scatter_list_index()` to Python `ScatterManager` class.  This
method corresponds to the CUDA
`ScatterManager::local_scatter_list_index()` method.
Add IndirectScatterManager class

The `IndirectScatterManager` class extends `ScatterManager` to allow the
`scatter_lists` to be processed in a custom order (instead of in a
linear sequence).  See doctest for example usage.
Add CUDA `IndirectScatterManager` class

Like the corresponding Python class, the CUDA `IndirectScatterManager`
class extends `ScatterManager` to allow the `scatter_lists` to be
processed in a custom order (instead of in a linear sequence).
Add k_scatter_global() function

Distribute work to multiple CUDA thread blocks for a k_scatter/gather.
Fix shared memory size calculation,...

Simplify computation of global_index in CUDA k_scatter_global function.
The global_index is used to index into the scatter_list_order array.
Separate general CUDA code into cuda_common.py
Remove commented/if-zeroed code from CUDA header