You represent two basic types of value in algebra. One is called a constant. The other is called a variable. Both of these values are usually represented as letters. Most people are familiar with them as the letters a, b, c, or x, y, z. A constant does not change. A variable does. Various names are applied to constants and variables depending on how they are used. The following list reviews the primary uses of variables and constants.

You’ll notice that these terms are a little fuzzy. After all, in the equation x + 3 = 4, you can call x an unknown. On the other hand, it is also a variable, for you can substitute a value into it (1). If you consider the equation at length, you also see that the value that you substitute for x is always the same, so x is a constant.

The easiest way to think of these terms is as a hierarchy of variability. If you have an expression with a lot of letters, say u + a × t, you can decide that one or more of these are “fixed,” and the others are “variable.” The fixed terms might be called parameters. For a particular set of parameters, you have a particular behavior for the variable terms. Then you might fix one of the parameters even more strongly and call it a constant. Each choice of a constant gives you a family of families. Finally, you can vary the constant to give you a family of families of families!

Variables and constants are used in similar ways by mathematicians and programmers. There is one difference that stands out, however. Programmers are encouraged to create mnemonically significant variable and constant names. For example, rather than naming a variable in a program x, a programmer is encouraged to use a name such as numOfPlayers or accountNumber. Likewise, due to language conventions, programming languages might represent the Greek letter π with the characters PI. Constants, generally, are represented by words consisting of capital letters.

A mathematical combination of variables or constants is called an expression. For example, (a × x) + (x² × 4) + 3 is an expression using the variables a and x, and the constants 3 and 4. Another constant also appears. This is the 2 used as an exponent, which is shorthand for the expression x × x.

A term is any subexpression of the main expression that does not contain additions or subtractions. It is convenient to group expressions into terms. With (a × x) +(x² × 4) + 3, if you consider x to be a variable and a to be a constant, then there are three terms, a × x, x² × 4, and 3. A term can contain any number of variables multiplied by a constant, which is called the coefficient. In the term x² × 4, 4 is the coefficient of x².

Terms can be classified according to the exponents of the variables within them. The terms 3 × x² and –2 × x² are considered like terms because they both have the same exponent of the variable x, namely 2. On the other hand, 3 × x² and 3 × x are not like terms, because they contain different powers of x. Two terms are alike if they only differ by their coefficient.

To extend the discussion, consider the expressions 2x and p(1 + q). In both expressions, two or more values are written next to one another. Such a construction indicates that a multiplication is to be performed. As a general rule, a coefficient is always written before the variables (2x, not x2), and terms outside parentheses are written first p(1 + q), not (1 + q)p. A term is usually written as a single string without multiplication signs, so the expression a × x + x² × 4 + 3 is written as ax + 4x² + 3. This allows you to easily group terms according to the exponents of their variables. For example, you see the x term, the x² term, and then the constant.

A function is a map that takes values from one set, called the domain of the function, and transforms them into values from the same or another set, called the range of the function. Consider a situation in which rational numbers are transformed into integers. Functions in mathematics are usually represented as a single letter followed by open and close parentheses between which the parameter of the function is represented. For instance, the equation y = f(x) indicates that the value x in the domain is mapped to the value y in the range. Functions are usually read as “f of x.” The value of the range is a function of the value of the domain. If you have a function f(x), then you refer to the value f(3) as the result of substituting 3 for x in the function. The result of substituting 3 for x in the function x → x(x + 2) is the value 3 × (3 + 2) = 3 × 5 = 15. (The arrow is a logical symbol for “x maps to.”)

What applies to math also applies to programming. Consider the floor() function, introduced in Chapter 1. When you use this function, you feed it a number that is not an integer (3.45, for example). It then returns an integer (3). You can also have Boolean functions, which map their input to just two values, 0 and 1. As an example, one common Boolean function is named isPrime(). This function returns 1 if the input is a prime number and 0 otherwise. In typed computer languages, you generally need to specify in advance both the type of the input value of a function and the type of the output value. For example, you designate that the function requires an integer argument as input and returns a double (a floating-point value). This requirement formalizes the fundamental nature of functions, which requires that they draw from a specific domain and translate to a specific range.

