Other functions - Functions

Skip to content
Back to top
View this page
Edit this page

# Other functions

class sage.functions.other.Function_Order

  Bases: `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

      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)

  Python

      >>> from sage.all import *
      >>> x = SR('x')                                                           # needs sage.symbolic
      >>> x.Order()                                                             # needs sage.symbolic
      Order(x)
      >>> (x**Integer(2) + x).Order()                                                     # needs sage.symbolic
      Order(x^2 + x)

class sage.functions.other.Function_abs

  Bases: `GinacFunction`

  The absolute value function.

  EXAMPLES:

  Sage

      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)

  Python

      >>> from sage.all import *
      >>> abs(-Integer(2))
      2

      >>> # needs sage.symbolic
      >>> var('x y')
      (x, y)
      >>> abs(x)
      abs(x)
      >>> abs(x**Integer(2) + y**Integer(2))
      abs(x^2 + y^2)
      >>> sqrt(x**Integer(2))
      sqrt(x^2)
      >>> abs(sqrt(x))
      sqrt(abs(x))
      >>> complex(abs(Integer(3)*I))
      (3+0j)

      >>> f = sage.functions.other.Function_abs()
      >>> latex(f)
      \mathrm{abs}
      >>> latex(abs(x))                                                         # needs sage.symbolic
      {\left| x \right|}
      >>> abs(x)._sympy_()                                                      # needs sympy sage.symbolic
      Abs(x)

  Test pickling:

  Sage

      sage: loads(dumps(abs(x)))                                                  # needs sage.symbolic
      abs(x)

  [Python]

      >>> from sage.all import *
      >>> loads(dumps(abs(x)))                                                  # needs sage.symbolic
      abs(x)

class sage.functions.other.Function_arg

  Bases: `BuiltinFunction`

  The argument function for complex numbers.

  EXAMPLES:

  Sage

      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))

  Python

      >>> from sage.all import *
      >>> # needs sage.symbolic
      >>> arg(Integer(3)+i)
      arctan(1/3)
      >>> arg(-Integer(1)+i)
      3/4*pi
      >>> arg(Integer(2)+Integer(2)*i)
      1/4*pi
      >>> arg(Integer(2)+x)
      arg(x + 2)
      >>> arg(RealNumber('2.0')+i+x)
      arg(x + 2.00000000000000 + 1.00000000000000*I)
      >>> arg(-Integer(3))
      pi
      >>> arg(Integer(3))
      0
      >>> arg(Integer(0))
      0

      >>> # needs sage.symbolic
      >>> latex(arg(x))
      {\rm arg}\left(x\right)
      >>> maxima(arg(x))
      atan2(0,_SAGE_VAR_x)
      >>> maxima(arg(Integer(2)+i))
      atan(1/2)
      >>> maxima(arg(sqrt(Integer(2))+i))
      atan(1/sqrt(2))
      >>> arg(x)._sympy_()                                                      # needs sympy
      arg(x)

      >>> arg(Integer(2)+i)                                                              # needs sage.symbolic
      arctan(1/2)
      >>> arg(sqrt(Integer(2))+i)                                                        # needs sage.symbolic
      arg(sqrt(2) + I)
      >>> arg(sqrt(Integer(2))+i).simplify()                                             # needs sage.symbolic
      arctan(1/2*sqrt(2))

class sage.functions.other.Function_binomial

  Bases: `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

      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

  Python

      >>> from sage.all import *
      >>> # needs sage.symbolic
      >>> binomial(Integer(5), Integer(2))
      10
      >>> binomial(Integer(2), Integer(0))
      1
      >>> binomial(Integer(1)/Integer(2), Integer(0))                                                      # needs sage.libs.pari
      1
      >>> binomial(Integer(3), -Integer(1))
      0
      >>> binomial(Integer(20), Integer(10))
      184756
      >>> binomial(-Integer(2), Integer(5))
      -6
      >>> n = var('n'); binomial(n, Integer(2))
      1/2*(n - 1)*n
      >>> n = var('n'); binomial(n, n)
      1
      >>> n = var('n'); binomial(n, n - Integer(1))
      n
      >>> binomial(Integer(2)**Integer(100), Integer(2)**Integer(100))
      1

      >>> binomial(RealField()('2.5'), Integer(2))                                       # needs sage.rings.real_mpfr
      1.87500000000000

  Sage

      sage: k, i = var('k,i')                                                     # needs sage.symbolic
      sage: binomial(k,i)                                                         # needs sage.symbolic
      binomial(k, i)

  [Python]

      >>> from sage.all import *
      >>> k, i = var('k,i')                                                     # needs sage.symbolic
      >>> binomial(k,i)                                                         # needs sage.symbolic
      binomial(k, i)

  We can use a `hold` parameter to prevent automatic evaluation:

  Sage

      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

  Python

      >>> from sage.all import *
      >>> SR(Integer(5)).binomial(Integer(3), hold=True)                                          # needs sage.symbolic
      binomial(5, 3)
      >>> SR(Integer(5)).binomial(Integer(3), hold=True).simplify()                               # needs sage.symbolic
      10

