Bryan Simonson

From, Data Structures and Other Objects Using Java, Chapter 7, Project #8, page 396:

Make improvements to the car was simulation program

from Section 7.2.

Note: Portions of code taken from Michael Main’s version.

WARNING: Cheating is bad, mmmmkay children? Don’t cheat.

 /*
|	Bryan Simonson
 \	CS211 - Craig Niiyama
  | 2/21/2010
*/

// FILE: Carwash.java
// This program illustrates the use of the carWashSimulate method which uses
// a simple queue to simulate cars waiting at a car wash.
package bryansimonson;
import java.io.*;
import java.util.LinkedList;
import java.util.Queue;
import edu.colorado.simulations.BooleanSource;
import edu.colorado.simulations.Washer;
import edu.colorado.simulations.Averager;

/******************************************************************************
* The <CODE>CarWash</CODE> Java application illustrates the use of
* the <CODE>carWashSimulate</CODE> method.
* The illustration uses the following values:
*   <CODE>
*   <br>washTime = 240
*   <br>arrivalTime = 0.0025
*   <br>totalTime = 6000
*   </CODE>
*
* <p><dt><b>Java Source Code for this class:</b><dd>
*   <A HREF="../applications/CarWash.java">
*   http://www.cs.colorado.edu/~main/applications/CarWash.java
*   </A>
*
* @author Michael Main
*   <A HREF="mailto:main@colorado.edu"> (main@colorado.edu) </A>
*
* @version
*   Jun 12, 1998
******************************************************************************/
public class CarWash
{
   /**
   * The main method activates <CODE>carWashSimulate</CODE> with the values:
   *   <CODE>
   *   <br>washTime = 240
   *   <br>arrivalTime = 0.0025
   *   <br>totalTime = 6000
   *   </CODE>
   * <BR>The <CODE>String</CODE> argument (<CODE>args</CODE>) is not used in
   * this implementation.
   **/
   public static void main(String[ ] args) throws IOException
   {
	  BufferedReader stdin = new BufferedReader (new InputStreamReader(System.in));

	  // get total length of simulation from the user
      System.out.println("How many seconds would you like to simulate?");
      System.out.println("(Default is 6000)");
      int simtime = Integer.parseInt(stdin.readLine());

      // get the probability of a new customer from the user
      System.out.println("What is the probably of a new customer arriving in any given second?");
      System.out.println("(Default is 0.0025)");
      double probability = Double.parseDouble(stdin.readLine());

      // get the number of seconds it takes to wash the car from the user
      System.out.println("How many seconds does it take to wash one car?");
      System.out.println("(Default is 240)");
      int washtime = Integer.parseInt(stdin.readLine());

      carWashSimulate(washtime, probability, simtime);
   }

   /**
   * Simulate the running of a car washer for a specified amount of time.
   * @param <CODE>washTime</CODE>
   *   the number of seconds required to wash one car
   * @param <CODE>arrivalProb</CODE>
   *   the probability of a customer arriving in any second, for example
   *   0.1 is 10%
   * @param <CODE>totalTime</CODE>
   *   the total number of seconds for the simulation
   * <dt><b>Precondition:</b><dd>
   *   <CODE>washTime</CODE> and <CODE>totalTime</CODE> are positive;
   *   <CODE>arrivalProb</CODE> lies in the range 0 to 1.
   * <dt><b>Postcondition:</b><dd>
   *   The method has simulated a car wash where <CODE>washTime</CODE> is the
   *   number of seconds needed to wash one car, <CODE>arrivalProb</CODE> is
   *   the probability of a customer arriving in any second, and
   *   <CODE>totalTime</CODE> is the total number of seconds for the
   *   simulation. Before the simulation, the method has written its three
   *   parameters to <CODE>System.out</CODE>. After the simulation, the method
   *   has written two pieces of information to <CODE>System.out</CODE>:
   *   (1) The number of cars washed, and (2) The average waiting time for
   *   customers that had their cars washed. (Customers that are still in the
   *   queue ARE included in this average).
   * @exception java.lang.IllegalArgumentException
   *   Indicates that one of the arguments violates the precondition.
   **/
   public static void carWashSimulate
   (int washTime, double arrivalProb, int totalTime)
   {
      Queue<Integer> arrivalTimes = new LinkedList<Integer>( );
      int next;
      BooleanSource arrival = new BooleanSource(arrivalProb);
      Washer machine = new Washer(washTime);
      Averager waitTimes = new Averager( );
      int currentSecond;

      // Write the parameters to System.out.
      System.out.println("Seconds to wash one car: " + washTime);
      System.out.print("Probability of customer arrival during a second: ");
      System.out.println(arrivalProb);
      System.out.println("Total simulation seconds (open \"hours\"): " + totalTime);

      // Check the precondition:
      if (washTime <= 0 || arrivalProb < 0 || arrivalProb > 1 || totalTime < 0)
         throw new IllegalArgumentException("Values out of range"); 

      for (currentSecond = 0; currentSecond < totalTime || !arrivalTimes.isEmpty(); currentSecond++)
      {  // Simulate the passage of one second of time.

         // Check whether a new customer has arrived.
         if (arrival.query( ) && currentSecond <= totalTime)
            arrivalTimes.add(currentSecond);

         // Check whether we can start washing another car.
         if ((!machine.isBusy( ))  &&  (!arrivalTimes.isEmpty( )))
         {
            next = arrivalTimes.remove( );
            waitTimes.addNumber(currentSecond - next);
            machine.startWashing( );
         }

         // Subtract one second from the remaining time in the current wash cycle.
         machine.reduceRemainingTime( );
      }

      // Write the summary information about the simulation.
      System.out.println("Customers served: " + waitTimes.howManyNumbers( ));
      if (waitTimes.howManyNumbers( ) > 0)
         System.out.println("Average wait: " + waitTimes.average( ) + " sec");

      // Print ending second to compare to expected "closing time"
      System.out.println("Ending second (or last customer served): " + currentSecond);
   }

}

