本文整理汇总了Python中sage.symbolic.function.GinacFunction类的典型用法代码示例。如果您正苦于以下问题：Python GinacFunction类的具体用法？Python GinacFunction怎么用？Python GinacFunction使用的例子？那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了GinacFunction类的14个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: __init__
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"))示例2: __init__
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")示例3: __init__
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'))示例4: __init__
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}")示例5: __init__
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'))示例6: __init__
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")示例7: __init__
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'))示例8: __init__
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)示例9: __init__
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}")示例10: __call__
def __call__(self, x, coerce=True, hold=False, prec=None,
dont_call_method_on_arg=False):
"""
Note that the ``prec`` argument is deprecated. The precision for
the result is deduced from the precision of the input. Convert
the input to a higher precision explicitly if a result with higher
precision is desired.::
sage: t = exp(RealField(100)(2)); t
7.3890560989306502272304274606
sage: t.prec()
100
TESTS::
sage: exp(2,prec=100)
doctest:...: DeprecationWarning: The prec keyword argument is deprecated. Explicitly set the precision of the input, for example exp(RealField(300)(1)), or use the prec argument to .n() for exact inputs, e.g., exp(1).n(300), instead.
7.3890560989306502272304274606
"""
if prec is not None:
from sage.misc.misc import deprecation
deprecation("The prec keyword argument is deprecated. Explicitly set the precision of the input, for example exp(RealField(300)(1)), or use the prec argument to .n() for exact inputs, e.g., exp(1).n(300), instead.")
x = GinacFunction.__call__(self, x, coerce=coerce, hold=hold,
dont_call_method_on_arg=dont_call_method_on_arg)
return x.n(prec)
return GinacFunction.__call__(self, x, coerce=coerce, hold=hold,
dont_call_method_on_arg=dont_call_method_on_arg)示例11: __init__
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")示例12: __init__
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)示例13: __init__
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'))示例14: __init__
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'))