class sage.functions.other.Function_cases

  Bases: `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

      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

  Python

      >>> from sage.all import *
      >>> # needs sage.symbolic
      >>> ex = cases([(x==Integer(0), pi), (True, Integer(0))]); ex
      cases(((x == 0, pi), (1, 0)))
      >>> ex.subs(x==Integer(0))
      pi
      >>> ex.subs(x==Integer(2))
      0
      >>> ex + Integer(1)
      cases(((x == 0, pi), (1, 0))) + 1
      >>> _.subs(x==Integer(0))
      pi + 1

  The first encountered default is used, as well as the first relation that can be trivially decided:

  Sage

      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

  [Python]

      >>> from sage.all import *
      >>> cases(((True, pi), (True, Integer(0))))                                            # needs sage.symbolic
      pi

      >>> # needs sage.symbolic
      >>> _ = var('y')
      >>> ex = cases(((x==Integer(0), pi), (y==Integer(1), Integer(0)))); ex
      cases(((x == 0, pi), (y == 1, 0)))
      >>> ex.subs(x==Integer(0))
      pi
      >>> ex.subs(x==Integer(0), y==Integer(1))
      pi

class sage.functions.other.Function_ceil

  Bases: `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

      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

  Python

      >>> from sage.all import *
      >>> # needs sage.symbolic
      >>> a = ceil(Integer(2)/Integer(5) + x); a
      ceil(x + 2/5)
      >>> a(x=Integer(4))
      5
      >>> a(x=RealNumber('4.0'))
      5
      >>> ZZ(a(x=Integer(3)))
      4
      >>> a = ceil(x**Integer(3) + x + Integer(5)/Integer(2)); a
      ceil(x^3 + x + 5/2)
      >>> a.simplify()
      ceil(x^3 + x + 1/2) + 2
      >>> a(x=Integer(2))
      13

  Sage

      sage: ceil(sin(8)/sin(2))                                                   # needs sage.symbolic
      2

  [Python]

      >>> from sage.all import *
      >>> ceil(sin(Integer(8))/sin(Integer(2)))                                                   # needs sage.symbolic
      2

  Sage

      sage: ceil(5.4)
      6
      sage: type(ceil(5.4))
      <class 'sage.rings.integer.Integer'>

  Python

      >>> from sage.all import *
      >>> ceil(RealNumber('5.4'))
      6
      >>> type(ceil(RealNumber('5.4')))
      <class 'sage.rings.integer.Integer'>

  Sage

      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

  [Python]

      >>> from sage.all import *
      >>> ceil(factorial(Integer(50))/exp(Integer(1)))                                            # needs sage.symbolic
      11188719610782480504630258070757734324011354208865721592720336801
      >>> ceil(SR(Integer(10)**Integer(50) + Integer(10)**(-Integer(50))))                                            # needs sage.symbolic
      100000000000000000000000000000000000000000000000001
      >>> ceil(SR(Integer(10)**Integer(50) - Integer(10)**(-Integer(50))))                                            # needs sage.symbolic
      100000000000000000000000000000000000000000000000000

  Small numbers which are extremely close to an integer are hard to deal with:

  Sage

      sage: ceil((33^100 + 1)^(1/100))                                            # needs sage.symbolic
      Traceback (most recent call last):
      ...
      ValueError: cannot compute ceil(...) using 256 bits of precision

  Python

      >>> from sage.all import *
      >>> ceil((Integer(33)**Integer(100) + Integer(1))**(Integer(1)/Integer(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 `bits` argument:

  Sage

      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

  [Python]

      >>> from sage.all import *
      >>> ceil((Integer(33)**Integer(100) + Integer(1))**(Integer(1)/Integer(100)), bits=Integer(500))                                  # needs sage.symbolic
      Traceback (most recent call last):
      ...
      ValueError: cannot compute ceil(...) using 512 bits of precision
      >>> ceil((Integer(33)**Integer(100) + Integer(1))**(Integer(1)/Integer(100)), bits=Integer(1000))                                 # needs sage.symbolic
      34

  Sage

      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)

  Python

      >>> from sage.all import *
      >>> ceil(sec(e))                                                          # needs sage.symbolic
      -1

      >>> latex(ceil(x))                                                        # needs sage.symbolic
      \left \lceil x \right \rceil
      >>> ceil(x)._sympy_()                                                     # needs sympy sage.symbolic
      ceiling(x)

  Sage

      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.])

  [Python]

      >>> from sage.all import *
      >>> import numpy                                                          # needs numpy
      >>> a = numpy.linspace(Integer(0),Integer(2),Integer(6))                                             # needs numpy
      >>> ceil(a)                                                               # needs numpy
      array([0., 1., 1., 2., 2., 2.])

  Test pickling:

  Sage

      sage: loads(dumps(ceil))
      ceil

  Python

      >>> from sage.all import *
      >>> loads(dumps(ceil))
      ceil

