## Description

CMSC 203, Lab 11

Concepts tested by this program:

Inheritance

Interfaces

Polymorphism

Abstract classes

Overriding methods

JUnit Tests

Optimization of functions by estimation

NOTE: This lab requires attention to

detail. Follow the following instructions

carefully.

In this project, you will extend the graphing application developed in Lab 8 to estimate the optimal solution(s) to

three optimization problems presented in the MATH 181 YouTube videos by Dr Jason Lee entitled “Math 181

Section 4.6” (https://www.youtube.com/playlist?list=PL94c6yqxunA3fz2AJ7TzMehUcb08JuJjz). This

application will replace functions #1, #2, and #3 from Lab 8 with the three functions developed in the videos for

finding local extrema, and iterate over them from a left extent to a right extent to find the minimum or maximum.

It will report the results, and continue on to graph the function using the same methods developed in the previous

project. Based on good object-oriented programming practices, the function definitions can easily be changed, so

design and programming tasks are focused on iterating through the function to find the local extrema.

Operation

When the user selects the “Optimize a problem” button, the application will display the three problems and

ask the user to select one of them to optimize.

The application will then ask the user for the left and right extents, which will be the range over which the

function is computed.

Then the application will compute the maximum or minimum, depending on the problem, and display the

results.

Then the application will graph the function being optimized (as in the previous project).

The user may then re-optimize and graph the same or a different function, or exit.

Specifications

Data Element – (same as Lab 8)

Data Structure – Just as in Lab 8, the abstract class Function holds an abstract method fnValue that the

programmer will implement for each sub-class function, and an implemented function fnValueToPlot (provided)

that uses fnValue to transform the values to the display coordinate system.

The programmer will implement the three functions which are described in MATH 181 videos entitled “Math 181

Section 4.6”, each in a class that extends Function. The estimation approach will approximate local extrema

programmatically, avoiding the need to deal with critical points, the closed interval method, first derivative tests,

or second derivative tests. Note that this approach is not as precise as methods used in calculus.

Each function will have a toString() method that returns a description of the problem, preceded by its index, and

an answerString(…) method tailored to each problem. The answerString() method will take the four values held

by the Optimum instance, and display them as appropriate to the specific problem. Note that not all four values

will always be displayed. For example, in problem #1, z is just a place-holder, and is not displayed.

Data Manager – the OptimizerManager class implements the methods of OptimizerManagerInterface, plus other

helper methods as needed.

Just as in Lab 8, the OptimizerManager selects the correct instance of the function based on the integer chosen. It

implements its toString method by calling the three function toString methods. It will receive the user-selected

extents of x (left and right) and the grid width in pixels and compute the extents of f(x) (minimum and maximum)

as in the previous project.

Then the OptimizerManager will use its optimize() method to iterate from the left extent to the right extent

computing the value of the objective function at each point, and remember the minimum or maximum function

value found. OptimizerManager will call the answerString() method for the selected function to provide the

problem-specific solution.

Then the OptimizerManager will compute the value of the function within the coordinate system of the panel, just

as in Lab 8. This value will be returned to the GUI to be plotted.

GUI Driver

At start-up, a blank panel is displayed with an Exit Button and an Optimize button.

When the Optimize button is selected, a JOptionPane prompts the user to choose one of the three problems.

A JOptionPane is then used to select the left and right extents of x (i.e., the minimum and maximum values of

x).

The GUI will create and use a OptimizerManager object to iterate from left to right extents, and save the

minimum (or maximum depending on the problem) value of the function. This will be the “extremum”

reported in the answerString() method of the chosen function.

The user will then be allowed to repeat the process for the same or another function, or exit.

TASK #0 – Study the code

Familiarize yourself with the code. Note how it is extended from Lab 8. Compile it and observe that there

are errors in the OptimizerManager constructor, because none of the Function classes are implemented.

TASK #1 – Implement Problem #1

Create a subclass of the Function.java abstract class named Function1.java which implements the cost

function shown below, as well as the other functions required by Function.java.

In MATH 181 (Calculus I) you studied how to optimize problems that could be expressed as a function of

one variable. Three problems were presented in the MATH 181 YouTube videos by Dr Jason Lee

entitled “Math 181 Section 4.6”. If you need to review these problems go to the link at:

The first problem is to find the radius and height of a cylindrical can that would hold 2 liters of fluid and

minimize the cost of construction, according to different costs for the base and top versus the side. The

following shows the derivation of cost as a function of radius (height is a function of radius also).

So C(r) is the expression of cost as a function of the radius. Create a subclass of the Function.java abstract class

named Function1.java which implements the functions fnValue, toString, answerString, getXVal, getYVal, and

getZVal, according to the following descriptions:

fnValue(double x): returns a double which is the cost in terms of x, the specified radius. (Follow the

examples in Lab 8 for this method).

toString(): returns a string describing the problem, e.g., “Minimize the cost of a can that will hold 2 liters

of liquid”;

answerString(double cost, double radius, double height, double z): returns a string that describes the result

of the optimization. For problem 1, z is not used, so can be any value.

getXVal(double x): returns x, the radius

getYVal(double x): returns the height in terms of the radius, according to the formula derived above in

eliminating the variable h.

getZVal(double x): returns the double -1.0, but is not relevant to problem 1. This method is included

only to conform to the abstract class Function.java, which requires it to be implemented.

In order to run the application with only Function1.java implemented, you comment out the following lines:

two lines in OptimizerManager() constructor that attempt to instantiate Function2 and Function3

two lines in OptimizerManager.toString() that deal with functions 2 and 3

two lines in OptimizerManager.answerString(…) that deal with functions 2 and 3

When running the application, be careful not to select anything other than choice #1 .

TASK #2 – Implement Problem #2

The second problem discussed in the above videos is to find the minimum speed with which a dog can

run and swim to fetch the ball in the problem below, along with the distance the dog should run along the

beach (AB) before jumping in the water.

Using the Pythagorean Theorem, we can sketch out the dog’s path, and assign the variable x to the

distance it runs along the beach.

Using the time-distance formula and the known speeds on land and in the water, we find a formula for the

time, Q, it takes for the dog to reach the ball as a function of the distance x it runs along the beach.

Create a subclass of the Function.java abstract class named Function2.java which implements the six

functions described in Task #1. In this case, fnValue(double x): should return a double which is the time

required in terms of x.

TASK #3 – Implement Problem #3

The third problem discussed in the above videos is to find the closest point on a parabola to a given point.

The formula for the distance between an arbitrary point P on the parabola to the point Q is derived as:

As above, create a subclass of the Function.java abstract class named Function3.java which implements

the six functions described in Task #1. In this case, fnValue(double x): should return a double which is

the distance between P and Q, according to the above formula for D.

Note that the graph of the distance function is not a parabola, because D is not a quadratic formula. It

does make sense, however, in that there are two points at which the distance D will be minimized, for a

negative and a positive x.

Turn in the following:

The corrected java src directory in a compressed (zip or tar) file