Many mathematical functions have their own symbols, and these symbols are represented in program functions. The symbol represents the sqrt() function. Some mathematical functions directly correspond to program functions. Among these are sin(), cos(), and tan(). In other instances, the correspondence is not so clear. Consider the function x² + 2. This function might be formally expressed like this:

The R → R part of this formulation is required in a formal definition of a function. It is not necessary to include it in this context, however. In this case, all it means is that both the input and output of the function are real numbers.

If you have a function f(x) and there are no two distinct input values a and b in its domain such that f(a) = f(b), then you call the function one-to-one. For such functions, there is also an inverse function, sometimes expressed as f’. With an inverse function, for every a in the function’s complete domain, f’(f(a)) = a. For example, the cube function, x → x³ is one-to-one. On the other hand, the square function, x → x² is only one-to-one when considered over the domain of positive real numbers (a partial or limited domain). A function for which values in the domain map to the same value in the range is called many-to-one.

Functions are multivalued when there is at least one value in the range that can map to more than one value in the domain. Among these is the mathematical square root function. With this function, both 1 and –1 are square roots of 1. Multivalued functions are usually the inverses of many-to-one functions, as in the case of the square root function. Strictly speaking, these are not functions at all, but it is useful to refer to them as functions. As a further point, it is impossible for self-contained functions programmed using standard programming languages to be multivalued. For example, the sqrt() function is a regular one-to-one function from R^– to R⁺, and it always returns a positive square root.

A polynomial is a particular kind of function of the form a_nxⁿ where the values a₀, a₁, a₂,... are all real numbers. Polynomials are distinguished according to degree. The function x → 2x + 1 is a polynomial. It is called a linear or first-degree polynomial because the highest power of x is 1. The function x → 2 – x + 3x² is a quadratic or second-degree polynomial because the highest power of x is 2. It is also possible to have polynomials in more than one variable, such as x → x² + 2xy + y².

An equation is like a mathematical sentence. It states that one expression is equal to another. Consider 1 = 1. This is a simple and rather obvious equation, as is 2 + 2 = 4. In most contexts, the term equation refers to a sentence that includes a variable, such as x + 2 = 5. This is a sentence that tells you a fact about the unknown x. In this case, it tells you enough about it that if you know that the equation is true, you can deduce what the value of x must be, namely, x = 3. The process of deduction is the main focus of elementary algebra.

It is important to distinguish between a function, an expression, and an equation. A function is like a phrase with blanks in it. It might read, “The _--- with tall _---’s.” An expression goes a step farther. It fills in the blanks with dummy variables: “The nnn with tall mmm’s.” An equation then tells you something about this expression by relating it to another. “The nnn with tall mmm’s is a qqq.”

Of the three activities, only an equation can be true or false. In this case, you don’t know whether it is true or not because you don’t know what an nnn, an mmm, or a qqq are. But if the sentence were “an nnn is an nnn,” then you could know it is true, whatever an nnn might turn out to be. Such an equation is called a tautology. For example, x + 2 = x + 3 – 1 is a tautology because it is true no matter what the value of x is. The equation x + 1 = 2 is not a tautology, however. If x = 1, then the equation is true. If x is any other value, then it is false. The same happens in a program. If you are working with a variable x, and you have the line, if x + 2 = 3, then the program executes the next line if and only if x = 1—that is, if the equation is true. Reversing the reasoning, if you know the equation is true, then you know the value of x must be 1.

A formula is an equation with more than one variable, and it defines one variable in terms of others. For example, v = u + at is a formula that defines the value v in terms of the variables u, a and t. However, since formulas and equations can be treated identically, this is just a terminological distinction. Formulas are most often used to express relationships between physical values, such as distance = speed × time.

An inequality is like an equation, but it tells you something other than that the two equations are equal. The types of inequalities vary fairly extensively. An inequality might say that one expression is less than the other. Consider, for example, x + 1 < x + 2. This happens to be a tautological inequality, for it always true, no matter what the value of x. An inequality might also say that one expression is greater than another. Consider, for example x + 1 > y. This is an inequality that might or might not be true, depending on the values of x and y. On the other hand, an inequality might simply assert that two expressions are not the same. In a computer language, you might write x != y or x <> y. Mathematically, you usually write x ≠ y.

