Create an expression sequence
This functionality does not run in MATLAB.
$ 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
)
$ 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. See 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.
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 5th 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 A_{ij} = i j is generated:
n := 3: matrix([[i*j $ j = 1..n] $ i = 1..n])
delete n:
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
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:
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:
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 floatingpoint numbers:
1 $ 5/2 step 0.5
$ 1.1..2.1 step .2
f(i) $ i = 1/2..5/2 step 1/2
the $
expression returns
symbolically, if the given range is symbolic:
x $ n, $ a..b, f(i) $ i = a..b

Arbitrary MuPAD^{®} objects 
 

integer, rational, or floatingpoint numbers 

An identifier or a local variable
( 
Expression sequence of type "_exprseq" or
the void object of type DOM_NULL
.
a..b
, c..d
, e
, f
, i
, n
, object