Other functions¶
-
class
sage.functions.other.
Function_Order
¶ Bases:
sage.symbolic.function.GinacFunction
The order function.
This function gives the order of magnitude of some expression, similar to \(O\)-terms.
EXAMPLES:
sage: x = SR('x') sage: x.Order() Order(x) sage: (x^2 + x).Order() Order(x^2 + x)
-
class
sage.functions.other.
Function_abs
¶ 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)) sqrt(abs(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|} sage: abs(x)._sympy_() Abs(x)
Test pickling:
sage: loads(dumps(abs(x))) abs(x)
-
class
sage.functions.other.
Function_arg
¶ 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,_SAGE_VAR_x) sage: maxima(arg(2+i)) atan(1/2) sage: maxima(arg(sqrt(2)+i)) atan(1/sqrt(2)) sage: arg(x)._sympy_() arg(x) 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))
-
class
sage.functions.other.
Function_binomial
¶ Bases:
sage.symbolic.function.GinacFunction
Return the binomial coefficient
\[\binom{x}{m} = x (x-1) \cdots (x-m+1) / m!\]which is defined for \(m \in \ZZ\) and any \(x\). We extend this definition to include cases when \(x-m\) is an integer but \(m\) is not by
\[\binom{x}{m}= \binom{x}{x-m}\]If \(m < 0\), return \(0\).
INPUT:
x
,m
- numbers or symbolic expressions. Eitherm
orx-m
must be an integer, else the output is symbolic.
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:sage: SR(5).binomial(3, hold=True) binomial(5, 3) sage: SR(5).binomial(3, hold=True).simplify() 10
-
class
sage.functions.other.
Function_cases
¶ Bases:
sage.symbolic.function.GinacFunction
Formal function holding
(condition, expression)
pairs.Numbers are considered conditions with zero being
False
. A true condition marks a default value. The function is not evaluated as long as it contains a relation that cannot be decided by Pynac.EXAMPLES:
sage: ex = cases([(x==0, pi), (True, 0)]); ex cases(((x == 0, pi), (1, 0))) sage: ex.subs(x==0) pi sage: ex.subs(x==2) 0 sage: ex + 1 cases(((x == 0, pi), (1, 0))) + 1 sage: _.subs(x==0) pi + 1
The first encountered default is used, as well as the first relation that can be trivially decided:
sage: cases(((True, pi), (True, 0))) pi sage: _ = var('y') sage: ex = cases(((x==0, pi), (y==1, 0))); ex cases(((x == 0, pi), (y == 1, 0))) sage: ex.subs(x==0) pi sage: ex.subs(x==0, y==1) pi
-
class
sage.functions.other.
Function_ceil
¶ Bases:
sage.symbolic.function.BuiltinFunction
The ceiling function.
The ceiling of \(x\) is computed in the following manner.
The
x.ceil()
method is called and returned if it is there. If it is not, then Sage checks if \(x\) is one of Python’s native numeric data types. If so, then it calls and returnsInteger(math.ceil(x))
.Sage tries to convert \(x\) into a
RealIntervalField
with 53 bits of precision. Next, the ceilings of the endpoints are computed. If they are the same, then that value is returned. Otherwise, the precision of theRealIntervalField
is increased until they do match up or it reachesbits
of precision.If none of the above work, Sage returns a
Expression
object.
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
Small numbers which are extremely close to an integer are hard to deal with:
sage: ceil((33^100 + 1)^(1/100)) Traceback (most recent call last): ... ValueError: cannot compute ceil(...) using 256 bits of precision
This can be fixed by giving a sufficiently large
bits
argument:sage: ceil((33^100 + 1)^(1/100), bits=500) Traceback (most recent call last): ... ValueError: cannot compute ceil(...) using 512 bits of precision sage: ceil((33^100 + 1)^(1/100), bits=1000) 34
sage: ceil(sec(e)) -1 sage: latex(ceil(x)) \left \lceil x \right \rceil sage: ceil(x)._sympy_() ceiling(x)
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
-
class
sage.functions.other.
Function_conjugate
¶ 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
-
class
sage.functions.other.
Function_crootof
¶ Bases:
sage.symbolic.function.BuiltinFunction
Formal function holding
(polynomial, index)
pairs.The expression evaluates to a floating point value that is an approximation to a specific complex root of the polynomial. The ordering is fixed so you always get the same root.
The functionality is imported from SymPy, see http://docs.sympy.org/latest/_modules/sympy/polys/rootoftools.html
EXAMPLES:
sage: c = complex_root_of(x^6 + x + 1, 1); c complex_root_of(x^6 + x + 1, 1) sage: c.n() -0.790667188814418 + 0.300506920309552*I sage: c.n(100) -0.79066718881441764449859281847 + 0.30050692030955162512001002521*I sage: (c^6 + c + 1).n(100) < 1e-25 True
-
class
sage.functions.other.
Function_factorial
¶ Bases:
sage.symbolic.function.GinacFunction
Returns the factorial of \(n\).
INPUT:
n
- a non-negative integer, a complex number (except negative integers) or any symbolic expression
OUTPUT: an integer or symbolic expression
EXAMPLES:
sage: factorial(0) 1 sage: factorial(4) 24 sage: factorial(10) 3628800 sage: factorial(6) == 6*5*4*3*2 True sage: x = SR.var('x') 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
sage.functions.gamma.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 only defined for non-negative integers
And very large integers remain unevaluated:
sage: factorial(2**64) factorial(18446744073709551616) sage: SR(2**64).factorial() factorial(18446744073709551616)
-
class
sage.functions.other.
Function_floor
¶ Bases:
sage.symbolic.function.BuiltinFunction
The floor function.
The floor of \(x\) is computed in the following manner.
The
x.floor()
method is called and returned if it is there. If it is not, then Sage checks if \(x\) is one of Python’s native numeric data types. If so, then it calls and returnsInteger(math.floor(x))
.Sage tries to convert \(x\) into a
RealIntervalField
with 53 bits of precision. Next, the floors of the endpoints are computed. If they are the same, then that value is returned. Otherwise, the precision of theRealIntervalField
is increased until they do match up or it reachesbits
of precision.If none of the above work, Sage returns a symbolic
Expression
object.
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.4000000000000004) + 5 sage: a(x=2) 7
sage: floor(cos(8) / cos(2)) 0 sage: floor(log(4) / log(2)) 2 sage: a = floor(5.4 + x); a floor(x + 5.40000000000000) sage: a.subs(x==2) 7 sage: floor(log(2^(3/2)) / log(2) + 1/2) 2 sage: floor(log(2^(-3/2)) / log(2) + 1/2) -1
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
Small numbers which are extremely close to an integer are hard to deal with:
sage: floor((33^100 + 1)^(1/100)) Traceback (most recent call last): ... ValueError: cannot compute floor(...) using 256 bits of precision
This can be fixed by giving a sufficiently large
bits
argument:sage: floor((33^100 + 1)^(1/100), bits=500) Traceback (most recent call last): ... ValueError: cannot compute floor(...) using 512 bits of precision sage: floor((33^100 + 1)^(1/100), bits=1000) 33
sage: import numpy sage: a = numpy.linspace(0,2,6) sage: floor(a) array([0., 0., 0., 1., 1., 2.]) sage: floor(x)._sympy_() floor(x)
Test pickling:
sage: loads(dumps(floor)) floor
-
class
sage.functions.other.
Function_frac
¶ Bases:
sage.symbolic.function.BuiltinFunction
The fractional part function \(\{x\}\).
frac(x)
is defined as \(\{x\} = x - \lfloor x\rfloor\).EXAMPLES:
sage: frac(5.4) 0.400000000000000 sage: type(frac(5.4)) <type 'sage.rings.real_mpfr.RealNumber'> sage: frac(456/123) 29/41 sage: var('x') x sage: a = frac(5.4 + x); a frac(x + 5.40000000000000) sage: frac(cos(8)/cos(2)) cos(8)/cos(2) sage: latex(frac(x)) \operatorname{frac}\left(x\right) sage: frac(x)._sympy_() frac(x)
Test pickling:
sage: loads(dumps(floor)) floor
-
class
sage.functions.other.
Function_imag_part
¶ 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
-
class
sage.functions.other.
Function_limit
¶ Bases:
sage.symbolic.function.BuiltinFunction
Placeholder symbolic limit function that is only accessible internally.
This function is called to create formal wrappers of limits that Maxima can’t compute:
sage: a = lim(exp(x^2)*(1-erf(x)), x=infinity); a -limit((erf(x) - 1)*e^(x^2), x, +Infinity)
EXAMPLES:
sage: from sage.functions.other import symbolic_limit as slimit sage: slimit(1/x, x, +oo) limit(1/x, x, +Infinity) sage: var('minus,plus') (minus, plus) sage: slimit(1/x, x, +oo) limit(1/x, x, +Infinity) sage: slimit(1/x, x, 0, plus) limit(1/x, x, 0, plus) sage: slimit(1/x, x, 0, minus) limit(1/x, x, 0, minus)
-
class
sage.functions.other.
Function_prod
¶ Bases:
sage.symbolic.function.BuiltinFunction
Placeholder symbolic product function that is only accessible internally.
EXAMPLES:
sage: from sage.functions.other import symbolic_product as sprod sage: r = sprod(x, x, 1, 10); r product(x, x, 1, 10) sage: r.unhold() 3628800
-
class
sage.functions.other.
Function_real_nth_root
¶ Bases:
sage.symbolic.function.BuiltinFunction
Real \(n\)-th root function \(x^\frac{1}{n}\).
The function assumes positive integer \(n\) and real number \(x\).
EXAMPLES:
sage: real_nth_root(2, 3) 2^(1/3) sage: real_nth_root(-2, 3) -2^(1/3) sage: real_nth_root(8, 3) 2 sage: real_nth_root(-8, 3) -2 sage: real_nth_root(-2, 4) Traceback (most recent call last): ... ValueError: no real nth root of negative real number with even n
For numeric input, it gives a numerical approximation.
sage: real_nth_root(2., 3) 1.25992104989487 sage: real_nth_root(-2., 3) -1.25992104989487
Some symbolic calculus:
sage: f = real_nth_root(x, 5)^3 sage: f real_nth_root(x^3, 5) sage: f.diff() 3/5*x^2*real_nth_root(x^(-12), 5) sage: f.integrate(x) integrate((abs(x)^3)^(1/5)*sgn(x^3), x) sage: _.diff() (abs(x)^3)^(1/5)*sgn(x^3)
-
class
sage.functions.other.
Function_real_part
¶ 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
Sage can recognize some expressions as real and accordingly return the identical argument:
sage: SR.var('x', domain='integer').real_part() x sage: SR.var('x', domain='integer').imag_part() 0 sage: real_part(sin(x)+x) x + sin(x) sage: real_part(x*exp(x)) x*e^x sage: imag_part(sin(x)+x) 0 sage: real_part(real_part(x)) x sage: forget()
-
class
sage.functions.other.
Function_sqrt
¶ Bases:
object
-
class
sage.functions.other.
Function_sum
¶ Bases:
sage.symbolic.function.BuiltinFunction
Placeholder symbolic sum function that is only accessible internally.
EXAMPLES:
sage: from sage.functions.other import symbolic_sum as ssum sage: r = ssum(x, x, 1, 10); r sum(x, x, 1, 10) sage: r.unhold() 55
-
sage.functions.other.
sqrt
(x, *args, **kwds)¶ INPUT:
x
- a numberprec
- integer (default: None): if None, returns an exact square root; otherwise returns a numerical square root if necessary, to the given bits of precision.extend
- bool (default: True); this is a place holder, and is always ignored or passed to the sqrt function for x, since in the symbolic ring everything has a square root.all
- bool (default: False); if True, return all square roots of self, instead of just one.
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)
For a non-symbolic square root, there are a few options. The best is to numerically approximate afterward:
sage: sqrt(2).n() 1.41421356237310 sage: sqrt(2).n(prec=100) 1.4142135623730950488016887242
Or one can input a numerical type.
sage: sqrt(2.) 1.41421356237310 sage: sqrt(2.000000000000000000000000) 1.41421356237309504880169 sage: sqrt(4.0) 2.00000000000000
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 trac ticket #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. ])