12.7 Functional notation

Module: sage.misc.functional

Functional notation

These are function so that you can write foo(x) instead of x.foo() in certain common cases.

Author Log:

Module-level Functions

N( x, [prec=None], [digits=None])

Return a numerical approximation of x with at least prec bits of precision.

NOTE: Both upper case N and lower case n are aliases for numerical_approx.

Input:

x
- an object that has a numerical_approx method, or can be coerced into a real or complex field
prec (optional)
- an integer (bits of precision)
digits (optional)
- an integer (digits of precision)

If neither the prec or digits are specified, the default is 53 bits of precision.

sage: numerical_approx(pi, 10)
3.1
sage: numerical_approx(pi, digits=10)
3.141592654
sage: numerical_approx(pi^2 + e, digits=20)
12.587886229548403854
sage: n(pi^2 + e)        
12.5878862295484
sage: N(pi^2 + e)
12.5878862295484
sage: n(pi^2 + e, digits=50)
12.587886229548403854194778471228813633070946500941

You can also usually use method notation:

sage: (pi^2 + e).n()
12.5878862295484

acos( x)

Return the arc cosine of x.

additive_order( x)

Return the additive order of $ x$ .

arg( x)

Return the argument of a complex number $ x$ .

sage: z = CC(1,2)
sage: theta = arg(z)
sage: cos(theta)*abs(z)   
1.00000000000000
sage: sin(theta)*abs(z)
2.00000000000000

asin( x)

Return the arc sine of x.

atan( x)

Return the arc tangent of x.

base_field( x)

Return the base field over which x is defined.

base_ring( x)

Return the base ring over which x is defined.

sage: R = PolynomialRing(GF(7), 'x')
sage: base_ring(R)
Finite Field of size 7

basis( x)

Return the fixed basis of x.

sage: V = VectorSpace(QQ,3)
sage: S = V.subspace([[1,2,0],[2,2,-1]])
sage: basis(S)
[
(1, 0, -1),
(0, 1, 1/2)
]

category( x)

Return the category of x.

sage: V = VectorSpace(QQ,3)
sage: category(V)
Category of vector spaces over Rational Field

ceil( x)

characteristic_polynomial( x, [var=x])

Return the characteristic polynomial of x in the given variable.

sage: M = MatrixSpace(QQ,3,3)
sage: A = M([1,2,3,4,5,6,7,8,9])
sage: charpoly(A)
x^3 - 15*x^2 - 18*x
sage: charpoly(A, 't')
t^3 - 15*t^2 - 18*t

sage: k.<alpha> = GF(7^10); k
Finite Field in alpha of size 7^10
sage: alpha.charpoly('T')
T^10 + T^6 + T^5 + 4*T^4 + T^3 + 2*T^2 + 3*T + 3
sage: characteristic_polynomial(alpha, 'T')
T^10 + T^6 + T^5 + 4*T^4 + T^3 + 2*T^2 + 3*T + 3

charpoly( x, [var=x])

Return the characteristic polynomial of x in the given variable.

sage: M = MatrixSpace(QQ,3,3)
sage: A = M([1,2,3,4,5,6,7,8,9])
sage: charpoly(A)
x^3 - 15*x^2 - 18*x
sage: charpoly(A, 't')
t^3 - 15*t^2 - 18*t

sage: k.<alpha> = GF(7^10); k
Finite Field in alpha of size 7^10
sage: alpha.charpoly('T')
T^10 + T^6 + T^5 + 4*T^4 + T^3 + 2*T^2 + 3*T + 3
sage: characteristic_polynomial(alpha, 'T')
T^10 + T^6 + T^5 + 4*T^4 + T^3 + 2*T^2 + 3*T + 3

coerce( P, x)

cyclotomic_polynomial( n, [var=x])

sage: cyclotomic_polynomial(3)
x^2 + x + 1
sage: cyclotomic_polynomial(4)
x^2 + 1
sage: cyclotomic_polynomial(9)
x^6 + x^3 + 1
sage: cyclotomic_polynomial(10)
x^4 - x^3 + x^2 - x + 1
sage: cyclotomic_polynomial(11)
x^10 + x^9 + x^8 + x^7 + x^6 + x^5 + x^4 + x^3 + x^2 + x + 1

decomposition( x)

Return the decomposition of x.

denominator( x)

Return the denominator of x.

sage: denominator(17/11111)
11111
sage: R.<x> = PolynomialRing(QQ)
sage: F = FractionField(R)
sage: r = (x+1)/(x-1)
sage: denominator(r)
x - 1

det( x)

Return the determinant of x.

