CHAPTER 3

Real and Complex Numbers

3.1 Rational Numbers

A rational number is a number of the form p/q, where p and q are integers. That is, the rational numbers are those numbers that can be represented as the quotient of two integers. The way in which MATLAB treats rational numbers is different from the majority of calculators.

If we ask a calculator to calculate the sum 2/4 + 24/144, most will return something like 0.6666667, which is no more than an approximation of the result.

MATLAB can work with rational numbers in exact mode, so the result of arithmetic expressions involving rational numbers is always another rational number. To this end, it is necessary to activate the rational format with the command format rat. However, if the reader so wishes, MATLAB can also return decimal approximations of rational numbers, activating any other type of format (e.g. format short or format long). MATLAB evaluates rational expressions in exact mode as follows:

>> format rat

>> 2/4 + 24/144

ans =

2/3

By dealing with rational numbers exactly as ratios of integers, rounding errors are not introduced in calculations with fractions, which can become very serious, as evidenced by the theory of errors. Note that, once the rational format is enabled, when MATLAB is asked to add two rational numbers, it returns a rational number as a ratio of integers and thus represents it symbolically, as you can see in the following examples:

>> (2/3-3/5) * 5/2

ans =

1/6

>> 2 + 2/5

ans =

12/5

In the second example, the number 12/5 is exactly equivalent in value to 2.4, but MATLAB represents these numbers in different ways.

Once the rational format is enabled, operations with rational numbers will be exact until a different format is introduced, in which case we can also obtain decimal approximations.

A floating point or decimal number is interpreted as exact if the rational format has been enabled. If there is a number with a floating point expression, MATLAB will treat it as an exact expression and represent it as a rational number. If an irrational number appears in a rational expression, MATLAB will approximate it by a fraction and then work with it in rational form.

>> 1/2 + 2.4/144

ans =

31/60

>> .5/7 + pi

ans =

5626/1751

Another way to work with accurate results with rational numbers, without having to enable the rat format, is to use the command simplify. Using this command allows you to work with rational expressions exactly, even if the expressions contain irrational numbers. The use of this command requires that the numeric expressions be considered as symbolic, so you will need to prepend to all numeric expressions the command sym.

>> simplify(sym(2/5+3/4))

ans =

23/20

>> simplify(sym(2/5+3/4+pi))

ans =

2415951884441619/562949953421312

>> simplify(sym(2/5+3/4)+pi)

ans =

23/20 + pi

There are certain commands that can be used when working with rational numbers. Among the most important are the following:

• simplify(sym(rational_expr)) completely simplifies the specified rational expression and gives the result as a rational number
• [n,m] = numden(rational_expr) gives the simplified numerator and denominator of the rational expression
• maple(‘simplify(rational)’) simplifies the specified rational number
• maple(‘normal(rational_expr)’) simplifies the specified rational expression
• maple(‘convert(decimal,fraction)’) converts the decimal to a fraction
• maple(‘convert(decimal,rational)’) converts the decimal to rational form
• maple(‘denom(fraction)’) gives the denominator of the simplified fraction
• maple(‘num(fraction)’) gives the numerator of the simplified fraction

Here are some examples:

>> simplify (sym(125/1500))

ans =

1/12

>> maple('simplify(125/1500)')

ans =

1/12

>> maple('normal(125/1500)')

ans =

1/12

>> [n,m]=numden(sym(125/1500))

n =

1

m =

12

>> maple('denom(125/1500)')

ans =

12

>> maple('numer(125/1500)')

ans =

1

>> maple('convert(125.1500,fraction)')

ans =

2503/20

>> maple('convert(125.1500,rational)')

ans =

2503/20

3.2 Continued Fractions

MATLAB enables you to work with continued fractions using the following commands. With the exception of the first and last commands, these can be found in Maple’s numtheory library:

• rat(r): returns the continued fraction of the rational number r
• maple(‘cfrac (r)’): returns the continued fraction of the rational number r
• maple(‘cfrac(polynomial)’): returns the continued fraction for each of the real roots of the given univariate polynomial
• maple(‘invcfrac (frac)’): converts the continued fraction frac to an irrational quadratic
• maple(‘nthnumer(expr,n)’): gives the nth numerator of the continued fraction expr
• maple(‘nthdenom(expr,n)’): gives the nth denominator of the continued fraction expr
• maple(‘nthdconver(expr,n)’): gives the nth partial quotient of the continued fraction expr
• maple(‘pdexpand(rational)’): gives the periodic expansion of the given rational number, i.e. it gives the sign, the positive integer part, the non-recurrent part and the periodic part
• maple(‘convert(number,confrac,m)’): converts a number to a continued fraction with m partial quotients

Here are some examples:

>> rat(3/5)

ans =

1 + 1/(-3 + 1/(2))

>> maple('cfrac(3/5)')

ans =

1/(1+1/(1+1/2))

>> pretty(sym(maple('cfrac(3/5)')))

     1
-----------
       1
1 + -------
    1 + 1/2

>> pretty(sym(maple('cfrac(125.1500)')))

           1
125 + -----------
             1
      6 + -------
          1 + 1/2

>> maple('convert(125.1500, confrac, 4)')

ans =

[125, 6, 1, 2]

>> maple nthnumer([125, 6, 1, 2],3)

ans =

2503

>> maple nthdenom([125, 6, 1, 2],3)

ans =

20

3.3 Irrational Numbers

Irrational numbers, because of their special nature, have always created difficulties in numerical calculations. The impossibility of representing an irrational accurately in numeric mode (using ten decimal digits, for example) is the cause of most of the problems. MATLAB can represent the results with greater accuracy or to any accuracy specified by the user. Nevertheless, by definition, an irrational number cannot be represented exactly as the ratio of two integers. If ordered to find the square root of 17, MATLAB will return 4.12310562561766. However, the result can be treated symbolically using the maple command, so that sqrt[17] will be represented by 17 ^(1/2):

>> sqrt(17)

ans =

   4.12310562561766

>> maple('sqrt(17)')

ans =

17 ^(1/2)

Note that if the square root of a floating point (decimal) number, e.g. √17.0, is requested, MATLAB always calculates an approximate result, even using the command maple.

>> maple ('sqrt (17.0)')

ans =

4.123105625617661

The main difficulty presented by the treatment of irrational numbers is the impossibility of representing them accurately, unless they are treated as symbolic constants, so that if it is asked to calculate the sum of the square root of 2 and the square root of 3 (using the function sqrt), MATLAB will return as a result 2^(1/2) + 3^(1/2), since this is the only way to accurately represent the sum (using the command maple). In all subsequent calculations involving 2^(1/2) and 3^(1/2) they will be operated on symbolically following the mathematical rules of calculation with radicals.

Of course we can also work with decimal approximations of irrational numbers, as we pointed out above.

Among the commands used to work with irrational numbers, we have the following:

• maple(‘radsimp(expr)’) simplifies the expression and, where necessary, rationalizes denominators
• maple(‘simplify(expr,radical)’) simplifies the given irrational expression using standard rules of radicals
• maple(‘simplify(expr,symbolic)’) simplifies the expression assuming all algebraic subexpressions are positive
• maple(‘combine(expr,radical)’) simplifies the given irrational expression and returns the result in radical form
• maple(‘combine(expr,radical,symbolic)’) simplifies the given irrational expression and returns the result in radical form, assuming all algebraic subexpressions are positive
• maple(‘combine(expr,power)’) simplifies the given irrational expression returning the result in terms of powers
• maple(‘normal(expr)’) simplifies the given irrational expression
• maple(‘readlib(radnormal): radnormal(irrational_expression)’) simplifies expressions containing various levels of radicals
• maple(‘readlib(radnormal): rationalize(irrational_expression)’) rationalizes denominators
• maple(‘simplify(irrat_expr)’) simplifies the given irrational expression

3.4 Algebraic Numbers

MATLAB can operate with algebraic numbers using two types of representations, one in the form of radicals and the other in terms of roots of polynomials (RootOf(polynomial)).

Using the command convert, MATLAB can convert a radical representation to a RootOf representation and vice versa, when possible.

The commands for working with algebraic numbers are as follows:

• maple(‘convert(RootOf_expression,radical)’) converts a RootOf expression to a radical expression
• maple(‘convert(radical_expression, RootOf)’) converts a  radical expression to a RootOf expression
• maple(‘simplify RootOf(expression)’) simplifies the RootOf expression