Other symbols for inequalities are compounded or more abstract. Consider ≤ and ≥, representing “less than or equal to” and “greater than or equal to.” Still another symbol, not asserting inequality but instead a limited form of equality, is ≈, meaning “approximately equal to.” There is also the congruency symbol ≡. The latter two are not generally referred to as inequalities, but neutrally as statements.

An equation is said to be like a set of scales. If you know that a pair of scales balances, then you know that if you add or take away the same amount from each side of the scales, the scales will still balance. The same is true of an equation. The two expressions on each side of the equals sign are equal by definition. If you add the same value to both sides, they will still be equal. In fact, if you apply any non-multivalued function to both sides of an equation, the equation remains true.

Why specify that the function must not be multivalued? Imagine that you have the equation a² = b². It is tempting to take the square root of both sides of the equation, yielding a = b, but this is not necessarily true. It is not true because if a = 2 and b = –2, then the first equation is true but the second is not. This is because the function x is multivalued. Two distinct values in its domain can map to the same value in the range. All you can say with safety is that a = ±b, where the ± symbol means “plus or minus.”

The process of solving an equation in an unknown involves performing operations on both sides of the equation to find the value of the unknown. The most general equation is something like f(x) = g(x) for some functions f and g. If you subtract g(x) from both sides of the equation, you have f(x) – g(x) = 0. This can be as a new function q(x), where q(x) = f(x) – g(x). Generally, then, in its simplest terms, solving an equation is trying to find the inverse of the function q at 0.

Consider a less theoretical example. Suppose the equation is 2x + 3 = 7. Here, the left-hand side of the equation has two terms. One term contains x. The other provides a constant. To solve the equation, you can begin by subtracting the constant from both sides:

Now you have an equation with one term on each side. On the left-hand side is a multiple 2 of x. On the right-hand side is a constant, 4. Now, to isolate the value of x, divide both sides by 2:

Using this process, you find the value of x, which is 2. If you check the work, you find that 2 × 2 + 3 is indeed equal to 7.

As was emphasized previously, you can think of 2 × 2 + 3 differently, in terms of functions. If you do this, you have a function x→2x+3 which presents a good starting place for exploring inversion. Since the function multiplies by 2 and then adds 3, the inverse is a process of subtracting 3 and then dividing by 2. This amounts to the reverse steps in the reverse order. The inverse function is x→(x–3)/2. If you apply this function to both sides of the equation, the left-hand side maps to x (by the construction of the inverse function), and the right-hand side maps to (7 – 3)/2 = 4/2 = 2. This activity is the same as what was done previously, but the reasoning behind it is a little different.

It isn’t always so easy to solve an equation through inversion. Consider the equation . You have a bit of work to do before you can isolate the value of x. To do so, you must resort to simplification. To simplify an equation (or function), you reorganize it so that it is in successively simpler forms. In the end, you reach the simplest form. What constitutes the simplest form depends on the circumstances, but there are a few processes that you can apply regardless of circumstances. Here is a short list:

The third example (c) in the previous list proves troublesome due to the minus sign in the first expression of the equation. Items within the parentheses are multiplied by –2. When multiplying values within parentheses by a negative number, the negative number applies to all values inside the parentheses. To explore a different view of this topic, suppose that the original expression had been written as 5 + (–2) × (2x + 1). Comparing this version of the equation with the original allows you to see the effect of the negative sign.

Beyond negatives, you can also multiply together the values contained by parentheses. One approach to such a problem is to split it into two steps. Here is an example of how to proceed:

To extend the discussion, if you encounter an expression that is common, you might be able to transform the equation into another form by defining a new variable. While this is an obscure technique, it is useful in complicated circumstances. For example, suppose you want to solve the equation 4x⁴ – 9 = 0. Notice that 4x⁴ = (2x²)². To simplify the expression, you can substitute a variable, p, defining it as p = 2^x. Since 4x⁴ = p², you have p² – 9 = 0, or p² = 9. Since the square root of 9 is 3, p² = ±9.

