recursal/MDN huggingface dataset:
Boolean() constructor
=====================

El constructor **`Boolean()`** se usa para crear objetos `Boolean`.

Pruébalo
--------

La fuente de este ejemplo interactivo se almacena en un repositorio de GitHub. Si deseas contribuir al proyecto de ejemplos interactivos, clona https://github.com/mdn/interactive-examples y envíanos una solicitud de extracción.

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

new Boolean([value])
```

### Parámetros

`value` Opcional

El valor inicial del objeto `Boolean`.

Ejemplos
--------

### Creación de objetos `Boolean` con un valor inicial de `false`


```js
var bNoParam = new Boolean();
var bZero = new Boolean(0);
var bNull = new Boolean(null);
var bEmptyString = new Boolean("");
var bfalse = new Boolean(false);
```

### Creación de objetos `Boolean` con un valor inicial de `true`


```js
var btrue = new Boolean(true);
var btrueString = new Boolean("true");
var bfalseString = new Boolean("false");
var bSuLin = new Boolean("Su Lin");
var bArrayProto = new Boolean([]);
var bObjProto = new Boolean({});
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-boolean-constructor |

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

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

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

* Boolean
Boolean.prototype.toSource()
============================

**No estándar:** Esta característica no es parte de los estándares. No la uses en sitios Web en producción: no funcionará para todos los usuarios. Podrían haber también incompatibilidades considerables entre distintas implementaciones y el comportamiento podría cambiar en el futuro.

Resumen
-------

Devuelve una cadena que representa el código fuente del objeto.

Sintaxis
--------

`toSource()`

### Parámetros

Ninguno.

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

El método `toSource` devuelve los siguientes valores:

* Para objetos built-in `Boolean`, `toSource` devuelve la siguiente cadena indicando que el código fuente no está disponible:


```js
function Boolean() {
   [código nativo]
}
```


* Para instancias de `Boolean`, `toSource` devuelve una cadena representando el código fuente.

Este método se utiliza habitualmente en llamadas internas por JavaScript y no en código explícito.

Vea También
-----------

* `Object.prototype.toSource()` 
Non-standard
Math.tanh()
===========

La funcion **`Math.tanh()`** devuelve la hyperbolica tangente de un numero, esto es



tanh
x
=

sinh
x

cosh
x

=

e
x

-

e

-
x


e
x

+

e

-
x

=

e

2
x

-
1

e

2
x

+
1

\tanh x = \frac{\sinh x}{\cosh x} = \frac {e^x - e^{-x}} {e^x + e^{-x}} = \frac{e^{2x} - 1}{e^{2x}+1}

Pruébalo
--------

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

Math.tanh(x)
```

### Parametros

`x`

Un numero.

### Devolver valor

La hyperbolica tangente del numero obtenido.

Descripcion
-----------

Porque `tanh()` es un metodo estatico de `Math`, siempre se usa como `Math.tanh()`, en lugar de ser un metodo de `Math` objeto que creas (`Math` no es un constructor).

Ejemplos
--------

### Usando `Math.tanh()`


```js
Math.tanh(0); // 0
Math.tanh(Infinity); // 1
Math.tanh(1); // 0.7615941559557649
```

Polyfill
--------

Esto puede ser emulado con ayuda de `Math.exp()` funcion:


```js
Math.tanh =
  Math.tanh ||
  function (x) {
    var a = Math.exp(+x),
      b = Math.exp(-x);
    return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (a + b);
  };
```

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

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

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

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

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

* `Math.acosh()`
* `Math.asinh()`
* `Math.atanh()`
* `Math.cosh()` (en-US)
* `Math.sinh()` (en-US)
Math.LOG2E
==========

Resumen
-------

El base 2 del logaritmo natural de E (aproximadamente 1.442).

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

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

Porque `LOG2E` es una propiedad estática de `Math`, siempre usted lo usa como `Math.LOG2E`, en lugar de una propedad de un objecto de `Math` usted creó.

Ejemplos
--------

### Ejemplo: Usar `Math.LOG2E`

La función siguiente devuelve el base 2 del logaritmo natural del `E`:


```js
function getLog2e() {
  return Math.LOG2E;
}
```

Ven También
-----------

* El `Math` objeto.
Math.log()
==========

La función **`Math.log()`** devuelve la base neutral de un número (base `e`)



∀
x
>
0
,

Math.log
(
x
)

=
ln
(
x
)
=
the unique

y

such that

e
y

=
x

\forall x > 0, \mathtt{\operatorname{Math.log}(x)} = \ln(x) = \text{el unico} ; y ; \text{tal que} ; e^y = x


La función en JavaScrcrip **`Math.log()`** es equivalente a *ln(x)* en matematicas.

Pruébalo
--------

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

Math.log(x)
```

### Parametetros

`x`

Es un numero.

### Retorna el valor

La base natural (base `e`) del número dado. Si el número es negativo, se devuelve `NaN`

Descripcion
-----------

If the value of `x` is negative, the return value is always `NaN`.

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

If you need the natural log of 2 or 10, use the constants `Math.LN2` or `Math.LN10` . If you need a logarithm to base 2 or 10, use `Math.log2()` or `Math.log10()` . If you need a logarithm to other bases, use Math.log(x) / Math.log(otherBase) as in the example below; you might want to precalculate 1 / Math.log(otherBase) .

Examples
--------

### Using `Math.log()`


```js
Math.log(-1); // NaN, out of range
Math.log(0); // -Infinity
Math.log(1); // 0
Math.log(10); // 2.302585092994046
```

### Using `Math.log()` with a different base

The following function returns the logarithm of `y` with base `x` (ie. 


log
x

y

\log\_x y

):


```js
function getBaseLog(x, y) {
  return Math.log(y) / Math.log(x);
}
```


If you run `getBaseLog(10, 1000)` it returns `2.9999999999999996` due to floating-point rounding, which is very close to the actual answer of 3.

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

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

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

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

See also
--------

* `Math.exp()`
* `Math.log1p()` (en-US)
* `Math.log10()`
* `Math.log2()`
* `Math.pow()`
Math.LOG10E
===========

La propiedad **`Math.LOG10E`** representa el logaritmo base 10 de e, el cual es aproximadamente 0.434:


Math.LOG10E

=

log
10

(
e
)
≈
0.434

\mathtt{\mi{Math.LOG10E}} = \log\_10(e) \approx 0.434



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

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

Debido a que LOG10E es una propiedad estatica del módulo Math, se debe de invocar siempre como Math.LOG10E, en lugar de invocarla como una propiedad de algun objeto Math que hayas creado ( Math no es un constructor ).

Ejemplos
--------

### Utilizando `Math.LOG10E`

La siguiente funcion regresa el logaritmo base 10 de e:


```js
function getLog10e() {
  return Math.LOG10E;
}

getLog10e(); // 0.4342944819032518
```

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

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

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

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

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

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

Resumen
-------

La función **`Math.sin()`** devuelve el seno de un número.

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

Math.sin(x)
```

### Parámetros

`x`

Un número (en radianes).

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

 El método `Math.sin()` devuelve un valor numérico entre -1 y 1, que representa el seno del ángulo dado en radianes.
 Debido a que `sin()` es un método estático de `Math`, siempre se usa como `Math.sin()`, en vez de crear un objeto `Math` y usarlo como un método (`Math` no es un constructor).

Ejemplos
--------

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


```js
Math.sin(0); // 0
Math.sin(1); // 0.8414709848078965

Math.sin(Math.PI / 2); // 1
```

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

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

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.cos()`
* `Math.tan()`
Math.ceil()
===========

La función **`Math.ceil()`** devuelve el entero mayor o igual más próximo a un número dado.

Pruébalo
--------

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

Math.ceil(x)
```

### Parámetros

`x`

Un número.

### Valor devuelto

El número entero mayor o igual más próximo que el número dado.

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

Como `ceil()` es un método estático de `Math`, siempre debe usarlo como `Math.ceil()`, en lugar de como un método de un objeto que ha creado `Math` (`Math` no es un constructor).

Ejemplos
--------

### Utilizando `Math.ceil()`

El siguiente ejemplo muestra el uso de `Math.ceil()`.


```js
Math.ceil(0.95); // 1
Math.ceil(4); // 4
Math.ceil(7.004); // 8
Math.ceil(-0.95); // -0
Math.ceil(-4); // -4
Math.ceil(-7.004); // -7
```

### Ajuste decimal


```js
// Closure
(function () {
  /\*\*
 \* Ajuste decimal de un número.
 \*
 \* @param {String} type El tipo de ajuste.
 \* @param {Number} value El número.
 \* @param {Integer} exp El exponente (El logaritmo de ajuste en base 10).
 \* @returns {Number} El valor ajustado.
 \*/
  function decimalAdjust(type, value, exp) {
    // Si exp es undefined o cero...
    if (typeof exp === "undefined" || +exp === 0) {
      return Math[type](value);
    }
    value = +value;
    exp = +exp;
    // Si el valor no es un número o exp no es un entero...
    if (isNaN(value) || !(typeof exp === "number" && exp % 1 === 0)) {
      return NaN;
    }
    // Shift
    value = value.toString().split("e");
    value = Math[type](+(value[0] + "e" + (value[1] ? +value[1] - exp : -exp)));
    // Shift back
    value = value.toString().split("e");
    return +(value[0] + "e" + (value[1] ? +value[1] + exp : exp));
  }

  // Decimal round
  if (!Math.round10) {
    Math.round10 = function (value, exp) {
      return decimalAdjust("round", value, exp);
    };
  }
  // Decimal floor
  if (!Math.floor10) {
    Math.floor10 = function (value, exp) {
      return decimalAdjust("floor", value, exp);
    };
  }
  // Decimal ceil
  if (!Math.ceil10) {
    Math.ceil10 = function (value, exp) {
      return decimalAdjust("ceil", value, exp);
    };
  }
})();

// Round
Math.round10(55.55, -1); // 55.6
Math.round10(55.549, -1); // 55.5
Math.round10(55, 1); // 60
Math.round10(54.9, 1); // 50
Math.round10(-55.55, -1); // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1); // -50
Math.round10(-55.1, 1); // -60
// Floor
Math.floor10(55.59, -1); // 55.5
Math.floor10(59, 1); // 50
Math.floor10(-55.51, -1); // -55.6
Math.floor10(-51, 1); // -60
// Ceil
Math.ceil10(55.51, -1); // 55.6
Math.ceil10(51, 1); // 60
Math.ceil10(-55.59, -1); // -55.5
Math.ceil10(-59, 1); // -50
```

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

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

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

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

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

* `Math.abs()`
* `Math.floor()`
* `Math.round()`
* `Math.sign()`
* `Math.trunc()`
Math.tan()
==========

La función **`Math.tan()`** retorna la tangente de un número.

Pruébalo
--------

La fuente para este ejemplo interactivo se encuentra almacenada en un repositorio de GitHub. Si quieres contribuir al proyecto de ejemplos interactivos, por favor, clona el repositorio en este link: https://github.com/mdn/interactive-examples y envíanos un *Pull Request*.

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

Math.tan(x)
```

### Parámetros

`x`

Un número que representa un ángulo en radianes.

### Valor de retorno

La tangente del número proporcionado.

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

El método `Math.tan()` retorna un valor numérico que representa la tangente de un ángulo.

Dado que `tan()` es un método estático de `Math`, siempre debes usarlo como `Math.tan()`, y no como un método de un objeto `Math` que hayas creado (`Math` no es un constructor).

Ejemplos
--------

### Usando `Math.tan()`


```js
Math.tan(1); // 1.5574077246549023
```


Ya que la función `Math.tan()` acepta radianes, pero es más fácil trabajar con grados, la siguiente función acepta un valor en grados, lo convierte a radianes, y retorna la tangente de dicho valor.


```js
function getTanDeg(deg) {
  var rad = (deg \* Math.PI) / 180;
  return Math.tan(rad);
}
```

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

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

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.cos()`
* `Math.sin()`
Math.E
======

La propiedad **`Math.E`** representa la base de los logaritmos naturales, e, aproximadamente 2.718.


Math.E

=
e
≈
2.718

\mathtt{\mi{Math.E}} = e \approx 2.718

Pruébalo
--------

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

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

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

Ejemplos
--------

### Utilizando `Math.E`

La función siguiente devuelve e:


```js
function getNapier() {
  return Math.E;
}

getNapier(); // 2.718281828459045
```

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

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

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.log1p()` (en-US)
Math.log2()
===========

La función **`Math.log2()`** retorna el logaritmo base 2 de un número, esto es



∀
x
>
0
,

Math.log2
(
x
)

=

log
2

(
x
)
=
the unique

y

such that

2
y

=
x

\forall x > 0, \mathtt{\operatorname{Math.log2}(x)} = \log\_2(x) = \text{the unique} ; y ; \text{such that} ; 2^y = x

Pruébalo
--------

Syntax
------
```

Math.log2(x)
```

### Parámetros

`x`

Un número.

### Valor de retorno

El logaritmo base 2 del número usado como parámetro. Si el número es negativo, `NaN` será retornado.

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

Si el valor de `x` es mejor a 0, el valor de retorno es siempre `NaN`.

Debido a que `log2()` es una función estática de `Math`, siempre debe ser usado como `Math.log2()`, en lugar de ser usado como un método del objeto `Math` (`Math` no es un constructor).

Esta función es equivalente a Math.log(x) / Math.log(2). Para log2(e) use la constante `Math.LOG2E` que es 1 / `Math.LN2`.

Ejemplos
--------

### Usando `Math.log2()`


```js
Math.log2(3); // 1.584962500721156
Math.log2(2); // 1
Math.log2(1); // 0
Math.log2(0); // -Infinity
Math.log2(-2); // NaN
Math.log2(1024); // 10
```

Polyfill
--------

This Polyfill emulates the `Math.log2` function. Note that it returns imprecise values on some inputs (like 1 << 29), wrap into `Math.round()` if working with bit masks.


```js
Math.log2 =
  Math.log2 ||
  function (x) {
    return Math.log(x) \* Math.LOG2E;
  };
```

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

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

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

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

See also
--------

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

Resumen
-------

La función **`Math.pow()`** devuelve la `base` elevada al `exponente` , esto es, `baseexponente`.

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

Math.pow(base, exponente)
```

### Parametros

`base`

El número base.

`exponente`

El exponente utilizado para elevar la `base`.

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

La función **`Math.pow()`** retorna la `base` elevada al `exponente`, es decir, `baseexponente`. La base y el exponente estan en el sistema numérico decimal.

Puesto que `pow()` es un método estático de `Math`, siempre se utiliza como `Math.pow()`. Si la base es negativa y el exponente no es un número entero, el resultado será NaN.

Ejemplos
--------

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


```js
// simple
Math.pow(7, 2); // 49
Math.pow(7, 3); // 343
Math.pow(2, 10); // 1024
// exponentes fraccionales
Math.pow(4, 0.5); // 2 (raíz cuadrada de 4)
Math.pow(8, 1 / 3); // 2 (raíz cúbica de 8)
Math.pow(2, 0.5); // 1.412135623730951 (raíz cuadrada de 2)
Math.pow(2, 1 / 3); // 1.2599210498948732 (raíz cúbica de 2)
// exponentes con signo
Math.pow(7, -2); // 0.02040816326530612 (1/49)
Math.pow(8, -1 / 3); // 0.5
// bases con signo
Math.pow(-7, 2); // 49 (los cuadrados son positivos)
Math.pow(-7, 3); // -343 (El cubo de una base negativa puede ser negativo)
Math.pow(-7, 0.5); // NaN (Los números negativos no tienen raíz cuadrada real)
Math.pow(-7, 1 / 3); // NaN
```

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

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

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

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

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

* `Math.cbrt()` 
Experimental
* `Math.exp()`
* `Math.log()`
* `Math.sqrt()`
Math.log10()
============

**`Math.log10()`** funcion que retorna el logaritmo de base 10 de un numero, esto es



∀
x
>
0
,

Math.log10
(
x
)

=

log
10

(
x
)
=
la unica

y tal que

10
y

=
x

\forall x > 0, \mathtt{\operatorname{Math.log10}(x)} = \log\_10(x) = \text{the unique} ; y ; \text{such that} ; 10^y = x

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

Math.log10(x)
```

### Parametros

`x`

Un Numero

### Valor de Retorno

El logaritmo de base 10 del numero dado. SI el numero es negativo, `NaN` es devuelto.

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

Si el valor de x es menor que cero, el valor de retorno siempre es `NaN`.

Porque `log10()` `es un metodo estatico de Math`, debe usarse siempre `Math.log10()`, en vez de usarse como un metodo del objeto math que se ha creado (`Math` no es un constructor).

Esta función es equivalente de Math.log(x) / Math.log(10). Para log10(e) use la constante `Math.LOG10E` que es 1 / `Math.LN10`.

Ejemplos
--------

### usando `Math.log10()`


```js
Math.log10(2); // 0.3010299956639812
Math.log10(1); // 0
Math.log10(0); // -Infinito
Math.log10(-2); // NaN
Math.log10(100000); // 5
```

Polyfill
--------

Puede ser emulada con la siguiente función


```js
Math.log10 =
  Math.log10 ||
  function (x) {
    return Math.log(x) \* Math.LOG10E;
  };
```

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

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

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

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

Vea Tambien
-----------

* `Math.exp()`
* `Math.log()`
* `Math.log1p()` (en-US)
* `Math.log2()`
* `Math.pow()`
Math.sign()
===========

La función **`Math.sign()`** retorna el signo de un número, indicando si el número es positivo, negativo o cero.

Syntaxis
--------
```

Math.sign(x)
```

### Parametros

`x`

Un número.

### Valor de retorno

Un número representando el signo del argumento dado. Si el argumento es un número positivo, negativo, cero positivo, o cero negativo, la función retornará `1`, `-1`, `0` or `-0` respectivamente. De lo contrario, retorna `NaN`.

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

Como `sign()` es un método estático de `Math`, siempre se utiliza como `Math.sign()`, en vez de un método de un objeto Math que hayas creado. (`Math` no es un constructor).

Esta función tiene 5 tipos de valores de retorno, `1`, `-1`, `0`, `-0`, `NaN`, que representan "número positivo", "número negativo", "cero positivo", "cero negativo" y `NaN` respectivamente.

El argumento pasado a esta función será convertido a tipo `x` implicitamente.

Ejemplos
--------

### Usando `Math.sign()`


```js
Math.sign(3); // 1
Math.sign(-3); // -1
Math.sign("-3"); // -1
Math.sign(0); // 0
Math.sign(-0); // -0
Math.sign(NaN); // NaN
Math.sign("foo"); // NaN
Math.sign(); // NaN
```

Polyfill
--------


```js
if (!Math.sign) {
  Math.sign = function (x) {
    // Si x es NaN, el resultado es NaN.
    // Si x es -0, el resultado es -0.
    // Si x es +0, el resultado es +0.
    // Si x es negativo y no -0, el resultado es -1.
    // Si x es positivo y no +0, el resultado es +1.
    x = +x; // convertir a número
    if (x === 0 || isNaN(x)) {
      return Number(x);
    }
    return x > 0 ? 1 : -1;
  };
}
```

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

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

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

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

Ver También
-----------

* `Math.abs()`
* `Math.ceil()`
* `Math.floor()`
* `Math.round()`
* `Math.trunc()`
Math.acosh()
============

La función **`Math.acosh()`** retorna el arco coseno hiperbólico de un número que es:


Para todo x mayor ó igual a 1,se cumple que : la funcion Math.acosh(x) = arcosh(x) = al único y mayor ó igual a 0 ; tal que; cosh(y) = x

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

Math.acosh(x)
```

### Parámetros

`x`

Un número.

### Valor retornado

El arco coseno hiperbólico del número dado. Si el número es menor que 1, `NaN`.

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

Como `acosh()` es un método estático de `Math`, siempre debe ser usado como `Math.acosh()`, en vez de como un método de un objeto `Math` creado (`Math` no es constructor).

Ejemplos
--------

### Utilizando `Math.acosh()`


```js
Math.acosh(-1); // NaN
Math.acosh(0); // NaN
Math.acosh(0.5); // NaN
Math.acosh(1); // 0
Math.acosh(2); // 1.3169578969248166
```


Para valores menores que 1 `Math.acosh()` retorna `NaN`.

Polyfill
--------

Para todo 


x
≥
1

x mayor ó igual a 1

, se tiene que el arcosh(x) 


= ln(x + la raiz cuadrada de(x cuadrado - 1)) 

 y esto puede ser emulado con la siguiente funcion:


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

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

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

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

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

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

* `Math.asinh()`
* `Math.atanh()`
* `Math.cosh()` (en-US)
* `Math.sinh()` (en-US)
* `Math.tanh()`