Other functions#
- class sage.functions.other.Function_Order#
Bases:
GinacFunctionThe order function.
This function gives the order of magnitude of some expression, similar to \(O\)-terms.
EXAMPLES:
sage: x = SR('x') # needs sage.symbolic sage: x.Order() # needs sage.symbolic Order(x) sage: (x^2 + x).Order() # needs sage.symbolic Order(x^2 + x)
- class sage.functions.other.Function_abs#
Bases:
GinacFunctionThe absolute value function.
EXAMPLES:
sage: abs(-2) 2 sage: # needs sage.symbolic sage: var('x y') (x, y) sage: abs(x) abs(x) sage: abs(x^2 + y^2) abs(x^2 + y^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)) # needs sage.symbolic {\left| x \right|} sage: abs(x)._sympy_() # needs sympy sage.symbolic Abs(x)
Test pickling:
sage: loads(dumps(abs(x))) # needs sage.symbolic abs(x)
- class sage.functions.other.Function_arg#
Bases:
BuiltinFunctionThe argument function for complex numbers.
EXAMPLES:
sage: # needs sage.symbolic 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: # needs sage.symbolic 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_() # needs sympy arg(x) sage: arg(2+i) # needs sage.symbolic arctan(1/2) sage: arg(sqrt(2)+i) # needs sage.symbolic arg(sqrt(2) + I) sage: arg(sqrt(2)+i).simplify() # needs sage.symbolic arctan(1/2*sqrt(2))
- class sage.functions.other.Function_binomial#
Bases:
GinacFunctionReturn 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. Eithermorx-mmust be an integer, else the output is symbolic.
OUTPUT: number or symbolic expression (if input is symbolic)
EXAMPLES:
sage: # needs sage.symbolic sage: binomial(5, 2) 10 sage: binomial(2, 0) 1 sage: binomial(1/2, 0) # needs sage.libs.pari 1 sage: binomial(3, -1) 0 sage: binomial(20, 10) 184756 sage: binomial(-2, 5) -6 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: binomial(RealField()('2.5'), 2) # needs sage.rings.real_mpfr 1.87500000000000
sage: k, i = var('k,i') # needs sage.symbolic sage: binomial(k,i) # needs sage.symbolic binomial(k, i)
We can use a
holdparameter to prevent automatic evaluation:sage: SR(5).binomial(3, hold=True) # needs sage.symbolic binomial(5, 3) sage: SR(5).binomial(3, hold=True).simplify() # needs sage.symbolic 10
- class sage.functions.other.Function_cases#
Bases:
GinacFunctionFormal 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: # needs sage.symbolic 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))) # needs sage.symbolic pi sage: # needs sage.symbolic 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:
BuiltinFunctionThe 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
RealIntervalFieldwith 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 theRealIntervalFieldis increased until they do match up or it reachesbitsof precision.If none of the above work, Sage returns a
Expressionobject.
EXAMPLES:
sage: # needs sage.symbolic sage: a = ceil(2/5 + x); 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)) # needs sage.symbolic 2
sage: ceil(5.4) 6 sage: type(ceil(5.4)) <class 'sage.rings.integer.Integer'>
sage: ceil(factorial(50)/exp(1)) # needs sage.symbolic 11188719610782480504630258070757734324011354208865721592720336801 sage: ceil(SR(10^50 + 10^(-50))) # needs sage.symbolic 100000000000000000000000000000000000000000000000001 sage: ceil(SR(10^50 - 10^(-50))) # needs sage.symbolic 100000000000000000000000000000000000000000000000000
Small numbers which are extremely close to an integer are hard to deal with:
sage: ceil((33^100 + 1)^(1/100)) # needs sage.symbolic Traceback (most recent call last): ... ValueError: cannot compute ceil(...) using 256 bits of precision
This can be fixed by giving a sufficiently large
bitsargument:sage: ceil((33^100 + 1)^(1/100), bits=500) # needs sage.symbolic Traceback (most recent call last): ... ValueError: cannot compute ceil(...) using 512 bits of precision sage: ceil((33^100 + 1)^(1/100), bits=1000) # needs sage.symbolic 34
sage: ceil(sec(e)) # needs sage.symbolic -1 sage: latex(ceil(x)) # needs sage.symbolic \left \lceil x \right \rceil sage: ceil(x)._sympy_() # needs sympy sage.symbolic ceiling(x)
sage: import numpy # needs numpy sage: a = numpy.linspace(0,2,6) # needs numpy sage: ceil(a) # needs numpy array([0., 1., 1., 2., 2., 2.])
Test pickling:
sage: loads(dumps(ceil)) ceil
- class sage.functions.other.Function_conjugate#
Bases:
GinacFunctionReturns the complex conjugate of the input.
It is possible to prevent automatic evaluation using the
holdparameter:sage: conjugate(I, hold=True) # needs sage.symbolic conjugate(I)
To then evaluate again, we currently must use Maxima via
sage.symbolic.expression.Expression.simplify():sage: conjugate(I, hold=True).simplify() # needs sage.symbolic -I
- class sage.functions.other.Function_crootof#
Bases:
BuiltinFunctionFormal 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: # needs sage.symbolic 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_elementof#
Bases:
BuiltinFunctionFormal set membership function that is only accessible internally.
This function is called to express a set membership statement, usually as part of a solution set returned by
solve(). Seesage.sets.set.Setandsage.sets.real_set.RealSetfor possible set arguments.EXAMPLES:
sage: # needs sage.symbolic sage: from sage.functions.other import element_of sage: element_of(x, SR(ZZ)) element_of(x, Integer Ring) sage: element_of(sin(x), SR(QQ)) element_of(sin(x), Rational Field) sage: element_of(x, SR(RealSet.open_closed(0,1))) element_of(x, (0, 1]) sage: element_of(x, SR(Set([4,6,8]))) element_of(x, {8, 4, 6})
- class sage.functions.other.Function_factorial#
Bases:
GinacFunctionReturns 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: # needs sage.symbolic 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
holdargument:sage: factorial(5, hold=True) # needs sage.symbolic factorial(5)
To then evaluate again, we currently must use Maxima via
sage.symbolic.expression.Expression.simplify():sage: factorial(5, hold=True).simplify() # needs sage.symbolic 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) # needs sage.symbolic 1/2*sqrt(pi) sage: factorial(3/4) # needs sage.symbolic gamma(7/4) sage: factorial(2.3) # needs sage.symbolic 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) # needs sage.symbolic factorial(18446744073709551616) sage: SR(2**64).factorial() # needs sage.symbolic factorial(18446744073709551616)
- class sage.functions.other.Function_floor#
Bases:
BuiltinFunctionThe 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
RealIntervalFieldwith 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 theRealIntervalFieldis increased until they do match up or it reachesbitsof precision.If none of the above work, Sage returns a symbolic
Expressionobject.
EXAMPLES:
sage: floor(5.4) 5 sage: type(floor(5.4)) <class 'sage.rings.integer.Integer'> sage: # needs sage.symbolic sage: var('x') x sage: a = floor(5.25 + x); a floor(x + 5.25000000000000) sage: a.simplify() floor(x + 0.25) + 5 sage: a(x=2) 7
sage: # needs sage.symbolic 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)) # needs sage.symbolic 11188719610782480504630258070757734324011354208865721592720336800 sage: floor(SR(10^50 + 10^(-50))) # needs sage.symbolic 100000000000000000000000000000000000000000000000000 sage: floor(SR(10^50 - 10^(-50))) # needs sage.symbolic 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)) # needs sage.symbolic Traceback (most recent call last): ... ValueError: cannot compute floor(...) using 256 bits of precision
This can be fixed by giving a sufficiently large
bitsargument:sage: floor((33^100 + 1)^(1/100), bits=500) # needs sage.symbolic Traceback (most recent call last): ... ValueError: cannot compute floor(...) using 512 bits of precision sage: floor((33^100 + 1)^(1/100), bits=1000) # needs sage.symbolic 33
sage: import numpy # needs numpy sage: a = numpy.linspace(0,2,6) # needs numpy sage: floor(a) # needs numpy array([0., 0., 0., 1., 1., 2.]) sage: floor(x)._sympy_() # needs sympy sage.symbolic floor(x)
Test pickling:
sage: loads(dumps(floor)) floor
- class sage.functions.other.Function_frac#
Bases:
BuiltinFunctionThe 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)) <class 'sage.rings.real_mpfr.RealNumber'> sage: frac(456/123) 29/41 sage: # needs sage.symbolic 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_() # needs sympy frac(x)
Test pickling:
sage: loads(dumps(floor)) floor
- class sage.functions.other.Function_imag_part#
Bases:
GinacFunctionReturns the imaginary part of the (possibly complex) input.
It is possible to prevent automatic evaluation using the
holdparameter:sage: imag_part(I, hold=True) # needs sage.symbolic 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() # needs sage.symbolic 1
- class sage.functions.other.Function_limit#
Bases:
BuiltinFunctionPlaceholder 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 # needs sage.symbolic -limit((erf(x) - 1)*e^(x^2), x, +Infinity)
EXAMPLES:
sage: # needs sage.symbolic 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:
BuiltinFunctionPlaceholder 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 # needs sage.symbolic product(x, x, 1, 10) sage: r.unhold() # needs sage.symbolic 3628800
- class sage.functions.other.Function_real_nth_root#
Bases:
BuiltinFunctionReal \(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) # needs sage.symbolic 2^(1/3) sage: real_nth_root(-2, 3) # needs sage.symbolic -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: # needs sage.symbolic sage: f = real_nth_root(x, 5)^3; f real_nth_root(x^3, 5) sage: f.diff() 3/5*x^2*real_nth_root(x^(-12), 5) sage: result = f.integrate(x) ... sage: result 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:
GinacFunctionReturns the real part of the (possibly complex) input.
It is possible to prevent automatic evaluation using the
holdparameter:sage: real_part(I, hold=True) # needs sage.symbolic 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() # needs sage.symbolic 0
EXAMPLES:
sage: z = 1+2*I # needs sage.symbolic sage: real(z) # needs sage.symbolic 1 sage: real(5/3) 5/3 sage: a = 2.5 sage: real(a) 2.50000000000000 sage: type(real(a)) <class '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: # needs sage.symbolic 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:
BuiltinFunctionPlaceholder 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 # needs sage.symbolic sum(x, x, 1, 10) sage: r.unhold() # needs sage.symbolic 55