Tutorial 12     Lecturer: Craig MacDonald  Tutorial: Mon@10:10am    971201
===========

CSC 108, Fall 1997                                    Tutorial notes,  T12
==========================================================================

Topics
======

  - Collect the project
  - (1) object oriented example
  - (2) 1-D array example
  - (3) 2-D array example
  - tracing a program (see material that was not finished in tutorial 11)
  - other examples (you might like to go thru these examples on your own)


(1) Object Oriented Example
---------------------------

Suppose you are writing a program to keep track of inventory in a
warehouse.  For each inventory item, you will store
an identification number, and a
count of the number of units currently in stock.  The following
operations can be performed on an Inventory Item:
	- record arrival: Record the fact that a given number of units of
	  the Inventory Item have arrived at the warehouse.
	- record shipment:  Record the fact that a given number of units of
	  the Inventory Item have been shipped out of the warehouse.
	- number of units: Return the number of units
	  of the Inventory Item that are currently in stock.

Write a Java class for InventoryItem.

Write a main program that would use this class
to create an object, and that would call each of the
three methods on this object.

-----

    class InventoryItem {
        private int itemID;         // item ID number
        private int inStock;        // number of items currently in stock

        // constructor
        public InventoryItem(int identifier) {
             itemID = identifier;
             inStock = 0;
        }

        public void recordArrival (int numUnits) {
             inStock = inStock + numUnits;
        }

        // note that we could add a check to this method to make sure
        // that the number of items in stock never becomes negative.
        public void recordShipment (int numUnits) {
             inStock = inStock - numUnits;
        }

        public int numberOfUnits () {
             return inStock;
        }
    }

    class WareHouse {

      public static void main (String[] args) {

        InventoryItem stereo = new InventoryItem (55);

        stereo.recordArrival (100);
        stereo.recordShipment (10);

        System.out.println ("Item 55: Currently "+
                      stereo.numberOfUnits()+" in stock.");
      }
    }

2) 1D Array Example
-------------------

Write a method to reverse the elements in an array of integers.

    public static void reverset (int[] A) {
	// Subtle: Can't go all the way to the end! Why not?
	// Subtle: What if length is odd?
	for (int i=0; i<A.length/2; i++) {
		int temp = A[i];
		A[i] = A[A.length-1-i];
		A[A.length-1-i] = temp;
	}
    }




3) 2D Array Example
-------------------

Complete the following method, whose purpose is to return the maximum
of the column sums in a 2D array of floats.  Assume that the array is square.

    public static float maxColumnSum (float[][] A) {
	float biggestSum;
	float thisSum;
		
	for (int c=0; c<A.length; c++) {

	    // Sum up column c.
	    thisSum = 0.0f;
	    for (int r=0; r<A.length; r++) 
		thisSum += A[r][c];

	    // Subtle: second condition only evaluated if c isn't 0,
	    // in which case biggestSum does have a value.
	    if (c==0 || thisSum > biggestSum)
		biggestSum = thisSum;
	}
        return biggestSum;
    }




**************************************************
Please see Tutorial 11 Fall 1997 notes for tracing examples.
**************************************************



***************************************************
The Remainder of this page contains examples that
were not discussed in the tutorial.  You might want
to work through these on your own.
***************************************************

4) Strings & StringTokenizers
-----------------------------

Complete the method below.  It is given (1) a String s containing a sequence 
of words separated by blanks, and (2) a reference to a String array called list.
The method must construct an actual array for list to refer to (anything it 
may have formerly referred to is lost), and put one word from s into each 
slot of the array.  

No blanks should be stored in the array, either on their own or as part of
a word.  For full marks, the array must be constructed to be exactly the
right size to store the number of words in s.

	public static void pullApartWords (String s, String[] list)

SOLUTION:

import java.io.*;
import java.util.*;

class TokenizerExample {

   // This method is passed a string 's' that contains several
   // words separated by spaces.  It creates an array called
   // 'list' that contains each word in 's.'

   public static void pullApartWords (String s, String[] list) {

      // Make 's' a StringTokenizer object
      StringTokenizer words = new StringTokenizer (s);

      // Create an array to hold the tokens
      // ** Note that we cannot do "new" here, or else it loses
      //       the reference from the main method. **
      // list = new String[words.countTokens()];

      int count =0;                    // Counts each token

      // As long as there are more tokens in 'words,' put
      // the next token into the 'list' 
      while (words.hasMoreTokens()) {
         list[count] = new String (words.nextToken());
         count++;
      }
   }

   // This method shows how the 'pullApartWords' method could be
   // used.  It creates a string, and calls the 'pullApartWords' method
   // to create an array containing the words in this string.  It
   // then prints out the words in this string.

   public static void main (String[] args) {

      String sentence = "This is the sentence to be broken up into tokens.";
      String[] tokenArray;             // This array will store the tokens

      tokenArray = new String[new StringTokenizer(sentence).countTokens()];

      // Takes each token in 'sentence' and puts it into the 'tokenArray'
      pullApartWords (sentence, tokenArray);

      // Output Section

      System.out.println ("The sentence is:");
      System.out.println ("  "+sentence);
      System.out.println ();

      System.out.println ("There are "+tokenArray.length+" tokens in the sentence.");
      System.out.println ();

      // Print each token in the 'tokenArray'
      for (int i=0; i<tokenArray.length; i++) {
         System.out.println ("  tokenArray["+i+"] = "+tokenArray[i]);
      }
   }
}

