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.

See also

Order(), big_oh

EXAMPLES:

sage: x = SR('x')
sage: x.Order()
Order(x)
sage: (x^2 + x).Order()
Order(x^2 + x)
sage: x.Order()._sympy_()
O(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. Either m or x-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.

  1. 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 returns Integer(math.ceil(x)).
  2. 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 the RealIntervalField is increased until they do match up or it reaches bits of precision.
  3. 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.

  1. 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 returns Integer(math.floor(x)).
  2. 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 the RealIntervalField is increased until they do match up or it reaches bits of precision.
  3. 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_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 number
  • prec - 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.        ])