# Lecture 14: Mathematical Functions

Most languages already have many procedures and functions implemented. As an example, we will discuss the most usefull functions of PASCAL. It is not very important to remember the exact format and use of these functions. Much better is to remember that such things exist and when you need them, read the manual of the language you are using and chose the function you need.

 Function description argument result examples Abs absolute value of parameter  parameter can be real or integer  Abs returns the same type real  integer real  integer Abs(-23.2) = 23.1  Abs(12.3) = 12.3  Abs(-10) = 10 Cos Cosine of argument. Argument in   radians (2p rad = 360o) real real Cos(1.0) = 0.5403 Sin Sine of argument. Argument in   radians (2p rad = 360o) real real Sin(1.0) = 0.8415 ArcTan Inverse tangent of argument real real ArcTan(1.0) = p/4 Exp Exponent of argument real real Exp(1.0) = 2.718 Ln Natural logarithm of argument real (>0) real Ln(10.0) = 2.303 Odd Test whether argument is odd or even integer boolean Odd(3) = TRUE Round Rounding of argument to closest  complete number real integer Round(3.4) = 3  Round(3.5) = 4 Int Rounding down to complete number real real Int(3.99) = 3.00 Frac returns fractional part of argument real real Frac(3.99) = 0.99 Trunc Rounding down to complete number real integer Trunc(3.99) = 3 Sqrt Square root of argument real (>0) real Sqrt(3.0) = 1.732 Sqr Square of argument real real Sqr(2.0) = 4.0 Random Generates random number integer real  integer Random = 0.0234  Random(10) = 3 Randomize Randomizes the random number  generator.

## Trigonometric functions

As trigonometric functions we have Sin and Cos which return the sine and cosine of the argument, respectively. Note that the Tangent function doesn't exist, but as we all know (hopefully) Tan(x) is equal to Sin(x)/Cos(x). Note that the arguments (the parameters to pass to the function) have units radian (2p rad = 360o). As an example:
 program code PROGRAM Trigonometry; Var xdeg, xrad, ysin, ycos, ytan: real; begin   xdeg := 45.0;   xrad := Pi*xdeg/180.0;     (* convert to radians! Note that the      value Pi is defined in PASCAL *)    ysin := Sin(xrad);   ycos := Cos(xrad);   ytan := ysin/ycos;   Writeln('x = ',xdeg:0:3);   WriteLn('Sin = ', ysin:0:4);   WriteLn('Cos = ', ycos:0:4);   WriteLn('Tan = ', ytan:0:4); end. output x = 45.000 Sin = 0.7071 Cos = 0.7071 Tan = 1.0000

There exists only one inverse trigonometric function, namely tan-1 which is called ArcTan in PASCAL (and in some languages ATan). The others (ArcCos and ArcSin) can be derived from ArcTan. In the next lecture I will prove this.
 program code PROGRAM InverseTrigonometry; Var x, y, angle: real; begin   x := 0.5;   y := ArcTan(x);   angle := 180.0*y/Pi;   Writeln('x = ', x:0:3);   WriteLn('ArcTan = ', angle:0:4); end. output x = 0.500 ArcTan = 26.5651

## Exponential and power functions

The function Exp returns the exponent of the argument:
Exp(x) = ex
Ln returns the (natural) logarithm of the argument. The argument should be larger than zero, of course. The 10Log(x) function or in general the nLog(x) function and the general power fucntion xn do not exist in PASCAL, but we can easily derive them from the functions above:
xn = Exp(Ln(xn)) = Exp(n*Ln(x))
nLog(x) = nLog(eLn(x)) = Ln(x)* nLog(e) = Ln(x) / eLog(n) = Ln(x) / Ln(n)
In many languages the power function (for example in C: pow(x,n)) is implemented in this way any way.
In most modern computers with mathematical coprocessors (all Pentium processors have one built in) these complicated calculations of Ln, Exp, but also Cos, Sin and ArcTan are executed very fast because they make use of tables with precalculated values inside the processor.
In some languages, confusingly, with Log, the natural logarithm Ln is meant. Therefore, always READ THE INSTRUCTIONS!
Example:
 program code PROGRAM ExponentAndLogarithm; Var x, y: real; begin   x := 100.0;   y := Ln(x)/Ln(10.0);   WriteLn('Log(',x:0:1,') = ',y:0:1);   x := 3.0;   y := Exp(x*Ln(10));   WriteLn('10^',x:0:1,' = ',y:0:1); end. output Log(100.0) = 2.0 10^3.0 = 1000.0
