Sign of a real or complex number

MuPAD® notebooks will be removed in a future release. Use MATLAB® live scripts instead.

MATLAB live scripts support most MuPAD functionality, though there are some differences. For more information, see Convert MuPAD Notebooks to MATLAB Live Scripts.




sign(z) returns the sign of the number z.

Mathematically, the sign of a complex number z ≠ 0 is defined as . For real numbers, this reduces to 1 or - 1.

sign() and sign(0.0) return 0. The user may redefine this value by a direct assignment, e.g.:

unprotect(sign): sign(0) := 1: protect(sign):

If the type of z is DOM_INT, DOM_RAT, or DOM_FLOAT, a fast kernel function is used to determine the sign. The return value is either - 1, 0, or 1.

If the sign of the expression cannot be determined, a symbolic function call is returned. Certain simplifications are implemented. In particular, numerical factors of symbolic products are simplified. Cf. Example 2.

The expand function rewrites the sign of a product to a product of signs. E.g., expand(sign(x*y)) yields sign(x)*sign(y). Cf. Example 2.

For constant expressions such as PI - sqrt(2), exp(I*3) - I*sin(3) etc., internal floating-point evaluation is used to determine, whether the expression represents a non-zero real number. If so, the sign - 1 or 1 is returned. Internally, the floating-point approximation is checked for reliability. Cf. Example 4.

Environment Interactions

sign respects properties of identifiers. For real expressions, the result may depend on the value of the environment variable DIGITS.


Example 1

We compute the sign of various real numbers and expressions:

sign(-8/3), sign(3.2), sign(exp(3) - sqrt(2)*PI), sign(0)

The sign of a complex number z is the complex number z/abs(z):

sign(0.5 + 1.1*I), sign(2 + 3*I), sign(exp(sin(2 + 3*I)))

Example 2

sign yields a symbolic, yet simplified, function call if identifiers are involved:

sign(x), sign(2*x*y), sign(2*x + y),  sign(PI*exp(2 + y))

In special cases, the expand function may provide further simplifications:

expand(sign(2*x*y)), expand(sign(PI*exp(2 + y)))

Example 3

sign respects properties of identifiers:

sign(x + PI)

assume(x > -3): sign(x + PI)


Example 4

The following rational number approximates π to about 30 digits:

p:= 39269908169872415480783042291/12500000000000000000000000000:

With the standard precision DIGITS =10, the float test inside sign does not give a decisive answer, whether p is larger or smaller than π:

float(PI - p)

This result is subject to numerical roundoff and does not allow a conclusion on the sign of the number PI - p. The float test inside sign checks the reliablity of floating-point approximations. In this case, no simplified result is returned:

sign(PI - p)

With increased DIGITS, a reliable decision can be taken:

DIGITS := 30: sign(PI - p)

delete p, DIGITS:



An arithmetical expression

Return Values

Arithmetical expression.

Overloaded By


See Also

MuPAD Functions