Assignment number 1 in CS211 (Java) programming class. (No stealing! I want full point on my grade!)

PseudoRandomDemo.java

 /*
|	Bryan Simonson
 \	CS211 - Craig Niiyama
  | 1/19/2010
*/

package bryansimonson;
import bryansimonson.PseudoRandom;

/**
 * @author Bryan Simonson (manticor@gmail.com)
 */
public class PseudoRandomDemo {

	/**
	 * The main function generates a table that counts how many
	 * instances of a pseudorandom number fall within a certain range.
	 */
	public static void main(String[] args) {
		final int INTRVL = 10;				// interval of distribution table
		final int LOOPS = 1000000;			// number of times to run loop
		final int SEED = 1;					// initial seed value
		final int INCR = 3641;				// increment
		final int MOD = 729;				// modulus
		final int MULT = 40;				// multiplier
		int[] dist = new int[INTRVL];		// distribution table

		PseudoRandom x = new PseudoRandom(SEED, MULT, INCR, MOD);

		System.out.println("Output of PseudoRandomDemo");
		System.out.println();

		// Show initial values
		System.out.println("Initial values");
		System.out.println("Interval:\t"+INTRVL);
		System.out.println("Seed:\t\t"+SEED);
		System.out.println("Multiplier:\t"+MULT);
		System.out.println("Increment:\t"+INCR);
		System.out.println("Modulus:\t"+MOD);
		System.out.println();

		// Demonstrate current() function
		System.out.println("Demonstrate current() function");
		System.out.println(x.current());
		System.out.println();

		// Demonstrate next() function
		System.out.println("Demonstrate next() function");
		System.out.println(x.next());
		System.out.println(x.next());
		System.out.println(x.next());
		System.out.println();

		// Demonstrate nextMod() function
		System.out.println("Demonstrate nextMod() function");
		System.out.print("nextMod() value: ");
		System.out.printf("%6.2f",x.nextMod());
		System.out.println();
		System.out.println("new seed value:"+x.current());

		// Demonstrate changeSeed() function
		x.changeSeed(SEED);
		System.out.println("\nSeed has been reset using changeSeed("+SEED+")\n");

		// Populate array with count of instances between each interval
		for (int i = 0; i<LOOPS; i++){
			dist[(int)(x.nextMod()*INTRVL)]++;
		}

		// Print out a table with instance counts per interval
		System.out.println("Count of instances");
		System.out.println("Range\t\tNumber of Occurrences");
		for (int i=0; i<INTRVL; i++){
			System.out.println(
					"["+
					((double)(i)/INTRVL)+
					".."+
					((double)(i+1)/INTRVL)+
					")\t"+
					dist[i]
			);
		}
	}
}

PseudoRandom.java (Class)

package bryansimonson;

 /*
|	Bryan Simonson
 \	CS211 - Craig Niiyama
  | 1/19/2010
*/

/**
 * @author Bryan Simonson (manticor@gmail.com)
 *
 */
public class PseudoRandom {
	private int seed;
	private int multiplier;
	private int increment;
	private int modulus;

	/**
	 * Constructor for PseudoRandom object.
	 * @param firstseed - The original seed value
	 * @param mult - Multiplier
	 * @param incr - Increment
	 * @param mod - Modulus value
	 */
	public PseudoRandom (int firstseed, int mult, int incr, int mod){
		multiplier = mult;
		increment = incr;
		modulus = mod;
		seed = (mult * firstseed + incr) % mod;
	}

	/**
	 * Access the current seed value
	 * @return
	 * 	The current seed value
	 */
	public int current(){
		return seed;
	}

	/**
	 * Generates the next pseudorandom number iteration
	 * @return
	 * 	The next pseudorandom number iteration
	 * @postcondition
	 * 	The current seed value set to the same value that is returned
	 */
	public int next(){
		seed = (multiplier * seed + increment) % modulus;
		return seed;
	}

	/**
	 * Change the current seed value
	 * @param newseed
	 * @postcondition
	 * 	The current seed value is replaced by <code>newseed</code>
	 */
	public void changeSeed(int newseed){
		seed = newseed;
	}

	/**
	 * Generates the next pseudorandom number divided by the modulus value
	 * @return
	 * 	a double in the range [0..1)
	 * @postcondition
	 * 	the current seed value is set to whatever the next pseudorandom integer
	 */
	public double nextMod(){
		return (next()/(double)modulus);
	}
}