class sage.functions.other.Function_conjugate

  Bases: `GinacFunction`

  Return the complex conjugate of the input.

  It is possible to prevent automatic evaluation using the `hold` parameter:

  Sage

      sage: conjugate(I, hold=True)                                               # needs sage.symbolic
      conjugate(I)

  Python

      >>> from sage.all import *
      >>> 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

      sage: conjugate(I, hold=True).simplify()                                    # needs sage.symbolic
      -I

  [Python]

      >>> from sage.all import *
      >>> conjugate(I, hold=True).simplify()                                    # needs sage.symbolic
      -I

class sage.functions.other.Function_crootof

  Bases: `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

      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

  Python

      >>> from sage.all import *
      >>> # needs sage.symbolic
      >>> c = complex_root_of(x**Integer(6) + x + Integer(1), Integer(1)); c
      complex_root_of(x^6 + x + 1, 1)
      >>> c.n()
      -0.790667188814418 + 0.300506920309552*I
      >>> c.n(Integer(100))
      -0.79066718881441764449859281847 + 0.30050692030955162512001002521*I
      >>> (c**Integer(6) + c + Integer(1)).n(Integer(100)) < RealNumber('1e-25')
      True

class sage.functions.other.Function_elementof

  Bases: `BuiltinFunction`

  Formal 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()`. See `sage.sets.set.Set` and `sage.sets.real_set.RealSet` for possible set arguments.

  EXAMPLES:

  Sage

      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})

  Python

      >>> from sage.all import *
      >>> # needs sage.symbolic
      >>> from sage.functions.other import element_of
      >>> element_of(x, SR(ZZ))
      element_of(x, Integer Ring)
      >>> element_of(sin(x), SR(QQ))
      element_of(sin(x), Rational Field)
      >>> element_of(x, SR(RealSet.open_closed(Integer(0),Integer(1))))
      element_of(x, (0, 1])
      >>> element_of(x, SR(Set([Integer(4),Integer(6),Integer(8)])))
      element_of(x, {8, 4, 6})

class sage.functions.other.Function_factorial

  Bases: `GinacFunction`

  Return the factorial of \(n\).

  INPUT:

  - `n` – a nonnegative integer, a complex number (except negative integers) or any symbolic expression

  OUTPUT: integer or symbolic expression

  EXAMPLES:

  Sage

      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

  Python

      >>> from sage.all import *
      >>> factorial(Integer(0))
      1
      >>> factorial(Integer(4))
      24
      >>> factorial(Integer(10))
      3628800
      >>> factorial(Integer(6)) == Integer(6)*Integer(5)*Integer(4)*Integer(3)*Integer(2)
      True

      >>> # needs sage.symbolic
      >>> x = SR.var('x')
      >>> f = factorial(x + factorial(x)); f
      factorial(x + factorial(x))
      >>> f(x=Integer(3))
      362880
      >>> factorial(x)**Integer(2)
      factorial(x)^2

  To prevent automatic evaluation use the `hold` argument:

  Sage

      sage: factorial(5, hold=True)                                               # needs sage.symbolic
      factorial(5)

  [Python]

      >>> from sage.all import *
      >>> factorial(Integer(5), hold=True)                                               # needs sage.symbolic
      factorial(5)

  To then evaluate again, we currently must use Maxima via `sage.symbolic.expression.Expression.simplify()`:

  Sage

      sage: factorial(5, hold=True).simplify()                                    # needs sage.symbolic
      120

  Python

      >>> from sage.all import *
      >>> factorial(Integer(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

      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

  [Python]

      >>> from sage.all import *
      >>> factorial(Integer(1)/Integer(2))                                                        # needs sage.symbolic
      1/2*sqrt(pi)
      >>> factorial(Integer(3)/Integer(4))                                                        # needs sage.symbolic
      gamma(7/4)
      >>> factorial(RealNumber('2.3'))                                                        # needs sage.symbolic
      2.68343738195577

  But negative input always fails:

  Sage

      sage: factorial(-32)
      Traceback (most recent call last):
      ...
      ValueError: factorial only defined for nonnegative integers

  Python

      >>> from sage.all import *
      >>> factorial(-Integer(32))
      Traceback (most recent call last):
      ...
      ValueError: factorial only defined for nonnegative integers

  And very large integers remain unevaluated:

  Sage

      sage: factorial(2**64)                                                      # needs sage.symbolic
      factorial(18446744073709551616)
      sage: SR(2**64).factorial()                                                 # needs sage.symbolic
      factorial(18446744073709551616)

  [Python]

      >>> from sage.all import *
      >>> factorial(Integer(2)**Integer(64))                                                      # needs sage.symbolic
      factorial(18446744073709551616)
      >>> SR(Integer(2)**Integer(64)).factorial()                                                 # needs sage.symbolic
      factorial(18446744073709551616)

class sage.functions.other.Function_floor

  Bases: `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

      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

  Python

      >>> from sage.all import *
      >>> floor(RealNumber('5.4'))
      5
      >>> type(floor(RealNumber('5.4')))
      <class 'sage.rings.integer.Integer'>

      >>> # needs sage.symbolic
      >>> var('x')
      x
      >>> a = floor(RealNumber('5.25') + x); a
      floor(x + 5.25000000000000)
      >>> a.simplify()
      floor(x + 0.25) + 5
      >>> a(x=Integer(2))
      7

  Sage

      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

  [Python]

      >>> from sage.all import *
      >>> # needs sage.symbolic
      >>> floor(cos(Integer(8)) / cos(Integer(2)))
      0
      >>> floor(log(Integer(4)) / log(Integer(2)))
      2
      >>> a = floor(RealNumber('5.4') + x); a
      floor(x + 5.40000000000000)
      >>> a.subs(x==Integer(2))
      7
      >>> floor(log(Integer(2)**(Integer(3)/Integer(2))) / log(Integer(2)) + Integer(1)/Integer(2))
      2
      >>> floor(log(Integer(2)**(-Integer(3)/Integer(2))) / log(Integer(2)) + Integer(1)/Integer(2))
      -1

  Sage

      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

  Python

      >>> from sage.all import *
      >>> floor(factorial(Integer(50))/exp(Integer(1)))                                           # needs sage.symbolic
      11188719610782480504630258070757734324011354208865721592720336800
      >>> floor(SR(Integer(10)**Integer(50) + Integer(10)**(-Integer(50))))                                           # needs sage.symbolic
      100000000000000000000000000000000000000000000000000
      >>> floor(SR(Integer(10)**Integer(50) - Integer(10)**(-Integer(50))))                                           # needs sage.symbolic
      99999999999999999999999999999999999999999999999999
      >>> floor(int(Integer(10)**Integer(50)))
      100000000000000000000000000000000000000000000000000

  Small numbers which are extremely close to an integer are hard to deal with:

  Sage

      sage: floor((33^100 + 1)^(1/100))                                           # needs sage.symbolic
      Traceback (most recent call last):
      ...
      ValueError: cannot compute floor(...) using 256 bits of precision

  [Python]

      >>> from sage.all import *
      >>> floor((Integer(33)**Integer(100) + Integer(1))**(Integer(1)/Integer(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 `bits` argument:

  Sage

      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

  Python

      >>> from sage.all import *
      >>> floor((Integer(33)**Integer(100) + Integer(1))**(Integer(1)/Integer(100)), bits=Integer(500))                                 # needs sage.symbolic
      Traceback (most recent call last):
      ...
      ValueError: cannot compute floor(...) using 512 bits of precision
      >>> floor((Integer(33)**Integer(100) + Integer(1))**(Integer(1)/Integer(100)), bits=Integer(1000))                                # needs sage.symbolic
      33

  Sage

      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)

  [Python]

      >>> from sage.all import *
      >>> import numpy                                                          # needs numpy
      >>> a = numpy.linspace(Integer(0),Integer(2),Integer(6))                                             # needs numpy
      >>> floor(a)                                                              # needs numpy
      array([0., 0., 0., 1., 1., 2.])
      >>> floor(x)._sympy_()                                                    # needs sympy sage.symbolic
      floor(x)

  Test pickling:

  Sage

      sage: loads(dumps(floor))
      floor

  Python

      >>> from sage.all import *
      >>> loads(dumps(floor))
      floor

class sage.functions.other.Function_frac

  Bases: `BuiltinFunction`

  The fractional part function \(\{x\}\).

  `frac(x)` is defined as \(\{x\} = x - \lfloor x\rfloor\).

  EXAMPLES:

  Sage

      sage: frac(5.4)                                                             # needs sage.rings.real_mpfr
      0.400000000000000
      sage: type(frac(5.4))                                                       # needs sage.rings.real_mpfr
      <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)

  Python

      >>> from sage.all import *
      >>> frac(RealNumber('5.4'))                                                             # needs sage.rings.real_mpfr
      0.400000000000000
      >>> type(frac(RealNumber('5.4')))                                                       # needs sage.rings.real_mpfr
      <class 'sage.rings.real_mpfr.RealNumber'>
      >>> frac(Integer(456)/Integer(123))
      29/41

      >>> # needs sage.symbolic
      >>> var('x')
      x
      >>> a = frac(RealNumber('5.4') + x); a
      frac(x + 5.40000000000000)
      >>> frac(cos(Integer(8))/cos(Integer(2)))
      cos(8)/cos(2)
      >>> latex(frac(x))
      \operatorname{frac}\left(x\right)
      >>> frac(x)._sympy_()                                                     # needs sympy
      frac(x)

  Test pickling:

  Sage

      sage: loads(dumps(floor))
      floor

  [Python]

      >>> from sage.all import *
      >>> loads(dumps(floor))
      floor

class sage.functions.other.Function_imag_part

  Bases: `GinacFunction`

  Return the imaginary part of the (possibly complex) input.

  It is possible to prevent automatic evaluation using the `hold` parameter:

  Sage

      sage: imag_part(I, hold=True)                                               # needs sage.symbolic
      imag_part(I)

  Python

      >>> from sage.all import *
      >>> 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

      sage: imag_part(I, hold=True).simplify()                                    # needs sage.symbolic
      1

  [Python]

      >>> from sage.all import *
      >>> imag_part(I, hold=True).simplify()                                    # needs sage.symbolic
      1

class sage.functions.other.Function_limit

  Bases: `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

      sage: a = lim(exp(x^2)*(1-erf(x)), x=infinity); a                               # needs sage.symbolic
      -limit((erf(x) - 1)*e^(x^2), x, +Infinity)

  Python

      >>> from sage.all import *
      >>> a = lim(exp(x**Integer(2))*(Integer(1)-erf(x)), x=infinity); a                               # needs sage.symbolic
      -limit((erf(x) - 1)*e^(x^2), x, +Infinity)

  EXAMPLES:

  Sage

      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)

  [Python]

      >>> from sage.all import *
      >>> # needs sage.symbolic
      >>> from sage.functions.other import symbolic_limit as slimit
      >>> slimit(Integer(1)/x, x, +oo)
      limit(1/x, x, +Infinity)
      >>> var('minus,plus')
      (minus, plus)
      >>> slimit(Integer(1)/x, x, +oo)
      limit(1/x, x, +Infinity)
      >>> slimit(Integer(1)/x, x, Integer(0), plus)
      limit(1/x, x, 0, plus)
      >>> slimit(Integer(1)/x, x, Integer(0), minus)
      limit(1/x, x, 0, minus)

class sage.functions.other.Function_prod

  Bases: `BuiltinFunction`

  Placeholder symbolic product function that is only accessible internally.

  EXAMPLES:

  Sage

      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

  Python

      >>> from sage.all import *
      >>> from sage.functions.other import symbolic_product as sprod
      >>> r = sprod(x, x, Integer(1), Integer(10)); r                                                 # needs sage.symbolic
      product(x, x, 1, 10)
      >>> r.unhold()                                                                # needs sage.symbolic
      3628800

class sage.functions.other.Function_real_nth_root

  Bases: `BuiltinFunction`

  Real \(n\)-th root function \(x^\frac{1}{n}\).

  The function assumes positive integer \(n\) and real number \(x\).

  EXAMPLES:

  Sage

      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

  Python

      >>> from sage.all import *
      >>> real_nth_root(Integer(2), Integer(3))                                                       # needs sage.symbolic
      2^(1/3)
      >>> real_nth_root(-Integer(2), Integer(3))                                                      # needs sage.symbolic
      -2^(1/3)
      >>> real_nth_root(Integer(8), Integer(3))
      2
      >>> real_nth_root(-Integer(8), Integer(3))
      -2

      >>> real_nth_root(-Integer(2), Integer(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

      sage: real_nth_root(2., 3)                                                      # needs sage.rings.real_mpfr
      1.25992104989487
      sage: real_nth_root(-2., 3)                                                     # needs sage.rings.real_mpfr
      -1.25992104989487

  [Python]

      >>> from sage.all import *
      >>> real_nth_root(RealNumber('2.'), Integer(3))                                                      # needs sage.rings.real_mpfr
      1.25992104989487
      >>> real_nth_root(-RealNumber('2.'), Integer(3))                                                     # needs sage.rings.real_mpfr
      -1.25992104989487

  Some symbolic calculus:

  Sage

      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)

  Python

      >>> from sage.all import *
      >>> # needs sage.symbolic
      >>> f = real_nth_root(x, Integer(5))**Integer(3); f
      real_nth_root(x^3, 5)
      >>> f.diff()
      3/5*x^2*real_nth_root(x^(-12), 5)
      >>> result = f.integrate(x)
      ...
      >>> result
      integrate((abs(x)^3)^(1/5)*sgn(x^3), x)
      >>> _.diff()
      (abs(x)^3)^(1/5)*sgn(x^3)

class sage.functions.other.Function_real_part

  Bases: `GinacFunction`

  Return the real part of the (possibly complex) input.

  It is possible to prevent automatic evaluation using the `hold` parameter:

  Sage

      sage: real_part(I, hold=True)                                               # needs sage.symbolic
      real_part(I)

  Python

      >>> from sage.all import *
      >>> 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

      sage: real_part(I, hold=True).simplify()                                    # needs sage.symbolic
      0

  [Python]

      >>> from sage.all import *
      >>> real_part(I, hold=True).simplify()                                    # needs sage.symbolic
      0

  EXAMPLES:

  Sage

      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)                                                               # needs sage.rings.real_mpfr
      2.50000000000000
      sage: type(real(a))                                                         # needs sage.rings.real_mpfr
      <class 'sage.rings.real_mpfr.RealLiteral'>
      sage: real(1.0r)
      1.0
      sage: real(complex(3, 4))
      3.0

  Python

      >>> from sage.all import *
      >>> z = Integer(1)+Integer(2)*I                                                             # needs sage.symbolic
      >>> real(z)                                                               # needs sage.symbolic
      1
      >>> real(Integer(5)/Integer(3))
      5/3
      >>> a = RealNumber('2.5')
      >>> real(a)                                                               # needs sage.rings.real_mpfr
      2.50000000000000
      >>> type(real(a))                                                         # needs sage.rings.real_mpfr
      <class 'sage.rings.real_mpfr.RealLiteral'>
      >>> real(1.0)
      1.0
      >>> real(complex(Integer(3), Integer(4)))
      3.0

  Sage can recognize some expressions as real and accordingly return the identical argument:

  Sage

      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()

  [Python]

      >>> from sage.all import *
      >>> # needs sage.symbolic
      >>> SR.var('x', domain='integer').real_part()
      x
      >>> SR.var('x', domain='integer').imag_part()
      0
      >>> real_part(sin(x)+x)
      x + sin(x)
      >>> real_part(x*exp(x))
      x*e^x
      >>> imag_part(sin(x)+x)
      0
      >>> real_part(real_part(x))
      x
      >>> forget()

class sage.functions.other.Function_sqrt

  Bases: `object`

class sage.functions.other.Function_sum

  Bases: `BuiltinFunction`

  Placeholder symbolic sum function that is only accessible internally.

  EXAMPLES:

  Sage

      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

  Python

      >>> from sage.all import *
      >>> from sage.functions.other import symbolic_sum as ssum
      >>> r = ssum(x, x, Integer(1), Integer(10)); r                                                  # needs sage.symbolic
      sum(x, x, 1, 10)
      >>> r.unhold()                                                                # needs sage.symbolic
      55