$, _seqgen, _seqin, _seqstep

Create an expression sequence

Use only in the MuPAD Notebook Interface.

This functionality does not run in MATLAB.

Syntax

$ a .. b
_seqgen(a .. b)
$ c .. d step e
_seqstep(c .. d, e)
f $ n
_seqgen(f, n)
f $ c step e 
_seqstep(f, c, e)
f $ i = a .. b
_seqgen(f, i, a .. b)
f $ i = c .. d step e
_seqstep(f, i, c .. d, e)
f $ i in object
_seqin(f, i, object)

Description

$ a..b creates the sequence of integers from a through b.

$c..d step e creates the sequence of numbers from c through d with increment e.

f $ n creates the sequence f,..., f consisting of n copies of f.

f $ c step e creates the sequence f,..., f consisting of trunc(c/e) copies of f.

f(i) $ i = a..b creates the sequence f(a), f(a+1),..., f(b).

f(i) $ i = c..d step e creates the sequence f(c), f(c+e),..., f(c+j*e), with j such that c+j*e <= d and c+(j+1)*e > d.

f(i) $ i in object creates the sequence f(i1), f(i2), ..., where i1, i2 etc. are the operands of the object.

The $ operator is a most useful tool. It serves for generating sequences of objects. Sequences are used to define sets or lists, and may be passed as arguments to system functions. Cf. Example 1.

$ a..b and the equivalent function call _seqgen(a..b) produce the sequence of integers a, a + 1, ... , b. The void object of type DOM_NULL is produced if a > b.

$ c..d step e and the equivalent function call _seqstep(c..d, e) produce the sequence of numbers c, c + e, ... , c + j*e, with j such that c + j*e <= d and c + (j + 1)*e > d. The void object of type DOM_NULL is produced if c > d.

f $ n and the equivalent function call _seqgen(f, n) produce a sequence of n copies of the object f. Note that f is evaluated only once, before the sequence is created. The empty sequence of type DOM_NULL is produced if n is not positive.

f $ c step e and the equivalent function call _seqstep(f, c, e) produce a sequence of trunc(c/e) copies of the object f. Note that f is evaluated only once, before the sequence is created. The empty sequence of type DOM_NULL is produced if trunc(c/e) is not positive.

f $ i = a..b and the equivalent function call _seqgen(f, i, a..b) successively set i := a through i := b and evaluate f with these values. After this (or in case of an error, earlier), the previous value of i is restored.

Note that f is not evaluated before the first assignment. The void object of type DOM_NULL is produced if a > b.

f $ i = c..d step e and the equivalent function call _seqstep(f, i, c..d, e) successively set i := c, i := c + e, ... until the value of i exceeds d and evaluate f with these values. After this (or in case of an error, earlier), the previous value of i is restored.

Note that f is not evaluated before the first assignment. The void object of type DOM_NULL is produced if c > d.

f $ i in object and the equivalent function call _seqin(f, i, object) successively assign the operands of the object to i: they set i := op(object, 1) through i := op(object, n) and evaluate f with these values, returning the result. (n = nops(object) is the number of operands.)

Note that f is not evaluated before the assignments. The empty sequence of type DOM_NULL is produced if the object has no operands.

The "loop variable" i in f $ i = a..b and f $ i in object may have a value. This value is restored after the $ statement returns.

Examples

Example 1

The following sequence can be passed as arguments to the function _plus, which adds up its arguments:

i^2 $ i = 1..5

_plus(i^2 $ i = 1..5)

The 5-th derivative of the expression exp(x^2) is:

diff(exp(x^2), x $ 5)

We compute the first derivatives of sin(x):

diff(sin(x), x $ i) $ i = 0..5

We use ithprime to compute the first 10 prime numbers:

ithprime(i) $ i = 1..10

We select all primes from the set of integers between 1990 and 2010:

select({$ 1990..2010}, isprime)

The 3×3matrix with entries Aij = ij is generated:

n := 3: matrix([[i*j $ j = 1..n] $ i = 1..n])

delete n:

Example 2

In f $ n, the object f is evaluated only once. The result is copied n times. Consequently, the following call produces copies of one single random number:

random() $ 3

The following call evaluates random for each value of of i:

random() $ i = 1..3

Example 3

In the following call, i runs through the list:

i^2 $ i in [3, 2, 1]

Note that the screen output of sets does not necessarily coincide with the internal ordering:

set := {i^2 $ i = 1..19}: 
set; 
[op(set)]

The $ operator respects the internal ordering:

i^2 $ i in set

delete set:

Example 4

Arbitrary objects f are allowed in f $ i = a..b. In the following call, f is an assignment (it has to be enclosed in brackets). The sequence computes a table f[i] = i!:

f[0] := 1: (f[i] := i*f[i - 1]) $ i = 1..4: f

delete f:

Example 5

Apart from the usual sequence generator with the step size 1, _seqstep allows arbitrary integer, rational, or real numbers as step sizes:

1 $ 2 step 0.5

$ 1..2 step .2

f(i) $ i = 1..2 step 1/2

Like in a for-loop, the step size can be negative:

f(i) $ i = 5..1 step -2

In contrast to _seqgen the range bounds in _seqstep can be rational or floating-point numbers:

1 $ 5/2 step 0.5

$ 1.1..2.1 step .2

f(i) $ i = 1/2..5/2 step 1/2

Example 6

the $-expression returns symbolically, if the given range is symbolic:

x $ n, $ a..b, f(i) $ i = a..b

Parameters

f, object

Arbitrary MuPAD® objects

n, a, b

integers

c, d, e

integer, rational, or floating-point numbers

i

An identifier or a local variable (DOM_VAR) of a procedure

Return Values

Expression sequence of type "_exprseq" or the void object of type DOM_NULL.

Overloaded By

a..b, c..d, e, f, i, n, object

See Also

MuPAD Functions

Was this topic helpful?