def __init__(self): r""" 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: diff(asech(x), x) -1/(sqrt(-x^2 + 1)*x) sage: latex(arcsech(x)) \operatorname{arcsech}\left(x\right) """ GinacFunction.__init__(self, "arcsech", latex_name=r"\operatorname{arcsech}", conversions=dict(maxima='asech'))
def __init__(self): r""" 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 :meth:`sage.symbolic.expression.Expression.simplify`:: sage: sinh(arccosh(x),hold=True).simplify() sqrt(x + 1)*sqrt(x - 1) """ GinacFunction.__init__(self, "sinh", latex_name=r"\sinh")
def __init__(self): r""" 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: diff(acsch(x), x) -1/(sqrt(x^2 + 1)*x) sage: latex(arccsch(x)) \operatorname{arccsch}\left(x\right) """ GinacFunction.__init__(self, "arccsch", latex_name=r"\operatorname{arccsch}", conversions=dict(maxima='acsch'))
def __init__(self): """ The cosine function. EXAMPLES:: sage: cos(pi) -1 sage: cos(x).subs(x==pi) -1 sage: cos(2).n(100) -0.41614683654714238699756822950 sage: loads(dumps(cos)) cos We can prevent evaluation using the ``hold`` parameter:: sage: cos(0,hold=True) cos(0) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = cos(0,hold=True); a.simplify() 1 TESTS:: sage: conjugate(cos(x)) cos(conjugate(x)) """ GinacFunction.__init__(self, "cos", latex_name=r"\cos", conversions=dict(maxima='cos',mathematica='Cos'))
def __init__(self): """ The sine function. EXAMPLES:: sage: sin(0) 0 sage: sin(x).subs(x==0) 0 sage: sin(2).n(100) 0.90929742682568169539601986591 sage: loads(dumps(sin)) sin We can prevent evaluation using the ``hold`` parameter:: sage: sin(0,hold=True) sin(0) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = sin(0,hold=True); a.simplify() 0 TESTS:: sage: conjugate(sin(x)) sin(conjugate(x)) """ GinacFunction.__init__(self, "sin", latex_name=r"\sin", conversions=dict(maxima='sin',mathematica='Sin'))
def __init__(self): """ The arcsine function. EXAMPLES:: sage: arcsin(0.5) 0.523598775598299 sage: arcsin(1/2) 1/6*pi sage: arcsin(1 + 1.0*I) 0.666239432492515 + 1.06127506190504*I We can delay evaluation using the ``hold`` parameter:: sage: arcsin(0,hold=True) arcsin(0) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = arcsin(0,hold=True); a.simplify() 0 ``conjugate(arcsin(x))==arcsin(conjugate(x))``, unless on the branch cuts which run along the real axis outside the interval [-1, +1].:: sage: conjugate(arcsin(x)) conjugate(arcsin(x)) sage: var('y', domain='positive') y sage: conjugate(arcsin(y)) conjugate(arcsin(y)) sage: conjugate(arcsin(y+I)) conjugate(arcsin(y + I)) sage: conjugate(arcsin(1/16)) arcsin(1/16) sage: conjugate(arcsin(2)) conjugate(arcsin(2)) sage: conjugate(arcsin(-2)) -conjugate(arcsin(2)) TESTS:: sage: arcsin(x)._sympy_() asin(x) sage: arcsin(x).operator() arcsin sage: asin(complex(1,1)) (0.6662394324925152+1.0612750619050357j) Check that :trac:`22823` is fixed:: sage: bool(asin(SR(2.1)) == NaN) True sage: asin(SR(2.1)).is_real() False """ GinacFunction.__init__(self, 'arcsin', latex_name=r"\arcsin", conversions=dict(maxima='asin', sympy='asin', fricas="asin", giac="asin"))
def __init__(self): r""" 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: csch(0) Infinity sage: csch(pi*I) Infinity sage: csch(pi*I/2) -I sage: csch(7*pi*I/2) I sage: csch(7.*pi*I/2) -I*csc(3.50000000000000*pi) sage: bool(diff(csch(x), x) == diff(1/sinh(x), x)) True sage: diff(csch(x), x) -coth(x)*csch(x) sage: latex(csch(x)) {\rm csch}\left(x\right) """ GinacFunction.__init__(self, "csch", latex_name=r"{\rm csch}")
def __init__(self): r""" 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: sech(0) 1 sage: sech(pi*I) -1 sage: sech(pi*I/2) Infinity sage: sech(7*pi*I/2) Infinity sage: sech(8*pi*I/2) 1 sage: sech(8.*pi*I/2) sec(4.00000000000000*pi) sage: bool(diff(sech(x), x) == diff(1/cosh(x), x)) True sage: diff(sech(x), x) -sech(x)*tanh(x) sage: latex(sech(x)) \operatorname{sech}\left(x\right) """ GinacFunction.__init__(self, "sech", latex_name=r"\operatorname{sech}",)
def __init__(self): r""" The unit step function, ``unit_step(x)``. INPUT: - ``x`` - a real number or a symbolic expression EXAMPLES:: sage: unit_step(-1) 0 sage: unit_step(1) 1 sage: unit_step(0) 1 sage: unit_step(x) unit_step(x) sage: latex(unit_step(x)) \mathrm{u}\left(x\right) TESTS:: sage: t = loads(dumps(unit_step(x)+1)); t unit_step(x) + 1 sage: t.subs(x=0) 2 """ GinacFunction.__init__(self, "unit_step", latex_name=r"\mathrm{u}", conversions=dict(mathematica='UnitStep'))
def __init__(self): r""" 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) sage: cosh(x)._sympy_() cosh(x) To prevent automatic evaluation, use the ``hold`` parameter:: sage: cosh(arcsinh(x),hold=True) cosh(arcsinh(x)) To then evaluate again, use the ``unhold`` method:: sage: cosh(arcsinh(x),hold=True).unhold() sqrt(x^2 + 1) """ GinacFunction.__init__(self, "cosh", latex_name=r"\cosh")
def __init__(self): r""" The absolute value function. EXAMPLES:: sage: var('x y') (x, y) sage: abs(x) abs(x) sage: abs(x^2 + y^2) abs(x^2 + y^2) sage: abs(-2) 2 sage: sqrt(x^2) sqrt(x^2) sage: abs(sqrt(x)) abs(sqrt(x)) sage: complex(abs(3*I)) (3+0j) sage: f = sage.functions.other.Function_abs() sage: latex(f) \mathrm{abs} sage: latex(abs(x)) {\left| x \right|} """ GinacFunction.__init__(self, "abs", latex_name=r"\mathrm{abs}")
def __init__(self): r""" The Heaviside step function, ``heaviside(x)``. INPUT: - ``x`` - a real number or a symbolic expression EXAMPLES:: sage: heaviside(-1) 0 sage: heaviside(1) 1 sage: heaviside(0) heaviside(0) sage: heaviside(x) heaviside(x) sage: latex(heaviside(x)) H\left(x\right) sage: heaviside(x)._sympy_() Heaviside(x) sage: heaviside(x)._giac_() Heaviside(x) sage: h(x) = heaviside(x) sage: h(pi).numerical_approx() 1.00000000000000 """ GinacFunction.__init__(self, "heaviside", latex_name="H", conversions=dict(maxima='hstep', mathematica='HeavisideTheta', sympy='Heaviside', giac='Heaviside'))
def __init__(self): r""" 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) sage: sinh(x)._sympy_() sinh(x) To prevent automatic evaluation, use the ``hold`` parameter:: sage: sinh(arccosh(x),hold=True) sinh(arccosh(x)) To then evaluate again, use the ``unhold`` method:: sage: sinh(arccosh(x),hold=True).unhold() sqrt(x + 1)*sqrt(x - 1) """ GinacFunction.__init__(self, "sinh", latex_name=r"\sinh")
def __init__(self): r""" Derivatives of the Riemann zeta function. EXAMPLES:: sage: zetaderiv(1, x) zetaderiv(1, x) sage: zetaderiv(1, x).diff(x) zetaderiv(2, x) sage: var('n') n sage: zetaderiv(n,x) zetaderiv(n, x) sage: zetaderiv(1, 4).n() -0.0689112658961254 sage: import mpmath; mpmath.diff(lambda x: mpmath.zeta(x), 4) mpf('-0.068911265896125382') TESTS:: sage: latex(zetaderiv(2,x)) \zeta^\prime\left(2, x\right) sage: a = loads(dumps(zetaderiv(2,x))) sage: a.operator() == zetaderiv True """ GinacFunction.__init__(self, "zetaderiv", nargs=2)
def __init__(self): r""" 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 2e-15 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 :meth:`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) sage: tanh(x)._sympy_() tanh(x) Check that real/imaginary parts are correct (:trac:`20098`):: sage: tanh(1+2*I).n() 1.16673625724092 - 0.243458201185725*I sage: tanh(1+2*I).real().n() 1.16673625724092 sage: tanh(1+2*I).imag().n() -0.243458201185725 sage: tanh(x).real() sinh(2*real_part(x))/(cos(2*imag_part(x)) + cosh(2*real_part(x))) sage: tanh(x).imag() sin(2*imag_part(x))/(cos(2*imag_part(x)) + cosh(2*real_part(x))) """ GinacFunction.__init__(self, "tanh", latex_name=r"\tanh")
def __init__(self): """ The arctangent function. EXAMPLES:: sage: arctan(1/2) arctan(1/2) sage: RDF(arctan(1/2)) # rel tol 1e-15 0.46364760900080615 sage: arctan(1 + I) arctan(I + 1) sage: arctan(1/2).n(100) 0.46364760900080611621425623146 We can delay evaluation using the ``hold`` parameter:: sage: arctan(0,hold=True) arctan(0) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = arctan(0,hold=True); a.simplify() 0 ``conjugate(arctan(x))==arctan(conjugate(x))``, unless on the branch cuts which run along the imaginary axis outside the interval [-I, +I].:: sage: conjugate(arctan(x)) conjugate(arctan(x)) sage: var('y', domain='positive') y sage: conjugate(arctan(y)) arctan(y) sage: conjugate(arctan(y+I)) conjugate(arctan(y + I)) sage: conjugate(arctan(1/16)) arctan(1/16) sage: conjugate(arctan(-2*I)) conjugate(arctan(-2*I)) sage: conjugate(arctan(2*I)) conjugate(arctan(2*I)) sage: conjugate(arctan(I/2)) arctan(-1/2*I) TESTS:: sage: arctan(x).operator() arctan Check that :trac:`19918` is fixed:: sage: arctan(-x).subs(x=oo) -1/2*pi sage: arctan(-x).subs(x=-oo) 1/2*pi """ GinacFunction.__init__(self, "arctan", latex_name=r'\arctan', conversions=dict(maxima='atan', sympy='atan'))
def __init__(self): r""" 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 :meth:`sage.symbolic.expression.Expression.simplify`:: sage: cosh(arcsinh(x),hold=True).simplify() sqrt(x^2 + 1) """ GinacFunction.__init__(self, "cosh", latex_name=r"\cosh")
def __init__(self): r""" The hyperbolic cotangent function. EXAMPLES:: sage: coth(pi) coth(pi) sage: coth(0) Infinity sage: coth(pi*I) Infinity sage: coth(pi*I/2) 0 sage: coth(7*pi*I/2) 0 sage: coth(8*pi*I/2) Infinity sage: coth(7.*pi*I/2) -I*cot(3.50000000000000*pi) sage: coth(3.1415) 1.00374256795520 sage: float(coth(pi)) 1.0037418731973213 sage: RR(coth(pi)) 1.00374187319732 sage: bool(diff(coth(x), x) == diff(1/tanh(x), x)) True sage: diff(coth(x), x) -1/sinh(x)^2 sage: latex(coth(x)) \operatorname{coth}\left(x\right) """ GinacFunction.__init__(self, "coth", latex_name=r"\operatorname{coth}")
def __init__(self): r""" The cotangent function. EXAMPLES:: sage: cot(pi/4) 1 sage: RR(cot(pi/4)) 1.00000000000000 sage: cot(1/2) cot(1/2) sage: cot(0.5) 1.83048772171245 sage: latex(cot(x)) \cot\left(x\right) We can prevent evaluation using the ``hold`` parameter:: sage: cot(pi/4,hold=True) cot(1/4*pi) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = cot(pi/4,hold=True); a.simplify() 1 EXAMPLES:: sage: cot(pi/4) 1 sage: cot(x).subs(x==pi/4) 1 sage: cot(pi/7) cot(1/7*pi) sage: cot(x) cot(x) sage: n(cot(pi/4),100) 1.0000000000000000000000000000 sage: float(cot(1)) 0.64209261593433... sage: bool(diff(cot(x), x) == diff(1/tan(x), x)) True sage: diff(cot(x), x) -cot(x)^2 - 1 TESTS: Test complex input:: sage: cot(complex(1,1)) # rel tol 1e-15 (0.21762156185440273-0.8680141428959249j) sage: cot(1.+I) 0.217621561854403 - 0.868014142895925*I """ GinacFunction.__init__(self, "cot", latex_name=r"\cot")
def __init__(self): """ The cosine function. EXAMPLES:: sage: cos(pi) -1 sage: cos(x).subs(x==pi) -1 sage: cos(2).n(100) -0.41614683654714238699756822950 sage: loads(dumps(cos)) cos sage: cos(x)._sympy_() cos(x) We can prevent evaluation using the ``hold`` parameter:: sage: cos(0,hold=True) cos(0) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = cos(0,hold=True); a.simplify() 1 If possible, the argument is also reduced modulo the period length `2\pi`, and well-known identities are directly evaluated:: sage: k = var('k', domain='integer') sage: cos(1 + 2*k*pi) cos(1) sage: cos(k*pi) cos(pi*k) sage: cos(pi/3 + 2*k*pi) 1/2 TESTS:: sage: conjugate(cos(x)) cos(conjugate(x)) sage: cos(complex(1,1)) # rel tol 1e-15 (0.8337300251311491-0.9888977057628651j) Check that :trac:`20752` is fixed:: sage: cos(3*pi+41/42*pi) cos(1/42*pi) sage: cos(-5*pi+1/42*pi) -cos(1/42*pi) sage: cos(pi-1/42*pi) -cos(1/42*pi) """ GinacFunction.__init__(self, 'cos', latex_name=r"\cos", conversions=dict(maxima='cos',mathematica='Cos',giac='cos'))
def __init__(self): r""" The inverse of the hyperbolic sine function. EXAMPLES:: sage: asinh arcsinh sage: asinh(0.5) 0.481211825059603 sage: asinh(1/2) arcsinh(1/2) sage: asinh(1 + I*1.0) 1.06127506190504 + 0.666239432492515*I To prevent automatic evaluation use the ``hold`` argument:: sage: asinh(-2,hold=True) arcsinh(-2) To then evaluate again, use the ``unhold`` method:: sage: asinh(-2,hold=True).unhold() -arcsinh(2) ``conjugate(asinh(x))==asinh(conjugate(x))`` unless on the branch cuts which run along the imaginary axis outside the interval [-I, +I].:: sage: conjugate(asinh(x)) conjugate(arcsinh(x)) sage: var('y', domain='positive') y sage: conjugate(asinh(y)) arcsinh(y) sage: conjugate(asinh(y+I)) conjugate(arcsinh(y + I)) sage: conjugate(asinh(1/16)) arcsinh(1/16) sage: conjugate(asinh(I/2)) arcsinh(-1/2*I) sage: conjugate(asinh(2*I)) conjugate(arcsinh(2*I)) TESTS:: sage: asinh(x).operator() arcsinh sage: latex(asinh(x)) \operatorname{arsinh}\left(x\right) sage: asinh(x)._sympy_() asinh(x) """ GinacFunction.__init__(self, "arcsinh", latex_name=r"\operatorname{arsinh}", conversions=dict(maxima='asinh', sympy='asinh', fricas='asinh', giac='asinh'))
def __init__(self): r""" The polylog function `\text{Li}_n(z) = \sum_{k=1}^{\infty} z^k / k^n`. INPUT: - ``n`` - object - ``z`` - object EXAMPLES:: sage: polylog(1, x) -log(-x + 1) sage: polylog(2,1) 1/6*pi^2 sage: polylog(2,x^2+1) polylog(2, x^2 + 1) sage: polylog(4,0.5) polylog(4, 0.500000000000000) sage: f = polylog(4, 1); f 1/90*pi^4 sage: f.n() 1.08232323371114 sage: polylog(4, 2).n() 2.42786280675470 - 0.174371300025453*I sage: complex(polylog(4,2)) (2.4278628067547032-0.17437130002545306j) sage: float(polylog(4,0.5)) 0.5174790616738993 sage: z = var('z') sage: polylog(2,z).series(z==0, 5) 1*z + 1/4*z^2 + 1/9*z^3 + 1/16*z^4 + Order(z^5) sage: loads(dumps(polylog)) polylog sage: latex(polylog(5, x)) {\rm Li}_{5}(x) TESTS: Check if #8459 is fixed:: sage: t = maxima(polylog(5,x)).sage(); t polylog(5, x) sage: t.operator() == polylog True sage: t.subs(x=.5).n() 0.508400579242269 """ GinacFunction.__init__(self, "polylog", nargs=2)
def __init__(self): """ The tangent function. EXAMPLES:: sage: tan(pi) 0 sage: tan(3.1415) -0.0000926535900581913 sage: tan(3.1415/4) 0.999953674278156 sage: tan(pi/4) 1 sage: tan(1/2) tan(1/2) sage: RR(tan(1/2)) 0.546302489843790 We can prevent evaluation using the ``hold`` parameter:: sage: tan(pi/4,hold=True) tan(1/4*pi) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = tan(pi/4,hold=True); a.simplify() 1 If possible, the argument is also reduced modulo the period length `\pi`, and well-known identities are directly evaluated:: sage: k = var('k', domain='integer') sage: tan(1 + 2*k*pi) tan(1) sage: tan(k*pi) 0 TESTS:: sage: tan(x)._sympy_() tan(x) sage: conjugate(tan(x)) tan(conjugate(x)) sage: tan(complex(1,1)) # rel tol 1e-15 (0.2717525853195118+1.0839233273386946j) Check that :trac:`19791` is fixed:: sage: tan(2+I).imag().n() 1.16673625724092 """ GinacFunction.__init__(self, 'tan', latex_name=r"\tan")
def __init__(self): """ The arccosine function. EXAMPLES:: sage: arccos(0.5) 1.04719755119660 sage: arccos(1/2) 1/3*pi sage: arccos(1 + 1.0*I) 0.904556894302381 - 1.06127506190504*I sage: arccos(3/4).n(100) 0.72273424781341561117837735264 We can delay evaluation using the ``hold`` parameter:: sage: arccos(0,hold=True) arccos(0) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = arccos(0,hold=True); a.simplify() 1/2*pi ``conjugate(arccos(x))==arccos(conjugate(x))``, unless on the branch cuts, which run along the real axis outside the interval [-1, +1].:: sage: conjugate(arccos(x)) conjugate(arccos(x)) sage: var('y', domain='positive') y sage: conjugate(arccos(y)) conjugate(arccos(y)) sage: conjugate(arccos(y+I)) conjugate(arccos(y + I)) sage: conjugate(arccos(1/16)) arccos(1/16) sage: conjugate(arccos(2)) conjugate(arccos(2)) sage: conjugate(arccos(-2)) pi - conjugate(arccos(2)) TESTS:: sage: arccos(x)._sympy_() acos(x) sage: arccos(x).operator() arccos sage: acos(complex(1,1)) (0.9045568943023814-1.0612750619050357j) """ GinacFunction.__init__(self, 'arccos', latex_name=r"\arccos", conversions=dict(maxima='acos', sympy='acos'))
def __init__(self): """ TESTS:: sage: from sage.functions.log import logb sage: loads(dumps(logb)) log """ GinacFunction.__init__(self, 'log', ginac_name='logb', nargs=2, latex_name=r'\log', conversions=dict(maxima='log'))
def __init__(self): """ TESTS:: sage: loads(dumps(exp)) exp sage: maxima(exp(x))._sage_() e^x """ GinacFunction.__init__(self, "exp", latex_name=r"\exp", conversions=dict(maxima='exp', fricas='exp'))
def __init__(self): r""" The inverse of the hyperbolic tangent function. EXAMPLES:: sage: atanh(0.5) 0.549306144334055 sage: atanh(1/2) 1/2*log(3) sage: atanh(1 + I*1.0) 0.402359478108525 + 1.01722196789785*I To prevent automatic evaluation use the ``hold`` argument:: sage: atanh(-1/2,hold=True) arctanh(-1/2) To then evaluate again, use the ``unhold`` method:: sage: atanh(-1/2,hold=True).unhold() -1/2*log(3) ``conjugate(arctanh(x))==arctanh(conjugate(x))`` unless on the branch cuts which run along the real axis outside the interval [-1, +1].:: sage: conjugate(atanh(x)) conjugate(arctanh(x)) sage: var('y', domain='positive') y sage: conjugate(atanh(y)) conjugate(arctanh(y)) sage: conjugate(atanh(y+I)) conjugate(arctanh(y + I)) sage: conjugate(atanh(1/16)) 1/2*log(17/15) sage: conjugate(atanh(I/2)) arctanh(-1/2*I) sage: conjugate(atanh(-2*I)) arctanh(2*I) TESTS:: sage: atanh(x).operator() arctanh sage: latex(atanh(x)) \operatorname{artanh}\left(x\right) sage: atanh(x)._sympy_() atanh(x) """ GinacFunction.__init__(self, "arctanh", latex_name=r"\operatorname{artanh}", conversions=dict(maxima='atanh', sympy='atanh', fricas='atanh', giac='atanh'))
def __init__(self): r""" Riemann zeta function at s with s a real or complex number. INPUT: - ``s`` - real or complex number If s is a real number the computation is done using the MPFR library. When the input is not real, the computation is done using the PARI C library. EXAMPLES:: sage: zeta(x) zeta(x) sage: zeta(2) 1/6*pi^2 sage: zeta(2.) 1.64493406684823 sage: RR = RealField(200) sage: zeta(RR(2)) 1.6449340668482264364724151666460251892189499012067984377356 sage: zeta(I) zeta(I) sage: zeta(I).n() 0.00330022368532410 - 0.418155449141322*I It is possible to use the ``hold`` argument to prevent automatic evaluation:: sage: zeta(2,hold=True) zeta(2) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = zeta(2,hold=True); a.simplify() 1/6*pi^2 TESTS:: sage: latex(zeta(x)) \zeta(x) sage: a = loads(dumps(zeta(x))) sage: a.operator() == zeta True sage: zeta(1) Infinity sage: zeta(x).subs(x=1) Infinity """ GinacFunction.__init__(self, "zeta")
def __init__(self): r""" The cosecant function. EXAMPLES:: sage: csc(pi/4) sqrt(2) sage: csc(x).subs(x==pi/4) sqrt(2) sage: csc(pi/7) csc(1/7*pi) sage: csc(x) csc(x) sage: RR(csc(pi/4)) 1.41421356237310 sage: n(csc(pi/4),100) 1.4142135623730950488016887242 sage: float(csc(pi/4)) 1.4142135623730951 sage: csc(1/2) csc(1/2) sage: csc(0.5) 2.08582964293349 sage: bool(diff(csc(x), x) == diff(1/sin(x), x)) True sage: diff(csc(x), x) -cot(x)*csc(x) sage: latex(csc(x)) \csc\left(x\right) sage: csc(x)._sympy_() csc(x) We can prevent evaluation using the ``hold`` parameter:: sage: csc(pi/4,hold=True) csc(1/4*pi) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = csc(pi/4,hold=True); a.simplify() sqrt(2) TESTS: Test complex input:: sage: csc(complex(1,1)) # rel tol 1e-15 (0.6215180171704284-0.30393100162842646j) """ GinacFunction.__init__(self, 'csc', latex_name=r"\csc")
def __init__(self): r""" The dilogarithm function `\text{Li}_2(z) = \sum_{k=1}^{\infty} z^k / k^2`. This is simply an alias for polylog(2, z). EXAMPLES:: sage: dilog(1) 1/6*pi^2 sage: dilog(1/2) 1/12*pi^2 - 1/2*log(2)^2 sage: dilog(x^2+1) dilog(x^2 + 1) sage: dilog(-1) -1/12*pi^2 sage: dilog(-1.1) -0.890838090262283 sage: float(dilog(1)) 1.6449340668482262 sage: var('z') z sage: dilog(z).diff(z, 2) log(-z + 1)/z^2 - 1/((z - 1)*z) sage: dilog(z).series(z==1/2, 3) (1/12*pi^2 - 1/2*log(2)^2) + (-2*log(1/2))*(z - 1/2) + (2*log(1/2) + 2)*(z - 1/2)^2 + Order(1/8*(2*z - 1)^3) sage: latex(dilog(z)) {\rm Li}_2\left(z\right) TESTS: ``conjugate(dilog(x))==dilog(conjugate(x))`` unless on the branch cuts which run along the positive real axis beginning at 1.:: sage: conjugate(dilog(x)) conjugate(dilog(x)) sage: var('y',domain='positive') y sage: conjugate(dilog(y)) conjugate(dilog(y)) sage: conjugate(dilog(1/19)) dilog(1/19) sage: conjugate(dilog(1/2*I)) dilog(-1/2*I) sage: dilog(conjugate(1/2*I)) dilog(-1/2*I) sage: conjugate(dilog(2)) conjugate(dilog(2)) """ GinacFunction.__init__(self, 'dilog', conversions=dict(maxima='li[2]'))
def __init__(self): r""" The cosecant function. EXAMPLES:: sage: csc(pi/4) sqrt(2) sage: csc(x).subs(x==pi/4) sqrt(2) sage: csc(pi/7) csc(1/7*pi) sage: csc(x) csc(x) sage: RR(csc(pi/4)) 1.41421356237310 sage: n(csc(pi/4),100) 1.4142135623730950488016887242 sage: float(csc(pi/4)) 1.4142135623730951 sage: csc(1/2) csc(1/2) sage: csc(0.5) 2.08582964293349 sage: bool(diff(csc(x), x) == diff(1/sin(x), x)) True sage: diff(csc(x), x) -cot(x)*csc(x) sage: latex(csc(x)) \csc\left(x\right) We can prevent evaluation using the ``hold`` parameter:: sage: csc(pi/4,hold=True) csc(1/4*pi) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = csc(pi/4,hold=True); a.simplify() sqrt(2) TESTS: Test complex input:: sage: csc(complex(1,1)) # rel tol 1e-15 (0.6215180171704284-0.30393100162842646j) """ GinacFunction.__init__(self, "csc", latex_name=r"\csc")
def __init__(self): """ The arcsine function. EXAMPLES:: sage: arcsin(0.5) 0.523598775598299 sage: arcsin(1/2) 1/6*pi sage: arcsin(1 + 1.0*I) 0.666239432492515 + 1.06127506190504*I We can delay evaluation using the ``hold`` parameter:: sage: arcsin(0,hold=True) arcsin(0) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = arcsin(0,hold=True); a.simplify() 0 ``conjugate(arcsin(x))==arcsin(conjugate(x))``, unless on the branch cuts which run along the real axis outside the interval [-1, +1].:: sage: conjugate(arcsin(x)) conjugate(arcsin(x)) sage: var('y', domain='positive') y sage: conjugate(arcsin(y)) conjugate(arcsin(y)) sage: conjugate(arcsin(y+I)) conjugate(arcsin(y + I)) sage: conjugate(arcsin(1/16)) arcsin(1/16) sage: conjugate(arcsin(2)) conjugate(arcsin(2)) sage: conjugate(arcsin(-2)) -conjugate(arcsin(2)) TESTS:: sage: arcsin(x).operator() arcsin """ GinacFunction.__init__(self, 'arcsin', latex_name=r"\arcsin", conversions=dict(maxima='asin', sympy='asin'))
def __init__(self): """ The arccotangent function. EXAMPLES:: sage: arccot(1/2) arccot(1/2) sage: RDF(arccot(1/2)) # abs tol 2e-16 1.1071487177940906 sage: arccot(1 + I) arccot(I + 1) sage: arccot(1/2).n(100) 1.1071487177940905030170654602 sage: float(arccot(1/2)) # abs tol 2e-16 1.1071487177940906 sage: bool(diff(acot(x), x) == -diff(atan(x), x)) True sage: diff(acot(x), x) -1/(x^2 + 1) We can delay evaluation using the ``hold`` parameter:: sage: arccot(1,hold=True) arccot(1) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = arccot(1,hold=True); a.simplify() 1/4*pi TESTS: Test complex input:: sage: arccot(x)._sympy_() acot(x) sage: arccot(complex(1,1)) # rel tol 1e-15 (0.5535743588970452-0.4023594781085251j) sage: arccot(1.+I) 0.553574358897045 - 0.402359478108525*I """ GinacFunction.__init__(self, 'arccot', latex_name=r"\operatorname{arccot}", conversions=dict(maxima='acot', sympy='acot', fricas='acot', giac='acot'))
def __init__(self): r""" 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 :meth:`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) """ GinacFunction.__init__(self, "arctanh", latex_name=r"{\rm arctanh}", conversions=dict(maxima='atanh', sympy='atanh'))
def __init__(self): """ The arccosine function. EXAMPLES:: sage: arccos(0.5) 1.04719755119660 sage: arccos(1/2) 1/3*pi sage: arccos(1 + 1.0*I) 0.904556894302381 - 1.06127506190504*I sage: arccos(3/4).n(100) 0.72273424781341561117837735264 We can delay evaluation using the ``hold`` parameter:: sage: arccos(0,hold=True) arccos(0) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = arccos(0,hold=True); a.simplify() 1/2*pi ``conjugate(arccos(x))==arccos(conjugate(x))``, unless on the branch cuts, which run along the real axis outside the interval [-1, +1].:: sage: conjugate(arccos(x)) conjugate(arccos(x)) sage: var('y', domain='positive') y sage: conjugate(arccos(y)) conjugate(arccos(y)) sage: conjugate(arccos(y+I)) conjugate(arccos(y + I)) sage: conjugate(arccos(1/16)) arccos(1/16) sage: conjugate(arccos(2)) conjugate(arccos(2)) sage: conjugate(arccos(-2)) pi - conjugate(arccos(2)) TESTS:: sage: arccos(x).operator() arccos """ GinacFunction.__init__(self, 'arccos', latex_name=r"\arccos", conversions=dict(maxima='acos', sympy='acos'))
def __init__(self): r""" The secant function. EXAMPLES:: sage: sec(pi/4) sqrt(2) sage: sec(x).subs(x==pi/4) sqrt(2) sage: sec(pi/7) sec(1/7*pi) sage: sec(x) sec(x) sage: RR(sec(pi/4)) 1.41421356237310 sage: n(sec(pi/4),100) 1.4142135623730950488016887242 sage: float(sec(pi/4)) 1.4142135623730951 sage: sec(1/2) sec(1/2) sage: sec(0.5) 1.13949392732455 sage: bool(diff(sec(x), x) == diff(1/cos(x), x)) True sage: diff(sec(x), x) sec(x)*tan(x) sage: latex(sec(x)) \sec\left(x\right) We can prevent evaluation using the ``hold`` parameter:: sage: sec(pi/4,hold=True) sec(1/4*pi) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = sec(pi/4,hold=True); a.simplify() sqrt(2) TESTS: Test complex input:: sage: sec(complex(1,1)) # rel tol 1e-15 (0.49833703055518686+0.5910838417210451j) """ GinacFunction.__init__(self, "sec", latex_name=r"\sec")
def __init__(self): r""" The digamma function, `\psi(x)`, is the logarithmic derivative of the gamma function. .. MATH:: \psi(x) = \frac{d}{dx} \log(\Gamma(x)) = \frac{\Gamma'(x)}{\Gamma(x)} EXAMPLES:: sage: from sage.functions.gamma import psi1 sage: psi1(x) psi(x) sage: psi1(x).derivative(x) psi(1, x) :: sage: psi1(3) -euler_gamma + 3/2 :: sage: psi(.5) -1.96351002602142 sage: psi(RealField(100)(.5)) -1.9635100260214234794409763330 TESTS:: sage: latex(psi1(x)) \psi\left(x\right) sage: loads(dumps(psi1(x)+1)) psi(x) + 1 sage: t = psi1(x); t psi(x) sage: t.subs(x=.2) -5.28903989659219 sage: psi(x)._sympy_() polygamma(0, x) """ GinacFunction.__init__(self, "psi", nargs=1, latex_name=r'\psi', conversions=dict(mathematica='PolyGamma', maxima='psi[0]', sympy='digamma'))
def __init__(self): r""" Stieltjes constant of index ``n``. ``stieltjes(0)`` is identical to the Euler-Mascheroni constant (:class:`sage.symbolic.constants.EulerGamma`). The Stieltjes constants are used in the series expansions of `\zeta(s)`. INPUT: - ``n`` - non-negative integer EXAMPLES:: sage: _ = var('n') sage: stieltjes(n) stieltjes(n) sage: stieltjes(0) euler_gamma sage: stieltjes(2) stieltjes(2) sage: stieltjes(int(2)) stieltjes(2) sage: stieltjes(2).n(100) -0.0096903631928723184845303860352 sage: RR = RealField(200) sage: stieltjes(RR(2)) -0.0096903631928723184845303860352125293590658061013407498807014 It is possible to use the ``hold`` argument to prevent automatic evaluation:: sage: stieltjes(0,hold=True) stieltjes(0) sage: latex(stieltjes(n)) \gamma_{n} sage: a = loads(dumps(stieltjes(n))) sage: a.operator() == stieltjes True sage: stieltjes(x)._sympy_() stieltjes(x) sage: stieltjes(x).subs(x==0) euler_gamma """ GinacFunction.__init__(self, "stieltjes", nargs=1, conversions=dict(mathematica='StieltjesGamma', sympy='stieltjes'), latex_name=r'\gamma')
def __init__(self): """ The cosine function. EXAMPLES:: sage: cos(pi) -1 sage: cos(x).subs(x==pi) -1 sage: cos(2).n(100) -0.41614683654714238699756822950 sage: loads(dumps(cos)) cos sage: cos(x)._sympy_() cos(x) We can prevent evaluation using the ``hold`` parameter:: sage: cos(0,hold=True) cos(0) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = cos(0,hold=True); a.simplify() 1 TESTS:: sage: conjugate(cos(x)) cos(conjugate(x)) sage: cos(complex(1,1)) # rel tol 1e-15 (0.8337300251311491-0.9888977057628651j) Check that :trac:`20752` is fixed:: sage: cos(3*pi+41/42*pi) cos(1/42*pi) sage: cos(-5*pi+1/42*pi) -cos(1/42*pi) sage: cos(pi-1/42*pi) -cos(1/42*pi) """ GinacFunction.__init__(self, 'cos', latex_name=r"\cos", conversions=dict(maxima='cos', mathematica='Cos'))
def __init__(self): """ TESTS:: sage: loads(dumps(ln)) log sage: maxima(ln(x))._sage_() log(x) """ GinacFunction.__init__(self, 'log', latex_name=r'\log', conversions=dict(maxima='log', fricas='log', mathematica='Log'))
def __init__(self): """ The arcsecant function. EXAMPLES:: sage: arcsec(2) arcsec(2) sage: arcsec(2.0) 1.04719755119660 sage: arcsec(2).n(100) 1.0471975511965977461542144611 sage: arcsec(1/2).n(100) 1.3169578969248167086250463473*I sage: RDF(arcsec(2)) # abs tol 1e-15 1.0471975511965976 sage: arcsec(1 + I) arcsec(I + 1) sage: diff(asec(x), x) 1/(sqrt(x^2 - 1)*x) sage: arcsec(x)._sympy_() asec(x) We can delay evaluation using the ``hold`` parameter:: sage: arcsec(1,hold=True) arcsec(1) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = arcsec(1,hold=True); a.simplify() 0 TESTS: Test complex input:: sage: arcsec(complex(1,1)) # rel tol 1e-15 (1.118517879643706+0.5306375309525178j) """ GinacFunction.__init__(self, 'arcsec', latex_name=r"\operatorname{arcsec}", conversions=dict(maxima='asec', sympy='asec', fricas='asec', giac='asec'))
def __init__(self): r""" Derivatives of the digamma function `\psi(x)`. T EXAMPLES:: sage: from sage.functions.other import psi2 sage: psi2(2, x) psi(2, x) sage: psi2(2, x).derivative(x) psi(3, x) sage: n = var('n') sage: psi2(n, x).derivative(x) psi(n + 1, x) :: sage: psi2(0, x) psi(x) sage: psi2(-1, x) log(gamma(x)) sage: psi2(3, 1) 1/15*pi^4 :: sage: psi2(2, .5).n() -16.8287966442343 sage: psi2(2, .5).n(100) -16.828796644234319995596334261 Tests:: sage: psi2(n, x).derivative(n) Traceback (most recent call last): ... RuntimeError: cannot diff psi(n,x) with respect to n sage: latex(psi2(2,x)) \psi\left(2, x\right) sage: loads(dumps(psi2(2,x)+1)) psi(2, x) + 1 """ GinacFunction.__init__(self, "psi", nargs=2, latex_name='\psi', conversions=dict(mathematica='PolyGamma'))
def __init__(self): r""" Returns the real part of the (possibly complex) input. It is possible to prevent automatic evaluation using the ``hold`` parameter:: sage: real_part(I,hold=True) real_part(I) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: real_part(I,hold=True).simplify() 0 EXAMPLES:: sage: z = 1+2*I sage: real(z) 1 sage: real(5/3) 5/3 sage: a = 2.5 sage: real(a) 2.50000000000000 sage: type(real(a)) <type 'sage.rings.real_mpfr.RealLiteral'> sage: real(1.0r) 1.0 TESTS:: sage: loads(dumps(real_part)) real_part Check if #6401 is fixed:: sage: latex(x.real()) \Re \left( x \right) sage: f(x) = function('f',x) sage: latex( f(x).real()) \Re \left( f\left(x\right) \right) """ GinacFunction.__init__(self, "real_part", conversions=dict(maxima='realpart'))
def __init__(self): r""" 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: bool(diff(acoth(x), x) == diff(atanh(x), x)) True sage: diff(acoth(x), x) -1/(x^2 - 1) Using first the `.n(53)` method is slightly more precise than converting directly to a ``float``:: sage: float(arccoth(2)) # abs tol 1e-16 0.5493061443340548 sage: float(arccoth(2).n(53)) # Correct result to 53 bits 0.5493061443340549 sage: float(arccoth(2).n(100)) # Compute 100 bits and then round to 53 0.5493061443340549 TESTS:: sage: latex(arccoth(x)) \operatorname{arccoth}\left(x\right) sage: acoth(x)._sympy_() acoth(x) Check if :trac:`23636` is fixed:: sage: arccoth(float(1.1)) 1.5222612188617113 """ GinacFunction.__init__(self, "arccoth", latex_name=r"\operatorname{arccoth}", conversions=dict(maxima='acoth', sympy='acoth', fricas='acoth'))
def __init__(self): """ The arccosecant function. EXAMPLES:: sage: arccsc(2) arccsc(2) sage: RDF(arccsc(2)) # rel tol 1e-15 0.5235987755982988 sage: arccsc(2).n(100) 0.52359877559829887307710723055 sage: float(arccsc(2)) 0.52359877559829... sage: arccsc(1 + I) arccsc(I + 1) sage: diff(acsc(x), x) -1/(sqrt(x^2 - 1)*x) sage: arccsc(x)._sympy_() acsc(x) We can delay evaluation using the ``hold`` parameter:: sage: arccsc(1,hold=True) arccsc(1) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = arccsc(1,hold=True); a.simplify() 1/2*pi TESTS: Test complex input:: sage: arccsc(complex(1,1)) # rel tol 1e-15 (0.45227844715119064-0.5306375309525178j) """ GinacFunction.__init__(self, 'arccsc', latex_name=r"\operatorname{arccsc}", conversions=dict(maxima='acsc', sympy='acsc', fricas='acsc', giac='acsc'))
def __init__(self): r""" 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)) 0.997524731976 - 0.002790687681*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 :meth:`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) """ GinacFunction.__init__(self, "tanh", latex_name=r"\tanh")
def __init__(self): """ The tangent function. EXAMPLES:: sage: tan(pi) 0 sage: tan(3.1415) -0.0000926535900581913 sage: tan(3.1415/4) 0.999953674278156 sage: tan(pi/4) 1 sage: tan(1/2) tan(1/2) sage: RR(tan(1/2)) 0.546302489843790 We can prevent evaluation using the ``hold`` parameter:: sage: tan(pi/4,hold=True) tan(1/4*pi) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = tan(pi/4,hold=True); a.simplify() 1 TESTS:: sage: tan(x)._sympy_() tan(x) sage: conjugate(tan(x)) tan(conjugate(x)) sage: tan(complex(1,1)) # rel tol 1e-15 (0.2717525853195118+1.0839233273386946j) Check that :trac:`19791` is fixed:: sage: tan(2+I).imag().n() 1.16673625724092 """ GinacFunction.__init__(self, 'tan', latex_name=r"\tan")
def __init__(self): r""" 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: sech(0) 1 sage: sech(pi*I) -1 sage: sech(pi*I/2) Infinity sage: sech(7*pi*I/2) Infinity sage: sech(8*pi*I/2) 1 sage: sech(8.*pi*I/2) sec(4.00000000000000*pi) sage: bool(diff(sech(x), x) == diff(1/cosh(x), x)) True sage: diff(sech(x), x) -sech(x)*tanh(x) sage: latex(sech(x)) \operatorname{sech}\left(x\right) sage: sech(x)._sympy_() sech(x) """ GinacFunction.__init__( self, "sech", latex_name=r"\operatorname{sech}", )
def __init__(self): r""" The digamma function, `\psi(x)`, is the logarithmic derivative of the gamma function. `\psi(x) = \frac{d}{dx} \log(\Gamma(x)) = \frac{\Gamma'(x)}{\Gamma(x)}` EXAMPLES:: sage: from sage.functions.other import psi1 sage: psi1(x) psi(x) sage: psi1(x).derivative(x) psi(1, x) :: sage: psi1(3) -euler_gamma + 3/2 :: sage: psi(.5) -1.96351002602142 sage: psi(RealField(100)(.5)) -1.9635100260214234794409763330 Tests:: sage: latex(psi1(x)) \psi\left(x\right) sage: loads(dumps(psi1(x)+1)) psi(x) + 1 """ GinacFunction.__init__(self, "psi", nargs=1, latex_name='\psi', conversions=dict(maxima='psi[0]', mathematica='PolyGamma'))
def __init__(self): """ The sine function. EXAMPLES:: sage: sin(0) 0 sage: sin(x).subs(x==0) 0 sage: sin(2).n(100) 0.90929742682568169539601986591 sage: loads(dumps(sin)) sin We can prevent evaluation using the ``hold`` parameter:: sage: sin(0,hold=True) sin(0) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = sin(0,hold=True); a.simplify() 0 TESTS:: sage: conjugate(sin(x)) sin(conjugate(x)) sage: sin(complex(1,1)) # rel tol 1e-15 (1.2984575814159773+0.6349639147847361j) """ GinacFunction.__init__(self, "sin", latex_name=r"\sin", conversions=dict(maxima='sin', mathematica='Sin'))
def __init__(self): r""" The hyperbolic cotangent function. EXAMPLES:: sage: coth(pi) coth(pi) sage: coth(0) Infinity sage: coth(pi*I) Infinity sage: coth(pi*I/2) 0 sage: coth(7*pi*I/2) 0 sage: coth(8*pi*I/2) Infinity sage: coth(7.*pi*I/2) -I*cot(3.50000000000000*pi) sage: coth(3.1415) 1.00374256795520 sage: float(coth(pi)) 1.0037418731973213 sage: RR(coth(pi)) 1.00374187319732 sage: coth(complex(1, 2)) # abs tol 1e-15 (0.8213297974938518+0.17138361290918508j) sage: bool(diff(coth(x), x) == diff(1/tanh(x), x)) True sage: diff(coth(x), x) -1/sinh(x)^2 sage: latex(coth(x)) \coth\left(x\right) sage: coth(x)._sympy_() coth(x) """ GinacFunction.__init__(self, "coth", latex_name=r"\coth")
def __init__(self): r""" Returns the imaginary part of the (possibly complex) input. It is possible to prevent automatic evaluation using the ``hold`` parameter:: sage: imag_part(I,hold=True) imag_part(I) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: imag_part(I,hold=True).simplify() 1 TESTS:: sage: z = 1+2*I sage: imaginary(z) 2 sage: imag(z) 2 sage: loads(dumps(imag_part)) imag_part Check if #6401 is fixed:: sage: latex(x.imag()) \Im \left( x \right) sage: f(x) = function('f',x) sage: latex( f(x).imag()) \Im \left( f\left(x\right) \right) """ GinacFunction.__init__(self, "imag_part", conversions=dict(maxima='imagpart'))
def __init__(self): r""" The inverse of the hyperbolic cosecant function. EXAMPLES:: sage: acsch(2.0) 0.481211825059603 sage: acsch(2) arccsch(2) sage: acsch(1 + I*1.0) 0.530637530952518 - 0.452278447151191*I sage: acsch(1).n(200) 0.88137358701954302523260932497979230902816032826163541075330 sage: float(acsch(1)) 0.881373587019543 sage: diff(acsch(x), x) -1/(sqrt(x^2 + 1)*x) sage: latex(acsch(x)) \operatorname{arcsch}\left(x\right) TESTS: Check if :trac:`20818` is fixed:: sage: acsch(float(0.1)) 2.99822295029797 sage: acsch(x)._sympy_() acsch(x) """ GinacFunction.__init__(self, "arccsch", latex_name=r"\operatorname{arcsch}", conversions=dict(maxima='acsch', sympy='acsch', fricas='acsch'))
def __init__(self): """ The cosine function. EXAMPLES:: sage: cos(pi) -1 sage: cos(x).subs(x==pi) -1 sage: cos(2).n(100) -0.41614683654714238699756822950 sage: loads(dumps(cos)) cos We can prevent evaluation using the ``hold`` parameter:: sage: cos(0,hold=True) cos(0) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = cos(0,hold=True); a.simplify() 1 TESTS:: sage: conjugate(cos(x)) cos(conjugate(x)) """ GinacFunction.__init__(self, "cos", latex_name=r"\cos", conversions=dict(maxima='cos', mathematica='Cos'))
def __init__(self): r""" Derivatives of the Riemann zeta function. EXAMPLES:: sage: zetaderiv(1, x) zetaderiv(1, x) sage: zetaderiv(1, x).diff(x) zetaderiv(2, x) sage: var('n') n sage: zetaderiv(n,x) zetaderiv(n, x) TESTS:: sage: latex(zetaderiv(2,x)) \zeta^\prime\left(2, x\right) sage: a = loads(dumps(zetaderiv(2,x))) sage: a.operator() == zetaderiv True """ GinacFunction.__init__(self, "zetaderiv", nargs=2)
def __init__(self): """ The tangent function. EXAMPLES:: sage: tan(pi) 0 sage: tan(3.1415) -0.0000926535900581913 sage: tan(3.1415/4) 0.999953674278156 sage: tan(pi/4) 1 sage: tan(1/2) tan(1/2) sage: RR(tan(1/2)) 0.546302489843790 We can prevent evaluation using the ``hold`` parameter:: sage: tan(pi/4,hold=True) tan(1/4*pi) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = tan(pi/4,hold=True); a.simplify() 1 TESTS:: sage: conjugate(tan(x)) tan(conjugate(x)) """ GinacFunction.__init__(self, "tan", latex_name=r"\tan")
def __init__(self): r""" The modified arctangent function. Returns the arc tangent (measured in radians) of `y/x`, where unlike ``arctan(y/x)``, the signs of both ``x`` and ``y`` are considered. In particular, this function measures the angle of a ray through the origin and `(x,y)`, with the positive `x`-axis the zero mark, and with output angle `\theta` being between `-\pi<\theta<=\pi`. Hence, ``arctan2(y,x) = arctan(y/x)`` only for `x>0`. One may consider the usual arctan to measure angles of lines through the origin, while the modified function measures rays through the origin. Note that the `y`-coordinate is by convention the first input. EXAMPLES: Note the difference between the two functions:: sage: arctan2(1,-1) 3/4*pi sage: arctan(1/-1) -1/4*pi This is consistent with Python and Maxima:: sage: maxima.atan2(1,-1) (3*%pi)/4 sage: math.atan2(1,-1) 2.356194490192345 More examples:: sage: arctan2(1,0) 1/2*pi sage: arctan2(2,3) arctan(2/3) sage: arctan2(-1,-1) -3/4*pi Of course we can approximate as well:: sage: arctan2(-1/2,1).n(100) -0.46364760900080611621425623146 sage: arctan2(2,3).n(100) 0.58800260354756755124561108063 We can delay evaluation using the ``hold`` parameter:: sage: arctan2(-1/2,1,hold=True) arctan2(-1/2, 1) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: arctan2(-1/2,1,hold=True).simplify() -arctan(1/2) The function also works with numpy arrays as input:: sage: import numpy sage: a = numpy.linspace(1, 3, 3) sage: b = numpy.linspace(3, 6, 3) sage: atan2(a, b) array([ 0.32175055, 0.41822433, 0.46364761]) sage: atan2(1,a) array([ 0.78539816, 0.46364761, 0.32175055]) sage: atan2(a, 1) array([ 0.78539816, 1.10714872, 1.24904577]) TESTS:: sage: x,y = var('x,y') sage: arctan2(y,x).operator() arctan2 Check if :trac:`8565` is fixed:: sage: atan2(-pi,0) -1/2*pi Check if :trac:`8564` is fixed:: sage: arctan2(x,x)._sympy_() atan2(x, x) Check if numerical evaluation works :trac:`9913`:: sage: arctan2(0, -log(2)).n() 3.14159265358979 Check that atan2(0,0) returns NaN :trac:`21614`:: sage: atan2(0,0) NaN sage: atan2(0,0).n() NaN sage: atan2(0,0,hold=True) arctan2(0, 0) sage: atan2(0,0,hold=True).n() Traceback (most recent call last): ... RuntimeError: atan2(): division by zero Check if :trac:`10062` is fixed, this was caused by ``(I*I).is_positive()`` returning ``True``:: sage: arctan2(0, I*I) pi """ GinacFunction.__init__(self, 'arctan2', nargs=2, latex_name=r"\arctan", conversions=dict(maxima='atan2', sympy='atan2'))
def __init__(self): r""" The sine function. EXAMPLES:: sage: sin(0) 0 sage: sin(x).subs(x==0) 0 sage: sin(2).n(100) 0.90929742682568169539601986591 sage: loads(dumps(sin)) sin sage: sin(x)._sympy_() sin(x) We can prevent evaluation using the ``hold`` parameter:: sage: sin(0,hold=True) sin(0) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = sin(0,hold=True); a.simplify() 0 If possible, the argument is also reduced modulo the period length `2\pi`, and well-known identities are directly evaluated:: sage: k = var('k', domain='integer') sage: sin(1 + 2*k*pi) sin(1) sage: sin(k*pi) 0 TESTS:: sage: conjugate(sin(x)) sin(conjugate(x)) sage: sin(complex(1,1)) # rel tol 1e-15 (1.2984575814159773+0.6349639147847361j) sage: sin(pi/5) 1/4*sqrt(-2*sqrt(5) + 10) sage: sin(pi/8) 1/2*sqrt(-sqrt(2) + 2) sage: sin(pi/24) 1/4*sqrt(-2*sqrt(6) - 2*sqrt(2) + 8) sage: sin(pi/30) -1/8*sqrt(5) + 1/4*sqrt(-3/2*sqrt(5) + 15/2) - 1/8 sage: sin(104*pi/105) sin(1/105*pi) sage: cos(pi/8) 1/2*sqrt(sqrt(2) + 2) sage: cos(pi/10) 1/4*sqrt(2*sqrt(5) + 10) sage: cos(pi/12) 1/4*sqrt(6) + 1/4*sqrt(2) sage: cos(pi/15) 1/8*sqrt(5) + 1/4*sqrt(3/2*sqrt(5) + 15/2) - 1/8 sage: cos(pi/24) 1/4*sqrt(2*sqrt(6) + 2*sqrt(2) + 8) sage: cos(104*pi/105) -cos(1/105*pi) sage: tan(pi/5) sqrt(-2*sqrt(5) + 5) sage: tan(pi/8) sqrt(2) - 1 sage: tan(pi/10) 1/5*sqrt(-10*sqrt(5) + 25) sage: tan(pi/16) -sqrt(2) + sqrt(2*sqrt(2) + 4) - 1 sage: tan(pi/20) sqrt(5) - sqrt(2*sqrt(5) + 5) + 1 sage: tan(pi/24) sqrt(6) - sqrt(3) + sqrt(2) - 2 sage: tan(104*pi/105) -tan(1/105*pi) sage: cot(104*pi/105) -cot(1/105*pi) sage: sec(104*pi/105) -sec(1/105*pi) sage: csc(104*pi/105) csc(1/105*pi) sage: all(sin(rat*pi).n(200)-sin(rat*pi,hold=True).n(200) < 1e-30 for rat in [1/5,2/5,1/30,7/30,11/30,13/30,1/8,3/8,1/24,5/24,7/24,11/24]) True sage: all(cos(rat*pi).n(200)-cos(rat*pi,hold=True).n(200) < 1e-30 for rat in [1/10,3/10,1/12,5/12,1/15,2/15,4/15,7/15,1/8,3/8,1/24,5/24,11/24]) True sage: all(tan(rat*pi).n(200)-tan(rat*pi,hold=True).n(200) < 1e-30 for rat in [1/5,2/5,1/10,3/10,1/20,3/20,7/20,9/20,1/8,3/8,1/16,3/16,5/16,7/16,1/24,5/24,7/24,11/24]) True Check that :trac:`20456` is fixed:: sage: assume(x>0) sage: sin(pi*x) sin(pi*x) sage: forget() Check that :trac:`20752` is fixed:: sage: sin(3*pi+41/42*pi) -sin(1/42*pi) sage: sin(-5*pi+1/42*pi) -sin(1/42*pi) sage: sin(pi-1/42*pi) sin(1/42*pi) """ GinacFunction.__init__(self, 'sin', latex_name=r"\sin", conversions=dict(maxima='sin', mathematica='Sin', giac='sin'))
def __init__(self): """ The arctangent function. EXAMPLES:: sage: arctan(1/2) arctan(1/2) sage: RDF(arctan(1/2)) # rel tol 1e-15 0.46364760900080615 sage: arctan(1 + I) arctan(I + 1) sage: arctan(1/2).n(100) 0.46364760900080611621425623146 We can delay evaluation using the ``hold`` parameter:: sage: arctan(0,hold=True) arctan(0) To then evaluate again, we currently must use Maxima via :meth:`sage.symbolic.expression.Expression.simplify`:: sage: a = arctan(0,hold=True); a.simplify() 0 ``conjugate(arctan(x))==arctan(conjugate(x))``, unless on the branch cuts which run along the imaginary axis outside the interval [-I, +I].:: sage: conjugate(arctan(x)) conjugate(arctan(x)) sage: var('y', domain='positive') y sage: conjugate(arctan(y)) arctan(y) sage: conjugate(arctan(y+I)) conjugate(arctan(y + I)) sage: conjugate(arctan(1/16)) arctan(1/16) sage: conjugate(arctan(-2*I)) conjugate(arctan(-2*I)) sage: conjugate(arctan(2*I)) conjugate(arctan(2*I)) sage: conjugate(arctan(I/2)) arctan(-1/2*I) TESTS:: sage: arctan(x)._sympy_() atan(x) sage: arctan(x).operator() arctan sage: atan(complex(1,1)) (1.0172219678978514+0.4023594781085251j) Check that :trac:`19918` is fixed:: sage: arctan(-x).subs(x=oo) -1/2*pi sage: arctan(-x).subs(x=-oo) 1/2*pi """ GinacFunction.__init__(self, 'arctan', latex_name=r"\arctan", conversions=dict(maxima='atan', sympy='atan', fricas='atan', giac='atan'))