cs231 Lecture Notes
Week 3, Monday

Homework hints
--------------

isStraight: forgot to handle wraparound!  Suggestions?


A little Java
-------------

Global variables:  not local to any method;

		   visible from all methods (in a class)

Two kinds:  instance variables (associated with objects)
	    static variables (associated with class)

Syntax:

public class Banana {
    double weight;       // pertains to individual bananas
    static Color color;  // pertains to all bananas
    static int number;   // how many bananas objects are there?
}

You can initialize static variables in situ:

public class Banana {
    static Color color = Color.yellow;
    static int number = 0; 

    public Banana (double w) {
        weight = w;
	number++;
    }
}

You can access static variables from both class and object methods.

Changing an instance variable affects only a single object.
Changing a static variable changes EVERYONE's state.

Use static variables sparingly, because they make it
very difficult to reason about programs.

And that's my next topic...


Precomputing Histograms
-----------------------

Last time we talked about using histograms to make it easier
to classify hands.

We need those histograms to be precomputed and then used by
many different methods.

Instance variables are "visible" from any method, so they
are a reasonable mechanism.

We could compute them at the time the Deck gets created, but
that might be wasteful.

    Card[] cards;
    int[] suitHist;
    int[] rankHist;

Then we can write a method that initializes the instance variable
(and does the corresponding computation) later...

    public void makeSuitHist () {
	suitHist = new int[4];

	for (int i=0; i<cards.length; i++) {
	    suitHist[cards[i].suit]++;
	}
    }

It's ok to postpone initializing some of the instance variables,
although sometimes it makes things tricky.

For example, we have to make sure that we make the rankHist
before calling isPair, and make sure we make the suitHist before
calling isFlush.


Invariants / preconditions
--------------------------

Invariant:  something that is provably true at some point in a program

Precondition: a condition that a method requires to be true when it
	      executes, in order to work correctly

Postcondition: a condition that is provably true at the end of a method
	       (provided that the precondition is satisfied)

What are the preconditions for isFlush?  isPair?  isStraightFlush?

What should a method do about its preconditions?

1) fail: the method says, "if you (the caller) don't satisfy my
   preconditions, I simply won't do what I said I would do."

   Often, that means generating a run time error (for example,
   if rankHist is null)

   Sometimes, it means just not doing the right thing.  For example,
   what does findBisect do if the deck is not actually in order?

2) check: some preconditions can be checked cheaply

   (rankHist != null)

   some can be checked, but they are a little expensive

   (is the array sorted)

   some cannot be checked (for various reasons).

   Obviously, this last group is the most unpleasant.

3) eliminate (minimize)

   it is often a good idea to both check and correct missing
   preconditions.  For example:

   if (rankHist == null) makeRankHist ();

PRECONDITIONS ARE THE MOST IMPORTANT THINGS TO INCLUDE IN COMMENTS.

The comments at the beginning of a method are like a contract.
They describe what the method does, but they include a catch

     The method is only guaranteed to work if the preconditions
     are satisfied.

Please read Appendix C.3, pages 496 through 501 for more
information about Proving Programs Correct.