def __init__(self): r""" Symbolic `\min` function. The Python builtin `\min` function doesn't work as expected when symbolic expressions are given as arguments. This function delays evaluation until all symbolic arguments are substituted with values. EXAMPLES:: sage: min_symbolic(3, x) min(3, x) sage: min_symbolic(3, x).subs(x=5) 3 sage: min_symbolic(3, 5, x) min(x, 3) sage: min_symbolic([3, 5, x]) min(x, 3) TESTS:: sage: loads(dumps(min_symbolic(x, 5))) min(x, 5) sage: latex(min_symbolic(x, 5)) \min\left(x, 5\right) sage: min_symbolic(x, 5)._sympy_() Min(5, x) """ BuiltinFunction.__init__(self, 'min', nargs=0, latex_name=r"\min", conversions=dict(sympy='Min'))
def __init__(self): r""" Symbolic `max` function. The Python builtin `max` function doesn't work as expected when symbolic expressions are given as arguments. This function delays evaluation until all symbolic arguments are substituted with values. EXAMPLES:: sage: max_symbolic(3, x) max(3, x) sage: max_symbolic(3, x).subs(x=5) 5 sage: max_symbolic(3, 5, x) max(x, 5) sage: max_symbolic([3,5,x]) max(x, 5) TESTS:: sage: loads(dumps(max_symbolic(x,5))) max(x, 5) sage: latex(max_symbolic(x,5)) \max\left(x, 5\right) """ BuiltinFunction.__init__(self, 'max', nargs=0, latex_name="\max")
def __init__(self): """ The arcsecant function. EXAMPLES:: sage: arcsec(2) arcsec(2) sage: arcsec(2.0) 1.04719755119660 sage: RDF(arcsec(2)) # abs tol 1e-15 1.0471975511965976 sage: arcsec(1 + I) arcsec(I + 1) 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 """ BuiltinFunction.__init__(self, "arcsec", latex_name=r'{\rm arcsec}', conversions=dict(maxima='asec'))
def __init__(self): """ Initialize class. EXAMPLES:: sage: maxima(hypergeometric) hypergeometric TESTS:: sage: F = hypergeometric([-4,2],[1],1) # optional - maple sage: G = maple(F); G # optional - maple hypergeom([-4, 2],[1],1) sage: G.simplify() # optional - maple 0 """ BuiltinFunction.__init__(self, 'hypergeometric', nargs=3, conversions={ 'mathematica': 'HypergeometricPFQ', 'maxima': 'hypergeometric', 'maple': 'hypergeom', 'sympy': 'hyper', 'fricas': 'hypergeometricF' })
def __init__(self): """ Class to represent an indefinite integral. EXAMPLES:: sage: from sage.symbolic.integration.integral import indefinite_integral sage: indefinite_integral(log(x), x) #indirect doctest x*log(x) - x sage: indefinite_integral(x^2, x) 1/3*x^3 sage: indefinite_integral(4*x*log(x), x) 2*x^2*log(x) - x^2 sage: indefinite_integral(exp(x), 2*x) 2*e^x """ # The automatic evaluation routine will try these integrators # in the given order. This is an attribute of the class instead of # a global variable in this module to enable customization by # creating a subclasses which define a different set of integrators self.integrators = [external.maxima_integrator] BuiltinFunction.__init__(self, "integrate", nargs=2, conversions={'sympy': 'Integral', 'giac': 'integrate'})
def __init__(self): """ The arcsecant function. EXAMPLES:: sage: arcsec(2) arcsec(2) sage: RDF(arcsec(2)) 1.0471975512 sage: arcsec(1 + I) arcsec(I + 1) 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 """ BuiltinFunction.__init__(self, "arcsec", latex_name=r'{\rm arcsec}', conversions=dict(maxima='asec'))
def __init__(self): """ The arccotangent function. EXAMPLES:: sage: arccot(1/2) arccot(1/2) sage: RDF(arccot(1/2)) 1.10714871779 sage: arccot(1 + I) arccot(I + 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 """ BuiltinFunction.__init__(self, "arccot", latex_name=r'{\rm arccot}', conversions=dict(maxima='acot', sympy='acot'))
def __init__(self): r""" The cosecant function. EXAMPLES:: sage: csc(pi/4) sqrt(2) sage: RR(csc(pi/4)) 1.41421356237310 sage: n(csc(pi/4),100) 1.4142135623730950488016887242 sage: csc(1/2) csc(1/2) sage: csc(0.5) 2.08582964293349 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) """ BuiltinFunction.__init__(self, "csc", latex_name=r"\csc")
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 """ BuiltinFunction.__init__(self, "cot", latex_name=r"\cot")
def __init__(self): r""" The Dirac delta (generalized) function, ``dirac_delta(x)``. INPUT: - ``x`` - a real number or a symbolic expression EXAMPLES:: sage: dirac_delta(1) 0 sage: dirac_delta(0) dirac_delta(0) sage: dirac_delta(x) dirac_delta(x) sage: latex(dirac_delta(x)) \delta\left(x\right) sage: loads(dumps(dirac_delta(x))) dirac_delta(x) sage: dirac_delta(x)._sympy_() DiracDelta(x) """ BuiltinFunction.__init__(self, "dirac_delta", latex_name=r"\delta", conversions=dict(maxima='delta', mathematica='DiracDelta', sympy='DiracDelta'))
def __init__(self, name, latex_name=None, conversions=None, evalf_float=None): """ Note that subclasses of HyperbolicFunction should be instantiated only once, since they inherit from BuiltinFunction which only uses the name and class to check if a function was already registered. EXAMPLES:: sage: from sage.functions.hyperbolic import HyperbolicFunction sage: class Barh(HyperbolicFunction): ....: def __init__(self): ....: HyperbolicFunction.__init__(self, 'barh') sage: barh = Barh() sage: barh(x) barh(x) """ self._evalf_float = evalf_float BuiltinFunction.__init__(self, name, latex_name=latex_name, conversions=conversions)
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 """ BuiltinFunction.__init__(self, "unit_step", latex_name=r"\mathrm{u}", conversions=dict(mathematica='UnitStep'))
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) """ BuiltinFunction.__init__(self, "heaviside", latex_name="H", conversions=dict(maxima='hstep', mathematica='HeavisideTheta', sympy='Heaviside'))
def __init__(self): """ Class to represent an indefinite integral. EXAMPLES:: sage: from sage.symbolic.integration.integral import indefinite_integral sage: indefinite_integral(log(x), x) #indirect doctest x*log(x) - x sage: indefinite_integral(x^2, x) 1/3*x^3 sage: indefinite_integral(4*x*log(x), x) 2*x^2*log(x) - x^2 sage: indefinite_integral(exp(x), 2*x) 2*e^x """ # The automatic evaluation routine will try these integrators # in the given order. This is an attribute of the class instead of # a global variable in this module to enable customization by # creating a subclasses which define a different set of integrators self.integrators = [external.maxima_integrator] BuiltinFunction.__init__(self, "integrate", nargs=2, conversions={'sympy': 'Integral'})
def __init__(self): """ The arccosecant function. EXAMPLES:: sage: arccsc(2) arccsc(2) sage: RDF(arccsc(2)) 0.523598775598 sage: arccsc(1 + I) arccsc(I + 1) 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 """ BuiltinFunction.__init__(self, "arccsc", latex_name=r'{\rm arccsc}', conversions=dict(maxima='acsc'))
def __init__(self): r""" Initialize ``self``. EXAMPLES:: sage: erfinv(2)._sympy_() erfinv(2) sage: maxima(erfinv(2)) inverse_erf(2) TESTS: Check that :trac:`11349` is fixed:: sage: _ = var('z,t') sage: PDF = exp(-x^2 /2)/sqrt(2*pi) sage: integralExpr = integrate(PDF,x,z,oo).subs(z==log(t)) sage: y = solve(integralExpr==z,t)[0].rhs().subs(z==1/4) sage: y e^(sqrt(2)*erfinv(1/2)) sage: y.n() 1.96303108415826 """ BuiltinFunction.__init__(self, "erfinv", latex_name=r"\operatorname{erfinv}", conversions=dict(sympy='erfinv', maxima='inverse_erf'))
def __init__(self): r""" Symbolic `\max` function. The Python builtin `\max` function doesn't work as expected when symbolic expressions are given as arguments. This function delays evaluation until all symbolic arguments are substituted with values. EXAMPLES:: sage: max_symbolic(3, x) max(3, x) sage: max_symbolic(3, x).subs(x=5) 5 sage: max_symbolic(3, 5, x) max(x, 5) sage: max_symbolic([3,5,x]) max(x, 5) TESTS:: sage: loads(dumps(max_symbolic(x,5))) max(x, 5) sage: latex(max_symbolic(x,5)) \max\left(x, 5\right) """ BuiltinFunction.__init__(self, 'max', nargs=0, latex_name="\max")
def __init__(self): r""" The generalized derivative of the Airy Ai function INPUT: - ``alpha`` -- Return the `\alpha`-th order fractional derivative with respect to `z`. For `\alpha = n = 1,2,3,\ldots` this gives the derivative `\operatorname{Ai}^{(n)}(z)`, and for `\alpha = -n = -1,-2,-3,\ldots` this gives the `n`-fold iterated integral. .. MATH:: f_0(z) = \operatorname{Ai}(z) f_n(z) = \int_0^z f_{n-1}(t) dt - ``x`` -- The argument of the function EXAMPLES:: sage: from sage.functions.airy import airy_ai_general sage: x, n = var('x n') sage: airy_ai_general(-2, x) airy_ai(-2, x) sage: derivative(airy_ai_general(-2, x), x) airy_ai(-1, x) sage: airy_ai_general(n, x) airy_ai(n, x) sage: derivative(airy_ai_general(n, x), x) airy_ai(n + 1, x) """ BuiltinFunction.__init__(self, "airy_ai", nargs=2, latex_name=r"\operatorname{Ai}")
def __init__(self): """ Return the value of the complex exponential integral Ei(z) at a complex number z. EXAMPLES:: sage: Ei(10) Ei(10) sage: Ei(I) Ei(I) sage: Ei(3+I) Ei(I + 3) sage: Ei(1.3) 2.72139888023202 The branch cut for this function is along the negative real axis:: sage: Ei(-3 + 0.1*I) -0.0129379427181693 + 3.13993830250942*I sage: Ei(-3 - 0.1*I) -0.0129379427181693 - 3.13993830250942*I ALGORITHM: Uses mpmath. """ BuiltinFunction.__init__(self, "Ei", conversions=dict(maxima='expintegral_ei'))
def __init__(self): r""" Symbolic `\min` function. The Python builtin `\min` function doesn't work as expected when symbolic expressions are given as arguments. This function delays evaluation until all symbolic arguments are substituted with values. EXAMPLES:: sage: min_symbolic(3, x) min(3, x) sage: min_symbolic(3, x).subs(x=5) 3 sage: min_symbolic(3, 5, x) min(x, 3) sage: min_symbolic([3,5,x]) min(x, 3) TESTS:: sage: loads(dumps(min_symbolic(x,5))) min(x, 5) sage: latex(min_symbolic(x,5)) \min\left(x, 5\right) sage: min_symbolic(x, 5)._sympy_() Min(5, x) """ BuiltinFunction.__init__(self, 'min', nargs=0, latex_name="\min", conversions=dict(sympy='Min'))
def __init__(self): """ The symbolic function representing a definite integral. EXAMPLES:: sage: from sage.symbolic.integration.integral import definite_integral sage: definite_integral(sin(x),x,0,pi) 2 """ # The automatic evaluation routine will try these integrators # in the given order. This is an attribute of the class instead of # a global variable in this module to enable customization by # creating a subclasses which define a different set of integrators self.integrators = [ external.maxima_integrator, external.giac_integrator, external.sympy_integrator ] BuiltinFunction.__init__(self, "integrate", nargs=4, conversions={ 'sympy': 'Integral', 'giac': 'integrate' })
def __init__(self): r""" The incomplete gamma function. EXAMPLES:: sage: gamma_inc(CDF(0,1), 3) 0.00320857499337 + 0.0124061858119*I sage: gamma_inc(RDF(1), 3) 0.0497870683678639 sage: gamma_inc(3,2) gamma(3, 2) sage: gamma_inc(x,0) gamma(x) sage: latex(gamma_inc(3,2)) \Gamma\left(3, 2\right) sage: loads(dumps((gamma_inc(3,2)))) gamma(3, 2) sage: i = ComplexField(30).0; gamma_inc(2, 1 + i) 0.70709210 - 0.42035364*I sage: gamma_inc(2., 5) 0.0404276819945128 """ BuiltinFunction.__init__(self, "gamma", nargs=2, latex_name=r"\Gamma", conversions={ 'maxima': 'gamma_incomplete', 'mathematica': 'Gamma', 'maple': 'GAMMA' })
def __init__(self): """ The secant function EXAMPLES:: sage: sec(pi/4) sqrt(2) sage: RR(sec(pi/4)) 1.41421356237310 sage: n(sec(pi/4),100) 1.4142135623730950488016887242 sage: sec(1/2) sec(1/2) sage: sec(0.5) 1.13949392732455 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) """ BuiltinFunction.__init__(self, "sec", latex_name=r"\sec")
def __init__(self): r""" The Dirac delta (generalized) function, ``dirac_delta(x)``. INPUT: - ``x`` - a real number or a symbolic expression EXAMPLES:: sage: dirac_delta(1) 0 sage: dirac_delta(0) dirac_delta(0) sage: dirac_delta(x) dirac_delta(x) sage: latex(dirac_delta(x)) \delta\left(x\right) sage: loads(dumps(dirac_delta(x))) dirac_delta(x) """ BuiltinFunction.__init__(self, "dirac_delta", latex_name=r"\delta", conversions=dict(maxima='delta', mathematica='DiracDelta'))
def __init__(self): r""" The incomplete gamma function. EXAMPLES:: sage: gamma_inc(CDF(0,1), 3) 0.00320857499337 + 0.0124061858119*I sage: gamma_inc(RDF(1), 3) 0.0497870683678639 sage: gamma_inc(3,2) gamma(3, 2) sage: gamma_inc(x,0) gamma(x) sage: latex(gamma_inc(3,2)) \Gamma\left(3, 2\right) sage: loads(dumps((gamma_inc(3,2)))) gamma(3, 2) sage: i = ComplexField(30).0; gamma_inc(2, 1 + i) 0.70709210 - 0.42035364*I sage: gamma_inc(2., 5) 0.0404276819945128 """ BuiltinFunction.__init__(self, "gamma", nargs=2, latex_name=r"\Gamma", conversions={'maxima':'gamma_incomplete', 'mathematica':'Gamma', 'maple':'GAMMA'})
def __init__(self): """ The arccosecant function. EXAMPLES:: sage: arccsc(2) arccsc(2) sage: RDF(arccsc(2)) # rel tol 1e-15 0.5235987755982988 sage: arccsc(1 + I) arccsc(I + 1) 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 """ BuiltinFunction.__init__(self, "arccsc", latex_name=r'{\rm arccsc}', conversions=dict(maxima='acsc'))
def __init__(self): r""" EXAMPLES:: sage: loads(dumps(elliptic_eu)) elliptic_eu """ BuiltinFunction.__init__(self, 'elliptic_eu', nargs=2, conversions=dict(maxima='elliptic_eu'))
def __init__(self): """ TESTS:: sage: Ei(10) Ei(10) sage: Ei(x)._sympy_() Ei(x) """ BuiltinFunction.__init__(self, "Ei", conversions=dict(maxima="expintegral_ei", sympy="Ei"))
def __init__(self): """ Class to represent an indefinite integral. EXAMPLES:: sage: from sage.symbolic.integration.integral import indefinite_integral sage: indefinite_integral(log(x), x) #indirect doctest x*log(x) - x sage: indefinite_integral(x^2, x) 1/3*x^3 sage: indefinite_integral(4*x*log(x), x) 2*x^2*log(x) - x^2 sage: indefinite_integral(exp(x), 2*x) 2*e^x TESTS: Check for :trac:`28913`:: sage: Ex = (1-2*x^(1/3))^(3/4)/x sage: integrate(Ex, x, algorithm="giac") # long time 4*(-2*x^(1/3) + 1)^(3/4) + 6*arctan((-2*x^(1/3) + 1)^(1/4)) - 3*log((-2*x^(1/3) + 1)^(1/4) + 1) + 3*log(abs((-2*x^(1/3) + 1)^(1/4) - 1)) Check for :trac:`29833`:: sage: (x,a,b)=var('x a b') sage: assume(b > 0) sage: f = (exp((x-a)/b) + 1)**(-1) sage: (f*f).integrate(x, algorithm="mathematica_free") # optional -- internet -b*log(e^(a/b) + e^(x/b)) + x + b/(e^(-(a - x)/b) + 1) Check for :trac:`25119`:: sage: result = integrate(sqrt(x^2)/x,x) ... sage: result x*sgn(x) """ # The automatic evaluation routine will try these integrators # in the given order. This is an attribute of the class instead of # a global variable in this module to enable customization by # creating a subclasses which define a different set of integrators self.integrators = [ external.maxima_integrator, external.libgiac_integrator, external.sympy_integrator ] BuiltinFunction.__init__(self, "integrate", nargs=2, conversions={ 'sympy': 'Integral', 'giac': 'integrate' })
def __init__(self): r""" EXAMPLES:: sage: loads(dumps(harmonic_number(x,5))) harmonic_number(x, 5) sage: harmonic_number(x, x)._sympy_() harmonic(x, x) """ BuiltinFunction.__init__(self, "harmonic_number", nargs=2, conversions={'sympy':'harmonic'})
def __init__(self): r""" TESTS:: sage: latex(hurwitz_zeta(x, 2)) \zeta\left(x, 2\right) sage: hurwitz_zeta(x, 2)._sympy_() zeta(x, 2) """ BuiltinFunction.__init__( self, "hurwitz_zeta", nargs=2, conversions=dict(mathematica="HurwitzZeta", sympy="zeta"), latex_name="\zeta" )
def __init__(self): r""" The lower incomplete gamma function. It is defined by the integral .. MATH:: \Gamma(a,z)=\int_0^z t^{a-1}e^{-t}\,\mathrm{d}t EXAMPLES:: sage: gamma_inc_lower(CDF(0,1), 3) -0.1581584032951798 - 0.5104218539302277*I sage: gamma_inc_lower(RDF(1), 3) 0.950212931632136 sage: gamma_inc_lower(3, 2, hold=True) gamma_inc_lower(3, 2) sage: gamma_inc_lower(3, 2) -10*e^(-2) + 2 sage: gamma_inc_lower(x, 0) 0 sage: latex(gamma_inc_lower(x, x)) \gamma\left(x, x\right) sage: loads(dumps((gamma_inc_lower(x, x)))) gamma_inc_lower(x, x) sage: i = ComplexField(30).0; gamma_inc_lower(2, 1 + i) 0.29290790 + 0.42035364*I sage: gamma_inc_lower(2., 5) 0.959572318005487 Interfaces to other software:: sage: gamma_inc_lower(x,x)._sympy_() lowergamma(x, x) sage: maxima(gamma_inc_lower(x,x)) gamma_greek(_SAGE_VAR_x,_SAGE_VAR_x) .. SEEALSO:: :class:`Function_gamma_inc` """ BuiltinFunction.__init__(self, "gamma_inc_lower", nargs=2, latex_name=r"\gamma", conversions={ 'maxima': 'gamma_greek', 'mathematica': 'Gamma', 'maple': 'GAMMA', 'sympy': 'lowergamma', 'giac': 'igamma' })
def __init__(self): r""" See the docstring for :meth:`Function_lambert_w`. EXAMPLES:: sage: lambert_w(0, 1.0) 0.567143290409784 """ BuiltinFunction.__init__(self, "lambert_w", nargs=2, conversions={'mathematica':'ProductLog', 'maple':'LambertW'})
def __init__(self): r""" Representation of a complex number in a polar form. INPUT: - ``z`` - a complex number `z = a + ib`. OUTPUT: A complex number with modulus `\exp(a)` and argument `b`. If `-\pi < b \leq \pi` then `\operatorname{exp\_polar}(z)=\exp(z)`. For other values of `b` the function is left unevaluated. EXAMPLES: The following expressions are evaluated using the exponential function:: sage: exp_polar(pi*I/2) I sage: x = var('x', domain='real') sage: exp_polar(-1/2*I*pi + x) e^(-1/2*I*pi + x) The function is left unevaluated when the imaginary part of the input `z` does not satisfy `-\pi < \Im(z) \leq \pi`:: sage: exp_polar(2*pi*I) exp_polar(2*I*pi) sage: exp_polar(-4*pi*I) exp_polar(-4*I*pi) This fixes :trac:`18085`:: sage: integrate(1/sqrt(1+x^3),x,algorithm='sympy') 1/3*x*gamma(1/3)*hypergeometric((1/3, 1/2), (4/3,), -x^3)/gamma(4/3) .. SEEALSO:: `Examples in Sympy documentation <http://docs.sympy.org/latest/modules/functions/special.html?highlight=exp_polar>`_, `Sympy source code of exp_polar <http://docs.sympy.org/0.7.4/_modules/sympy/functions/elementary/exponential.html>`_ REFERENCES: :wikipedia:`Complex_number#Polar_form` """ BuiltinFunction.__init__(self, "exp_polar", latex_name=r"\operatorname{exp\_polar}", conversions=dict(sympy='exp_polar'))
def __init__(self): """ See the docstring for ``Function_log_integral-offset``. EXAMPLES:: sage: log_integral_offset(3) log_integral(3) - log_integral(2) """ BuiltinFunction.__init__(self, "log_integral_offset", nargs=1, latex_name=r'log_integral_offset')
def __init__(self): """ TESTS:: sage: Ei(10) Ei(10) sage: Ei(x)._sympy_() Ei(x) """ BuiltinFunction.__init__(self, "Ei", conversions=dict(maxima='expintegral_ei', sympy='Ei'))
def __init__(self): r""" The argument function for complex numbers. EXAMPLES:: sage: arg(3+i) arctan(1/3) sage: arg(-1+i) 3/4*pi sage: arg(2+2*i) 1/4*pi sage: arg(2+x) arg(x + 2) sage: arg(2.0+i+x) arg(x + 2.00000000000000 + 1.00000000000000*I) sage: arg(-3) pi sage: arg(3) 0 sage: arg(0) 0 sage: latex(arg(x)) {\rm arg}\left(x\right) sage: maxima(arg(x)) atan2(0,x) sage: maxima(arg(2+i)) atan(1/2) sage: maxima(arg(sqrt(2)+i)) atan(1/sqrt(2)) sage: arg(2+i) arctan(1/2) sage: arg(sqrt(2)+i) arg(sqrt(2) + I) sage: arg(sqrt(2)+i).simplify() arctan(1/2*sqrt(2)) TESTS:: sage: arg(0.0) 0.000000000000000 sage: arg(3.0) 0.000000000000000 sage: arg(-2.5) 3.14159265358979 sage: arg(2.0+3*i) 0.982793723247329 """ BuiltinFunction.__init__(self, "arg", conversions=dict(maxima='carg', mathematica='Arg'))
def __init__(self): r""" TESTS:: sage: latex(hurwitz_zeta(x, 2)) \zeta\left(x, 2\right) sage: hurwitz_zeta(x, 2)._sympy_() zeta(x, 2) """ BuiltinFunction.__init__(self, 'hurwitz_zeta', nargs=2, conversions=dict(mathematica='HurwitzZeta', sympy='zeta'), latex_name=r'\zeta')
def __init__(self): """ See the docstring for :meth:`Function_Bessel_Y`. EXAMPLES:: sage: sage.functions.bessel.Function_Bessel_Y()(0, x) bessel_Y(0, x) """ BuiltinFunction.__init__(self, "bessel_Y", nargs=2, conversions=dict(mathematica='BesselY', maxima='bessel_y', sympy='bessely'))
def __init__(self): """ EXAMPLES:: sage: loads(dumps(elliptic_pi)) elliptic_pi sage: elliptic_pi(x, pi/4, 1)._sympy_() elliptic_pi(x, pi/4, 1) """ BuiltinFunction.__init__(self, 'elliptic_pi', nargs=3, conversions=dict(mathematica='EllipticPi', maxima='EllipticPi', sympy='elliptic_pi'))
def __init__(self): """ EXAMPLES:: sage: loads(dumps(elliptic_f)) elliptic_f sage: elliptic_f(x, 2)._sympy_() elliptic_f(x, 2) """ BuiltinFunction.__init__(self, 'elliptic_f', nargs=2, conversions=dict(mathematica='EllipticF', maxima='elliptic_f', sympy='elliptic_f'))
def __init__(self): """ See the docstring for :class:`Function_cos_integral`. EXAMPLES:: sage: cos_integral(1) cos_integral(1) """ BuiltinFunction.__init__(self, "cos_integral", nargs=1, latex_name=r'\operatorname{Ci}', conversions=dict(maxima='expintegral_ci'))
def __init__(self): """ See the docstring for :meth:`Function_Bessel_I`. EXAMPLES:: sage: bessel_I(1,x) bessel_I(1, x) """ BuiltinFunction.__init__(self, "bessel_I", nargs=2, conversions=dict(mathematica='BesselI', maxima='bessel_i', sympy='besseli'))
def __init__(self): """ See the docstring for :meth:`Function_Bessel_K`. EXAMPLES:: sage: sage.functions.bessel.Function_Bessel_K() bessel_K """ BuiltinFunction.__init__(self, "bessel_K", nargs=2, conversions=dict(mathematica='BesselK', maxima='bessel_k', sympy='besselk'))
def __init__(self): """ See the docstring for ``Function_sin_integral``. EXAMPLES:: sage: sin_integral(1) sin_integral(1) """ BuiltinFunction.__init__(self, "sin_integral", nargs=1, latex_name=r'\operatorname{Si}', conversions=dict(maxima='expintegral_si'))
def __init__(self): """ See the docstring for ``Function_log_integral``. EXAMPLES:: sage: log_integral(3) log_integral(3) """ BuiltinFunction.__init__(self, "log_integral", nargs=1, latex_name=r'log_integral', conversions=dict(maxima='expintegral_li'))
def __init__(self): """ See the docstring for :class:`Function_exp_integral_e1`. EXAMPLES:: sage: exp_integral_e1(1) exp_integral_e1(1) """ BuiltinFunction.__init__(self, "exp_integral_e1", nargs=1, latex_name=r'exp_integral_e1', conversions=dict(maxima='expintegral_e1'))
def __init__(self): """ See the docstring for :meth:`Function_exp_integral_e`. EXAMPLES:: sage: exp_integral_e(1,0) exp_integral_e(1, 0) """ BuiltinFunction.__init__(self, "exp_integral_e", nargs=2, latex_name=r'exp_integral_e', conversions=dict(maxima='expintegral_e'))