recursal/MDN huggingface dataset:
Math.min()
==========

La función **`Math.min()`** devuelve el menor de cero o más números.

Sintaxis
--------
```

Math.min([valor1[, valor2[, ...]]])
```

### Parámetros

`valor1, valor2, ...`

Números.

Descripción
-----------

Ya que `min()` es un método estático de `Math`, siempre debe usarse como `Math.min()`, en lugar de como un método de un objeto `Math` instanciado (Math no es un constructor).

Si no se proporcionan argumentos, el resultado es `Infinity`.

Si al menos uno de los argumentos no puede ser convertido a número, el resultado es `NaN`.

Ejemplos
--------

### Usando `Math.min()`

Lo siguiente encuentra el mínimo de `x` e `y` y lo asigna a `z`:


```js
var x = 10,
  y = -20;
var z = Math.min(x, y);
```

### Recortando un valor con `Math.min()`

`Math.min()` es a menudo usado para recortar un valor de tal manera que siempre sea menor o igual a un límite. Este ejemplo


```js
var x = f(foo);

if (x > limite) {
  x = limite;
}
```


puede ser escrito de la siguiente manera


```js
var x = Math.min(f(foo), limite);
```


`Math.max()` puede ser usado en una forma similar para recortar un valor en el otro extremo.

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.min |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver además
----------

* `Math.max()`
Math.max()
==========

La función **`Math.max()`** retorna el mayor de cero o más números dados como parámetros de entrada, o `NaN` si cualquier parámetro no es un número y no puede ser convertido en uno.

Pruébalo
--------

Sintaxis
--------


```js
Math.max();
Math.max(valor0);
Math.max(valor0, valor1);
Math.max(valor0, valor1, /\* ... ,\*/ valorN);
```

### Parámetros

`valor1`, `valor2`, ... , `valorN`

Cero o más números entre los cuales el mayor valor será seleccionado y retornado.

### Valor retornado

 El mayor de los números dados. Si uno o más de los parámetros no puede ser convertido a
 un número, retorna `NaN`. El resultado es
 -`Infinity` si no se proveen parámetros.

Descripción
-----------

 Como `max()` es un método estático de `Math`, siempre se usa
 como `Math.max()`, en lugar de como un método de un objeto `Math`
 creado (`Math` no es un constructor).

Si no se proveen argumentos, el resultado es -`Infinity`.

 Si al menos uno de los argumentos no puede ser convertido a número, el resultado es
 `NaN`.

Ejemplos
--------

### Usando Math.max()


```js
Math.max(10, 20); // 20
Math.max(-10, -20); // -10
Math.max(-10, 20); // 20
```

### Obteniendo el elemento máximo de un arreglo

 Se puede usar `Array.reduce()` para encontrar el
 elemento máximo en un arreglo numérico, comparando cada valor:


```js
var arr = [1, 2, 3];
var max = arr.reduce(function (a, b) {
  return Math.max(a, b);
}, -Infinity);
```


 La siguiente función usa `Function.prototype.apply()` para obtener el máximo
 de un arreglo. `getMaxOfArray([1, 2, 3])` es equivalente a
 `Math.max(1, 2, 3)`, pero se puede usar `getMaxOfArray()` en
 arreglos construidos de manera programada. Esto debería ser usado solamente para arreglos con
 relativamente pocos elementos.


```js
function getMaxOfArray(numArray) {
  return Math.max.apply(null, numArray);
}
```


 La nueva sintaxis extendida
 es una manera más corta de escribir la solución con `apply` para obtener
 el máximo de un arreglo:


```js
var arr = [1, 2, 3];
var max = Math.max(...arr);
```


 Sin embargo, tanto la sintaxis extendida (`...`) como `apply` fallarán o retornarán
 un resultado incorrecto si el arreglo tiene demasiados elementos, porque intentan pasar el arreglo
 de elementos como parámetros de función.
 Ver apply y funciones incorporadas
 para más detalles. La solución con `reduce` no tiene este problema.

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.max |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Véase también
-------------

* `Math.min()`
Math.SQRT1\_2
=============

