You are here: irt.org | Articles | JavaScript | Text, String, and Number | Math functions in JavaScript [ previous next ]

*Published on:* Saturday 21st March 1998* By:* Janus Boye

- Introduction
- The top level predefined JavaScript Object Math
- The limitations
- When to use Math in JavaScript, and why?
- Random numbers
- Rounding numbers
- Special numeric values
- Don't know much about trigonometry
- Reverse trigonometric
- Property Summary
- Method Summary
- Conclusion

Math is power. So says one of the many ads on the Internet. JavaScript has the power, to do all functions that are on a normal pocket calculator, and even a few more.

Try out the pocket calculator example.

Did you by the way, remember to turn the calculator on?

This article will focus on the *Math* object. Towards the end, I've put a complete listing, of all the properties and methods, you may use, and
as an example of those, I've provided some simple programs. The first will give you a random number, and the second, will show you how to round a
number, to the nearest integer.

*Math* is a built-in object that has properties and methods for mathematical constants and functions. For example, the *Math* object's
*PI* property has the value of pi.

When using *Math*, it is important to remember that all properties and methods of *Math* are static. You refer to the property *PI*
as *Math*.*PI* and you call the method as *Math*.*sin*(x), where x is the method's argument. Properties are defined with the
full precision of real numbers in JavaScript. More on precision later.

You will often find it convenient to use the *with* statement, when a section of code uses several *Math* properties and methods, so you
don't have to type '*Math*' repeatedly. For example:

with(Math) { a =PI* r*r y = r*sin(theta) x = r*cos(theta) b = a + y/x }

Before moving onto working examples and much more, we need to address the limitations of using *Math* in JavaScript.

One of the interesting features of JavaScript is, that the precision it uses to judge the accuracy of its calculation algorithms is noticeably lower than that of other programming languages. Despite it now being at revision 1.2, this standard has not yet been improved.

To give you an idea of the nature and depth of the problem, although for instance Authorware, Turbo Pascal, Excel and even Word6 will calculate the following correctly, multiplying:

0.119 by 100 in JavaScript evaluates to 11.899999.

0.14 by 100 in JavaScript evaluates to 14.0000000000002

Normally in JavaScript a value has 16 digits of precision, and this just seems to be the limitations inherent in the routines used.

As you move along with JavaScript, you are going to find that using *Math* in JavaScript may be a good place to start. It's nice and simple, but
still gives you some pretty big challenges, if that's what you want.

With *Math*, you may start with those sweet functions, that give you a random number (pseudo-random that is). You could use this to do a random
function, display a random image and much more.

Enough said about limitations, precision, and the cross-browser issue, let's move on to a example, that'll show you how to get a pseudo-random number between 0 and 1. The random number generator is seeded from the current time, as in Java.

//Returns a random number between 0 and 1 functiongetRandom(){ returnMath.random(); }

In this examples and others we have create out own *getRandom()* function to make it easier to use the required method. That way we don't have
to keep including '*Math*'.

To use the above *getRandom()* function is simplicity itself:

alert(getRandom()); var a =getRandom();

You can read more on random numbers and their limitations in Selecting Random Number by Martin Webb.

In other cases, you might want a number to be rounded to the nearest integer, this little example will show you how:

document.write ('<P>The rounded value is ' +Math.round(20.49)); //Displays the value of 20 document.write ('<P>The rounded value is ' +Math.round(20.5)); //Displays the value of 21 document.write ('<P>The rounded value is ' +Math.round(-20.5)): //Displays the value of -20 document.write ('<P>The rounded value is ' +Math.round(-20.51)): //Displays the value of -21

If the fractional portion of number is .5 or greater, the argument is rounded to the next highest integer. If the fractional portion of number is less than .5, the argument is rounded to the next lowest integer.

Because *round()* is a static method of *Math*, you always use it as *Math*.*round()*, rather than as a method of a
*Math* object you created. In other words the following is wrong:

var a = 13; a.round();

And would cause a JavaScript error.

There are several special numeric values used by JavaScript. When a floating-point value becomes larger than the largest representable type, the result is a special infinity value, which JavaScript prints as Infinity. Similarly, when a negative value becomes more negative than the most negative representable number, the result is negative infinity, printed as -Infinity. (Internet Explorer 3.0 prints these special infinity values in a less intuitive fashion; this is fixed in IE4.0).

Another special JavaScript numeric value is returned when a mathematical operation (such as division by zero) yields an undefined result or an error.
In this case, the result is the special Not-a-Number value, printed as *NaN*. The special Not-a-Number value has special behaviour: it does not
compare equal to any number, including itself! For this reason, a special function *isNaN()* is required to test for this value. In Navigator
2.0, the *NaN* value and *isNaN()* do not work correctly on Windows and other platforms. On 2.0 Windows platforms, *0* is returned
instead of *NaN* when a numeric value is undefined. Similarly, *NaN* does not work in Internet Explorer 3.0, although it will in future
versions. In IE 3.0, *isNaN()* always returns false, and *0* is returned instead of *NaN*.

