CSE 131 Module 1: Types & Names

• Module Home
• Studio
• Lab
• Extensions

Extensions

• Extension 1 for this module (5 points):

  Calculator

  In this extension you complete the functionality of a calculator. You accomplish this using the arithmetic, String, boolean, and casting operations discussed in the book.

  • In eclipse, open the calculator package found in the extensions source folder.
  • You will find the following Java files:
    • Calculator Go ahead and run this as a Java application. Play around with the interface and try out some simple computations. Notice that most computations produce the same result. That is because you have not done your work on this extension yet.
    • Computations Notice that all of these methods compute a variable named ans and then return that result. The calculator calls upon these methods to perform the appropriate computations.
    • ComputationsTest is the unit test for this extension. Your code must pass this test for you to earn credit.

      To run the unit test, right (control) click on the ComputationsTest file in the package explorer, drag down to Run as and select JUnit Test.

      The results will be a red or green bar. The red bar means you have errors, and you can see those by clicking on the flagged methods below the red bar. The green bar means your code has passed the test.

  • At the top of each method, a comment explains the computation you must perform in assigning the value to ans for that method.
  • For example, we have completed addDoubles for you. The assignment to ans computes the value d1+d2.

  Methodology

  • Perform your work one section at a time. For example, complete the double operators and test those before moving on to the other data types.

    Resist the urge to finish coding all of your work! If you are doing something wrong, you will go further down a bad path than you should go. Instead, proceed as follows.

    • Run the Calculator program and test your new functionality.

      To test the cast operations, use the copy and paste buttons to transfer a value from one type to another.

    • Run the ComputationsTest and ensure that your new functionality passes the unit test.
  • Move on to the next section and repeat the above until done.

  Some methods in this lab (specifically the casting methods) are not expected to produce any reasonable output. For example, a double cannot be cast to a boolean.

  Your method must nontheless return some value, so return any value you like, but call the error() method so that the program will report an error in the GUI window.

  For example, if a method should return an int but the operation does not make sense, then you would write:

       error();
       return 0;
  

  When you done with this extension, you must be cleared by the TA to receive credit.

  • Commit all your work to your repository
  • Fill in the form below with the relevant information
  • Have a TA check your work
  • The TA should check your work and then fill in his or her name
  • Click OK while the TA watches
  • If you request propagation, it does not happen immediately, but should be posted in the next day or so

  	Last name	WUSTL Key	Propagate?
  		(or your numeric ID)		Do not propagate
  e.g.	Smith	j.smith
  1				Copy from 1 to all others
  2				Copy from 2 to all others

  ---

  TA: Password:
  

  End of extension 1

  ---

