# Math.hypot()

The Math.hypot() function returns the square root of the sum of squares of its arguments, that is:

$Math.hypot(v1,v2,…,vn)=∑i=1nvi2=v12+v22+…+vn2\mathtt{\operatorname{Math.hypot}(v_1, v_2, \dots, v_n)} = \sqrt{\sum_{i=1}^n v_i^2} = \sqrt{v_1^2 + v_2^2 + \dots + v_n^2}$

## Syntax

Math.hypot([value1[, value2[, ...]]])

### Parameters

value1, value2, ...
Numbers.

### Return value

The square root of the sum of squares of the given arguments. If at least one of the arguments cannot be converted to a number, NaN is returned.

## Description

Calculating the hypotenuse of a right triangle, or the magnitude of a complex number, uses the formula Math.sqrt(v1*v1 + v2*v2) where v1 and v2 are either the sides of the triangle, or the real and complex values.  For calculating distance in 2 or more dimensions, simply add in more squares inside the square root sign, like Math.sqrt(v1*v1 + v2*v2 + v3*v3 + v4*v4).

This function makes it a little easier and faster, you just call Math.hypot(v1, v2) , or Math.hypot(v1, v2, v3, v4, ...) .

It also avoids a problem if the magnitude of your numbers is huge.  The largest number you can represent in JS's double floats is Number.MAX_VALUE = 1.797...e+308 .  If your numbers are larger  than about 1e154, taking the square of them will result in Infinity, demolishing your results.  For example, Math.sqrt(1e200*1e200 + 1e200*1e200) = Infinity .  If you use hypot() instead, you get a good answer Math.hypot(1e200, 1e200) = 1.4142...e+200 .  This is also true with very small numbers.  Math.sqrt(1e-200*1e-200 + 1e-200*1e-200) = 0, but Math.hypot(1e-200, 1e-200) =1.4142...e-200, a good answer.

Because hypot() is a static method of Math, you always use it as Math.hypot(), rather than as a method of a Math object you created (Math is not a constructor).

If no arguments are given, the result is +0.

If at least one of the arguments cannot be converted to a number, the result is NaN.

With one argument, Math.hypot() returns the same as Math.abs().

## Polyfill

This can be emulated using the following function:

if (!Math.hypot) Math.hypot = function() {
var y = 0, i = arguments.length;
while (i--) y += arguments[i] * arguments[i];
return Math.sqrt(y);
};


A polyfill that avoids underflows and overflows:

if (!Math.hypot) Math.hypot = function (x, y) {
// https://bugzilla.mozilla.org/show_bug.cgi?id=896264#c28
var max = 0;
var s = 0;
for (var i = 0; i < arguments.length; i += 1) {
var arg = Math.abs(Number(arguments[i]));
if (arg > max) {
s *= (max / arg) * (max / arg);
max = arg;
}
s += arg === 0 && max === 0 ? 0 : (arg / max) * (arg / max);
}
return max === 1 / 0 ? 1 / 0 : max * Math.sqrt(s);
};


## Examples

### Using Math.hypot()

Math.hypot(3, 4);        // 5
Math.hypot(3, 4, 5);     // 7.0710678118654755
Math.hypot();            // 0
Math.hypot(NaN);         // NaN
Math.hypot(3, 4, 'foo'); // NaN, +'foo' => NaN
Math.hypot(3, 4, '5');   // 7.0710678118654755, +'5' => 5
Math.hypot(-3);          // 3, the same as Math.abs(-3)


## Specifications

Specification
ECMAScript (ECMA-262)
The definition of 'Math.hypot' in that specification.

## Browser compatibility

Update compatibility data on GitHub
Desktop Mobile Server Chrome Edge Firefox Internet Explorer Opera Safari Android webview Chrome for Android Firefox for Android Opera for Android Chrome Full support 38 Edge Full support 12 Firefox Full support 27 IE No support No Opera Full support 25 Safari Full support 8 WebView Android Full support 38 Chrome Android Full support 38 Firefox Android Full support 27 Opera Android Full support 25 Safari iOS Full support 8 Samsung Internet Android Full support 3.0 nodejs Full support 0.12

Full support
Full support
No support
No support