sage: M = MatrixSpace(QQ,3,3)
sage: A = M([1,2,3,4,5,6,7,8,9])
sage: det(A)
0

dim( x)

Return the dimension of x.

sage: V = VectorSpace(QQ,3)
sage: S = V.subspace([[1,2,0],[2,2,-1]])
sage: dimension(S)
2

dimension( x)

Return the dimension of x.

sage: V = VectorSpace(QQ,3)
sage: S = V.subspace([[1,2,0],[2,2,-1]])
sage: dimension(S)
2

disc( x)

sage: R.<x> = PolynomialRing(QQ)
sage: S = R.quotient(x^29 - 17*x - 1, 'alpha')
sage: K = S.number_field()
sage: discriminant(K)
-15975100446626038280218213241591829458737190477345113376757479850566957249
523

discriminant( x)

sage: R.<x> = PolynomialRing(QQ)
sage: S = R.quotient(x^29 - 17*x - 1, 'alpha')
sage: K = S.number_field()
sage: discriminant(K)
-15975100446626038280218213241591829458737190477345113376757479850566957249
523

eta( x)

Return the value of the eta function at $ x$ , which must be in the upper half plane.

The $ \eta$ function is

$\displaystyle \eta(z) = e^{\pi i z / 12} \prod_{n=1}^{\infty}(1-e^{2\pi inz})
$

sage: eta(1+I)
0.742048775837 + 0.19883137023*I

exp( x)

Return the value of the exponentation function at x.

factor( x)

Return the prime factorization of x.

sage: factor(factorial(10))
2^8 * 3^4 * 5^2 * 7
sage: n = next_prime(10^6); n
1000003
sage: factor(n)
1000003

factorisation( x)

Return the prime factorization of x.

sage: factor(factorial(10))
2^8 * 3^4 * 5^2 * 7
sage: n = next_prime(10^6); n
1000003
sage: factor(n)
1000003

factorization( x)

Return the prime factorization of x.

sage: factor(factorial(10))
2^8 * 3^4 * 5^2 * 7
sage: n = next_prime(10^6); n
1000003
sage: factor(n)
1000003

fcp( x, [var=x])

Return the factorization of the characteristic polynomial of x.

sage: M = MatrixSpace(QQ,3,3)
sage: A = M([1,2,3,4,5,6,7,8,9])
sage: fcp(A, 'x')
x * (x^2 - 15*x - 18)

gen( x)

Return the generator of x.

gens( x)

Return the generators of x.

hecke_operator( x, n)

Return the n-th Hecke operator T_n acting on x.

sage: M = ModularSymbols(1,12)
sage: hecke_operator(M,5)
Hecke operator T_5 on Modular Symbols space of dimension 3 for Gamma_0(1)
of weight 12 with sign 0 over Rational Field

ideal( )

Return the ideal generated by x where x is an element or list.

sage: R.<x> = PolynomialRing(QQ)
sage: ideal(x^2-2*x+1, x^2-1)
Principal ideal (x - 1) of Univariate Polynomial Ring in x over Rational
Field
sage: ideal([x^2-2*x+1, x^2-1])
Principal ideal (x - 1) of Univariate Polynomial Ring in x over Rational
Field

imag( x)

Return the imaginary part of x.

image( x)

Return the image of x.

sage: M = MatrixSpace(QQ,3,3)
sage: A = M([1,2,3,4,5,6,7,8,9])
sage: image(A)
Vector space of degree 3 and dimension 2 over Rational Field
Basis matrix:
[ 1  0 -1]
[ 0  1  2]

imaginary( x)

Return the imaginary part of a complex number.

sage: z = 1+2*I
sage: imaginary(z)
2
sage: imag(z)
2

integral( x)

Return an indefinite integral of an object x.

First call x.integrate() and if that fails make an object and integrate it using maxima, maple, etc, as specified by algorithm.

sage: f = cyclotomic_polynomial(10)
sage: integral(f)
1/5*x^5 - 1/4*x^4 + 1/3*x^3 - 1/2*x^2 + x
sage: integral(sin(x),x)
-cos(x)

sage: y = var('y')
sage: integral(sin(x),y)
sin(x)*y
sage: integral(sin(x), x, 0, pi/2)
1
sage: sin(x).integral(x, 0,pi/2)
1

integral_closure( x)

interval( a, b)

Integers between a and b inclusive (a and b integers).

sage: I = interval(1,3)
sage: 2 in I
True
sage: 1 in I
True
sage: 4 in I
False

is_commutative( x)

sage: R = PolynomialRing(QQ, 'x')
sage: is_commutative(R)
True

is_even( x)