• Extension 2 for this module (8 points):

  Credits:

  • Dr. Anne Bracy greatly improved the write-up of this exercise.
  • Logan Sorrentino implemented the GUI that drives the image processing filters.

  Image Processor

  Background

  Pixels

  The word pixel stands for Picture Element. A pixel is a small part of a picture. Pixels are the little dots that make up LCD screens. When you see a low-resolution picture that is grainy, the grain you're seeing are the pixels.

  Representing color in Java

  Pixels are made up of 3 colors: red, green, and blue (hence the term RGB). The color of a pixel is made up of a combination of the intensities of each of red, green, and blue components. Intensities range from 0 (meaning none of that color is present) to 255 (meaning as much as possible of that color is present). You declare a new pixel by coding

  new Color(redValue, greenValue,blueValue)
  

  where redValue is the intensity (an integer between 0 and 255) of red, greenValue is the intensity of green, and blueValue is the intensity of blue.
  

  For example, you get the color black with new Color (0,0,0) (0 intensity for all colors). You get red with new Color (255,0,0) (highest intesity for red, 0 intensity for green and blue).

  Filters

  This work involves writing a number of filters that are applied to images to achieve a given result. There are two kinds of methods that you complete, and each is described below:

  int foo(int pixelComponent)

  Methods with the above signature take in a single pixel component intensity value: an integer between 0 and 255 inclusively. They are obligated to return an intensity value as their result.

  These methods are used by the course software as shown below:

  

  1. A Color object is broken into its red, green, and blue components.
  2. Each component is passed to your foo method, and the result of that function is retained.
  3. The three results are combined into a new Color object.

  In other words, the foo function is used as a filter on each of a Color's components. The foo function is unaware of which component it is processing: it treats each equally.

  Color bar(Color c)

  Methods with the above signature accept and produce a standard Java Color object. These methods can themselves decompose a Color object into its components and create a resulting Color object to achieve whatever effect is desired.

  Project: Image Processing Methods

  1. In Eclipse, open the extensions source folder and then open the imageprocessor package. Find and open the ImageProcessor class.

     This is the main program you run to see the results of your work.

     Go ahead and run it as a Java application. You should see a window pop up with some images preloaded.

  2. Try the darker filter. It has been implemented for you, and it should produce an image in the Target window that resembles the image in the source1 window, but is a bit darker.
  3. Try the combine filter. It has also been implemented but its effects may seem a bit strange. You will soon implement a smarter version of this kind of a filter.
  4. The other methods are not yet implemented, but you are free to try them.

     By the way, you can drag images between the icon panel at the top and the working panels in the middle, or vice versa, so that you can manipulate other images than the ones that are preloaded.

     You can also load your own images by clicking on the icon that resembles a plus sign.

  Directions:

  Now open the Filters class and begin your work as described below.

  It is strongly suggested that you test each filter after its completion before you move on to the next filter. This will ensure that you are making progress and not going down a wrong path.

  Complete the provided stub methods as described below. In the method bodies, use mathematical expressions. Do not use a conditional (if) statement.

  Intensity filters

  Use no conditional execution for this part: only arithmetic expressions as you have learned them in Module 1.

  1. Complete the method called copy, so that each provided intensity value is copied exactly from the source to the target panel.

     Hint: This is a very simple method.

     
  2. Complete the method that will composite the images in the two source panels by averaging their components. This method accepts two parameters, which are color components from the two source panels.
  3. Complete the method called negative that will produce the negative image by inverting the intensity of each component.

     For example, if the parameter value is 0, you should return 255. If the parameter value is 1, you should return 254, and so on.

     
  4. Complete the method posterize that will reduce the number of possible colors in an image. For a given color component, your method will choose between two intensities, 0 or 255, which correspond to that color component being turned off or on completely. So, since each color has three components (red, green, and blue), you will end up with an image that has only 8 different colors.

     Remember that you are not allowed to use conditionals (if) statements for this part of the lab.

     Hint: : Recall that color components are in the range 0-255. Also, recall that if you divide an int by another int, the result number will be truncated. For example, 130 / 128 = 1, but 125 / 128 = 0.

     

  Color filters

  Note that each pixel of an image is represented as a Color object.

  • Continue to use no conditional execution for this part: only arithmetic expressions as you have learned them in Module 1.
  • To create a new Color, you must specify its red, green, and blue components in that order. For example

    Color c = new Color(25,128,0);
    

    declares c to be a color with some red (25 out of 255), half of the possible green, and no blue.
  • If you have a Color c, then you can get its red, green, and blue components as follows:

    int red = c.getRed();
    int green = c.getGreen();
    int blue = c.getBlue();
    

  Create and test methods (whose parameters and return values are Colors) with the following specifications.

  1. Complete the method brighter that will return, for each pixel, a Color that is brighter than the original.

     The Color class makes this easy because it already provides a brighter() method that returns a brighter color.

     If c is a color, then c.brighter() is a brighter version of c's color.

     
  2. Complete the method grayscale that will make a grayscale image from a color image. To do this, you will take in one Color parameter (the Color object for a pixel from the original image) and will produce a new Color in which all the components (red, green, and blue) have the same value.

     Hint: To choose which value, average the three components of the original color.

     

  More Color filters

  OK, now you can use if statements!

  
  
  1. Complete the method blackAndWhite that produces a black and white image by returning, for each pixel, a Color that is either black or white, depending upon the overall intensity of the original color.

     For your return value, use the constant Color.BLACK or Color.WHITE. It's up to you how to decide when a color's components, taken as a whole, should be considered black or white.

     
  2. Complete the method combineBrighter that combines two images by choosing for each pixel the color from the image that has the brighter pixel in that location. To determine which pixel is brighter, compare the sums of the red, green, and blue components of the two pixels. Since the ProcessorTool will run your method for every pair of pixels, the resulting image will have some pixels from the first image and some from the second image.
     

  When you done with this extension, you must be cleared by the TA to receive credit.

  • Commit all your work to your repository
  • Fill in the form below with the relevant information
  • Have a TA check your work
  • The TA should check your work and then fill in his or her name
  • Click OK while the TA watches
  • If you request propagation, it does not happen immediately, but should be posted in the next day or so

  	Last name	WUSTL Key	Propagate?
  		(or your numeric ID)		Do not propagate
  e.g.	Smith	j.smith
  1				Copy from 1 to all others
  2				Copy from 2 to all others

  ---

  TA: Password:
  

  End of extension 2

  ---