La propiedad **`Math.SQRT1_2`** representa la raiz cuadrada de 1/2, la cual es equivalente al inverso de la raiz cuadrada de 2, aproximadadamente 0.707:


Math.SQRT1\_2

=

1
2

=

1

2

≈
0.707

\mathtt{\mi{Math.SQRT1\_2}} = \sqrt{\frac{1}{2}} = \frac{1}{\sqrt{2}} \approx 0.707

Descripción
-----------

Debido a que SQRT1\_2 es una propiedad estatica de Math, siempre debes utilizarla como Math.SQRT1\_2, en lugar de invocarla como una propiedad de alguna instancia de Math que hayas creado ( Math no es un constructor ).

Ejemplos
--------

### Utilizando `Math.SQRT1_2`

La siguiente funcion regresa la raiz cuadrada de 1/2:


```js
function getRoot1\_2() {
  return Math.SQRT1\_2;
}

getRoot1\_2(); // 0.7071067811865476
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.sqrt1\_2 |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver Tambien
-----------

* `Math.pow()`
* `Math.sqrt()`
Math.abs()
==========

La función **`Math.abs()`** retorna el valor absoluto de un número, que es



Math.abs
(
x
)

=

|
x
|

=

{

x

if

x
>
0

0

if

x
=
0

-
x

if

x
<
0


{\mathtt{\operatorname{Math.abs}(x)}} = {|x|} = \begin{cases} x & \text{if} \quad x \geq 0 \ -x & \text{if} \quad x < 0 \end{cases}

Sintaxis
--------
```

Math.abs(x)
```

### Parámetros

`x`

Un número.

### Valor de retorno

El valor absoluto del número dado.

Descripción
-----------

Como `abs()` es un método estático de `Math`, deberías siempre usar `Math.abs()`, en lugar de un método de un objeto `Math` que crees (`Math` no es un constructor).

Ejemplos
--------

### Comportamiento de `Math.abs()`

Pasando un string no-numérico o una variable `undefined`/empty retorna `NaN`. Pasando `null` retorna 0.


```js
Math.abs("-1"); // 1
Math.abs(-2); // 2
Math.abs(null); // 0
Math.abs(""); // 0
Math.abs([]); // 0
Math.abs([2]); // 2
Math.abs([1, 2]); // NaN
Math.abs({}); // NaN
Math.abs("string"); // NaN
Math.abs(); // NaN
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.abs |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* `Math.ceil()`
* `Math.floor()`
* `Math.round()`
* `Math.sign()` 
Experimental
* `Math.trunc()` 
Experimental
Math.cos()
==========

La función estática **`Math.cos()`** devuelve el coseno del ángulo especificado, que debe ser especificado en radianes. Este valor es 


longitud

adyacente


longitud

hipotenusa


.

Pruébalo
--------

El código fuente de este ejemplo interactivo está almacenado en un repositorio de GitHub. Si te gustaría contribuir con el proyecto de ejemplos interactivos, por favor clona https://github.com/mdn/interactive-examples y envíanos un pull request.

Sintaxis
--------
```

Math.cos(x)
```

### Parametros

`x`

El ángulo en radianes por el cual devolverá el coseno.

### Valor de retorno

El coseno del número dado.

Descripción
-----------

El método `Math.cos()` retorna un valor numérico entre -1 y 1, que representa el coseno del ángulo.

Debido a que `cos()` es un método estático de `Math`, siempre debes utilizarlo como `Math.cos()`, en lugar de como un método de un objeto `Math` que hayas creado (`Math` no es un constructor).

Ejemplos
--------

### Usando `Math.cos()`


