   thrust::scatter(input_column,
                   input_column + num_rows,
                   row_output_locations,
-                  partitioned_output_column);
+                  output_column);
 
   CUDA_CHECK_LAST();
 
   return gdf_status;
 }
 
+/* --------------------------------------------------------------------------*/
+/** 
+ * @brief  Creates the partitioned output table by scattering the rows of the 
+   input table to rows of the output table based on each rows output location.
+   I.e., input_table[i] will be scattered to 
+   partitioned_output_table[row_output_locations[i]]
+ * 
+ * @Param[in] input_table The input table to scatter
+ * @Param[in] row_output_locations The mapping from input row locations to output row
+   locations
+ * @Param[out] partitioned_output_table The rearrangement of the input table based 
+   on the mappings from the row_output_locations array
+ * 
+ * @Returns   
+ */
+/* ----------------------------------------------------------------------------*/
 template <typename size_type>
 gdf_error scatter_gdf_table(gdf_table<size_type> const & input_table,
                             size_type const * const row_output_locations,

}


template <template <typename> class hash_function,
          typename size_type>
struct table_row_hasher
{
  table_row_hasher(gdf_table<size_type> const & table_to_hash) 
    : the_table{table_to_hash}
  {}
  
  __device__
  hash_value_type operator()(size_type row_index) const
  {
    return the_table.template hash_row<hash_function>(row_index);
  }

  gdf_table<size_type> const & the_table;
};


/* --------------------------------------------------------------------------*/
/** 
 * @Synopsis  Functor to map a hash value to a particular 'bin' or partition number

                                                                                        gdf_columns_to_hash.data())};

  gdf_error gdf_status{GDF_SUCCESS};

  switch(hash)
  {
    case GDF_HASH_MURMUR3:
