### Navigation

- index
- modules |
- next |
- previous |
- Functions »

# Hyperbolic Functions

class `sage.functions.hyperbolic.``Function_arccosh`

  Bases: `sage.symbolic.function.GinacFunction`

  The inverse of the hyperbolic cosine function.

  EXAMPLES:

      sage: arccosh(1/2)
      arccosh(1/2)
      sage: arccosh(1 + I*1.0)
      1.06127506190504 + 0.904556894302381*I
      sage: float(arccosh(2))
      1.3169578969248168
      sage: cosh(float(arccosh(2)))
      2.0

  Warning

  If the input is in the complex field or symbolic (which includes rational and integer input), the output will be complex. However, if the input is a real decimal, the output will be real or \(NaN\). See the examples for details.

      sage: arccosh(0.5)
      NaN
      sage: arccosh(1/2)
      arccosh(1/2)
      sage: arccosh(1/2).n()
      NaN
      sage: arccosh(CC(0.5))
      1.04719755119660*I
      sage: arccosh(0)
      1/2*I*pi
      sage: arccosh(-1)
      I*pi

  To prevent automatic evaluation use the `hold` argument:

      sage: arccosh(-1,hold=True)
      arccosh(-1)

  To then evaluate again, we currently must use Maxima via `sage.symbolic.expression.Expression.simplify()`:

      sage: arccosh(-1,hold=True).simplify()
      I*pi

  `conjugate(arccosh(x))==arccosh(conjugate(x))` unless on the branch cut which runs along the real axis from +1 to -inf.:

      sage: conjugate(arccosh(x))
      conjugate(arccosh(x))
      sage: var('y', domain='positive')
      y
      sage: conjugate(arccosh(y))
      conjugate(arccosh(y))
      sage: conjugate(arccosh(y+I))
      conjugate(arccosh(y + I))
      sage: conjugate(arccosh(1/16))
      conjugate(arccosh(1/16))
      sage: conjugate(arccosh(2))
      arccosh(2)
      sage: conjugate(arccosh(I/2))
      arccosh(-1/2*I)

  TESTS:

      sage: arccosh(x).operator()
      arccosh
      sage: latex(arccosh(x))
      {\rm arccosh}\left(x\right)

class `sage.functions.hyperbolic.``Function_arccoth`

  Bases: `sage.functions.hyperbolic.HyperbolicFunction`

  The inverse of the hyperbolic cotangent function.

  EXAMPLES:

      sage: arccoth(2.0)
      0.549306144334055
      sage: arccoth(2)
      arccoth(2)
      sage: arccoth(1 + I*1.0)
      0.402359478108525 - 0.553574358897045*I
      sage: arccoth(2).n(200)
      0.54930614433405484569762261846126285232374527891137472586735
      sage: float(arccoth(2))
      0.5493061443340549

      sage: latex(arccoth(x))
      {\rm arccoth}\left(x\right)

class `sage.functions.hyperbolic.``Function_arccsch`

  Bases: `sage.functions.hyperbolic.HyperbolicFunction`

  The inverse of the hyperbolic cosecant function.

  EXAMPLES:

      sage: arccsch(2.0)
      0.481211825059603
      sage: arccsch(2)
      arccsch(2)
      sage: arccsch(1 + I*1.0)
      0.530637530952518 - 0.452278447151191*I
      sage: arccsch(1).n(200)
      0.88137358701954302523260932497979230902816032826163541075330
      sage: float(arccsch(1))
      0.881373587019543

      sage: latex(arccsch(x))
      {\rm arccsch}\left(x\right)

class `sage.functions.hyperbolic.``Function_arcsech`

  Bases: `sage.functions.hyperbolic.HyperbolicFunction`

  The inverse of the hyperbolic secant function.

  EXAMPLES:

      sage: arcsech(0.5)
      1.31695789692482
      sage: arcsech(1/2)
      arcsech(1/2)
      sage: arcsech(1 + I*1.0)
      0.530637530952518 - 1.11851787964371*I
      sage: arcsech(1/2).n(200)
      1.3169578969248167086250463473079684440269819714675164797685
      sage: float(arcsech(1/2))
      1.3169578969248168

      sage: latex(arcsech(x))
      {\rm arcsech}\left(x\right)

class `sage.functions.hyperbolic.``Function_arcsinh`

  Bases: `sage.symbolic.function.GinacFunction`

  The inverse of the hyperbolic sine function.

  EXAMPLES:

      sage: arcsinh
      arcsinh
      sage: arcsinh(0.5)
      0.481211825059603
      sage: arcsinh(1/2)
      arcsinh(1/2)
      sage: arcsinh(1 + I*1.0)
      1.06127506190504 + 0.666239432492515*I

  To prevent automatic evaluation use the `hold` argument:

      sage: arcsinh(-2,hold=True)
      arcsinh(-2)

  To then evaluate again, we currently must use Maxima via `sage.symbolic.expression.Expression.simplify()`:

      sage: arcsinh(-2,hold=True).simplify()
      -arcsinh(2)

  `conjugate(arcsinh(x))==arcsinh(conjugate(x))` unless on the branch cuts which run along the imaginary axis outside the interval [-I, +I].:

      sage: conjugate(arcsinh(x))
      conjugate(arcsinh(x))
      sage: var('y', domain='positive')
      y
      sage: conjugate(arcsinh(y))
      arcsinh(y)
      sage: conjugate(arcsinh(y+I))
      conjugate(arcsinh(y + I))
      sage: conjugate(arcsinh(1/16))
      arcsinh(1/16)
      sage: conjugate(arcsinh(I/2))
      arcsinh(-1/2*I)
      sage: conjugate(arcsinh(2*I))
      conjugate(arcsinh(2*I))

  TESTS:

      sage: arcsinh(x).operator()
      arcsinh
      sage: latex(arcsinh(x))
      {\rm arcsinh}\left(x\right)

class `sage.functions.hyperbolic.``Function_arctanh`

  Bases: `sage.symbolic.function.GinacFunction`

  The inverse of the hyperbolic tangent function.

  EXAMPLES:

      sage: arctanh(0.5)
      0.549306144334055
      sage: arctanh(1/2)
      arctanh(1/2)
      sage: arctanh(1 + I*1.0)
      0.402359478108525 + 1.01722196789785*I

  To prevent automatic evaluation use the `hold` argument:

      sage: arctanh(-1/2,hold=True)
      arctanh(-1/2)

  To then evaluate again, we currently must use Maxima via `sage.symbolic.expression.Expression.simplify()`:

      sage: arctanh(-1/2,hold=True).simplify()
      -arctanh(1/2)

  `conjugate(arctanh(x))==arctanh(conjugate(x))` unless on the branch cuts which run along the real axis outside the interval [-1, +1].:

      sage: conjugate(arctanh(x))
      conjugate(arctanh(x))
      sage: var('y', domain='positive')
      y
      sage: conjugate(arctanh(y))
      conjugate(arctanh(y))
      sage: conjugate(arctanh(y+I))
      conjugate(arctanh(y + I))
      sage: conjugate(arctanh(1/16))
      arctanh(1/16)
      sage: conjugate(arctanh(I/2))
      arctanh(-1/2*I)
      sage: conjugate(arctanh(-2*I))
      arctanh(2*I)

  TESTS:

      sage: arctanh(x).operator()
      arctanh
      sage: latex(arctanh(x))
      {\rm arctanh}\left(x\right)

class `sage.functions.hyperbolic.``Function_cosh`

  Bases: `sage.symbolic.function.GinacFunction`

  The hyperbolic cosine function.

  EXAMPLES:

      sage: cosh(pi)
      cosh(pi)
      sage: cosh(3.1415)
      11.5908832931176
      sage: float(cosh(pi))
      11.591953275521519
      sage: RR(cosh(1/2))
      1.12762596520638

      sage: latex(cosh(x))
      \cosh\left(x\right)

  To prevent automatic evaluation, use the `hold` parameter:

      sage: cosh(arcsinh(x),hold=True)
      cosh(arcsinh(x))

  To then evaluate again, we currently must use Maxima via `sage.symbolic.expression.Expression.simplify()`:

      sage: cosh(arcsinh(x),hold=True).simplify()
      sqrt(x^2 + 1)