```js
Math.cos(0); // 1
Math.cos(1); // 0.5403023058681398

Math.cos(Math.PI); // -1
Math.cos(2 \* Math.PI); // 1
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.cos |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* `Math.acos()`
* `Math.asin()`
* `Math.atan()`
* `Math.atan2()`
* `Math.sin()`
* `Math.tan()`
Math.LN10
=========

La propiedad **`Math.LN10`** representa el logaritmo natural de 10, aproximadamente 2.302:


Math.LN10

=
ln
(
10
)
≈
2.302

\mathtt{\mi{Math.LN10}} = \ln(10) \approx 2.302

Pruébalo
--------

| Atributos de la propiedad `Math.LN10` |
| --- |
| Sobrescribir | No |
| Numerable | No |
| Configurable | No |

Descripción
-----------

Porque `LN10` es una propiedad estática de `Math`, siempre usted lo usa como `Math.LN10`, en lugar de como una propiedad de un objeto `Math` creado (`Math` no es un constructor).

Ejemplos
--------

### Utilizando `Math.LN10`

La función siguiente devuelve el logaritmo natural de 10:


```js
function getNatLog10() {
  return Math.LN10;
}

getNatLog10(); // 2.302585092994046
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.ln10 |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* `Math.exp()`
* `Math.log()`
* `Math.log10()`
Math.SQRT2
==========

La propiedad **Math.SQRT2** representa la raíz cuadrada de de 2, aproximadamente 1.414:


Math.SQRT2

=

2

≈
1.414

\mathtt{\mi{Math.SQRT2}} = \sqrt{2} \approx 1.414



| Atributos de la propiedad `Math.SQRT2` |
| --- |
| Sobrescribir | No |
| Numerable | No |
| Configurable | No |

Descripción
-----------

Debido a que SQRT2 es una propiedad estática de `Math`, siempre se utiliza como `Math.SQRT2`, en lugar de una propiedad de un objeto `Math` creado`.`

Ejemplos
--------

### Utilizando Math.SQRT2

La siguiente función retorna la raíz cuadrada de 2:


```js
function getRoot2() {
  return Math.SQRT2;
}

getRoot2(); // 1.4142135623730951
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.sqrt2 |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* `Math.pow()`
* `Math.sqrt()`
Math.PI
=======

La propiedad **`Math.PI`** representa la relacion entre la longitud de la circunferencia de un circulo y su diametro, la cual es aproximadamente 3.14159.


Math.PI

=
π
≈
3.14159

\mathtt{\mi{Math.PI}} = \pi \approx 3.14159



| Atributos de la propiedad `Math.PI` |
| --- |
| Sobrescribir | No |
| Numerable | No |
| Configurable | No |

Descripción
-----------

Debido a que PI es una propiedad estatica del modulo **`Math`**, siempre debes de utilizarla como **`Math.PI`**, en lugar de una propiedad de un objeto **`Math`** que tu hayas creado ( **`Math`** no es un constructor ).

Ejemplos
--------

### Utilizando `Math.PI`

La siguiente función utiliza **`Math.PI`** para calcular la longitud de la circunferencia de un circulo mediante el radio del circulo proporcionado como parametro.


```js
function calculaCircunferencia(radio) {
  return 2 \* Math.PI \* radio;
}

calculaCircunferencia(1); // 6.283185307179586
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.pi |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver tambien
-----------

* `Math`
Math.asinh()
============

La función **`Math.asinh()`** retorna el arcoseno hyperbólico de un número, es decir



Math.asinh
(
x
)

=
arsinh
(
x
)
=
 the unique 

y

such that

sinh
(
y
)
=
x

\mathtt{\operatorname{Math.asinh}(x)} = \operatorname{arsinh}(x) = \text{ the unique } ; y ; \text{such that} ; \sinh(y) = x

Sintáxis
--------


```js
Math.asinh(x);
```

### Parámetros

`x`

Un número.

### Valor de retorno

El arcoseno hyperbólico del número dado.

Descripción
-----------

Debido a que `asinh()` es un método estático de `Math`, siempre hay que usarlo como `Math.asinh()`, en lugar de como un método del objeto `Math` que se hayamos creado (`Math` no es un constructor).

Ejemplos
--------

### Usos de `Math.asinh()`


```js
Math.asinh(1); // 0.881373587019543
Math.asinh(0); // 0
```

Polyfill
--------

As a quick and dirty hack the expression 


arsinh
(
x
)
=
ln

(

x
+

x
2

+
1

)