Return whether or not an integer x is even, e.g., divisible by 2.

sage: is_even(-1)
False
sage: is_even(4)
True
sage: is_even(-2)
True

is_field( x)

sage: R = PolynomialRing(QQ, 'x')
sage: F = FractionField(R)
sage: is_field(F)
True

is_integrally_closed( x)

is_noetherian( x)

is_odd( x)

Return whether or not x is odd. This is by definition the complement of is_even.

sage: is_odd(-2)
False
sage: is_odd(-3)
True
sage: is_odd(0)
False
sage: is_odd(1)
True

isqrt( x)

Return an integer square root, i.e., the floor of a square root.

sage: isqrt(10)
3
sage: isqrt(10r)
3

kernel( x)

Return the kernel of x.

sage: M = MatrixSpace(QQ,3,3)
sage: A = M([1,2,3,4,5,6,7,8,9])
sage: kernel(A)
Vector space of degree 3 and dimension 1 over Rational Field
Basis matrix:
[ 1 -2  1]

krull_dimension( x)

lift( x)

Lift an object of a quotient ring $ R/I$ to $ R$ .

We lift an integer modulo $ 3$ .

sage: Mod(2,3).lift()
2

We lift an element of a quotient polynomial ring.

sage: R.<x> = QQ['x']
sage: S.<xmod> = R.quo(x^2 + 1)
sage: lift(xmod-7)
x - 7

log( x, [b=None])

Return the log of x to the base b. The default base is e.

Input:

x
- number
b
- base (default: None, which means natural log)

Output: number

Note: In Magma, the order of arguments is reversed from in Sage, i.e., the base is given first. We use the opposite ordering, so the base can be viewed as an optional second argument.

minimal_polynomial( x, [var=x])

Return the minimal polynomial of x.

sage: a = matrix(ZZ, 2, [1..4])
sage: minpoly(a)
x^2 - 5*x - 2
sage: minpoly(a,'t')
t^2 - 5*t - 2
sage: minimal_polynomial(a)
x^2 - 5*x - 2
sage: minimal_polynomial(a,'theta')
theta^2 - 5*theta - 2

minpoly( x, [var=x])

Return the minimal polynomial of x.

sage: a = matrix(ZZ, 2, [1..4])
sage: minpoly(a)
x^2 - 5*x - 2
sage: minpoly(a,'t')
t^2 - 5*t - 2
sage: minimal_polynomial(a)
x^2 - 5*x - 2
sage: minimal_polynomial(a,'theta')
theta^2 - 5*theta - 2

multiplicative_order( x)

Return the multiplicative order of self, if self is a unit, or raise ArithmeticError otherwise.

n( x, [prec=None], [digits=None])

Return a numerical approximation of x with at least prec bits of precision.

NOTE: Both upper case N and lower case n are aliases for numerical_approx.

Input:

x
- an object that has a numerical_approx method, or can be coerced into a real or complex field
prec (optional)
- an integer (bits of precision)
digits (optional)
- an integer (digits of precision)

If neither the prec or digits are specified, the default is 53 bits of precision.

sage: numerical_approx(pi, 10)
3.1
sage: numerical_approx(pi, digits=10)
3.141592654
sage: numerical_approx(pi^2 + e, digits=20)
12.587886229548403854
sage: n(pi^2 + e)        
12.5878862295484
sage: N(pi^2 + e)
12.5878862295484
sage: n(pi^2 + e, digits=50)
12.587886229548403854194778471228813633070946500941

You can also usually use method notation:

sage: (pi^2 + e).n()
12.5878862295484

ngens( x)

Return the number of generators of x.

norm( x)

Return the norm of x.

sage: z = 1+2*I
sage: norm(z)
5
sage: norm(CDF(z))
5.0
sage: norm(CC(z))
5.00000000000000

numerator( x)

Return the numerator of x.

sage: R.<x> = PolynomialRing(QQ)
sage: F = FractionField(R)
sage: r = (x+1)/(x-1)
sage: numerator(r)
x + 1
sage: numerator(17/11111)
17

numerical_approx( x, [prec=None], [digits=None])

Return a numerical approximation of x with at least prec bits of precision.

NOTE: Both upper case N and lower case n are aliases for numerical_approx.

Input:

x
- an object that has a numerical_approx method, or can be coerced into a real or complex field
prec (optional)
- an integer (bits of precision)
digits (optional)
- an integer (digits of precision)

If neither the prec or digits are specified, the default is 53 bits of precision.