Now to find x, you simply substitute back into the definition. Accordingly, since p = 2x², 2x² = ±3. Likewise, since 2x² must be positive, you can ignore the negative square root of p. As a result, 2x² = 3, so . As already mentioned, this is an exceptional and difficult technique you encounter only on occasion. It is used, for example, later in this chapter with equations involving cubed values.

Look again at the equation with which this section began. It provides an occasion for applying some of the notions developed in the previous sections.

To solve this equation, begin by simplifying the denominator. Toward this end, multiply out the parentheses:

Now combine like terms in the denominator:

To clean up the fraction, multiply both sides of the equation by the denominator. This gives you:

Now multiply out the parentheses on the right-hand side to get:

Finally, bring the terms from the left-hand side to the right-hand side and simplify again:

In the last line, the expressions have been switched (putting the 0 on the right). This is a traditional form of presenting an equation. When you have an equation with a constant on one side, you put the constant on the right. The practice corresponds to the convention in English of putting a proper noun before the verb in a sentence that contains a copulative verb. For example, speakers of English say, “Patch is a dog,” rather than “a dog is Patch.”

Given the preliminary discussion, here are some specific examples of factoring:

In addition to factors that are simple terms, whole expressions can be taken as factors. For example, in the expression x(x + 1) + 3(x + 1), the expression (x + 1) is a common factor, so the expression can be factored to (x + 1)(x + 3).

Consider what happens if you multiply out the terms in parentheses of (x + 1)(x + 3) and then join the like terms. This results in x² + 4x + 3. To factor this expression, given that you just performed the multiplication that created it, you can reverse the process and fairly easily reach its factored form. It is clear, however, that expressions such as x² + 4 x + 3 are not as easily factored as expressions like x(x + 1) + 3(x +1).

The expression x² + 4x + 3 is a quadratic expression. A quadratic is any expression of the form ax² + bx + c. If a quadratic expression can be factored, it takes the form (px + n)(qx + m).

To develop a general pattern for simplifying quadratic equations, you can equate the two expressions using the equation ax² + bx + c = (px + n)(qx + m).

If you multiply out the expression on the right-hand side and then combine terms, the equation assumes the following form:

This is an equation in which x is a variable, while a, b and c are parameters. For any possible value of x, given particular values of a, b and c, the equation is supposed to be true for any possible value of x. If this is to be so, each of the terms in x must match. As a result, if you assume that p= 1, you can reason as follows:

Consider a case in which a= 1. The general form of the quadratic becomes x² + bx + c. As a result, moving to the corresponding expression, n + m = b, and nm = c. Further, n and m are two numbers whose product is c and whose sum is b.

How can you find these numbers? One approach is to use inspection. Here are a few examples:

Notice that the numbers you are looking for vary according to the sign of the numbers b and c. In the last two examples, the absolute values of b and c are the same, but because the sign of c is different, the answer is changed significantly.

Can you always find two numbers, n and m, that satisfy this requirement? The answer is no. For example, if b = 1 and c = 1, then no pair of numbers whose sum and product are both 1 exists. As a general rule, you can only factor a quadratic expression as long as b² ≥ 4ac. This expression is called the discriminant. Why this is so is discussed shortly.

Given the quadratic form ax² + bx + c, what if a is not equal to 1? When this is so, you can reason things as follows:

In this case, you are looking for two values, am and n, whose sum is b and whose product is ac. While the technique used to factor remains much the same, after you have found am, you need to divide it by a to find m.

As an example, consider an equation examined earlier: 12x² – 57x + 63 = 0. To factor this equation, start by dividing the whole equation by a common factor, 3. This division results in 4x² – 19x + 21. For this equation, b = –19, and ac = 4 × 21 = 84. Consequently, you are looking for two numbers whose product is 84 and whose sum is –19. These numbers are –7 and –12. You can choose either one of these to be n and am. Since a = 4, however, and 4 is a factor of 12, it makes sense to choose n = –7, and m = –3. This way, it is not necessary to use fractions.

Given these preliminaries, you arrive at 4x² – 19x + 21 = (4x – 7)(x – 3). Working from the notion that the product must be zero, you also know that either x – 3 = 0 or 4x – 7 = 0. Working these out, you find that either x = 3 or x = 7/4. To test, substitute either of these values into the original equation and see if it evaluates correctly to 0.