3.5 Real Numbers

The disjoint union of the set of rational numbers and the set of irrational numbers is the set of real numbers. Included in the set of rational numbers is the set of integers, so all functions applicable to real numbers will also be valid for integers, rational and irrational numbers.

3.6 Common Functions with Real Arguments

MATLAB provides a full range of predefined functions, most of which are discussed later in this book. Within the group of functions with real arguments offered by MATLAB, the following are the most important:

First, we see how the function round rounds a real number:

>> round(2.574)

ans =

     3

>> round(2.4)

ans =

     2

>> round(sqrt(17))

ans =

     4

The function ceil is illustrated in the following two cases:

>> ceil (4.2)

ans =

     5

>> ceil (4.8)

ans =

     5

The floor function is illustrated in the following two examples:

>> floor (4.2)

ans =

     4

>> floor (4.8)

ans =

     4

The fix function simply removes the decimal part of a real number:

>> fix (5.789)

ans =

     5

3.7 Complex Numbers

Operations on complex numbers are well implemented in MATLAB. MATLAB follows the convention that i or j represents the key value in complex analysis, the imaginary number √- 1. All the usual arithmetic operators can be applied to complex numbers, and there are also some specific functions which have complex arguments. Both the real and the imaginary part of a complex number can be a real number or a symbolic constant, and operations with them are always performed in exact mode, unless otherwise instructed or necessary, in which case an approximation of the result is returned. As the imaginary unit is represented by the symbol i or j, the complex numbers are expressed in the form a+bi or a+bj. Note that you don't need to use the product symbol (asterisk) before the imaginary unit:

>> (2-3i)*(1-i)/(-1+2i)

ans =

  -1.8000 + 1.4000i

>> format rat
>> (2-3i)*(1-i) /(-1+2i)

ans =
    -9/5 + 7/5i

3.8 Common Functions with Complex Arguments

MATLAB performs the usual arithmetic operations with complex numbers, but in addition, there are several features built into the program especially designed to work with complex variables.

The function real(z) returns the real part of the complex number z:

>> real(3 + 4i)

ans =

      3

The function imag(z) returns the imaginary part of z:

>> imag(3 + 4i)

ans =

      4

The function conj(z) returns the conjugate of z:

>> conj(3 + 4i)

ans =

      3 - 4i

The function abs(z) returns the modulus (absolute value) of z:

>> abs(3 + 4i)

ans =

     5

The function angle(z) returns the argument of z:

>> angle(3 + 4i)

ans =

    0.9273

In addition to these specific functions of a complex variable, there are many other functions that can also be applied to complex numbers.

For example, the function round(z) rounds both the real part and the imaginary part of z:

>> round(2.7-8.4i)

ans =

   3.0000 - 8.0000i

There are many more functions in MATLAB that work with complex numbers, including sin, cos, exp, log, etc. Some of the most important are presented in the following table:

It should be noted that, as every real number is a complex number (with zero imaginary part), all functions defined above are also valid for real variables.

A number of commands used to simplify and transform complex expressions also play an important role in working with complex numbers. These include the following:

• expand(sym(expression)) simplifies the complex expression and usually gives the output in trigonometric or binary form
• maple(‘evalc(expression)’) simplifies the complex expression and usually gives the output in trigonometric or binary form
• maple(‘simplify(expression,polar)’) simplifies a complex expression in polar form
• maple(‘simplify(expression,trig)’) simplifies a complex expression in trigonometric form
• maple(‘simplify(expression,power)’) simplifies a complex expression with powers
• maple(‘simplify(expression,radical)’) simplifies a complex expression with radicals
• maple(‘simplify(expression,sqrt)’) simplifies a complex expression with square roots
• maple(‘simplify (expression,ln)’) simplifies a complex expression with logarithms
• maple(‘simplify RootOf(expression)’) simplifies a complex expression with algebraic numbers
• maple(‘convert(expression,polar)’) converts the expression to polar form
• maple(‘convert(expression,exp)’) converts the expression to exponential or binary form
• maple(‘convert(expression,trig)’) converts the expression to trigonometric or binary form

Here are some examples:

We convert 1 + i to polar form:

>> maple('convert(1+i,polar)')

ans =

polar (2 ^(1/2), 1/4 * pi)

We simplify the value of sqrt ((1+2*i) /(1-2*i)):

>> maple('evalc(sqrt((1+2*i)/(1-2*i)))')

ans =

1/5 * 5 ^(1/2) + 2/5 * i * 5 ^(1/2)

We convert the complex number 2 * cos(Pi/4) + 2 * I * sin(Pi/4) to binary form:

>> maple('convert(2*cos(Pi/4)+2*I*sin(Pi/4),trig)')

ans =
2 ^(1/2) + I * 2 ^(1/2)

We convert the complex number 3 * exp(Pi*I/4) to trigonometric and polar form:

>> maple('convert(3*exp(Pi*I/4),trig)')

ans =

3*cosh(1/4*pi*I)+3*sinh(1/4*pi*I)

>> maple('convert(3*exp(Pi*I/4),polar)')

ans =

polar(3*exp(1/4*pi*Re(I)),argument(exp(1/4*pi*I)))

3.9 Divisibility in the Complex Field. The Ring of Gaussian Integers

Within the set C of complex numbers, the subset G = {zC / z = a + bi, a,bZ} formed by all the complex numbers with integer real and imaginary parts is a ring, known as the ring of Gaussian integers. Within this ring, divisibility can be studied in a similar manner to the study of divisibility in the ring of integers.

There are some functions in MATLAB that allow you to work in this ring, as long as the extended symbolic math Toolbox is available. Among them are the following:

• maple(‘with(GaussInt)’) loads the Maple library GaussInt (required before using the commands specified below)
• maple(‘GIfactor(z)’) factorizes the Gaussian integer z
• maple(‘GIfactors(z)’) returns the prime factors of z and their orders
• maple(‘GIfacset(z)’) returns the set of prime factors of z
• maple(‘GIdivisor(z)’) returns the list of divisors of z in the first quadrant
• maple(‘GIprime(z)’) determines if the Gaussian integer z is prime
• maple(‘GIphi(z)’) returns the number of Gaussian integers in a reduced system modulo z
• maple(‘GInorm(z)’) returns the norm of z (norm(a+bi) = a² + b²)
• maple(‘GIbasis(z1,z2)’) determines whether z1 and z2 form a Gaussian basis (i.e if for all Gaussian integers z, there exist integers p and q such that z = pz1 + qz2)
• maple(‘GIcombine(a,b,c,d)’) is the Gaussian integer n such that: n=b(mod a) and n=d(mod c) (a, b, c and d are Gaussian integers)
• maple(‘GIquadres(z1,z2)’) determines whether there exists a Gaussian integer m such that m² = z1(mod z2)
• maple(‘GIorder(z1,z2)’) returns the smallest positive integer n such that z1ⁿ  = 1(mod z2).
• maple(‘GIquo(z1,z2)’) gives the quotient z1/z2
• maple(‘GIrem(z1,z2)’) gives the remainder of the quotient z1/z2
• maple(‘GIgcd(a,b,...c)’) gives the Gaussian integer in the first quadrant nearest to the greatest common divisor of the Gaussian integers a,b,...,c
• maple(‘GIlcm(a,b,...c)’) gives the Gaussian integer in the first quadrant closest to the least common multiple of the Gaussian integers a,b,...,c
• maple(‘GIissqr(z)’) determines if z is the square of a Gaussian integer
• maple(‘GIsqrt(z)’) gives the Gaussian integer best approximating the square root of z
• maple(‘GInearest(z)’) gives the Gaussian integer nearest to the complex number z
• maple(‘GIroots(complex_polynomial)’) gives the Gaussian integer roots of a univariate polynomial with Gaussian integer coefficients
• maple(‘GIchrem([n1,...,nx],[m1,...,mx])’) gives the unique Gaussian integer G such that G(mod mi) = y,  i = 1,..., x
• maple(‘GIfacpoly(polynomial)’) factorizes the polynomial over the Gaussian integers
• maple(‘GIgcdex(a,b,c,d)’) gives the Gaussian integer g located in the first quadrant which is the greatest common divisor of the Gaussian integers a and b, using Euclid’s algorithm, returning c and d such that g = c * a + d * b
• maple(‘GIhermite(M)’) calculates the Gaussian integer Hermite normal form of the integer matrix M. This is an upper triangular matrix with a number of non-zero rows equal to the rank of the matrix M.
• maple(‘GIhermite(M,A)’) calculates the Gaussian integer Hermite normal form H of the integer matrix M and the matrix A such that H = A * M
• maple(‘GInodiv(z)’) gives the number of non-associated factors of the Gaussian integer z
• maple(‘GInormal(z)’) normalizes the Gaussian integer z
• maple(‘GIsieve(z)’) generates the list of all prime Gaussian integers with norm less than or equal to z² (0≤x<y)
• maple(‘GIsmith(M)’) returns the Smith normal form of the matrix M of Gaussian integers
• maple(‘GIsmith(M,A,B)’) returns the Smith normal form of the matrix M of Gaussian integers and the matrices A and B  such that S = A * M * B
• maple(‘GIsqrfree(z)’) returns the square-free factorization of z,  [u,[[p[1],e[1]],...,[p[m],e[m]]] where p[i] is a principal factor of z, e[i] is its multiplicity, gcd(p[i],p[j]) = 1 "iπj, and u is a unit in the ring of Gaussian integers. The square-free factorization of z will be of the form: z = u * p[1]^e[1] * ... * p[m]^e[m].
• maple(‘GIunitnormal(z)’) normalizes the Gaussian integer z

Here are some examples:

We factorize the number 30 in the ring of Gaussian integers.

>> maple('with(GaussInt):GIfactor(30)')

ans =

 (i) *(1+i) ^ 2 *(1+2*i) *(1-2*i) *(-3)

The prime factors of 30 in the ring of Gaussian integers are: -3 with multiplicity 1,-1-2i with multiplicity 1,-1 + 2i with multiplicity 1, 1 + i with multiplicity 2 and i with multiplicity 1.

You can also find the set of prime factors of 30 or the list of prime factors together with their orders of multiplicity.

>> maple('with(GaussInt):GIfacset(30)')

ans =

{-3, 1+i, -1+2*i, -1-2*i}

>> maple('with(GaussInt):GIfactors(30)')

ans =

[i, [[1 + i, 2], [- 1 + 2 * i, 1], [- 1-2 * i, 1], [1, - 3]]]

You can also determine if a Gaussian integer is prime or not.

The number 1 + i is prime in the ring of Gaussian integers:

>> maple('with(GaussInt):GIprime(1+i)')

ans =

true

Here we have defined a matrix simply by placing its rows between square brackets, separated by commas. As we will see later, this is a standard way to define arrays in MATLAB.

3.10 Approximation and Precision

The accuracy of the output of numerical operations with MATLAB can be relaxed using special approximation techniques, returning results to a certain degree of precision.

MATLAB represents results with accuracy, but even if internally you are always working with exact calculations to avoid rounding errors, you can enable different approximate representation formats, which sometimes facilitate the interpretation of results. The following commands can be used for numerical approximation:

• format long: Delivers results to 16 significant decimal figures.
• format short: Delivers results to 4 decimal places. This is MATLAB’s default format.
• format long e: Provides the results to 16 decimal figures more than the power of 10 required.
• format short e: Provides the results to four decimal figures more than the power of 10 required.
• format long g: Delivers results in optimal long format.
• format short g: Delivers results in optimal short format.
• format bank: Delivers results to 2 decimal places.
• format rat: Offers an approximation of results in the form of a rational number
• format +: Returns the sign of the results (+, - or 0).
• format hex: Returns results in hexadecimal.
• vpa ‘operations’ n: Provides the result of operations to n significant decimal figures.
• numeric(‘expr’): Provides the value of the expression numerically approximated by the current active format.
• digits(n): Returns results to n significant digits.
• maple(‘evalf(expr)’): Evaluates the expression numerically up to an accuracy determined by digits.
• maple(‘evalf(expr,m)’): Evaluates the expression to m digits without affecting the value of digits.
• maple(‘value(expr)’): Evaluates symbolically or numerically the inert symbolic expression.
• maple(‘evalhf(expr)’): Evaluates the numerical expression with double precision to the number of accurate digits specified by digits.
• maple(‘evala(expr)’): Evaluates the expression algebraically.
• maple(‘evalc(expr)’): Evaluates the complex expression with double-precision.
• maple(‘evalr(expr)’): Evaluates an expression containing ranges of variables or inequalities or logical symbols.
• maple(‘evalb(expr)’): Evaluates an expression, equation, Boolean expression or inequality that contains relational operators.
• maple(‘eval(expr)’): Completely evaluates the expression.
• maple(‘eval(expr, n)’): Evaluates the expression to n levels. This is often used to evaluate the results of the command subs.
• maple(‘evaln(expr)’): Evaluates an expression to a name. This is equivalent to introducing quotes in the expression.
• maple(‘fnormal(expr)’): Normalizes a floating point expression.
• maple(‘fnormal(expr, n)’): Normalizes a floating point expression to n digits.
• maple(‘fnormal(expr,n,m)’): Normalizes a floating point expression to n digits with an error tolerance given by m.
• maple(‘Float(m,n)’): Gives the number m*10ⁿ in floating-point form. The result can be of the form integer.integer, integer, .integer or any of these forms multiplied by 10^exponent.

Here are some examples:

For each format, find a numerical approximation of √17:

>> sqrt(17)

ans =

    4.1231

>> format long; sqrt(17)

ans =

   4.12310562561766

>> format long e; sqrt(17)

ans =

    4.123105625617660e+000

>> format short e; sqrt(17)

ans =

  4.1231e+000

>> format long g; sqrt(17)

ans =

          4.12310562561766

>> format short g; sqrt(17)

ans =

       4.1231

>> format bank; sqrt(17)

ans =

          4.12

>> format hex; sqrt (17)

ans =

   40107e0f66afed07

Now we give some examples of the calculation of the value of sqrt(17) specifying the precision that we desire:

>> vpa 'sqrt(17)' 10

ans =

4.123105626

>> digits(15); maple('evalf(sqrt(17))')

ans =

4.12310562561766

>> digits(15); maple('evalhf(sqrt(17))')

ans =

4.123105625617661

>> digits (15); maple ('evala (sqrt (17))')

ans =

17 ^(1/2)

We find the decimal approximation of π to 100 digits of precision.

>> vpa 'pi' 100

ans =

3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068

>> digits(100); maple('evalf(pi)')

ans =

3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117068

Now we convert the numbers 12345 * 10^-4, 456 * 10^-4 and 12345 * 10¹⁸ -12345 * 10^-18 to floating point format:

>> maple('Float(123456,-4)')

ans =

12.3456

>> maple('Float(456,-4)')

ans =

.456e-1


>> maple('Float(12345,18)')

ans =

. 12345e23


>> maple ('Float(12345, - 18) ')

ans =

. 12345e-13

We convert 1234598678 * 10^-3 to a floating-point number:

>> maple ('Float(1234598678, - 3)')

ans =

1234598.678

We now consider the integral of x⁴ between 0 and 1 as an inert function and then calculate its numerical value:

>> maple('Int(x^4,x=0..1)')

ans =

Int(x^4,x = 0 .. 1)


>> maple('value(Int(x^4,x=0..1))')

ans =

1/5

3.11 Types of Numbers and Expressions

In MATLAB, you can work with different types of numbers and expressions. It is possible to declare the corresponding type of each number or expression, as well as to check the type of a given number or expression. These types of numbers and expressions cover integers, real numbers and complex numbers, and are used in arguments of functions whose definition is preceded by the command maple.

Among the types of numbers in MATLAB we have the following:

• integer: integer
• negint: negative integer
• posint: positive integer
• nonnegint: nonnegative integer
• even: even integer
• odd: odd integer
• prime: prime integer
• rational: rational number
• fractional: fraction
• realcons: real constant
• radical: radical number
• radext: algebraic extension in terms of radicals
• radnum: algebraic number in terms of radicals
• radnumext: radical number exension
• sqrt: number or expression in terms of square roots
• square: perfect square expression or number
• numeric: numeric expression
• number: constant or constant expression
• positive: positive number
• negative: negative number
• infinity: infinite number
• nonneg: nonnegative number
• algnum: algebraic number
• algnumext: algebraic number extension
• rootof: RootOf expression
• complex: complex number or complex expression
• complex(integer): complex number a+bi with a and b integer (possibly zero)
• complex(rational): complex number a+bi with a and b rational
• complex(float): complex number a+bi with a and b constant floating point
• complex(numeric): complex number a+bi of any of the above forms
• facint: integer in factored form
• float: number or floating point expression
• intersect: intersection
• union: union
• minus: difference
• list: list expression
• listlist: list of lists
• set: set
• relation: relational expression
• boolean: boolean expression
• logical: logical expression
• vector: vector
• array: array (vector or matrix)
• matrix: matrix
• scalar: scalar matrix
• name: name
• nothing: nothing (always returns false)
• protected: name protected by Maple (not editable)
• range: range
• string: string
• table: table
• text: text

Having described the types of numbers and the most important numerical expressions that can be declared in MATLAB, we now summarize the commands that handle them:

• type(expr, type): determines whether the number or expression expr is of the specified type
• tymematch(expr, type): determines if the number or expression expr is of the specified type
• whattype(expr): returns the type of the number or expression expr
• func(parameter::type) determines the type of the parameter of the function func

Here are some examples:

>> maple('type ((3+2*i), complex)')

ans =

true

>> maple('type(257,prime)')

ans =

true

>> maple('whattype([1,2,3])')

ans =

list

>> maple('whattype({1,2,3})')

ans =

set

3.12 Random Numbers

The automatic generation of (pseudo) random numbers is a problem well handled by MATLAB.

MATLAB provides the function rand to generate uniformly distributed random numbers and the function randn to generate normally distributed random numbers. The following functions can be used to generate random floating point numbers:

• rand: returns a random uniformly distributed decimal number in the interval [0,1]
• rand(n): returns a matrix of size n×n whose elements are random uniformly distributed decimal number in the interval [0,1]
• rand(m,n): returns a matrix of dimension m×n whose elements are random uniformly distributed decimal number in the interval [0,1]
• rand(size(a)): returns a matrix of the same size as the matrix a and whose elements are random uniformly distributed decimal number in the interval [0,1]
• rand(‘seed’): returns the current value of the uniform random number generator seed
• rand(‘seed’,n): sets the current value of the uniform random number generator seed to the value n
• randn: returns a normally distributed random decimal number with mean 0 and variance 1
• randn(n): returns a matrix of size n×n whose elements are normally distributed random decimal numbers with mean 0 and variance 1
• maple(‘with(linalg):randmatrix(m,n)’): returns a matrix of dimension m×n whose elements are random integers between -99 and 99
• maple(‘with(linalg):randmatrix(m,n,option)’): returns a matrix of dimension m×n whose elements are random integers between -99 and 99, and of the specified type in option, the possible options being symmetric, antisymmetric, diagonal, identity and sparse
• maple(‘with(linalg):randvector(n)’): returns a vector of dimension n whose elements are random integers between -99 and 99
• randn(m,n): returns a matrix of dimension m×n whose elements are normally distributed random decimal number with mean 0 and variance 1
• randn(size(A)): returns a matrix of the same size as the matrix A and whose elements are normally distributed random decimal number with mean 0 and variance 1
• randn (‘seed’): returns the current value of the normal random number generator seed
• randn(‘seed’,n): sets the current value of the normal random number generator seed to the value n

Here are some examples:

>> [rand, rand (1), randn, randn (1)]

ans =

    0.8310    0.0346    1.1650    0.6268

>> [rand(2), randn(2)]

ans =

    0.0535    0.6711    0.0751   -0.6965
    0.5297    0.0077    0.3516    1.6961

>> [rand(4,3), randn(4,3)]

ans =

    0.6326 0.2470 0.6515 - 0.0562   0.4005   0.7286
    0.7564 0.9826 0.0727   0.5135 - 1.3414 - 2.3775
    0.9910 0.7227 0.6316   0.3967   0.3750 - 0.2738
    0.7534 0.8847 0.7562   1.1252 - 0.3229

>> maple with(linalg):randmatrix(3,3,symmetric)

ans =

matrix([[-85,-55,-35], [-55,-37, 97], [-35, 97, 50]])