sage: numerical_approx(pi, 10)
3.1
sage: numerical_approx(pi, digits=10)
3.141592654
sage: numerical_approx(pi^2 + e, digits=20)
12.587886229548403854
sage: n(pi^2 + e)        
12.5878862295484
sage: N(pi^2 + e)
12.5878862295484
sage: n(pi^2 + e, digits=50)
12.587886229548403854194778471228813633070946500941

You can also usually use method notation:

sage: (pi^2 + e).n()
12.5878862295484

objgen( x)

sage: R, x = objgen(FractionField(QQ['x']))
sage: R
Fraction Field of Univariate Polynomial Ring in x over Rational Field
sage: x
x

objgens( x)

sage: R, x = objgens(PolynomialRing(QQ,3, 'x'))
sage: R
Multivariate Polynomial Ring in x0, x1, x2 over Rational Field
sage: x
(x0, x1, x2)

one( R)

Return the one element of the ring R.

sage: R.<x> = PolynomialRing(QQ)
sage: one(R)*x == x
True
sage: one(R) in R
True

order( x)

Return the order of x. If x is a ring or module element, this is the additive order of x.

sage: C = CyclicPermutationGroup(10)
sage: order(C)
10
sage: F = GF(7)
sage: order(F)
7

parent( x)

Return x.parent() if defined, or type(x) if not.

sage: Z = parent(int(5))
sage: Z(17)
17
sage: Z
<type 'int'>

quo( x, y)

Return the quotient object x/y, e.g., a quotient of numbers or of a polynomial ring x by the ideal generated by y, etc.

quotient( x, y)

Return the quotient object x/y, e.g., a quotient of numbers or of a polynomial ring x by the ideal generated by y, etc.

rank( x)

Return the rank of x.

We compute the rank of a matrix:

sage: M = MatrixSpace(QQ,3,3)
sage: A = M([1,2,3,4,5,6,7,8,9])
sage: rank(A)
2

We compute the rank of an elliptic curve:

sage: E = EllipticCurve([0,0,1,-1,0])
sage: rank(E)
1

real( x)

Return the real part of x.

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.RealNumber'>

regulator( x)

Return the regulator of x.

round( x, [ndigits=0])

round(number[, ndigits]) -> double-precision real number

Round a number to a given precision in decimal digits (default 0 digits). This always returns a real double field element.

sage: round(sqrt(2),2)
1.41
sage: round(sqrt(2),5)
1.41421
sage: round(pi)
3.0
sage: b = 5.4999999999999999
sage: round(b)
5

IMPLEMENTATION: If ndigits is specified, it calls Python's builtin round function, and converts the result to a real double field element. Otherwise, it tries the argument's .round() method, and if that fails, it falls back to the builtin round function.

NOTE: This is currently slower than the builtin round function, since it does more work - i.e., allocating an RDF element and initializing it. To access the builtin version do import __builtin__; __builtin__.round.

show( x)

Show a graphics object x.

Optional input:

filename
- (default: None) string

SOME OF THESE MAY APPLY: dpi - dots per inch figsize - [width, height] (same for square aspect) axes - (default: True) fontsize - positive integer frame - (default: False) draw a MATLAB-like frame around the image

sage: show(graphs(3))
sage: show(list(graphs(3)))

sqrt( x)

Return a square root of x.

sage: sqrt(10.1)
3.17804971641414
sage: sqrt(9)
3

squarefree_part( x)

Return the square free part of $ x$ , i.e., a divisor $ z$ such that $ x = z y^2$ , for a perfect square $ y^2$ .

sage: squarefree_part(100)
1
sage: squarefree_part(12)
3
sage: squarefree_part(10)
10

sage: x = QQ['x'].0
sage: S = squarefree_part(-9*x*(x-6)^7*(x-3)^2); S
-9*x^2 + 54*x
sage: S.factor()
(-9) * (x - 6) * x

sage: f = (x^3 + x + 1)^3*(x-1); f
x^10 - x^9 + 3*x^8 + 3*x^5 - 2*x^4 - x^3 - 2*x - 1
sage: g = squarefree_part(f); g
x^4 - x^3 + x^2 - 1
sage: g.factor()
(x - 1) * (x^3 + x + 1)

transpose( x)

sage: M = MatrixSpace(QQ,3,3)
sage: A = M([1,2,3,4,5,6,7,8,9])
sage: transpose(A)
[1 4 7]
[2 5 8]
[3 6 9]

xinterval( a, b)

Iterator over the integers between a and b, inclusive.

zero( R)

Return the zero element of the ring R.

sage: R.<x> = PolynomialRing(QQ)
sage: zero(R) in R
True
sage: zero(R)*x == zero(R)
True

See About this document... for information on suggesting changes.