CS100 J Project 5

CS100J Spring 2004
Project 5
Due Thursday 4/15 at 3pm

0. Objective

Completing all tasks in this assignment will help you learn about:

Array of objects
Two-dimensional (2-d) array
Simulation

First skim, and then carefully read the entire assignment before starting any tasks! You must use the identifiers (variable names, method names, etc.) exactly as we specify, including capitalization. Use good programming style and observe the style guidelines that are given in the previous grading guides.

1. Our second risky experiment

We will build on the skills we learned from Project 4. In Project 5, we will have Dice, a DiceSet, and we will simulate the rolling of multiple Dice in a DiceSet and calculate some statistics. You will be implementing a class Dice that is different from the Dice class in P4, so make sure that you keep your files for P5 in a separate directory (path) from P4.

Read carefully and think about implementing the classes carefully--developing a concise implementation is part of the work in this project. Whenever possible, reduce redundancy in your code by calling other (existing) methods. Program development is an iterative process--sometimes you will write code under a method and later decide that you should take part of that code out and set it up as a separate method. This iterative process is normal--you should not expect your first implementation to be perfect. Look for improvement as (after) you write code.

Let's first look at some example output so that you know what to expect. Notice that the histogram you will draw has horizontal "bars" (rows of asterisks).

Experiment One:
Enter number of Dice you want to create: 2
Creating the 1th Die
  Enter the number of faces of for the Die: 6
  Which side is weighted more, 1-6?  Enter 0 if it's a fair die: 0
Creating the 2th Die
  Enter the number of faces of for the Die: 6
  Which side is weighted more, 1-6?  Enter 0 if it's a fair die: 0
Start simulation...
Enter the number of trials: 100000
Calculating sum of two dice...
  Enter the first die: 1
  Enter the second die: 2
The count distribution for the sum of Dice 1 and 2:
1
2   **
3   ***
4   *****
5   *******
6   ********
7   **********
8   ********
9   *******
10  *****
11  ***
12  **

Another example run is shown at the end of the project statement.

2. A new class `Dice`

A Dice has

int top: Top face
int faces: Number of faces on the Dice
int[] weight: weight[i] is the likelihood of face i being the top face. We say side i has weight weight[i]. A fair Dice has weight[i]=1 for all i. A trick dice (say 6-sided) where face 2 is three times more likely to show face-up than face 1, face 3, face 4, ..., etc., has the values {0,1,3,1,1,1,1} in array weight. Note that we have chosen to keep an extra cell (at index 0). You may decide for yourself whether to use this extra cell. As always, write clear and concise comments to document your code. A Dice has at most one "weighted side" (face 2 in the previous example).

Class Dice has the following instance methods:

Overloaded constructors: /** A Dice has numFaces sides and the topFace is random */ public Dice(int numFaces) /** An unfair Dice has numFaces sides. Face weightedSide has weight w. The topFace is random */ public Dice(int numFaces, int weightedSide, int w)
A method roll to roll the Dice based on its array weight: /** top gets a value in 1..faces */ public void roll()
Getter methods topFace() and numberOfFaces()

3. Class `DiceSet`

A DiceSet is a set of Dice, of course! A DiceSet has

Dice[] set: references an array of Dice
int[][] outcome: references a 2-d array of outcomes
outcome[d][j] is the top face value of the dth Dice after the jth roll.
int[][] count: references a 2-d array of the counts of the outcomes
count[d][j]: is the number of times that face j has shown up for Dice d. Note that count may be a ragged array.
a class constant double MAXSTARS, which has the value 10.0. This is the maximum number of asterisks (stars) on any row in the histogram.

A DiceSet has the following methods:

static method createDiceSet creates an instance of DiceSet by prompting the user for the necessary values to create a DiceSet (see example runs). This method serves the purpose of the constructor:
public static DiceSet createDiceSet()
Here are some hints for the method:
- This method has to call the default constructor for DiceSet
- This method has to instantiate the set array
- Remember that a 2-d array is just a 1-d array of 1-d arrays, so you can instantiate the individual 1-d arrays separately. You will create only the first dimension of outcome and count in this method.
- There're multiple Dice in the DiceSet, so the creation of the a Dice, i.e., the call of the Dice constructor, should appear inside a loop.
- Prompt the user for information as necessary. For example, ask the user for the weight of the weighted side only if the user says the Dice is weighted.
instance method runSimulation takes as parameter the number of rolls and fill the outcome and count arrays. Before you fill the arrays, of course you need to finish creating them. Recall that in the method createDiceSet you have created only the first dimension. In this method you must instantiate the arrays for the second dimension.
public void runSimulation(int trials)
Note that in a simulation each Dice is rolled trials number of times. Note the terminology: a trial means rolling each Dice in the DiceSet once.
static method calculateCount computes the counts for an array of outcomes, i.e., it computes the data that can be used later for drawing a histogram. The computed counts are stored in a 1-d array and returned.
public static int[] calculateCount(int[] outcomes)
For example, if outcomes references an array with the values {2,4,3,1,2,3,2,4,4,1}, then the returned array storing the counts should be {0,2,3,2,3} since value 1 occurs 2 times, value 2 occurs 3 times, value 3 occurs 2 times, and value 4 occurs 3 times. This method needs to determine the length of the array to return! Again, your array may not have the first cell with value zero. It is up to you to design your code.
static method plotHistogram draws a histogram with horizontal bars (rows of asterisks) given a 1-d array data. The longest bar is always MAXSTARS long--we call such a histogram a normalized histogram. In normalizing the bars, always round to the nearest number.
public static void plotHistogram(int[] data)
For example, if data references an array with the values {0,2,3,2,3}, then the following histogram should be drawn:
```
  1   *******
  2   **********
  3   *******
  4   **********
  
```
Again, your data array may not have the first cell with value zero. It is up to you to design your code.
instance method printCount display the count distribution (histogram) for each Dice in the DiceSet. Display a title above each histogram. See example output at the end of the project statement.
public void printCount()
instance method getPairOutcomeSum calculates the sum of the faces shown by two specified Dice for each trial. The resulting sums are stored in an array and returned. /** = array of sums of outcomes for Dice d1 and d2 */ public int[] getPairOutcomeSum(int d1, int d2)
For example, this method (among others) needs to be called before you can produce the histogram shown in the example output above.
instance method countPairSameFace that counts the number of times that two specified Dice show the same face in a trial. /** = number of times Dice d1 and d2 both show face f */ public int countPairSameFace(int f, int d1, int d2)
instance method probabilityAnyPairSameFace estimates the probability of any two Dice in the DiceSet showing the same face in a trial. /** = probability of any pair of Dice showing face f in a trial */ public double probabilityAnyPairSameFace(int f) You must use simulation to estimate the probability. The probability of any pair of Dice showing face f is estimated by dividing the number of times that at least two Dice show face f with the number of trials.




4. Class P5 for simulation



In the main method, you will run several experiments.

Experiment 1: create a set of two six-sided fair dice.  Simulate 10 trials and show the count distributions for the set.
Experiment 2:  create a set of two six-sided dice: one fair, the other has side 3 weighted 5 times more than the other sides.  Simulate 100000 trials and show the count distributions for the set.  (This experiment gives the sample output shown at the end of the project statement).
Experiment 3:  create a set of three six-sided dice:  first two are fair, and the third has side 3 weighted 5 times more than the other sides.  Simulate 100000 trials and show the count distributions for the set.  Next show the histogram of the pair outcome for the first two dice.  (This part gives output similar to that shown at the beginning of the project statement).  Finally show the histogram of the pair outcome for the last two dice.  I hope you see some interesting results!  You can choose the value of constant MAXSTARS in class DiceSet to dramatize the results!
Experiment 4:  create a set of four dice:  first two are fair and have 6 sides each; the last two are 12-sided and unfair with face 4 weighted 5 times more than the other sides.  Simulate 100000 trials and show the count distributions for the set.  Next show the histogram of the pair outcome for the first two dice.  Now show the histogram of the pair outcome for two dice where one is fair and the other is unfair.  Finally, estimate (using existing methods) and display the probabilities of any two dice of the set having the same face:
  
  two dice showing face 1
  
two dice showing face 4
  
two dice showing face 10
  
Experiment 5:  You will simulate 100000 trials using a set of dice with with properties of your choosing!  Use some combination of properties that will result in a histogram of pair outcome that looks "different" from the histograms shown before.  How different?  Perhaps the "peak" shows up at a different location relative to the "tails", or perhaps one tail is thicker than another, or ...  Have fun!



6.  Another example run



Experiment Two:
Enter number of Dice you want to create: 2
Creating the 1th Die
  Enter the number of faces of for the Die: 6
  Which side is weighted more, 1-6?  Enter 0 if it's a fair die: 0
Creating the 2th Die
  Enter the number of faces of for the Die: 6
  Which side is weighted more, 1-6?  Enter 0 if it's a fair die: 3
  Enter the weight for side 3: 5
Start simulation...
Enter the number of runs: 100000

The count distribution of Dice 1:
1   **********
2   **********
3   **********
4   **********
5   **********
6   **********

The count distribution of Dice 2:
1   **
2   **
3   **********
4   **
5   **
6   **




7. Submitting Your Work


Submit your files Dice.java, DiceSet.java, and P5.java on-line using CMS (Course Management System) before the project deadline.  Make sure you are submitting the correct, up to date, .java files (not .class or .java~).  We will not accept any files after the deadline for any reason (except for documented medical reasons).  See the CMS link on the web page for instructions on using CMS.  If necessary, turn off the DrJava feature that saves the .java~ files (see course webpage announcement on 2/17 for instructions).

CS100J Spring 2004 Project 5 Due Thursday 4/15 at 3pm

0. Objective

1. Our second risky experiment

2. A new class Dice

3. Class DiceSet

4. Class P5 for simulation

6. Another example run

7. Submitting Your Work

CS100J Spring 2004
Project 5
Due Thursday 4/15 at 3pm

2. A new class `Dice`

3. Class `DiceSet`

4. Class `P5` for simulation