The most prevalent way that most people learn to solve quadratic equations involves using the quadratic formula, which reads, . To work with this formula, notice that if b² < 4ac, then the value under the square root sign is negative. There is no real number solution for x in these circumstances. If b² > 4ac you arrive at two values for x, one using the positive square root, the other using the negative. If b² = 4ac, then the quadratic equation is an exact square, and there is only one solution for x. This occurs in an equation such as x² – 6x + 9 = 0, which factors to (x – 3)(x – 3), or (x – 3)².

In addition to those that factor to exact squares, another kind of quadratic expression involves the difference of two squares. Consider the expression x² – 25. This expression factors neatly as (x – 5)(x + 5). How it factors provides a reliable model for approaching all such factorizations. If you want to multiply two numbers that differ by a small amount, you can do it by squaring the average of the two numbers and subtracting the square of half the difference. Here is an example:

It’s possible to solve higher-degree polynomials, too, although it involves a little more work. Consider, for example, cubic functions. A cubic function (or equation) always has at least one root (a value x such that f(x) = 0). It can have up to three. The standard form of a cubic function is Ax³ + Bx² + Cx + D = 0. The term D is referred to as the discriminant.

As with quadratic equations, you can find a solution to the cubic equation by finding a simpler equation. For starters, you find a quadratic equation that you can solve using the methods previously mentioned. For example, start by dividing the equation by A to obtain a simpler equation x³ + ax² + bx + c = 0. Then make a substitution, replacing the variable x with a new variable t such that . This results in a new cubic equation with no quadratic term:

As before, the key to solving this cubic is the discriminant, D, where D = p³ + q². Consider these notions:

Having found values for t, you can then transform these into values for x by taking again.

As you can see, this process is complicated. On the other hand, it is predictable enough to serve as the basis of an algorithm. From the algorithm, a reliable programming function can be generated. Here is one approach to such a function:

function solveCubic(a,b,c,d)
   // d is the coefficient of the cubic term, the default being 1
   if d is defined then divide a, b and c by d
   set p to b/3 - a*a/9
   set q to a*a*a/27—a*b/6 + c/2
   set disc to p*p*p + q*q
   if disc>=0 then
      set r to cubeRoot(-q+sqrt(disc))
      if disc=0 then set ret to [2*r, -r]
      otherwise
         set s to cubeRoot(-q-sqrt(disc))
         set ret to [r+s]
      end if
   otherwise
      set ang to acos(-q/sqrt(-p*p*p))
      set r to 2*sqrt(-p)
      set ret to an empty array
      repeat for k=-1 to 1
         set theta to (ang—2*pi*k)/3
         append r*cos(theta) to ret

         end repeat
      end if
      subtract a/3 from each element of ret
      return ret
   end function

There are two approaches generally used to solve equations. One is by substitution. The other is by elimination. Both approaches are usually interchangeable, but there are many instances in which you are likely to prefer one over the other.

function solveSimultaneous(simul)
   set redux to an empty array
   set n to the number of elements of simul
   repeat for i=n down to 1
      repeat for j=i down to 1
         if simul[j][i] is not 0 then
            set row=simul[j] and quit this loop
         end if
      end repeat
      if no row found then return "no unique solution"
      divide row by row[i]
      add row to redux
      delete row from simul
      repeat for j=i-1 down to 1
         if simul[j][i] is not 0 then
            subtract row*simul[j][i] from simul[j]
         end if
      end repeat
   end repeat
   set output to an array with n elements
   repeat for i =n down to 1
      set sum to 0
      repeat for j=i +1 to n
         add redux[i][j]*output[j] to sum
      end repeat
      set output[i] to redux[i][n+1]-sum
   end repeat
   return output
end

A graph is a way of representing data visually. The standard form of graph is the two-dimensional Cartesian graph, which displays all possible ordered pairs of two numbers in the form of points drawn on a flat sheet or Cartesian plane. To make a Cartesian plane, you need three things: an origin, which is a single point that you define as representing the point (0, 0), and two axes, (pronounced ax-ease, the plural of the word axis). An axis is a direction on the plane, and it is drawn as a line through the origin, with arrows to indicate the directions. The values plotted on the axes can be negative or positive. Those above or to the right of the origin are positive, and those to the left or below the origin are negative. The arrows indicate that the values in all directions continue to infinity. Figure 3.1 shows an empty Cartesian plane.

