Please make sure you adhere to the policies on academic honesty.

Please see the general programming webpage for details about the programming environment for this course, and specifically for directions in how to submit your programming assignment electronically.

The files you need for this assignment can be downloaded here.

Contents:

Preface

Also, you will need to use the vector template class which is part of the standard C++ libraries. We will highlight details of that class below.

Overview

• Each item has a weight which is somewhere between 0 and 1.

• Each item must be assigned to a particular bin.

• Each bin has a maximum capacity of 1.

• The goal is to use as few bins as possible.

This setup can actually be used in modeling a variety of different applications, and it has been given the name "Bin Packing" in the literature. Unfortunately, minimizing the number of bins appears to be a very difficult problem to solve efficiently (there are too many possibilities!). Fortunately a number of heuristics have been studied, and some of these seem to get quite good results.

Heuristics

A second heuristic is known as "worst-fit-decreasing." This heuristics considers items one-at-a-time, again placing each considered item into the bin with the most remaining space (if such a bin will hold the item). The difference between this heuristic and the last is that items are considered in order of decreasing weight, rather than in the original order. To do this, all items are initially placed into a priority queue and at each step the item with largest remaining weight is removed from this queue and then placed into a bin. (note that for this to work, you will have to adjust your view of priorities so that the "minKey" is the one with the largest weight). Looking at our previous example, the items would get considered in the order .81, .68, .29 and .11, and thus packed into two bins. By no means are these the only two approaches to bin packing. If anyone is interested in the history of the problem, we will be happy to provide references. But for this assignment, we will focus on these two heuristics.

The Driver

The driver accepts the following four command line arguments, as specified by the user. The first three of these are required; the fourth is optional.

• N - a non-negative integer, specifying the number of items
• u - a double in the range (0...1] specifying an upper limit on the range when choosing random weights.
• 0 or 1 - interpreted as a boolean specifying whether or not the program should give "verbose" output (explained later). 0 represents no verbose output, and 1 represents verbose.
• seed - an integer value used to seed the random number generator. If no argument is given, the seed is set based on the system clock.

  Although generating random data is useful for experiments, it is troublesome when developing and testing your program. The difficulty is that when a bug arises, you generally want to fix the bug and then re-test on the same data. But if data is generated at random, you will likely get a different data set when you re-test. By explicitly setting the "seed" you can later re-test on the identical data set.

After reading the parameters, our driver calls a routine (to be written by you) which performs the worst-fit heuristic, then another call is made to perform the worst-fit-decreasing heuristic.

Your Tasks

• bin packing heuristics

  As we mentioned, your primary task is to correctly implement both of these heuristics. Specifically, you are to implement the following routine in file Binpack.cc:

  int worstFit(double* w, int N, bool decreasing, bool verbose)

  The int return value should be the total number of bins which were used. The parameters are to be interpreted as follows:
  double* w -- the original list of grocery weights.
  int N -- the number of grocery items.
  bool decreasing -- if "false" you should implement worst-fit heuristic; if "true" you should implement worst-fit-decreasing heuristic.
  bool verbose -- if "true" you should produce verbose output as follows.

  In our original application, it does a person no good to simply say that the solution uses 59 bins; a program must give some sort of mapping to explain which items should be grouped in each such bin. For this reason, we want your program to be able to produce verbose output which gives such a mapping. Going back to the earlier sample, possible verbose output for the worst-fit heuristic might read (though you are free to format the information as you wish):

  Bin:  weight=0.40  [items: 0.29 0.11 ]
  Bin:  weight=0.81  [items: 0.81 ]
  Bin:  weight=0.68  [items: 0.68 ]

  At the same time, we will want to perform some large experiments. Verbose output would be very distracting if packing 1000000 items and producing such output would skew the running times. Therefore, no such output should be produced if the verbose parameter is "false"

• experiments and readme file

  We ask that you perform some experiments which will be reported in your 'readme' file. This will allow us to compare the quality of the solutions produced by the two heuristics as well as the efficiency of the two priority queue implementations.

  You must submit a plain-text readme file with the following information:

  • Show the output of your program, when run using "verbose" mode, for [N=20, u=.2, seed=9].

  • Show the output of your program, when run using "verbose" mode, for [N=20, u=.7, seed=9].

  • Give a table of results for u=.2, and as large of values of N as your program can handle from N=100, 1000, 10000, 100000, 1000000. Your table should contain the total sum S of the weights, the number of bins used by worst-fit, and the number of bins used by worst-fit decreasing.

  • Give a second table, as above, for the value u=.7.

  You have a choice in how to gather this information. One way is to sit at the computer for a while and gather piece after piece of information using our driver. A wise student might feel this is a mindless use of time and surely can be automated by a new or modified driver. For your benefit, we will tell you that our driver relies internally on a procedure runTrial(int N, double u, bool verbose, long seed) You could modify our driver adding a loop to call this method repeatedly with various parameter values.

Using a Comparator

Our generic Priority Queue template requires that you specify the type for the key, the type for the element, and a class which is a valid comparator for the specified key type.

To help out, we have written a comparator class for you, DoubleCompare. This class is based on the assumption that keys are of type double. This should suffice for the assignment, though you will still need to carefully consider what values to use for keys to get the desired behavior.

Recommended Steps for Progress

This program might seem intimidating because of the complexity. Here is our suggestion for getting going:

• Get used to the idea of using a priority queue and setting keys in a way so that elements are removed from a priority queue in the desired order.

  Specifically, your routine should start by inserting all of the grocery weights into a priority queue, which will be used in the next stage for processing these items one at a time. By setting the key for each item appropriately, you should be able to process the set of items either in the original order (for worst-fit) or in decreasing order of weight (for worst-fit-decreasing).

  To test your progress thus far, you might start removing items from the queue, printing each item before it is removed (you can eventually convert this loop to the loop which processes each item; the extraneous print statements should eventaully be commented out).

• Complete the task of implementing the worst-fit and worst-fit-decreasing heuristics. Before writing any code, you will want to think a bit about the logic. Decisions will need to be made as to how you can use a vector to represent each individual bin, how keys might be set so that you can use a priority queue of bins to quickly locate the potential "worst-fit" bin. Generating verbose output will allow you to examine the behavior of your code on some very small examples which you might be able to compare to a hand simulation.
• When you are confident that all of your code is written and working, start running the experiments.

Files you will need

Files to Submit

Grading Standards

The assignment is worth 10 points. In general, we will try to apportion the points based on the following break down (though we will use some of our own judgment in the end):

• correct implementations for worst-fit and worst-fit-decreasing (5 points)
• correct verbose output (3 points)
• experiments/readme (2 point)

Overview of C++ vector class

#include <vector>
using namespace std;

As with our priority queue, a vector can hold an arbitrary type of objects, but you must declare the type when creating a vector. Therefore, a vector V of double's can be declared as:

vector<double> V;

Very detailed documentation for the vector class is provided by SGI, however you will only need to use a limited subset of the functionality.

Vector's also allow you to access an element directly via indexing. For example, if V is a vector, than you can access the item at rank r as V[r].