class `sage.functions.hyperbolic.``Function_coth`

  Bases: `sage.functions.hyperbolic.HyperbolicFunction`

  The hyperbolic cotangent function.

  EXAMPLES:

      sage: coth(pi)
      coth(pi)
      sage: coth(3.1415)
      1.00374256795520
      sage: float(coth(pi))
      1.0037418731973213
      sage: RR(coth(pi))
      1.00374187319732

      sage: latex(coth(x))
      \coth\left(x\right)

class `sage.functions.hyperbolic.``Function_csch`

  Bases: `sage.functions.hyperbolic.HyperbolicFunction`

  The hyperbolic cosecant function.

  EXAMPLES:

      sage: csch(pi)
      csch(pi)
      sage: csch(3.1415)
      0.0865975907592133
      sage: float(csch(pi))
      0.0865895375300469...
      sage: RR(csch(pi))
      0.0865895375300470

      sage: latex(csch(x))
      {\rm csch}\left(x\right)

class `sage.functions.hyperbolic.``Function_sech`

  Bases: `sage.functions.hyperbolic.HyperbolicFunction`

  The hyperbolic secant function.

  EXAMPLES:

      sage: sech(pi)
      sech(pi)
      sage: sech(3.1415)
      0.0862747018248192
      sage: float(sech(pi))
      0.0862667383340544...
      sage: RR(sech(pi))
      0.0862667383340544

      sage: latex(sech(x))
      {\rm sech}\left(x\right)

class `sage.functions.hyperbolic.``Function_sinh`

  Bases: `sage.symbolic.function.GinacFunction`

  The hyperbolic sine function.

  EXAMPLES:

      sage: sinh(pi)
      sinh(pi)
      sage: sinh(3.1415)
      11.5476653707437
      sage: float(sinh(pi))
      11.54873935725774...
      sage: RR(sinh(pi))
      11.5487393572577

      sage: latex(sinh(x))
      \sinh\left(x\right)

  To prevent automatic evaluation, use the `hold` parameter:

      sage: sinh(arccosh(x),hold=True)
      sinh(arccosh(x))

  To then evaluate again, we currently must use Maxima via `sage.symbolic.expression.Expression.simplify()`:

      sage: sinh(arccosh(x),hold=True).simplify()
      sqrt(x + 1)*sqrt(x - 1)

class `sage.functions.hyperbolic.``Function_tanh`

  Bases: `sage.symbolic.function.GinacFunction`

  The hyperbolic tangent function.

  EXAMPLES:

      sage: tanh(pi)
      tanh(pi)
      sage: tanh(3.1415)
      0.996271386633702
      sage: float(tanh(pi))
      0.99627207622075
      sage: tan(3.1415/4)
      0.999953674278156
      sage: tanh(pi/4)
      tanh(1/4*pi)
      sage: RR(tanh(1/2))
      0.462117157260010

      sage: CC(tanh(pi + I*e))
      0.997524731976164 - 0.00279068768100315*I
      sage: ComplexField(100)(tanh(pi + I*e))
      0.99752473197616361034204366446 - 0.0027906876810031453884245163923*I
      sage: CDF(tanh(pi + I*e))  # rel tol 4e-16
      0.9975247319761636 - 0.002790687681003147*I

  To prevent automatic evaluation, use the `hold` parameter:

      sage: tanh(arcsinh(x),hold=True)
      tanh(arcsinh(x))

  To then evaluate again, we currently must use Maxima via `sage.symbolic.expression.Expression.simplify()`:

      sage: tanh(arcsinh(x),hold=True).simplify()
      x/sqrt(x^2 + 1)

  TESTS:

      sage: latex(tanh(x))
      \tanh\left(x\right)

class `sage.functions.hyperbolic.``HyperbolicFunction`(name, latex_name=None, conversions=None, evalf_float=None)

  Bases: `sage.symbolic.function.BuiltinFunction`

  Abstract base class for the functions defined in this file.

  EXAMPLES:

      sage: from sage.functions.hyperbolic import HyperbolicFunction
      sage: f = HyperbolicFunction('foo', latex_name='\\foo', conversions={'mathematica':'Foo'},evalf_float=lambda x: 2*x)
      sage: f(x)
      foo(x)
      sage: f(0.5r)
      1.0
      sage: latex(f(x))
      \foo\left(x\right)
      sage: f(x)._mathematica_init_()
      'Foo[x]'

### Navigation

- index
- modules |
- next |
- previous |
- Functions »