Figure 3.1. The Cartesian plane.

For the Cartesian plane to represent pairs of numbers, each axis must correspond to one number in the pair. While the horizontal axis represents the first number, the vertical axis represents the second. The two axes are usually labeled as x and y and drawn at right angles to one another. As illustrated by Figure 3.2, if you assign each axis a scale, then any pair of numbers (a, b) can be represented by measuring a distance a in the direction of the first axis, and a distance b in the direction of the second axis. This process is called plotting the point (a, b), and the values a and b are called coordinates. If the axes are x and y, then a is the x-coordinate, and b is the y-coordinate.

Figure 3.2. The points (3, 4), (–2, 3) and (–4, –1) plotted on the Cartesian plane.

You can also follow the opposite process, reading the value of a point P on the plane. If you draw a line through P, perpendicular to the x-axis, it has to meet the y-axis at some point Q. As illustrated by Figure 3.3, if you measure the distance from Q to P in the scale of the x-axis, this will give you the x-coordinate of P, and if you measure the distance from the origin (often abbreviated as O) to Q in the scale of the y-axis, this will give you the y-coordinate. Note that the point P has been marked, and P is the point (2, 4).

Figure 3.3. Reading the point (2,4) from a graph.

Graphs are most useful for representing functions. If you have a function f(x), then you can represent it on a graph by taking every possible value of x, finding the value of f(x), and plotting the point (x, f(x)). Generally, you plot the variable along the horizontal axis and the output of the function on the vertical axis. A common expression of this is plotting f(x) against x. Alternatively, you can label the vertical axis with y and say that you are plotting the graph of y = f(x). If f(x) = 2x + 1, then you are plotting the graph of y = 2x + 1.

It’s fairly straightforward to make the computer draw a graph. The precise details depend on the classes or functions that a given programming language offers. The drawGraph() function draws a graph on the basis of another function passed to it as a parameter along with a range of values for x. Representing the number of evenly spaced values of x to be plotted, the resolution parameter is used to determine how accurately the graph is drawn. It will also automatically scale the y-axis to fit the entire function into the graph. The dimensions of the graph are passed in as the last two parameters, and the graph is always drawn to include both axes.

function drawGraph(functionToDraw, minX, maxX, resolution, width, height)
   // calculate values of the function
   set xValues to an empty array
   set yValues to an empty array
   set spacing to (maxX—minX) / (resolution - 1)
   // spacing is the distance between consecutive x values
   repeat for i = 0 to (resolution–1)
      set x to minX + i * spacing
      set y to calculateValue(functionToDraw(x))
      // how this is done depends on how you want to represent
      // the function. In the version on the CD-ROM, you can
      // pass either a string such as "x*x + 2*x + 3" or the
      // name of any function defined somewhere. The latter is
      // more flexible as it allows you to deal with special

      // cases such as "undefined" (see later in the function)
      append x to xValues
      append y to yValues
   end repeat

   // calculate the scale of the graph
   set leftX to min(minX, 0)
   set rightX to max(maxX, 0)
   // leftX and rightX are the x-values at each end of the
   // x-axis to be drawn
   set xScale to width / (rightX - leftX)
   set topY to max(largest(yValues), 0)
   set bottomY to min(smallest(yValues) , 0)
   // largest() and smallest() should return the largest and
   // smallest values in the array respectively
   set yScale to height / (topY—bottomY)

   // draw axes
   set x0 to xScale * (-leftX)
   set y0 to yScale * (-bottomY)
   // x0 and y0 are the positions within the graph of the axes
   draw a line from the point (x0, 0) to the point (x0, height)
   // this is the y-axis—you should also add arrows,
   // a scale and labels here
   draw a line from the point (0, y0) to the point (width, y0)
   // this is the x-axis

   // draw the function
   set currentPoint to 0
   repeat for i = 1 to the number of elements in xValues
      set x to xValues[i]
      set y to yValues[i]
      if y = "undefined" then
         set currentPoint to 0
      otherwise
         set thisPoint to ((x—leftX)* xScale, (y-ybottom) * yScale)
         if currentPoint = 0 then
            plot the point thisPoint
         otherwise
            draw a line from currentPoint to thisPoint

            end if
            set currentPoint to thisPoint
         end if
      end repeat
   end

