Math 280 Project Report

Abstract

Graphing linefields is a useful learning tool for mathematics students, but it is an arduous process to do by hand. To solve this problem, a linefield graphing applet was constructed in Tcl/Tk, capable of being run in a web browser (Netscape 4/IE4) with appropriate plugin or stand alone via the 'wish' interpreter. It graphs linefields, displaying the results for the user's inspection. Approximations of solutions using Euler's method are implemented, allowing students to explore the solutions of the linefield as well.

Method

The tclet (a Tcl/Tk applet) was conceived and designed using a top-down design methodology. It's general structure follows:

• Basic configuration parameters

  config(level) = (basic | advanced)

  Sets the tclet to expect basic or advanced equation input. Basic input allows only the math directives outlined in the results section. Advanced allows any valid tcl code to be written as long as it returns a result value.

  config(x_width) = numeric

  Sets the width of the graphed area. This is the scrollable area in the X direction

  config(y_width) = numeric

  Sets the height of the graphed area. This is the scrollable area in the Y direction

  eq = equation expression

  Sets the default equation that is graphed at tclet startup.

  inf(dx) = numeric

  Step size in the X direction between sloped-lines

  inf(dy) = numeric

  Step size in the Y direction between sloped-lines

  inf(len) = numeric

  Length of sloped-lines. Should be smaller than min(inf(dx),inf(dy)) or solid slope lines may occur.

  inf(line_dx) = numeric

  X direction increment for approximated solution curves.

  inf(scale) = numeric

  Scaling factor to multiply coordinates by. For example, of the default graph size of -400 to 400, if you wanted to scale to -200 to 200 but wanted to have the graph's scrollable area be the same, you would set inf(scale) to be 0.5 (0.5 * 400 = 200).

• Graph 'class' definitions

  Variables:

  canvas (string)

  Contains the Tcl/Tk name of the graph. Don't change it.

  inf (array)

  Contains various configuration information listed above, as well as the numbers of some objects displayed on the graph so that they can be deleted to clear the graph.

  Procedures:

  Clear;

  Clears off all the slope-field lines (black lines). Used when a new field is to be graphed.

  ClearLine;

  Clears off the particular solution line (blue line). Used when a new solution line is to be graphed, or when a new line field is to be graphed.

  Click ;

  Calculates and displays a particular solution of the linefield at the point clicked. It uses Euler's method to do so. See below for an explanation of this technique.

  Create;

  Creates the graph, scroll bars, and the graph boundary numbers. Also draws the thick red axis bars onto the graph.

  UpdatePosition ;

  Updates the X,Y display at the lower left of the pointer position over the graph.

  SlopedLine;

  Compute and graph the line field over the graph. For the computational loop expressed in mathematical terms, see below.

• User interface setup
  Components are setup and placed in the window in the following order:
  1. Graph (and scroll bars, graph position readings, placed on top)
  2. Application credits (placed on bottom)
  3. X,Y position readout (placed to the left)
  4. Equation entry box (placed to the right)
• Final initialization is completed, the field is graphed, and then the tclet begins waiting for user input.

SlopedLine calculations

The core of the SlopedLine calculation is a double-nested for loop, running from the minimum value of x to the maximum, and for each of those values, running from the minimum value of y to the maximum. Inside both those loops is the computation of the slope at the current point, which is then converted to an angle to allow for constant length slope lines. Using that angle, an appropriately sloped line is drawn on the graph, and then moved from it's position at (0,0) when drawn to the current (x,y) position given by the double-nested for loops.

The pseudo-code form of this loop (written in a C like pseudo-code) is:

for (x = x_min;x <= x_max;x = x+dx) {
  for (y = y_min;y <= y_max;y = y+dy) {
    slope = evaluate_equation_at(equation,x,y);
    theta = inverse_tan(slope);

    draw_line_from_to(-len/2*cos(theta),-len/2*sin(theta),
                      len/2*cos(theta),len/2*sin(theta))
    move_line_from_to(0,0,x,y);
  }
}

Click calculations