\operatorname {arsinh} (x) = \ln \left(x + \sqrt{x^{2} + 1} \right)

 may be used directly for a coarse emulation by the following function:


```js
Math.asinh =
  Math.asinh ||
  function (x) {
    if (x === -Infinity) {
      return x;
    } else {
      return Math.log(x + Math.sqrt(x \* x + 1));
    }
  };
```


Been formally correct it suffers from a number of issues related to floating point computations. Accurate result requires special handling of positive/negative, small/large arguments as it done e.g. in glibc or GNU Scientific Library.

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.asinh |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

See also
--------

* `Math.acosh()`
* `Math.atanh()`
* `Math.cosh()` (en-US)
* `Math.sinh()` (en-US)
* `Math.tanh()`
Math.LN2
========

La propiedad **`Math.LN2`** representa el logaritmo natural de 2, aproximadamente 0.693:


Math.LN2

=
ln
(
2
)
≈
0.693

\mathtt{\mi{Math.LN2}} = \ln(2) \approx 0.693

Pruébalo
--------

| Atributos de la propiedad `Math.LN2` |
| --- |
| Sobrescribir | No |
| Numerable | No |
| Configurable | No |

Descripción
-----------

Como `LN2` es una propiedad estática de `Math`, siempre se usa como `Math.LN2`, en lugar de como una propiedad de un objeto `Math` que ha creado (`Math` no es un constructor).

Ejemplos
--------

### Utilizando `Math.LN2`

La función siguiente devuelve el logaritmo natural de 2:


```js
function getNatLog2() {
  return Math.LN2;
}

getNatLog2(); // 0.6931471805599453
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.ln2 |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* `Math.exp()`
* `Math.log()`
* `Math.log2()`
Math.expm1()
============

La función **`Math.expm1()`** regresa `e^x - 1`, donde `x` es el argumento, y e la base del logaritmo natural.

Pruébalo
--------

El código para este ejemplo interactivo está almacenado en un repositorio de GitHub. Sí te gustaría contribuir al proyecto de ejemplos interactivos If you'd like to contribute, por favor clona https://github.com/mdn/interactive-examples y envíanos un pull request.Sintaxis
--------
```

Math.expm1(x)
```

### Parámetos

`x`

Un número.

### Valor de retorno

Un número representando `e^x - 1`, donde `e` es Número de Euler y `x` es el argumento.

Descripción
-----------

Debido a que `expm1()` es un método estático de `Math`, uselo siempre como `Math.expm1()`, en lugar de como un método del objeto `Math` que creó (`Math` no es un constructor).

Ejemplos
--------

### Usando Math.expm1()


```js
Math.expm1(-1); // -0.6321205588285577
Math.expm1(0); // 0
Math.expm1(1); // 1.718281828459045
```

Polyfill
--------

Esto puede ser emulado con la ayuda de la función `Math.exp()`:


```js
Math.expm1 =
  Math.expm1 ||
  function (x) {
    return Math.exp(x) - 1;
  };
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.expm1 |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Vea también
-----------

* `Math.E`
* `Math.exp()`
* `Math.log()`
* `Math.log10()`
* `Math.log1p()` (en-US)
* `Math.log2()`
* `Math.pow()`
Math.atanh()
============

La función **`Math.atanh()`** nos retorna un arco hiperbólico de un numero, eso es:



∀
x
∊

(

-
1
,
1

)

,

Math.atanh
(
x
)

=
arctanh
(
x
)
=
 the unique 

y

such that

tanh
(
y
)
=
x

\forall x \in \left( -1, 1 \right), \mathtt{\operatorname{Math.atanh}(x)} = \operatorname{arctanh}(x) = \text{ el unico } ; y ; \text{de tal manera que} ; \tanh(y) = x

Pruébalo
--------

Sintaxis
--------
```

Math.atanh(x)
```

### Parametros

*x*

Un numero.

### Retorna un valor

El arco hiperbolico tangible nos otorga un numero.

Descripción
-----------