SAMPLE OUTPUT:

The sentence is:
  This is the sentence to be broken up into tokens.

There are 10 tokens in the sentence.

  tokenArray[0] = This
  tokenArray[1] = is
  tokenArray[2] = the
  tokenArray[3] = sentence
  tokenArray[4] = to
  tokenArray[5] = be
  tokenArray[6] = broken
  tokenArray[7] = up
  tokenArray[8] = into
  tokenArray[9] = tokens.

5) Using a class
----------------

Assume that the following class has already been defined:
[TAs, you don't need to write down all the comments -- you can give them
verbally to save time.]

class IntegerSet {
    // set[i] is true iff the integer (offset+i) is in the set.
    private boolean[] set; 
    private int offset;

    // Constructor.  Make an empty set capable of storing integers
    // between smallest and greatest inclusive.
    public IntegerSet (int smallest, int greatest) {
	set = new boolean[greatest-smallest+1];
	offset = smallest;
    }

    // Insert n into the set.
    public void insert (int n) {
	// Details omitted;
    }

    // Return true iff n is in the set.
    public boolean contains (int n) {
    	// Details omitted;
    }

    // Return the proportion of integers between smallest and greatest 
    // inclusive that are actually in the set.
    public float density () {
	// Details omitted;
    }

    // Reset the set to be empty.
    public void reset ()
}

Complete the following main method.  It should read from the standard input
a number, followed by that many integers, and insert all of the integers
into a set.  Finally,  it should print the "density" of the set.

Use a helper method for reading the integers.

    class Tester {

        // Helper method goes here:

        public static void main (String[] args) {
            // Complete this.
        }
    }

SOLUTION:

class IntegerSet {
   // set[i] is true iff the integer (offset+i) is in the set.
   private boolean[] set;   // indicate which integers are stored in the 'set'
   private int offset;      // position in set relative to first smallest value

   // Constructor.  Make an empty set capable of storing integers
   // between smallest and greatest inclusive.
   public IntegerSet (int smallest, int greatest) {
       set = new boolean[greatest-smallest+1];
       offset = smallest;
       // initialize set to contain all false values
       reset();
   }

   // Insert n into the set.
   public void insert (int n) {
      if (n<set.length+offset &&  n>=offset)
         set[n-offset] = true;
   }

   // Return true iff n is in the set.
   public boolean contains (int n) {
      if (n<set.length+offset && n>=offset)
         return (set[n-offset]);
      else
         return false;
   }

   // Return the proportion of integers between smallest and greatest
  // inclusive that are actually in the set.
   public float density () {
      int true_count = 0;
      for (int i=0; i<set.length; i++) {
         if (set[i])
            true_count++;
      }
      return (float)true_count/set.length;
   }

   // Reset the set to be empty.
   public void reset () {
      for (int i=0; i<set.length; i++) 
         set[i] = false;
   }
}

import java.io.*;
class Tester {

   // Read in the number of integers, and then read each integer
   // into the 'numbers' array.

   private static int[] readData () throws IOException {

      DataInputStream stdin = new DataInputStream (System.in);

      // Read in the number of integers into 'count' and create 'numbers'
      System.out.print ("Enter the number of integers (at least 2): ");
      int count = Integer.parseInt (stdin.readLine());
      int[] numbers = new int[count];

      // Now read in each integer into the 'numbers' array
      System.out.println ("Enter "+count+" integers, one integer per line.");
      for (int i=0; i<count; i++) {
         int num = Integer.parseInt(stdin.readLine());
         numbers[i] = num;
      }

      return numbers;
    }

    public static void main (String[] args) throws IOException {
        // Call the helper method to read numbers into 'list' array
        int[] list = readData ();

        // Create the set and insert the integers into it
        IntegerSet set = new IntegerSet (minInList(list), maxInList(list));

        for (int i=0; i<list.length; i++) {
            set.insert (list[i]);
        }

        // Print the "density" of the set
        System.out.println ("Density of set: "+set.density());
   }

   // Returns the largest integer in a list of integers
   private static int maxInList (int[] list) {
      int max = list[0];
      for (int i=1; i<list.length; i++) {
         if (list[i]>max)
            max = list[i];
      }
      return max;
   }

   // Returns the smallest integer in a list of integers
   private static int minInList (int[] list) {
      int min = list[0];
      for (int i=1; i<list.length; i++) {
         if (list[i]<min)
            min = list[i];
      }
      return min;
   }
}

SAMPLE RUN FOR 5):

Enter the number of integers (at least 2): 7
Enter 7 integers, one integer per line.
6
2
8
16
5
3
15
Density of set: 0.46666667








6) Writing a Class
------------------

Designing a new complex number class: Take this development to the
level of an object diagram (public fields and methods) but don't write
code.  Discuss these questions.

   What is a complex number? a+b*i

   What are the essential parts of a complex number? How can these be
   represented as fields in a ComplexNumber class? double a,b;
   
   Is this the only way to represent a complex number?
   r*e^(i*theta) where r=(a^2+b^2)^0.5 and theta =arccos (a/r) or equivalently
                       a = r cos theta, b = r sin theta
   
   What should the constructor for a ComplexNumber look like? two doubles
   
   What should the toString() method for a ComplexNumber look like? 
   
   Do you need any get() or set() methods? (Can a complex number change
   its state or should it be immutable?)
   
   What do you want to do with a complex number? What methods should you
   write?