Bases: sage.symbolic.function.GinacFunction
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|}
Test pickling:
sage: loads(dumps(abs(x)))
abs(x)
Bases: sage.symbolic.function.BuiltinFunction
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
Bases: sage.symbolic.function.GinacFunction
Return the beta function. This is defined by
for complex or symbolic input and
.
Note that the order of inputs does not matter:
.
GiNaC is used to compute . However, complex inputs
are not yet handled in general. When GiNaC raises an error on
such inputs, we raise a NotImplementedError.
If either input is 1, GiNaC returns the reciprocal of the other. In other cases, GiNaC uses one of the following formulas:
or
For numerical inputs, GiNaC uses the formula
INPUT:
OUTPUT: number or symbolic expression (if input is symbolic)
EXAMPLES:
sage: beta(3,2)
1/12
sage: beta(3,1)
1/3
sage: beta(1/2,1/2)
beta(1/2, 1/2)
sage: beta(-1,1)
-1
sage: beta(-1/2,-1/2)
0
sage: beta(x/2,3)
beta(3, 1/2*x)
sage: beta(.5,.5)
3.14159265358979
sage: beta(1,2.0+I)
0.400000000000000 - 0.200000000000000*I
sage: beta(3,x+I)
beta(3, x + I)
Note that the order of arguments does not matter:
sage: beta(1/2,3*x)
beta(1/2, 3*x)
The result is symbolic if exact input is given:
sage: beta(2,1+5*I)
beta(2, 5*I + 1)
sage: beta(2, 2.)
0.166666666666667
sage: beta(I, 2.)
-0.500000000000000 - 0.500000000000000*I
sage: beta(2., 2)
0.166666666666667
sage: beta(2., I)
-0.500000000000000 - 0.500000000000000*I
Test pickling:
sage: loads(dumps(beta))
beta
Bases: sage.symbolic.function.GinacFunction
Return the binomial coefficient
which is defined for and any
. We extend this definition to include cases when
is an integer but
is not by
If , return
.
INPUT:
OUTPUT: number or symbolic expression (if input is symbolic)
EXAMPLES:
sage: binomial(5,2)
10
sage: binomial(2,0)
1
sage: binomial(1/2, 0)
1
sage: binomial(3,-1)
0
sage: binomial(20,10)
184756
sage: binomial(-2, 5)
-6
sage: binomial(RealField()('2.5'), 2)
1.87500000000000
sage: n=var('n'); binomial(n,2)
1/2*(n - 1)*n
sage: n=var('n'); binomial(n,n)
1
sage: n=var('n'); binomial(n,n-1)
n
sage: binomial(2^100, 2^100)
1
sage: k, i = var('k,i')
sage: binomial(k,i)
binomial(k, i)
We can use a hold parameter to prevent automatic evaluation, but only using method notation:
sage: SR(5).binomial(3, hold=True)
binomial(5, 3)
sage: SR(5).binomial(3, hold=True).simplify()
10
TESTS: We verify that we can convert this function to Maxima and bring it back into Sage.
sage: n,k = var('n,k')
sage: maxima(binomial(n,k))
binomial(n,k)
sage: _.sage()
binomial(n, k)
sage: sage.functions.other.binomial._maxima_init_() # temporary workaround until we can get symbolic binomial to import in global namespace, if that's desired
'binomial'
Test pickling:
sage: loads(dumps(binomial(n,k)))
binomial(n, k)
Bases: sage.symbolic.function.BuiltinFunction
The ceiling function.
The ceiling of is computed in the following manner.
EXAMPLES:
sage: a = ceil(2/5 + x)
sage: a
ceil(x + 2/5)
sage: a(x=4)
5
sage: a(x=4.0)
5
sage: ZZ(a(x=3))
4
sage: a = ceil(x^3 + x + 5/2); a
ceil(x^3 + x + 5/2)
sage: a.simplify()
ceil(x^3 + x + 1/2) + 2
sage: a(x=2)
13
sage: ceil(sin(8)/sin(2))
2
sage: ceil(5.4)
6
sage: type(ceil(5.4))
<type 'sage.rings.integer.Integer'>
sage: ceil(factorial(50)/exp(1))
11188719610782480504630258070757734324011354208865721592720336801
sage: ceil(SR(10^50 + 10^(-50)))
100000000000000000000000000000000000000000000000001
sage: ceil(SR(10^50 - 10^(-50)))
100000000000000000000000000000000000000000000000000
sage: ceil(sec(e))
-1
sage: latex(ceil(x))
\left \lceil x \right \rceil
sage: import numpy
sage: a = numpy.linspace(0,2,6)
sage: ceil(a)
array([ 0., 1., 1., 2., 2., 2.])
Test pickling:
sage: loads(dumps(ceil))
ceil
Bases: sage.symbolic.function.GinacFunction
Returns the complex conjugate of the input.
It is possible to prevent automatic evaluation using the hold parameter:
sage: conjugate(I,hold=True)
conjugate(I)
To then evaluate again, we currently must use Maxima via sage.symbolic.expression.Expression.simplify():
sage: conjugate(I,hold=True).simplify()
-I
TESTS:
sage: x,y = var('x,y')
sage: x.conjugate()
conjugate(x)
sage: latex(conjugate(x))
\overline{x}
sage: f = function('f')
sage: latex(f(x).conjugate())
\overline{f\left(x\right)}
sage: f = function('psi',x,y)
sage: latex(f.conjugate())
\overline{\psi\left(x, y\right)}
sage: x.conjugate().conjugate()
x
sage: x.conjugate().operator()
conjugate
sage: x.conjugate().operator() == conjugate
True
Check if #8755 is fixed:
sage: conjugate(sqrt(-3))
conjugate(sqrt(-3))
sage: conjugate(sqrt(3))
sqrt(3)
sage: conjugate(sqrt(x))
conjugate(sqrt(x))
sage: conjugate(x^2)
conjugate(x)^2
sage: var('y',domain='positive')
y
sage: conjugate(sqrt(y))
sqrt(y)
Check if #10964 is fixed:
sage: z= I*sqrt(-3); z
I*sqrt(-3)
sage: conjugate(z)
-I*conjugate(sqrt(-3))
sage: var('a')
a
sage: conjugate(a*sqrt(-2)*sqrt(-3))
conjugate(sqrt(-2))*conjugate(sqrt(-3))*conjugate(a)
Test pickling:
sage: loads(dumps(conjugate))
conjugate
Bases: sage.symbolic.function.BuiltinFunction
The error function, defined for real values as
.
This function is also defined for complex values, via analytic continuation.
EXAMPLES:
We can evaluate numerically:
sage: erf(2)
erf(2)
sage: erf(2).n()
0.995322265018953
sage: erf(2).n(100)
0.99532226501895273416206925637
sage: erf(ComplexField(100)(2+3j))
-20.829461427614568389103088452 + 8.6873182714701631444280787545*I
Basic symbolic properties are handled by Sage and Maxima:
sage: x = var("x")
sage: diff(erf(x),x)
2*e^(-x^2)/sqrt(pi)
sage: integrate(erf(x),x)
x*erf(x) + e^(-x^2)/sqrt(pi)
ALGORITHM:
Sage implements numerical evaluation of the error function via the erf() function from mpmath. Symbolics are handled by Sage and Maxima.
REFERENCES:
TESTS:
Check limits:
sage: limit(erf(x),x=0)
0
sage: limit(erf(x),x=infinity)
1
Check that it's odd::
sage: erf(1.0)
0.842700792949715
sage: erf(-1.0)
-0.842700792949715
Check against other implementations and against the definition:
sage: erf(3).n()
0.999977909503001
sage: maxima.erf(3).n()
0.999977909503001
sage: (1-pari(3).erfc())
0.999977909503001
sage: RR(3).erf()
0.999977909503001
sage: (integrate(exp(-x**2),(x,0,3))*2/sqrt(pi)).n()
0.999977909503001
sage: N(erf(sqrt(2)),200)
0.95449973610364158559943472566693312505644755259664313203267
sage: n(erf(2),100)
0.99532226501895273416206925637
sage: erf(2).n(100)
0.99532226501895273416206925637
Test (indirectly) trac ticket #11885:
sage: erf(float(0.5))
0.5204998778130465
sage: erf(complex(0.5))
(0.5204998778130465+0j)
Ensure conversion from maxima elements works:
sage: merf = maxima(erf(x)).sage().operator()
sage: merf == erf
True
Make sure we can dump and load it:
sage: loads(dumps(erf(2)))
erf(2)
Special-case 0 for immediate evaluation:
sage: erf(0)
0
sage: solve(erf(x)==0,x)
[x == 0]
Make sure that we can hold:
sage: erf(0,hold=True)
erf(0)
sage: simplify(erf(0,hold=True))
0
Check that high-precision ComplexField inputs work:
sage: CC(erf(ComplexField(1000)(2+3j)))
-20.8294614276146 + 8.68731827147016*I
Bases: sage.symbolic.function.GinacFunction
Returns the factorial of .
INPUT:
OUTPUT: an integer or symbolic expression
EXAMPLES:
sage: x = var('x')
sage: factorial(0)
1
sage: factorial(4)
24
sage: factorial(10)
3628800
sage: factorial(6) == 6*5*4*3*2
True
sage: f = factorial(x + factorial(x)); f
factorial(x + factorial(x))
sage: f(x=3)
362880
sage: factorial(x)^2
factorial(x)^2
To prevent automatic evaluation use the hold argument:
sage: factorial(5,hold=True)
factorial(5)
To then evaluate again, we currently must use Maxima via sage.symbolic.expression.Expression.simplify():
sage: factorial(5,hold=True).simplify()
120
We can also give input other than nonnegative integers. For other nonnegative numbers, the gamma() function is used:
sage: factorial(1/2)
1/2*sqrt(pi)
sage: factorial(3/4)
gamma(7/4)
sage: factorial(2.3)
2.68343738195577
But negative input always fails:
sage: factorial(-32)
Traceback (most recent call last):
...
ValueError: factorial -- self = (-32) must be nonnegative
TESTS:
We verify that we can convert this function to Maxima and bring it back into Sage.:
sage: z = var('z')
sage: factorial._maxima_init_()
'factorial'
sage: maxima(factorial(z))
factorial(z)
sage: _.sage()
factorial(z)
sage: k = var('k')
sage: factorial(k)
factorial(k)
sage: factorial(3.14)
7.173269190187...
Test latex typesetting:
sage: latex(factorial(x))
x!
sage: latex(factorial(2*x))
\left(2 \, x\right)!
sage: latex(factorial(sin(x)))
\sin\left(x\right)!
sage: latex(factorial(sqrt(x+1)))
\left(\sqrt{x + 1}\right)!
sage: latex(factorial(sqrt(x)))
\sqrt{x}!
sage: latex(factorial(x^(2/3)))
\left(x^{\frac{2}{3}}\right)!
sage: latex(factorial)
{\rm factorial}
Check that #11539 is fixed:
sage: (factorial(x) == 0).simplify()
factorial(x) == 0
sage: maxima(factorial(x) == 0).sage()
factorial(x) == 0
sage: y = var('y')
sage: (factorial(x) == y).solve(x)
[factorial(x) == y]
Test pickling:
sage: loads(dumps(factorial))
factorial
Bases: sage.symbolic.function.BuiltinFunction
The floor function.
The floor of is computed in the following manner.
EXAMPLES:
sage: floor(5.4)
5
sage: type(floor(5.4))
<type 'sage.rings.integer.Integer'>
sage: var('x')
x
sage: a = floor(5.4 + x); a
floor(x + 5.40000000000000)
sage: a.simplify()
floor(x + 0.4) + 5
sage: a(x=2)
7
sage: floor(cos(8)/cos(2))
0
sage: floor(factorial(50)/exp(1))
11188719610782480504630258070757734324011354208865721592720336800
sage: floor(SR(10^50 + 10^(-50)))
100000000000000000000000000000000000000000000000000
sage: floor(SR(10^50 - 10^(-50)))
99999999999999999999999999999999999999999999999999
sage: floor(int(10^50))
100000000000000000000000000000000000000000000000000
sage: import numpy
sage: a = numpy.linspace(0,2,6)
sage: floor(a)
array([ 0., 0., 0., 1., 1., 2.])
Test pickling:
sage: loads(dumps(floor))
floor
Bases: sage.symbolic.function.GinacFunction
The Gamma function. This is defined by
for complex input with real part greater than zero, and by
analytic continuation on the rest of the complex plane (except
for negative integers, which are poles).
It is computed by various libraries within Sage, depending on the input type.
EXAMPLES:
sage: from sage.functions.other import gamma1
sage: gamma1(CDF(0.5,14))
-4.05370307804e-10 - 5.77329983455e-10*I
sage: gamma1(CDF(I))
-0.154949828302 - 0.498015668118*I
Recall that is
factorial:
sage: gamma1(11) == factorial(10)
True
sage: gamma1(6)
120
sage: gamma1(1/2)
sqrt(pi)
sage: gamma1(-1)
Infinity
sage: gamma1(I)
gamma(I)
sage: gamma1(x/2)(x=5)
3/4*sqrt(pi)
sage: gamma1(float(6))
120.0
sage: gamma1(x)
gamma(x)
sage: gamma1(pi)
gamma(pi)
sage: gamma1(i)
gamma(I)
sage: gamma1(i).n()
-0.154949828301811 - 0.498015668118356*I
sage: gamma1(int(5))
24
sage: conjugate(gamma(x))
gamma(conjugate(x))
sage: plot(gamma1(x),(x,1,5))
To prevent automatic evaluation use the hold argument:
sage: gamma1(1/2,hold=True)
gamma(1/2)
To then evaluate again, we currently must use Maxima via sage.symbolic.expression.Expression.simplify():
sage: gamma1(1/2,hold=True).simplify()
sqrt(pi)
TESTS:
We verify that we can convert this function to Maxima and convert back to Sage:
sage: z = var('z')
sage: maxima(gamma1(z)).sage()
gamma(z)
sage: latex(gamma1(z))
\Gamma\left(z\right)
Test that Trac ticket 5556 is fixed:
sage: gamma1(3/4)
gamma(3/4)
sage: gamma1(3/4).n(100)
1.2254167024651776451290983034
Check that negative integer input works:
sage: (-1).gamma()
Infinity
sage: (-1.).gamma()
NaN
sage: CC(-1).gamma()
Infinity
sage: RDF(-1).gamma()
NaN
sage: CDF(-1).gamma()
Infinity
Check if #8297 is fixed:
sage: latex(gamma(1/4))
\Gamma\left(\frac{1}{4}\right)
Test pickling:
sage: loads(dumps(gamma(x)))
gamma(x)
Bases: sage.symbolic.function.BuiltinFunction
The incomplete gamma function.
EXAMPLES:
sage: gamma_inc(CDF(0,1), 3)
0.00320857499337 + 0.0124061858119*I
sage: gamma_inc(RDF(1), 3)
0.0497870683679
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
Bases: sage.symbolic.function.GinacFunction
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 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: imag(complex(3, 4))
4.0
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)
Bases: sage.symbolic.function.GinacFunction
The principal branch of the logarithm of Gamma function.
Gamma is defined for complex input with real part greater
than zero, and by analytic continuation on the rest of the
complex plane (except for negative integers, which are poles).
It is computed by the function for the number type,
or by
in Ginac, failing that.
EXAMPLES:
Numerical evaluation happens when appropriate, to the appropriate accuracy (see #10072):
sage: log_gamma(6)
log(120)
sage: log_gamma(6.)
4.78749174278205
sage: log_gamma(6).n()
4.78749174278205
sage: log_gamma(RealField(100)(6))
4.7874917427820459942477009345
sage: log_gamma(2.4+i)
-0.0308566579348816 + 0.693427705955790*I
sage: log_gamma(-3.1)
0.400311696703985
Symbolic input works (see #10075):
sage: log_gamma(3*x)
log_gamma(3*x)
sage: log_gamma(3+i)
log_gamma(I + 3)
sage: log_gamma(3+i+x)
log_gamma(x + I + 3)
To get evaluation of input for which gamma is negative and the ceiling is even, we must explicitly make the input complex. This is a known issue, see #12521:
sage: log_gamma(-2.1)
NaN
sage: log_gamma(CC(-2.1))
1.53171380819509 + 3.14159265358979*I
In order to prevent evaluation, use the argument;
to evaluate a held expression, use the
numerical
evaluation method:
sage: log_gamma(SR(5),hold=True)
log_gamma(5)
sage: log_gamma(SR(5),hold=True).n()
3.17805383034795
TESTS:
sage: log_gamma(-2.1+i)
-1.90373724496982 - 0.901638463592247*I
sage: log_gamma(pari(6))
4.78749174278205
sage: log_gamma(CC(6))
4.78749174278205
sage: log_gamma(CC(-2.5))
-0.0562437164976740 + 3.14159265358979*I
conjugate(log_gamma(x))==log_gamma(conjugate(x)) unless on the branch cut, which runs along the negative real axis.:
sage: conjugate(log_gamma(x))
conjugate(log_gamma(x))
sage: var('y', domain='positive')
y
sage: conjugate(log_gamma(y))
log_gamma(y)
sage: conjugate(log_gamma(y+I))
conjugate(log_gamma(y + I))
sage: log_gamma(-2)
+Infinity
sage: conjugate(log_gamma(-2))
+Infinity
Bases: sage.symbolic.function.GinacFunction
The digamma function, , is the logarithmic derivative of the
gamma function.
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
sage: t = psi1(x); t
psi(x)
sage: t.subs(x=.2)
-5.28903989659219
Bases: sage.symbolic.function.GinacFunction
Derivatives of the digamma function . 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
Bases: sage.symbolic.function.GinacFunction
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 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
sage: real(complex(3, 4))
3.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)
Bases: object
x.__init__(...) initializes x; see help(type(x)) for signature
Gamma and incomplete gamma functions. This is defined by the integral
EXAMPLES:
Recall that `\Gamma(n)` is `n-1` factorial::
sage: gamma(11) == factorial(10)
True
sage: gamma(6)
120
sage: gamma(1/2)
sqrt(pi)
sage: gamma(-4/3)
gamma(-4/3)
sage: gamma(-1)
Infinity
sage: gamma(0)
Infinity
::
sage: gamma_inc(3,2)
gamma(3, 2)
sage: gamma_inc(x,0)
gamma(x)
::
sage: gamma(5, hold=True)
gamma(5)
sage: gamma(x, 0, hold=True)
gamma(x, 0)
::
sage: gamma(CDF(0.5,14))
-4.05370307804e-10 - 5.77329983455e-10*I
sage: gamma(CDF(I))
-0.154949828302 - 0.498015668118*I
The gamma function only works with input that can be coerced to the
Symbolic Ring::
sage: Q.<i> = NumberField(x^2+1)
sage: gamma(i)
doctest:...: DeprecationWarning: Calling symbolic functions with arguments that cannot be coerced into symbolic expressions is deprecated.
See http://trac.sagemath.org/7490 for details.
-0.154949828301811 - 0.498015668118356*I
We make an exception for elements of AA or QQbar, which cannot be
coerced into symbolic expressions to allow this usage::
sage: t = QQbar(sqrt(2)) + sqrt(3); t
3.146264369941973?
sage: t.parent()
Algebraic Field
Symbolic functions convert the arguments to symbolic expressions if they
are in QQbar or AA::
sage: gamma(QQbar(I))
-0.154949828301811 - 0.498015668118356*I
The digamma function, , is the logarithmic derivative of the
gamma function.
We represent the -th derivative of the digamma function with
or
.
EXAMPLES:
sage: psi(x)
psi(x)
sage: psi(.5)
-1.96351002602142
sage: psi(3)
-euler_gamma + 3/2
sage: psi(1, 5)
1/6*pi^2 - 205/144
sage: psi(1, x)
psi(1, x)
sage: psi(1, x).derivative(x)
psi(2, x)
sage: psi(3, hold=True)
psi(3)
sage: psi(1, 5, hold=True)
psi(1, 5)
TESTS:
sage: psi(2, x, 3)
Traceback (most recent call last):
...
TypeError: Symbolic function psi takes at most 2 arguments (3 given)
INPUT:
EXAMPLES:
sage: sqrt(-1)
I
sage: sqrt(2)
sqrt(2)
sage: sqrt(2)^2
2
sage: sqrt(4)
2
sage: sqrt(4,all=True)
[2, -2]
sage: sqrt(x^2)
sqrt(x^2)
sage: sqrt(2).n()
1.41421356237310
To prevent automatic evaluation, one can use the hold parameter after coercing to the symbolic ring:
sage: sqrt(SR(4),hold=True)
sqrt(4)
sage: sqrt(4,hold=True)
Traceback (most recent call last):
...
TypeError: _do_sqrt() got an unexpected keyword argument 'hold'
This illustrates that the bug reported in #6171 has been fixed:
sage: a = 1.1
sage: a.sqrt(prec=100) # this is supposed to fail
Traceback (most recent call last):
...
TypeError: sqrt() got an unexpected keyword argument 'prec'
sage: sqrt(a, prec=100)
1.0488088481701515469914535137
sage: sqrt(4.00, prec=250)
2.0000000000000000000000000000000000000000000000000000000000000000000000000
One can use numpy input as well:
sage: import numpy
sage: a = numpy.arange(2,5)
sage: sqrt(a)
array([ 1.41421356, 1.73205081, 2. ])