Por que `atanh()` es un metodo estatico de `Math`, tu siempre puedes usar eso como `Math.atanh()`, se puede usar como un metod de `Math` objeto que tu creaste (`Math` no es un constructor).

Polimorfismo
------------

Para 


|
x
|

<
1

\left|x\right| < 1

, tenemos 


artanh
(
x
)
=

1
2

ln

(

1
+
x

1
-
x

)

\operatorname {artanh} (x) = \frac{1}{2}\ln \left( \frac{1 + x}{1 - x} \right)

 por lo que esto puede estar emulado con la siguiente función:


```js
Math.atanh =
  Math.atanh ||
  function (x) {
    return Math.log((1 + x) / (1 - x)) / 2;
  };
```

Ejemplos
--------

### Using `Math.atanh()`


```js
Math.atanh(-2); // NaN
Math.atanh(-1); // -Infinito
Math.atanh(0); // 0
Math.atanh(0.5); // 0.5493061443340548
Math.atanh(1); // Infinito
Math.atanh(2); // NaN
```


Para valores mayores a 1 o menores a -1, `NaN` retorna.

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.atanh |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Puedes leer
-----------

* `Math.acosh()`
* `Math.asinh()`
* `Math.cosh()` (en-US)
* `Math.sinh()` (en-US)
* `Math.tanh()`
Math.cbrt()
===========

La función **`Math.cbrt()`** nos retorna la raíz del cubo del numero, eso es



M
a
t
h
.
c
b
r
t
(
x
)

=

x
3

=
the unique

y

such that

y
3

=
x

\mathtt{Math.cbrt(x)} = \sqrt[3]{x} = \text{un unico} ; y ; \text{de tal manera que} ; y^3 = x


Pruébalo
--------

The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone https://github.com/mdn/interactive-examples and send us a pull request.Sintaxis
--------
```

Math.cbrt(x)
```

### Parametros

*x*

Un numero

### Valor retornado

La raíz cubica del numero proporcionado

Descripción
-----------

Al `cbrt()` ser un metodo estatico de `Math`, tu siempre la puedes usar como `Math.cbrt()`,un metodo de `Math` que es un objeto que se crea (`Math` no es un constructor).

Poliformismo
------------

Para 


x
≥
0

x \geq 0

, tenemos 


x
3

=

x

1
/
3

\sqrt[3]{x} = x^{1/3}

 esto puede ser emulado con la siguiente función:


```js
if (!Math.cbrt) {
  Math.cbrt = (function (pow) {
    return function cbrt(x) {
      // Esto asegura que numeros negativos sigan siendo negativos
      return x < 0 ? -pow(-x, 1 / 3) : pow(x, 1 / 3);
    };
  })(Math.pow); // Localiza Math.pow para una mayor eficiencía
}
```

Ejemplos
--------

### Usando Math.cbrt()


```js
Math.cbrt(NaN); // NaN
Math.cbrt(-1); // -1
Math.cbrt(-0); // -0
Math.cbrt(-Infinity); // -Infinito
Math.cbrt(0); // 0
Math.cbrt(1); // 1
Math.cbrt(Infinity); // Infinito
Math.cbrt(null); // 0
Math.cbrt(2); // 1.2599210498948732
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.cbrt |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Puedes leer
-----------

* `Math.pow()`
* `Math.sqrt()`
Math.acos()
===========

La función **`Math.acos()`** devuelve el arco coseno (en radianes) de un número que es



∀
x
∊
[

-
1

;
1
]
,

Math.acos
(
x
)

=
arccos
(
x
)
=
 the unique 

y
∊
[
0
;
π
]

such that

cos
(
y
)
=
x

\forall x \in [{-1};1],;\mathtt{\operatorname{Math.acos}(x)} = \arccos(x) = \text{ the unique } ; y \in [0; \pi] , \text{such that} ; \cos(y) = x

Sintaxis
--------
```

