Functions from Math (brief review)

Definition:

   f(x) = 3x + 2

   g(x) = (x - 4)2

Where x is known as the independent variable, the function input, and/or the argument to the function. The functions (f and g) are defined by a simple equation.

In programming, we call x either the function's input or its formal argument (not the independent variable). Functions in programming languages are rarely defined so simply (except those of systems like Mathematica or Maple where the emphasis is on ease of use by students, teachers, etc.).

Evaluation:

   f(4) = 3*4 + 2 = 14

   g(4) = (4 - 4)2 = 0

   f(a) = 3a + 2

(Mathematica/Maple:

    a = 4
    f(a) = 3*a + 2 = 3*4 + 2 = 14)

This is known as evaluation of a function at a 'point' or at a particular value for the independent variable.

(The Mathematica/Maple example is merely saying that the variable a is assigned a value of 4 and that the function f is being evaluated at the current value of a.)

In programming, we refer to this as 'calling the function' and passing it the actual argument value. (The Mathematica/Maple example works in programming languages, too — passing a variable as an actual argument is perfectly legal.)

Composition:

                   2
f(g(4)) = 3*(4 - 4)  + 2 = 3*0 + 2 = 2

                       2           2
g(f(4)) = (3*4 + 2 - 4)  = (14 - 4)  = 100

Here we have evaluated a function at a value and then used that value as the input to the next (outer) function. (We could also solve for the actual formula of f(g(x)) in general. But we do not have to in programming, so why bother?)

In programming, this is called nesting a function call — one function call is used as the argument to the next (outer) one.

Multiple Independent Variables:

   f(x,y) = x2 + y2

   f(3,2) = 32 + 22 = 13

Here we have a function that has more than a single input. Functions with one independent variable generate curves/lines in the 2D (Cartesian) plane. Those with two independent variables generate surfaces in a 3D space. (More independent variables are possible, but are quite a bit more difficult to picture.)

Programming languages allow us to have multiple arguments to our functions, as well.

Translating Math Notation to C++

Most programming languages support pre-defined (built-in/library) functions to do many standard mathematical tasks. C++ is no different. Among the standard libraries of C++ you'll find the 'math' library. This library's interface is defined in cmath. To use functions defined in the cmath library, you must remember to place a #include for its interface at the top of your program (typically right after the one for the iostream library's interface inclusion).

   ___
 \/ x

  |x|

  xy

  ex

    const double MATH_E = exp(1.0);

  ln x

  log x

  | x |
  -- --

  __ __
  | x |

  sin x

  sin-1 x

Triangles and Circles and Waves...Oh, My!

Note that all math library functions assume they are receiving floating point arguments — double actually. Do NOT pass them whole valued arguments if at all possible (use a typecast if necessary).

Also note that all trigonometric functions either accept or return values measured in radians. You should always read from/print to the user in degrees (°) and convert to radians for calling the built-in trig functions. Likewise convert back from radians after an inverse trig operation for display for to the user. (The two main other trig functions besides sin are supported in a similar way: cos(), acos(), tan(), and atan()).)

BTW, there is also an atan2(y,x) function that will calculate the inverse tangent of y/x but use the signs of x and y to determine the quadrant of the angle. Instead of a standard range of (-π/2, π/2), its range is [-π, π]. I'd recommend its use to create a nice constant to represent π like so:

    const double PI = atan2(0.0, -1.0);

The Well-Rounded Programmer Knows

Note that there is no rounding function provided. Although some compilers have provided such functions, we'll not be using them — as they are not standard nor portable. Instead, we'll use the following formula which evaluates to the nearest whole value to x:

    floor(x + 0.5)

The reason this works is that floor() is essentially the same function as what we commonly think of as 'rounding to the nearest whole number' except that it has been translated half a step to the right. Or, in other words, rounding is the translation of floor() by 0.5 units to the left. (We recall from algebra that translation to the left occurs as adding to the incoming independent variable's value a non-negative quantity representing the number of units to shift...um. Yeah...it sounded so much better with a pretty graph to go along. I'll look for some graphs, but until then, pull out your old algebra book and flip through the translation section of the function chapter.) That is, if you move the graph of f(x) to the left by a units, you get the graph of f(x+a). (And if you move instead to the right by a units, you get the graph of f(x-a).)

But what if you need to round not just to the nearest whole number (the 1's place), but maybe to a different digit position (say the hundredths — 0.01), try this formula:

    floor(x / place + 0.5) * place

Here place represents the desired decimal place or digit position you'd like to round your number to. So, if you want to round 3456.128 to the nearest 0.01, you'd divide it by 0.01 — shifting the decimal place right 2 positions (dividing by a fraction is like multiplying by its reciprocal; here the reciprocal of 0.01 is 100): 345612.8. Now we add the 0.5 and take the floor() to round it: 345613. Finally, we multiply this result by 0.01 — shifting the decimal place left 2 positions again: 3456.13.

This will work for places that are any power of 10: 100, 1, 0.1, 10000, etc. In fact, this works even if 'place' is not a power of 10. You can round to the nearest multiple of 5, round to the nearest 25, or even round to the nearest half by using an appropriate value for place. (For the examples, those would be 5, 25, and 0.5 respectively. *grin*)

But there are those folks that don't really understand rounding all that well. And there are also those times where you don't really want to round, but rather want to force a value up or down to the next place. So, for such occasions, here's a handy chart:

But Life's More Than Numbers

Other libraries help to do more life-oriented things:

Character Manipulation Library: cctype

   char ch_var;

   ch_var = toupper(ch_var);

   string s_var;

   s_var[0] = toupper(s_var[0]);

    cout << static_cast<char>(toupper('a'));

   char ch_var;

   ch_var = tolower(ch_var);

   string s_var;

   s_var[0] = tolower(s_var[0]);

    cout << static_cast<char>(tolower('A'));

Time Library: ctime

Standard Library: cstdlib

Input/Output Stream Library: iostream

Input/Output Manipulation Library: iomanip

    #include <iomanip>

    int main(void)
    {
        // ...
        cin >> dec;
        // ...
        return 0;
    }

Constants in the Libraries

Using Functions

Some examples:

• Distance between two points (uses pow and sqrt from cmath)
• Modify users initials for stylized output (uses toupper and tolower from cctype as well as ignore with cin from iostream)
• Roll a 6-sided die (uses rand and srand from cstdlib as well as time from ctime and nullptr from cstddef — the last indirectly #included)
• Business Networking Helper (a conglomerate of the last two examples)
• English Clock (just time and nullptr here)
• Reading Time-of-Day (mixes characters with >> input from cin and uses dec from iomanip as a precaution)
• Converting Inches (use of % for unit conversion with ignore and the infinity-like numeric_limits<streamsize>::max() helping clean up the user's data entry)