In Navigator 3.0 (but not IE 3.0), there are constants defined for each of these special numeric values. These constants are listed below:

Constant | Meaning |

Number.MAX_VALUE | Largest representable number |

Number.MIN_VALUE | Most negative representable number |

Number.NaN | Special not-a-number value |

Number.POSITIVE_INFINITY | Special value to represent infinity |

Number.NEGATIVE_INFINITY | Special value to represent negative infinity |

Trigonometry hasn't gotten much simpler since you last worked with it, but JavaScript gives you a few methods, that'll basically does most of the work for you.

Let's say you want the sine of a number.

//Returns the sine of a number functiongetSine(x) { returnMath.sin(x); }

The *sin()* method returns a numeric value between –1 and 1, which represents the sine of the argument. Because *sin()* is a static
method of *Math*, you always use it as *Math*.*sin()*, rather than as a method of a *Math* object you created.

If you want to find the cosine of tangent of x, you simply just replace *Math*.*sin()* with either *Math*.*cos()* or
*Math*.*tan()*.

In real world math, and in JavaScript *Math*, there is a reverse trigonometric function acos. The *acos()* method returns the arccosine
(in radians of a number). If you for some odd reason want to use this on your page, you could do the following:

functiongetAcos(x) { returnMath.acos(x); }

The *acos()* method returns a numeric value between 0 and pi radians. If the value of number is outside the range, it returns 0.

If you pass –1 to *getAcos()*, it returns 3.14159265389793; if you pass 2, it returns 0 because 2 is out of range.

If you want to find the arcsine of arctangent (in radians), you simply just replace *acos()* with either *asin()* or *atan()*.

Here's a listing of all the properties in Math:

*E*- Euler's constant and the base of natural logarithms, approximately 2.718*LN10*- Natural logarithm of 10, approximately 2.302*LN2*- Natural logarithm of 2, approximately 0.693*LOG10E*- Base 10 logarithm of E (approximately 0.434)*LOG2E*- Base 2 logarithm of E (approximately 1.442)*PI*- Ratio of the circumference of a circle to its diameter, approximately 3.14159*SQRT1_2*- Square root of 1/2; equivalently, 1 over the square root of 2, approximately 0.707*SQRT2*- Square root of 2; approximately 1.414

Use these properties, as in the example below:

//Get's the value of PI functiongetPi(){ returnMath.PI; }

You may replace *PI* with any other *Math* property, and it'll work accordingly.

*abs()*- Returns the absolute value of a number*acos()*- Returns the arccosine (in radians) of a number*asin()*- Returns the arcsine (in radians) of a number*atan()*- Returns the arctangent (in radians) of a number*atan2()*- Returns the arctangent of the quotient of its arguments*ceil()*- Returns the smallest integer greater than or equal to the number*cos()*- Returns the cosine of a number*exp()*- Return the E^{number}, where number is the argument, and E is Euler's constant, the base of the natural logarithms.*floor()*- Returns the largest integer less than or equal to a number*log()*- Returns the natural logarithm (base E) of a number.*max()*- Returns the greater of two numbers*min()*- Returns the lesser of two numbers*pow()*- Returns base if the exponent power, that is base^{exponent}*random()*- Returns a pseudo-random number between 0 and 1*round()*- Returns the value of a number rounded to the nearest integer*sin()*- Returns the sine of a number*sqrt()*- Returns the squareroot of a number*tan()*- Returns the tangent of a number

Use these methods, as in the random or rounding numbers example, or in the below, that'll return the squareroot of x.

//Returns the squareroot of a given number functiongetRoot(x) { returnMath.sqrt(x); }

Well, that's it. Now the sky's the limit. I hope this little article have helped you en-route to understanding the powerful *Math* methods and
properties in JavaScript.

On the net, you'll find several JavaScripts, that'll do some really advanced mathematics in JavaScript.

Come back later to this site, to further understand the calculator that I showed you in the beginning, plus I'll show you a trick, that'll work as a nice workaround to the problem, with JavaScript being inaccurate.

How long is a piece of string?

Random Numbers & Random Events

*Tuesday February 15th, 2000 at 07:43:20*- Cyril*Saturday August 26th, 2000 at 20:06:19*- Raphael Augustin*Tuesday November 7th, 2000 at 22:51:52*- Don Gentry*Friday November 24th, 2000 at 17:40:53*- Lisa*Tuesday March 27th, 2001 at 12:00:26*- billemery*Wednesday June 12th, 2002 at 07:44:06*- anonymous*Tuesday June 18th, 2002 at 06:15:25*- Patrick Pietersz*Saturday May 26th, 2007 at 05:08:49*- Soner*Thursday April 17th, 2008 at 07:03:04*- Fenevad*Monday October 27th, 2008 at 08:42:05*- noname