Math object and Math functions in Javascript
By: Nicholas C. Zakas Emailed: 1598 times Printed: 2044 times
Latest comments

The Math object is the builtin object that you wish you had during those high school math classes: It knows all the formulas for the most complicated mathematical problems, and it can figure them out for you if you give it the numbers to work with. The Math object has several properties, consisting mostly of special values in the world of mathematics.
The following table describes these properties:
Property  Description 
E  The value of e, the base of the natural logarithms. 
LN10  The natural logarithm of 10. 
LN2  The natural logarithm of 2. 
LOG2E  The base 2 logarithm of E. 
LOG10E  The base 1 logarithm of E. 
PI  The value of π. 
SQRT1_2  The square root of 1⁄2. 
SQRT2  The square root of 2. 
Although the meanings and uses of these values is outside the scope of this book, if you know what they are, they are available when you need them. The Math object also contains many methods aimed at performing both simple and complex mathematical calculations.
The methods min() and max() are used to determine which number is the lowest or highest in a group of numbers. Each of these methods accepts any number of parameters:
var iMax = Math.max(3, 54, 32, 16);
alert(iMax); //outputs “54”
var iMin = Math.min(3, 54, 32, 16);
alert(iMin); //outputs “3”
Out of the number 3, 54, 32, and 16, max() returns the number 54 whereas min() returns the number 3. These methods are useful to avoid extra loops and if statements to determine the maximum value out of a group of numbers. Another method is abs(), which returns the absolute value of a number. The absolute value is the positive version of a negative number (positive numbers are their own absolute values).
var iNegOne = Math.abs(1);
alert(iNegOne); //outputs “1”
var iPosOne = Math.abs(1);
alert(iPosOne); //outputs “1”
In this example, abs(1) returns 1 and so does abs(1).
The next group of methods has to do with rounding decimal values into integers. Three methods, ceil(), floor(), and round(), handle rounding in different ways.

The ceil() method represents the ceiling function, which always rounds numbers up to the nearest value.

The floor() method represents the floor function, which always rounds numbers down to the nearest value.

The round() method represents a standard round function, which rounds up if the number is more than halfway to the next value (0.5 of the way there) and rounds down if not. This is the way you were taught to round in elementary school.
To illustrate how each of these methods works, consider using the value 25.5:
alert(Math.ceil(25.5)); //outputs “26”
alert(Math.round(25.5)); //outputs “26”
alert(Math.floor(25.5)); //outputs “25”
For ceil() and round(), passing in 25.5 returns 26, whereas floor() returns 25. Be careful not to use these methods interchangeably because you could end up with some unexpected results. Another group of methods relates to the use of exponents. These methods include the following: exp(), which raises Math.E to a given power; log(), which returns the natural logarithm of a particular number; pow(), which raises a given number to a given power; and sqrt(), which returns the square root of a given number.
Essentially, exp() and log() reverse each other, whereas exp() raises Math.E to a specific power and log() determines what exponent of Math.E is needed to equal the given value. For example:
var iNum = Math.log(Math.exp(10));
alert(iNum);
Here, Math.E is first raised to the power of 10 by using exp(), and then log() returns 10 as the exponent necessary to equal that number. If you are confused, you’re not alone. This type of stuff stumps high school and college math students worldwide. Chances are if you don’t know what the natural logarithm is, you’ll probably never need to code it.
The pow() method is used to raise a number to a given power, such as raising 2 to the power of 10 (represented in math as 210):
var iNum = Math.pow(2, 10);
The first argument of pow() is the base number, in this case, 2. The second argument is the power to raise it to, which is 10 in this example. The last method in this group is sqrt(), which returns the square root of a given number. It takes only one argument, which is the number whose square root you want to find. So to find the square root of 4, you need only this line of code:
var iNum = Math.sqrt(4);
alert(iNum); //outputs “2”
Of course, the square root of 4 is 2, which is output in this code.
You may ask, “What does the square root have to do with exponents?” The square root of a number is actually that number raised to the onehalf power; for example, 2 1/2 is the square root of 2.
There is also a complete set of geometric methods included in the Math object. These are displayed in the following table.
Method  Description 
acos(x)  Returns the arc cosine of x. 
asin(x)  Returns the arc sine of x. 
atan(x)  Returns the arc tangent of x. 
atan2(y, x)  Returns the arc cosine of y/x. 
cos(x)  Returns the cosine of x. 
sin(x)  Returns the sine of x. 
tan(x)  Returns the tangent of x. 
It is not recommended to use Math.E as a base for the pow() method. Always use exp() for this because it does special calculations to determine the value more accurately.
Even though these methods are defined by ECMA262, the results are implementationdependent because you can calculate each value in many different ways. Consequently, the precision of the results may also vary from one implementation to another.
The last method of the Math object is random(). This method returns a random number between the 0 and 1, not including 0 and 1. This is a favorite tool of Web sites that are trying to display random quotes or random facts upon entry. You can use random() to select numbers within a certain range by using the following formula:
number = Math.floor(Math.random() * total_number_of_choices + first_possible_value)
The floor() method is used here because random() always returns a decimal value, meaning that multiplying it by a number and adding another still yields a decimal value. Most of the time, you want to select a random integer. Because of that, the floor() method is needed. So, if you wanted to select a number between 1 and 10, the code looks like this:
var iNum = Math.floor(Math.random() * 10 + 1);
You see 10 possible values (1 through 10) with the first possible value being 1. If you want to select a number between 2 and 10, then the code looks like this:
var iNum = Math.floor(Math.random() * 9 + 2);
There are only nine numbers when counting from 2 to 10, so the total number of choices is 9 with the first possible value being 2. Many times, it’s just easier to use a function that handles the calculation of the total number of choices and the first possible value:
function selectFrom(iFirstValue, iLastValue) {
var iChoices = iLastValue – iFirstValue + 1;
return Math.floor(Math.random() * iChoices + iFirstValue);
}
//select from between 2 and 10
var iNum = selectFrom(2, 10);
Using the function, it’s easy to select a random item from an Array:
var aColors = [“red”, “green”, “blue”, “yellow”,
“black”, “purple”, “brown”];
var sColor = aColors[selectFrom(0, aColors.length1)];
Here, the second parameter to selectFrom() is the length of the array minus 1, which is the last position in an array.
Javascript Home  All Javascript Tutorials  Latest Javascript Tutorials
Sponsored Links 
If this tutorial doesn't answer your question, or you have a specific question, just ask an expert here. Post your question to get a direct answer.

Comments(0)
Be the first one to add a comment
Most Viewed Articles (in Javascript )

Most Emailed Articles (in Javascript)
