
   Tests the partitioning interfaces of sets.

   To make executables for all the tests:

shell$ make

   To run all the executables:

shell$ make run

   Test for homogeneous data distribution
   =======================================

   The speeds of the processors are assumed to be the same.
   There can be an upper bound on the number of elements that each
   processor can store.

   Files
   -----
   homogeneous.c

   HOW TO RUN
   ----------
   shell$ make homogeneous
   shell$ ./homogeneous

   ============================================================
   =                                                          =
   =              TESTS FOR NON-ORDERED SETS                  =
   =                                                          =
   ============================================================

   Test for heterogeneous data distribution for non-ordered sets 
   with speeds represented by single numbers
   ============================================================
   There is no upper bound on the number of elements that each
   processor can store.

   Files
   -----
   heterogeneous_non_ordered_sets_speeds_single_numbers.c

   HOW TO RUN
   ----------
   shell$ make heterogeneous_non_ordered_sets_speeds_single_numbers
   shell$ ./heterogeneous_non_ordered_sets_speeds_single_numbers

   Test with speeds represented as single numbers and set elements 
   having weights
   ===============================================================
   There are no upper bounds on the number of elements that a 
   processor can store.

   Files
   -----
   heterogeneous_non_ordered_sets_speeds_single_numbers_weighted_elements.c

   HOW TO RUN
   ----------
   shell$ make heterogeneous_non_ordered_sets_speeds_single_numbers_weighted_elements
   shell$ ./heterogeneous_non_ordered_sets_speeds_single_numbers_weighted_elements

   Test for non-ordered sets 
   Test for heterogeneous data distribution for non-ordered sets
   with speeds represented by function of problem size
   =============================================================
   There is no upper bound on the number of elements that each
   processor can store.

   Files
   -----
   heterogeneous_non_ordered_sets_speeds_functions_of_problem_size.c

   HOW TO RUN
   ----------
   shell$ make heterogeneous_non_ordered_sets_speeds_functions_of_problem_size
   shell$ ./heterogeneous_non_ordered_sets_speeds_functions_of_problem_size

   Test for non-ordered sets with speeds represented by functions of problem
   size and upper bounds exist for each processor on the number of elements
   it an store
   =========================================================================

   Files
   -----
   heterogeneous_non_ordered_sets_speeds_functions_of_problem_size_with_bounds.c

   HOW TO RUN
   ----------
   shell$ make heterogeneous_non_ordered_sets_speeds_functions_of_problem_size_with_bounds
   shell$ ./heterogeneous_non_ordered_sets_speeds_functions_of_problem_size_with_bounds

   Test for non-ordered sets with speeds represented by functions of problem size
   and set elements have weights
   ==============================================================================
   No upper bounds on the number of elements that a processor can store.

   Files
   -----
   heterogeneous_non_ordered_sets_speeds_functions_of_problem_size_with_weighted_elements.c

   HOW TO RUN
   ----------
   shell$ make heterogeneous_non_ordered_sets_speeds_functions_of_problem_size_with_weighted_elements
   shell$ ./heterogeneous_non_ordered_sets_speeds_functions_of_problem_size_with_weighted_elements

   Test for non-ordered sets with speeds represented by functions of problem size
   and set elements have weights and upper bounds exist on the number of 
   elements that a processor can store
   ==============================================================================
   
   Files
   -----
   heterogeneous_non_ordered_sets_speeds_functions_of_problem_size_with_weighted_elements_with_bounds.c

   HOW TO RUN
   ----------
   shell$ make heterogeneous_non_ordered_sets_speeds_functions_of_problem_size_with_weighted_elements_with_bounds
   shell$ ./heterogeneous_non_ordered_sets_speeds_functions_of_problem_size_with_weighted_elements_with_bounds

   =======================================================
   =                                                     =
   =              TESTS FOR ORDERED SETS                 =
   =                                                     =
   =======================================================

   Test for ordered sets with speeds represented by single 
   numbers
   =======================================================
   There are no upper bounds on the number of elements that
   a processor can store.

   Files
   -----
   heterogeneous_ordered_sets_speeds_single_numbers.c

   HOW TO RUN
   ----------
   shell$ make heterogeneous_ordered_sets_speeds_single_numbers
   shell$ ./heterogeneous_ordered_sets_speeds_single_numbers

   Test for ordered sets with speeds represented by single 
   numbers and set elements are weighted
   =======================================================
   There are no upper bounds on the number of elements that
   a processor can store.

   Files
   -----
   heterogeneous_ordered_sets_speeds_single_numbers_weighted_elements.c

   HOW TO RUN
   ----------
   shell$ make heterogeneous_ordered_sets_speeds_single_numbers_weighted_elements
   shell$ ./heterogeneous_ordered_sets_speeds_single_numbers_weighted_elements

   Test for ordered sets with speeds represented by speed
   functions 
   =======================================================
   There are no upper bounds on the number of elements that
   a processor can store.

   Files
   -----
   heterogeneous_ordered_sets_speeds_functions_of_problem_size.c

   HOW TO RUN
   ----------
   shell$ make heterogeneous_ordered_sets_speeds_functions_of_problem_size
   shell$ ./heterogeneous_ordered_sets_speeds_functions_of_problem_size
  
   Test for ordered sets with speeds represented by speed
   functions, sets have no weighted elements but upper
   bounds exist on the number of elements that a processor
   can store
   =======================================================

   Files
   -----
   heterogeneous_ordered_sets_speeds_functions_of_problem_size_with_bounds.c

   HOW TO RUN
   ----------
   shell$ make heterogeneous_ordered_sets_speeds_functions_of_problem_size_with_bounds
   shell$ ./heterogeneous_ordered_sets_speeds_functions_of_problem_size_with_bounds

   Test for ordered sets with speeds represented by speed functions
   sets have weighted elements, processors cannot be reordered, no
   upper bounds exist on the number of elements that a processor 
   can store
   =================================================================

   Files
   -----
   heterogeneous_ordered_sets_speeds_functions_of_problem_size_with_weighted_elements_no_processor_reordering.c

   HOW TO RUN
   ----------
   shell$ make heterogeneous_ordered_sets_speeds_functions_of_problem_size_with_weighted_elements_no_processor_reordering
   shell$ ./heterogeneous_ordered_sets_speeds_functions_of_problem_size_with_weighted_elements_no_processor_reordering

   Test for ordered sets with speeds represented by speed functions
   sets have weighted elements, processors cannot be reordered,
   upper bounds exist on the number of elements that a processor 
   can store
   =================================================================

   Files
   -----
   heterogeneous_ordered_sets_speeds_functions_of_problem_size_with_weighted_elements_no_processor_reordering_with_bounds.c

   HOW TO RUN
   ----------
   shell$ make heterogeneous_ordered_sets_speeds_functions_of_problem_size_with_weighted_elements_no_processor_reordering_with_bounds
   shell$ ./heterogeneous_ordered_sets_speeds_functions_of_problem_size_with_weighted_elements_no_processor_reordering_with_bounds

   Test for ordered sets with speeds represented by speed functions
   sets have weighted elements, processors can be reordered, no
   upper bounds exist on the number of elements that a processor 
   can store
   =================================================================

   Files
   -----
   heterogeneous_ordered_sets_speeds_functions_of_problem_size_with_weighted_elements_processor_reordering.c

   HOW TO RUN
   ----------
   shell$ make heterogeneous_ordered_sets_speeds_functions_of_problem_size_with_weighted_elements_rocessor_ordering
   shell$ ./heterogeneous_ordered_sets_speeds_functions_of_problem_size_with_weighted_elements_processor_reordering

   Test for ordered sets with speeds represented by speed functions
   sets have weighted elements, processors can be reordered,
   upper bounds exist on the number of elements that a processor 
   can store
   =================================================================

   Files
   -----
   heterogeneous_ordered_sets_speeds_functions_of_problem_size_with_weighted_elements_processor_reordering_with_bounds.c

   HOW TO RUN
   ----------
   shell$ make heterogeneous_ordered_sets_speeds_functions_of_problem_size_with_weighted_elements_rocessor_ordering_with_bounds
   shell$ ./heterogeneous_ordered_sets_speeds_functions_of_problem_size_with_weighted_elements_processor_reordering_with_bounds