• Extension 3 for this module (4 points):

  This is a continuation of the previous extension. It is therefore suggested that you do the previous extension first.

  Image Processor (continued)

  Directions:

  The main program you should run for this extension is Background, which conveniently sets up the images in the bar and panels for you to do this work.

  So run Background as a Java application. You will see two similar images in the source panels, and some other images in the image bar.

  Open the Filters class and begin your work as described below.

  Two more Color filters

  You can use if statements for this work.

  
  
  1. Complete the method bgSubtract so that it returns a Color as follows:
     • If the source1Color and source2Color colors are sufficiently similar, return Color.BLUE. It is up to you to determine what is sufficiently similar, but the idea is to subtract the background so that what is common between the two source images is shown in blue.
     • Otherwise, return source1Color.
     An example is shown below: Where the two images are similar, the corresponding pixel in the target image is blue, because your method returned Color.BLUE. Where the images differ, the first image is shown in the target, because your method returned the pixel color from the first image.

  2. Complete the method bgReplace that functions as follows:
     • If the source1Color is Color.BLUE, then return the source2Color.
     • Otherwise, return source1Color.
     The effect of this filter is to replace the blue color from the first image with the corresponding pixels from the second image.

     To see this work, perform the following steps:

     1. Drag the blue-screen image from the target panel and drop it into the leftmost source panel. The GUI should replace what was there with the blue-screen image.
     2. Drag the other two-bear picture (the reverse of the one shown in the source panel) from the top icon bar into the middle source panel.

        After dragging these images around the GUI, the results should resemble the following:

        Note: No transformation is applied yet. The copy operation appears as the menu choice but the Go button was not pressed.

        
     3. Now apply the bgReplace filter, and the results resemble the following:
     4. For fun, drag the chicken image from the top icon bar into the middle source panel, and reapply the bgReplace filter. The results should resemble the following: The chicken is a smaller image, so it did not take up the entire size of the bear image.

  When you done with this extension, you must be cleared by the TA to receive credit.

  • Commit all your work to your repository
  • Fill in the form below with the relevant information
  • Have a TA check your work
  • The TA should check your work and then fill in his or her name
  • Click OK while the TA watches
  • If you request propagation, it does not happen immediately, but should be posted in the next day or so

  	Last name	WUSTL Key	Propagate?
  		(or your numeric ID)		Do not propagate
  e.g.	Smith	j.smith
  1				Copy from 1 to all others
  2				Copy from 2 to all others

  ---

  TA: Password:
  

  End of extension 3

  ---