Math.acos(x)
```

### Parámetros

`x`

Un número.

### Valor devuelto

El arco coseno (en radianes) de un número dado si se encuentra entre **-1** y **1**; de otro modo, `NaN`.

Descripción
-----------

El método `Math.acos()` devuelve un valor numérico entre 0 y π radianes para `x` entre -1 y 1. Si el valor de `x` está fuera de este rango, devuelve `NaN`.

Debido a que `acos()` es un método estático de `Math`, siempre debe usarse como `Math.acos()`, en vez de como un método de un objeto `Math` creado (`Math` no es un constructor).

Ejemplos
--------

### Usando `Math.acos()`


```js
Math.acos(-2); // NaN
Math.acos(-1); // 3.141592653589793
Math.acos(0); // 1.5707963267948966
Math.acos(0.5); // 1.0471975511965979
Math.acos(1); // 0
Math.acos(2); // NaN
```


Para valores menores que -1 o mayores que 1, `Math.acos()` devuelve `NaN`.

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.acos |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* `Math.asin()`
* `Math.atan()`
* `Math.atan2()`
* `Math.cos()`
* `Math.sin()`
* `Math.tan()`
Math.exp()
==========

La función **Math.exp()** devuelve `ex`, donde `x` es el argumento, y `e` es El número de Euler (también conocido como la constante de Napier), la base de los algoritmos naturales.Sintaxis
--------
```

Math.exp(x)
```

### Parámetros

`x`

Un número.

### Valor devuelto

Un número represetando `ex`, donde `e` es número de Euler y `x` es el argumento.

Descripción
-----------

Porque `exp()` es un método estático de `Math`, siempre úsalo como `Math.exp()`, en vez de un método de un objeto `Math` que hayas creado (`Math` no es un constructor).

Ejemplos
--------

### Usando `Math.exp()`


```js
Math.exp(-1); // 0.36787944117144233
Math.exp(0); // 1
Math.exp(1); // 2.718281828459045
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.exp |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ve también
----------

* `Math.E`
* `Math.expm1()`
* `Math.log()`
* `Math.log10()`
* `Math.log1p()` (en-US)
* `Math.log2()`
* `Math.pow()`
Math.atan2()
============

Resumen
-------

La función **`Math.atan2()`** retorna la arcotangente del cociente de los argumentos.

Sintaxis
--------
```

Math.atan2(y, x)
```

### Parámetros

`y`

Primer número.

`x`

Segundo número.

Descripción
-----------

El método `Math.atan2()` retorna un valor númerico entre -π y π representando el ángulo theta de un punto `(x, y)`. Este es un ángulo en sentido antihorario, medido en radianes, entre el eje positivo X, y el punto (`x, y)`. Tenga en cuenta que esta función recibe la coordenada Y como primer argumento y X como segundo.

A la función `Math.atan2()` se le pasan los argumentos `x` y `y` por separado, y a `Math.atan()` se le pasa la relación de los dos argumentos.

Debido a que `atan2()` es un método estatico de `Math`, siempre se debe usar `Math.atan2()`, en vez de usarlo como un método creado por el objeto `Math` (`Math` no es un contructor).

Ejemplos
--------

### Ejemplo: Usando `Math.atan2()`


```js
Math.atan2(90, 15); // 1.4056476493802699
Math.atan2(15, 90); // 0.16514867741462683

Math.atan2(±0, -0);               // ±PI.
Math.atan2(±0, +0);               // ±0.
Math.atan2(±0, -x);               // ±PI for x > 0.
Math.atan2(±0, x);                // ±0 for x > 0.
Math.atan2(-y, ±0);               // -PI/2 for y > 0.
Math.atan2(y, ±0);                // PI/2 for y > 0.
Math.atan2(±y, -Infinity);        // ±PI for finite y > 0.
Math.atan2(±y, +Infinity);        // ±0 for finite y > 0.
Math.atan2(±Infinity, x);         // ±PI/2 for finite x.
Math.atan2(±Infinity, -Infinity); // ±3\*PI/4.
Math.atan2(±Infinity, +Infinity); // ±PI/4.
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.atan2 |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Ver también
-----------

* `Math.acos()`
* `Math.asin()`
* `Math.atan()`
* `Math.cos()`
* `Math.sin()`
* `Math.tan()`