Although any power function xn can be expressed with the functions Exp and Ln as described above, two of these powers are so often used that they are implemented with their own functions: Sqr gives x2 and Sqrt gives x1/2. Example:
 program code PROGRAM SquareRootAndSquare; Var x, y: real; begin   x := 3.0;   y := Sqrt(x);   WriteLn('The square-root of ', x:0:3,     ' is ',y:0:1);   y := Sqr(x);   WriteLn('The square of ',x:0:3,     ' is ',y:0:1); end. output The square-root of 3.0 is 1.732 The square of 3.0 is 9.000

## Rounding Functions

Four rounding fucntions are implemented in PASCAL, Round, Int, Frac, and Trunc.
Round returns the closest complete number. The returned value is of integer type. Examples: Round(1.2) = 1, Round(2.5) = 3, Round(4.99) = 5.
Int returns the part before the floating point, so, the closest complete number below. The returned value is of type real. This may cause some confusion; Int doesn't convert the number to integer, like in some other languages (C).  Examples Int(1.2) = 1.0, Int(2.5) = 2.0, Int(4.99) = 4, Int(5.0) = 5.0.
Frac returns the part of the number after the floating point, so a number between 0 and 1. It is therefore also of real type. Examples: Frac(1.2) = 0.2, Frac(2.5) = 0.5, Frac(4.99) = 0.99, Frac(5.0) = 0.0.
Trunc does the same as Int, but converts to integer. Examples: Trunc(1.2) = 1, Trunc(2.5) = 2, Trunc(4.99) = 4, Trunc(5.0) = 5.

## The odd function

An odd function is the function Odd. It returns TRUE if the argument is odd, FALSE otherwise. This function Odd(x) is therefore equal to(x MOD 2)>0 which also returns TRUE and FALSE, depending on the oddness of the argument x.

## Random numbers

One of the nicest things in programming is the use of random numbers. With randowm numbers even the programmer doesn't know the outcome of his own program. It is like flipping a coin or throwing dice. Even though you know exactly what a coin or a die is, you do not know the outcome of an exepriment with them. Generating random numbers with a computer is not easy. Computers are good at doing things in a predictable way, unlike humans, but not good at doing things randomly. There exist fucntions in PASCAL which generate random numbers that we can use. For all our purposes we can consider these numbers to be really random. Only upon closer scrutiny do they prove to be not random at all.
To generate a random number between 0 and 1 we can use the function Random. For example, calling this function five times might generate the series 0.3354, 0.2134, 0.2200, 0.9876, 0.0230.
If we want to have integer numbers between 0 and n-1 we can convert this number with the functions shown in the previous section: Trunc(n*Random). This result can also be obtained directly with the Random fucntion by supplying a parameter to the function: Random(n) returns integer numbers between 0 and n-1.
Note that everytime the program is ran, the random numbers follow the same sequence. If we want to start another sequence, we can call the procedure Randomize.
 program code PROGRAM RandomNumbers; Var x, y: real;     i: integer; begin   Randomize;   for i := 1 to 5 do     Writeln(Random:0:4);   for i := 1 to 5 do     WriteLn(Random(10)); end. output 0.7132 0.5111 0.0638 0.7837 0.3810 8 5 0 8 1
With these functions we can make cardgames, simulate nuclear decay, simulate traffic or any other kind of random process. The function Random is a homogeneous distribution; all numbers between 0 1nd 1 are equally likely to occur. If we want other distributions we can use the Random function as a starting function and convert it to these distributions. In other programming courses these things will be discussed further. For who wants to know more, I can recommend the book "Numerical Recipes in Pascal" (or in C or in Fortran).

## Quick Test

To test your knowledge of what you have learned in this lesson, click here for an on-line test.

Peter Stallinga. Universidade do Algarve, 17 março 2002