To approximate a solution, once a point is clicked that the approximation should go through, the tclet uses Euler's method to compute a left and right half (with the point as the center). The choice of this method was somewhat unfortunate, rendering the tclet unable to accurately handle linefields who's slope becomes infinity/undefined (because of the division by dX, the slope can become infinity/undefined if dX should be equal to 0).

Using Euler's, the tclet takes the point that is currently being looked at, and finds the slope at that point. Then, it computes a new point to be at, moving x by a little bit, and moving y by the slope times the distance x moved. It draws a line between the old and new positions, then writes the new position as the old ones, and repeats, until one of the positions moves out of bounds of the graph.

The pseudo-code form of this procedure (written in a C like pseudo-code) is:

  x_right = x_left = point_clicked_x;
  y_right = y_left = point_clicked_y;
  // dx = <distance for each step in line graphing, 1 in this case>

  // Graph the left side of the line
  while ( in_graph_bounds(x_left,y_left) ) {
    slope = evaluate_equation_at(equation,x_left,y_left);

    new_x = x_left - dx;
    new_y = y_left - slope*dx;

    draw_line_from_to(x_left,y_left,new_x,new_y);
    x_left = new_x;
    y_left = new_y;
  }

  // Graph the right side of the line
  while ( in_graph_bounds(x_right,y_right) ) {
    slope = evaluate_equation_at(equation,x_right,y_right);

    new_x = x_right + dx;
    new_y = y_right + slope*dx;

    draw_line_from_to(x_right,y_right,new_x,new_y);
    x_right = new_x;
    y_right = new_y;
  }

Results

The result is a useful linefield graphing tclet, which can either be embedded in a web page as it is below, or as a stand-alone application which can be run from any system which has the 'wish' interpreter available (Windows, MacOS, and UNIX with X) for it.

The field can be scrolled around using the scroll bars to the sides of it. The dark grey equation box is editable, to allow you to enter a new equation in slope form. The X,Y display is the current location of the mouse pointer inside the graph.

The following symbols are valid in the equation box:
• $x, $y -- the x or y coordinate at the point
• +, *, -, /, %, () -- Standard math operations and grouping symbols
• acos(x), asin(x), atan(x), atan2(y,x), ciel(x), cos(x), cosh(x), exp(x), floor(x), fmod(x,y), hypot(x,y), log(x), log10(x), pow(x,y), sin(x), sinh(x), sqrt(x), tan(x), tanh(x), abs(x), double(x), int(x), round(x), rand(), srand(x) -- builtin functions

Note that sometimes when graphing a field, the field will be too steep to be able to see anything interesting in it (such as: (dx/dy)=$y). In this case, multiply the field by a scalar, such as 0.01 and it will then be visible.

The source code is available here (approx 10kb), however downloading it will most likely just start the tclet fullscreen in your browser; instead use your browser's "Save as ..." option to save the code to disk. You may also download all the project files (the code and html files) in a large zip (approx 10kb) or tar-gzip file (approx 8kb).

Future Improvements

Some improvements could be made to the tclet, aside from general code cleanup. The following list contains improvements that would be useful:

• Converting the code to use a pfaffian form, rather than slope form for input. This would solve the divide-by-zero problem that occurs at some points with the slope form.
• Allow the user to slide a scroll bar to change the zoom factor on the graph.
• Try to get an approximate (nth power polynomial) of a solution curve.

References

1. Welch, Brent. Practical Programming in Tcl/Tk.
   New Jersey. Prentice Hall. 1997.
2. Tcl plugin and documentation [online]. Scriptics Corp.
   Available from WWW: <http://www.scriptics.com/>.
3. Skeel, R. Keiper, J. Elementary Numerical Computing
   with Mathematica. New York. McGraw-Hill, Inc. 1993.
4. Koopman, Phil. How To Write An Abstract [online].
   Available from WWW: <http://www.cs.cmu.edu/afs/cs.cmu.edu/local/mosaic/common/omega/Web/People/Koopman/essays/abstract.html>.

Home

Math280

Sitemap