Figure 3.4 provides samples of the output that drawGraph() function might generate. The version of the function used to generated Figure 3.4 provides labeling of the plots. You can access this function in the code for this chapter provided on the book’s companion website.

Figure 3.4. Graphs of the functions y = 15, y = 2x + 1, y = 4x² – 16 and y = 1/x.

As rudimentary as the output of the drawGraph() function is, it is still valuable as a template or creating functions that generate graphs. The chief characteristics are as follows:

While plots of graphs don’t tell you anything new about functions, they are of inestimable value in almost any mathematical, scientific, and technical context. Among other things, they allow certain important pieces of data to be seen quickly. Consider, for example, the questions of whether or where the line passes through the axes. Does it reach a maximum value or minimum value? Does it go off to infinity? Does it have asymptotes? As importantly, you can use this information to deduce other facts about the function. To explore such questions, consider what the graphs plotted in Figure 3.4 allow you to determine about the functions.

About Asymptotic Functions

The function generates asymptotes. Such functions are harder to characterize or read information from than are the others, but you can read off the values of the asymptotes directly. Caution is necessary, however. Many functions that seem to have asymptotes are actually just changing very slowly. Consider, for example, the graph in Figure 3.5 of y = log_e(x). The logarithm function does not have a maximum value, although from the graph it may seem that it does.

Figure 3.5. The graph of y = log_e(x)

Although simple functions are the most common things to draw on a graph, not all curves can be described in terms of a standard function. The graphs you have seen so far have been of single-valued functions. It is not possible to draw a circle using this technique because a circle does not have a distinct value of y for each x-coordinate. In terms of functions, a circle is multivalued.

One way to avoid the problem created by multivalued functions is to use a parameterization. When you do this, instead of using a single function f(x) and plotting y = f(x), you use two functions x(t) and y(t) and plot the points (x(t), y(t)) for each value of t. The token t serves as a dummy variable here. However, because parametric functions are often used to represent motion and motion involves time, t frequently represents time.

To illustrate how parametric equations work, suppose that two functions are given by the formulas x = at² and y = 2at. If you plot a graph of the points (x,y) given by allowing t to vary across the real numbers, you get the graph shown in Figure 3.6, which is a parabola lying on its side. In fact, it’s the parabola y²= 4ax, as you can find by substituting for t in the parametric formula.

Figure 3.6. The parabola formed from the parametric formula x = at², y = 2at.

This curve is one that you couldn’t draw using the drawGraph() function, because it’s multivalued in the y-coordinate. As you’ll see in later chapters, parametric formulas allow you to draw far more complex curves than simple functions, including the Bezier curves and splines seen in vector drawing and 3D modeling packages.

Write a function named substitute(functionString, x) that substitutes a value for x into a function given in standard notation.

The function should take two arguments, a string such as “5x^2 + 3(4-2x)” and a value such as 5, and should return the result of substituting the second argument for the variable x in the string. Use the ^ character as shown previously to represent powers, and the / and * characters to represent division and multiplication. Try to make the function as general as possible, particularly dealing with parentheses. Here are a few test functions you could try it out on: 5x + 3, 4 - 2(x-5), (x^3-4)/2, (x - 4)(2 - 3x), 2^(x - 4)/(x - 5)).

Write a function named simplify(functionString), which simplifies a given function as far as it can.

Simplification is a task requiring intelligence, and you won’t be able to make the function work as well as a human would, but you should be able to make some headway. Your program should be able to take a function, group like terms together, put fractions over a common denominator, and if you are very ambitious, factorize the result. You could work just with the variable x, or allow multiple variables.

Write a function named solve(equationString) which solves a given equation.

As before, this will not be infallible, but it should be able to deal with linear or quadratic equations. Use your previous function simplify to help you.