# extraction

matrix and list entry extraction

### Syntax

x(i) x(i,j) x(i,j,k,..) [...] = l(i) [...] = l(k1)...(kn)(i) or [...] = l(list(k1,...,kn,i)) l(k1)...(kn)(i,j) or l(list(k1,...,kn,list(i,j))

### Arguments

- x
matrix of any possible types

- l
list variable

- i,j, k
indices

- k1,...kn
indices

### Description

##### Matrix case

`i`

, `j`

,
`k`

,.. can be:

- a real scalar or a vector or a matrix with positive elements.
`r=x(i,j)`

builds the matrix`r`

such as`r(l,k)=x(int(i(l)),int(j(k)))`

for`l`

from 1 to`size(i,'*')`

and`k`

from 1 to`size(j,'*')`

.`i`

(`j`

) Maximum value must be less or equal to`size(x,1)`

(`size(x,2)`

).`r=x(i)`

with`x`

a 1x1 matrix builds the matrix`r`

such as`r(l,k)=x(int(i(l)),int(i(k)))`

for`l`

from 1 to`size(i,1)`

and`k`

from 1 to`size(i,2)`

.Note that in this case index

`i`

is valid only if all its entries are equal to one.`r=x(i)`

with`x`

a row vector builds the row vector`r`

such as`r(l)=x(int(i(l)))`

for`l`

from 1 to`size(i,'*')`

`i`

Maximum value must be less or equal to`size(x,'*')`

.`r=x(i)`

with`x`

a matrix with one or more columns builds the column vector`r`

such as`r(l)`

(`l`

from 1 to`size(i,'*')`

) contains the`int(i(l))`

entry of the column vector formed by the concatenation of the`x`

's columns.`i`

Maximum value must be less or equal to`size(x,'*')`

.

- the symbol
`:`

`which stands for "all elements".`

`r=x(i,:)`

builds the matrix`r`

such as`r(l,k)=x(int(i(l)),k))`

for`l`

from 1 to`size(i,'*')`

and`k`

from 1 to`size(x,2)`

`r=x(:,j)`

builds the matrix`r`

such as`r(l,k)=x(l,int(j(k)))`

for`l`

from 1 to`size(r,1)`

and`k`

from 1 to`size(j,'*')`

.`r=x(:)`

builds the column vector`r`

formed by the column concatenations of`x`

columns. It is equivalent to`matrix(x,size(x,'*'),1)`

.

- a vector of boolean
If an index (

`i`

or`j`

) is a vector of booleans it is interpreted as`find(i)`

or respectively`find(j)`

- a polynomial
If an index (

`i`

or`j`

) is a vector of polynomials or implicit polynomial vector it is interpreted as`horner(i,m)`

or respectively`horner(j,n)`

where`m`

and`n`

are associated`x`

dimensions. Even if this feature works for all polynomials, it is recommended to use polynomials in`$`

for readability.

For matrices with more than 2 dimensions (see:hypermatrices) the dimensionality is automatically reduced when right-most dimensions are equal to 1.

##### List or Tlist case

If they are present the `ki`

give the path to
a sub-list entry of `l`

data structure. They allow
a recursive extraction without intermediate copies. The
instructions

`[...]=l(k1)...(kn)(i)`

and

`[...]=l(list(k1,...,kn,i))`

are interpreted as:

`lk1 = l(k1)`

`.. = ..`

`lkn = lkn-1(kn)`

`[...] = lkn(i)`

.

And the `l(k1)...(kn)(i,j)`

and

`l(list(k1,...,kn,list(i,j))`

instructions
are interpreted as:

`lk1 = l(k1)`

`.. = ..`

`lkn = lkn-1(kn)`

`lkn(i,j)`

When path points to more than one list component, the instruction must have as many left-hand side arguments as selected components. But if the extraction syntax is used as function parameters, each returned list component is added to the function parameters.

Note that `l(list())`

is the same as
`l`

.

- i and j may be:
- real scalar or vector or matrix with positive elements.
`[r1,...rn]=l(i)`

extracts the`i(k)`

elements from the list`l`

and store them in`rk`

variables for`k`

from 1 to`size(i,'*')`

- the symbol
`:`

which stands for "all elements".

- a vector of booleans.
If

`i`

is a vector of booleans it is interpreted as`find(i)`

.- a polynomial
If

`i`

is a vector of polynomials or implicit polynomial vector it is interpreted as`horner(i,m)`

where`m=size(l)`

. Even if this feature works for all polynomials, it is recommended to use polynomials in`$`

for readability.

- k1 ... kn may be :
- real positive scalar
- a polynomial
interpreted as

`horner(ki,m)`

where`m`

is the corresponding sub-list size.- a character string
associated with a sub-list entry name.

##### Remarks

For soft coded matrix types such as rational functions and state
space linear systems, `x(i)`

syntax may not be used for
vector element extraction due to confusion with list element extraction.
`x(1,j)`

or `x(i,1)`

syntax must be
used.

### Examples

Matrix case:

a = [1 2 3 ; 4 5 6] a(1,2) a([1 1], 2) a(:, 1) a(:, 3:-1:1) a(1) a(6) a(:) a([%t %f %f %t]) a([%t %f], [2 3]) a(1:2, $-1) a($:-1:1, 2) a($) // x = 'test' x([1 1 ; 1 1 ; 1 1]) // b = [1/%s, (%s+1)/(%s-1)] b(1,1) b(1,$) b(2) // the numerator

List ot Tlist case:

### See also

- insertion — partial variable assignation or modification
- colon — Ranging operator. Addresses all elements along an array dimension or of a list.
- find — gives the indices of %T or non-zero elements
- horner — evaluates some polynomials or rationals for given values
- parentheses — ( ) left and right parenthesis

Report an issue | ||

<< &, && | Elementary Functions | ind2sub >> |