• Extension 4 for this module (5 points):

  Credits:

  • Alan Waldman

  Expected Value

  Background

  How do you feel about money, risk, and job satisfaction? In this extension you will examine some simple yet powerful ideas from economics, and you will write code to compute how a person should behave based how he or she views risk, reward, and job satisfaction.

  The concepts we explore are as follows:

  Utility

  Utility is an economic term referring to the total satisfaction you derive or receive from some action or activity.

  Given the choice of two activities and absent any other concerns, a rational person would chose the activity that yielded the higher utility.

  Expected Value

  If there is uncertainty about outcomes, then the expected value of a given outcome is the product of its probability of occurring and the value of achieving that outcome.

  Let's consider the following two examples:

  1. You are given $1. The probability of this event is 1, and your value for achieving the outcome is $1, so your expected value is $1.
  2. You enter into a (no-cost) lottery with 9,999 other people for a chance to win $10,000. If the probability of the winner is uniformly distributed among those who enter the lottery, you win $10,000 with probabilty 0.0001 and you lose (win $0) with probability 0.9999. The expected value computation for this scenario is as follows:
     (.0001 × $10,000) + (.9999 × $0)

     Your expected value here is therefore also $1.

  • Based only on expected value, a person confronted with a choice on the above two scenarios would have no reason to pick one over the other, since the expected value is the same.
  • Now suppose the money given to you for certain in the first scenario is doubled to $2. A rational person would surely pick $2 over the lottery entry, because $2 is twice the expected value of the lottery outcome.

  However, we know there are people who would choose entering the lottery over receiving a sure $1 or $2.

  In the Powerball Lottery, your chances of winning are 1 in 175,223,510. So a rational person shouldn't buy a ticket if the jackpot is under $175M. But allegedly rational people do buy tickets for jackpots under that threshold.

  How can we account for this behavior? Read on.

  Expected Utility Theory

  The above analysis assumes a linear value for wealth. We can account for those who favor or avoid risk using Expected Utility Theory. This theory admits that rational people may have nonlinear views of wealth. This means that you may like $1,000 more (or less) than 1,000 times as much as you like $1. Let's look at three examples:

  Expected utility function	Notes
  u(d) = d	Linear value of wealth. The above analysis applies to such a person. NOTE TO SELF: 2nd derivative 0 here
  u(d) = d2	This person values $10,000 the same way a linear person would value $100,000,000. In the scenario given above, this explains why a person would enter the lottery. The person's perceived value of winning $10,000 is NOTE TO SELF: show the application of u here $10,0002=$100,000,000, which at probability 0.0001 yields an expected utility of $10,000: far greater than the $1 given for certain. An alternate view is that this person has a linear view of wealth (u(d)=d) but an unrealistic view of the probability of winning. For example, if this person holds the false belief that the probability of winning is 0.1 instead of .0001, then the expected value jumps from $1 to $1,000 using a linear function for expected utility. Because economists try to model human behavior assuming rationality, they translate this inflated view of luck into a nonlinear view of wealth. Thus, the function u(d)=d2 captures a form of risk-loving behavior. More generally, when viewed from below, any convex function, of which u(d)=d2 is an example, models risk-loving behavior. NOTE TO SELF: 2nd derivative is positive Such a person is either more certain of winning than probabilities would indicate, or alternatively has a convex expected utility function.
  u(d) = sqrt(d)	On the other hand, this concave function captures risk-averse behavior. In the lottery scenario, a win of $10,000 would feel like a win of only $100 to this person. With a .0001 probability of winning, the expected utility under this function is only 1 cent. Such a person would not enter the lottery even if the no-risk payoff were reduced from $1 to 2 cents. NOTE TO SELF: 2nd derivateive is negative here

  Problem

  Suppose you are trying to decide between one of the following two careers:

  Gamer

  You join a start-up company, which is exciting and could have high pay-off, but this venture might fail. Let's say you succeed with probability p, and if so you will earn $190,000. But if you fail (with probability 1-p), you earn only $5000.

  Programmer

  This job has no risk, and offers a salary in the range of $110,000 to $160,000. Your salary will be determined by a random choice of a value drawn uniformly from that range.

  • Let's begin by assuming you have linear value for money. Based on the above description, write a program that does the following:
    • Prompts the user for a value for p, which is the probability of the game start-up venture succeeding. The text of your prompt should be a meaningful message.

      Think about the type of p. Also what is a good variable name for this concept?

    • Given p, compute the expected value of the gamer-job outcome.

      Again, think about the type you need to represent the computed value, and think of a good name for this concept.

    • Now pick a salary for the programming job by choosing a value uniformly between $110,000 and $160,000.
    • Print both outcomes and a message that indicates whether you should accept the gamer job over the programmer job for this particular calculation. Such output might resemble:

        Gamer: $97,500
        Programmer: $115,000
        You should be a gamer and not a programmer?  false
      

      Run your program for multiple values of p to be sure that your output makes sense.

  Which should you do to maximize your utility?

  Let's say your expected `utility for wealth given your job differs as follows:

  • EU (Gamer): 3*sqrt(wealth)
  • EU (Programmer): 2*sqrt(wealth)

  For more information

  When you done with this extension, you must be cleared by the TA to receive credit.

  • Commit all your work to your repository
  • Fill in the form below with the relevant information
  • Have a TA check your work
  • The TA should check your work and then fill in his or her name
  • Click OK while the TA watches
  • If you request propagation, it does not happen immediately, but should be posted in the next day or so

  	Last name	WUSTL Key	Propagate?
  		(or your numeric ID)		Do not propagate
  e.g.	Smith	j.smith
  1				Copy from 1 to all others
  2				Copy from 2 to all others

  ---

  TA: Password:
  

  End of extension 4

  ---