CSCI 1103 Lab09: Equations Object-Oriented Objects

Material from Eck Ch 5 is covered in this lab.

Throughout much of your Mathematics education, you've likely spent time using linear equations to represent the relationship between things and solved them as parts of larger problems. We like to solve problems with computers, so a good first step could be developing our own library of classes to represent these equations.

The primary motivation of the object-oriented programming paradigm is to guarantee that operations on data preserve internal invariants for that data. Most of us know that the radius and diameter of a circle have the relationship \(r = 2d\). If circles are represented using both radius and diameter, changing one must affect the other: a circle with radius 5 and diameter 322 badly violates our notion of what constitutes a proper circle. This is the essence of the object-oriented paradigm, to only allow access to manipulate an object via certain methods which will preserve the internal consistency of the object's state.

In this lab we will be representing linear equations with real number coefficients in a standard format. We need a representation that keeps track of the different variables and constants, and that also maintains the relationship between them as the variables are changed. We consider first the slope intercept form.

Should you need a math refresher, Wikipedia's Linear Equations article contains useful reminders of terminology and formulas.

A linear equation is in slope intercept form if it is written \[ y = m x + b \] where \(m\) and \(b\) are constants that do not change while \(x\) and \(y\) are variables that do change. Importantly, if x changes, y must change to maintain the equality. It is frequent that objects should maintain relationships between their parts, sometimes called an invariant. The purpose of object-oriented programming is to control access to data so that such relationships can be maintained.

Completing this lab will create a class which models a linear equation in slope intercept form where any changes to the x or y variables will result in changes to the other variable.

Examine the following session which shows how instances of the SlopeInterceptLE class behave. This session gives insight into which methods need to be in the class and how they affect the object.

Welcome to DrJava.
> SlopeInterceptLE si = new SlopeInterceptLE(1.0,2.0)        // first constructor, x defaults to 0.0
> si.toString()                                              // show pretty printing version                    
"y = 1.00 * x + 2.00"
> si                                                         // in DrJava don't need to invoke toString()
y = 1.00 * x + 2.00

> si.x                                                       // directly look at x??
Static Error: No field in SlopeInterceptLE has name 'x'      // fields are private
> si.getX()                                                  // ask for x with an accessor
0.0
> si.getY()                                                  // ask for y with an accessor
2.0
> si.value()                                                 // ask value on both sides of equation with accessor
2.0
> si.setX(4)                                                 // change for x with an accessor
> si.value()                                                 // value should have changed with x
6.0
> si.getY()                                                  // changes to x affect y
6.0

> SlopeIntercept2 si2 = new SlopeInterceptLE(0.25, 10.25, 1.0);  // second constructor takes inital x
> si2.getX()                                                 // check x, should be 1 from constructor
1.0
> si2.getY()                                                 // check y, should match be affected by y
10.5

> si2                                                        // si2 has its own distinct values
y = 0.25 * x + 10.25
> si                                                         // si has its own distinct values
y = 1.00 * x + 2.00

> si2.setY(4.5)                                              // change y value
> si2.getY()                                                 // check change
4.5
> si2.getX()                                                 // changes to y should alter x
-23.0
> si2
y = 0.25 * x + 10.25
> si2.value()                                                // changes to variables affect value
4.5

> si2 = new SlopeInterceptLE(-0.25, -10.25, -1.0);           // re-assign si2 to a new equation
> si2.toString()
y = -0.25 * x + -10.25
> si2 = new SlopeInterceptLE(0.67512, -1.999, -1.0);         // and again
> si2.toString()
y = 0.68 * x + -2.00

Below is an overview of the fields and methods in the SlopeInterceptLE class. Each of these will need to be implemented to complete the lab.

public class SlopeInterceptLE {
// A class to model linear equations of two variable (x and y) in
// slope intercept form which is
//
//  m*x + b = y
//
// The coefficients m and b are set during the constructor and never
// change.  The variables x and y can be changed using public methods.
// Changes to x automatically update y and changes to y automatically
// update x. The "value" of this equation can change based changes to
// x and y but both left and right sides will always be equal.  No
// public fields should be present and all changes to the state of the
// object should happen via public methods.

  // FIELDS
  private double m;  // the slope of the linear equation, never changes
  private double b;  // the intercept of the linear equation, never changes
  private double x;  // the x (left side) variable which can change
  private double y;  // the y (right side) variable which can change

  // METHODS

  public SlopeInterceptLE(double m, double b);
  // Public constructor that accepts values for the slope m and
  // intercept b, defaults the value of x to 0.0 and sets y
  // appropriately.

  public SlopeInterceptLE(double m, double b, double x);
  // Public constructor that accepts values for the slope m and
  // intercept b and initial value of x and sets y appropriately.

  public double value();
  // Return the numeric value of the equation which is the numeric
  // quantity that should be on both left and right sides of the equal
  // sign.

  public double getX();
  // Return the current value of x

  public double getY();
  // Return the current value of y

  public void setX(double x);
  // Set the value of x and change y accordingly to preserve the
  // equation.

  public void setY(double y);
  // Set the value of $y$ and change $x$ accordingly to preserve the
  // equation.

  public String toString();
  // Return a =String= version of the general form of the equation.
  // The pretty version's general format should be as follows.
  // 
  //   y = M.MM * x + B.BB
  //
  // M.MM is the slope with 2 digits of accuracy and B.BB is the
  // intercept with two digits of accuracy.  Make use of
  // String.format() to assist with formatting the string.
  //
  // Examples:
  //    y = 1.23 * x + 122.41
  //    y = -1.23 * x + -122.41

}

Make sure that all fields are private as this prevents outside entities changing the x or y parts of the equation without affecting the other. Such changes should be done through the setX(val) / setY(val) methods which will change the other variable to maintain the equality of left and right hand sides.

During the first constructor

public SlopeInterceptLE(double m, double b)

set x to be 0.0 and calculate what y should be. The second constructor

public SlopeInterceptLE(double m, double b, double x)

is given an initial x which should be honored.

The toString() method is very common for classes in Java.

public String toString()

In this case, it should return a String version of the general form of the equation. This string's general format should be

y = M.MM * x + B.BB

where M.MM is replaced with the value of \(m\) with 2 decimal digits of accuracy and similarly for B.BB being replaced by \(b\). For example, if \(m = 1.23, b= 122.408\), the appropriate string to produce is

y = 1.23 * x + 122.41

If \(m = -1.23, b= -122.408\), the appropriate string to produce is

y = -1.23 * x + -122.41

This task is significantly easier if you examine the String.format() method and learn a few things about format strings for producing nice looking output. Format strings are used with System.out.printf() which is derived from the C language printf function. There are several places to learn about them.

You should feel free at any time to get help from lab staff as you get stuck on the exercises.

By the end of the lab, make sure to demonstrate your code to a staff member. This will ensure that you receive full credit on the lab. Staff might ask you to

• Change what is printed
• Compile and run on the command line
• Run tests in DrJava or on the command line
• Show how to zip the folder with your programs in it

Be ready to do any or all of these.

Ensure that file PARTNERS.txt has your name and the name of your partner in it. This fill is located with the other Java files for the lab and can be edited with DrJava.

Once your are confident your code is working, you are ready to submit. Ensure your folder has all of the required files. Create a zip archive of your lab folder and submit it to blackboard.

On Canvas:

• Click on the Assignments section
• Click on the appropriate link for this lab
• Scroll down to "Attach a File"
• Click "Browse My Computer"
• Select you Zip file and press OK