Node:Rearranging Matrices, Next:Special Utility Matrices, Previous:Finding Elements and Checking Conditions, Up:Matrix Manipulation
fliplr (x) | Function File |
Return a copy of x with the order of the columns reversed. For
example,
fliplr ([1, 2; 3, 4]) => 2 1 4 3 Note that |
flipud (x) | Function File |
Return a copy of x with the order of the rows reversed. For
example,
flipud ([1, 2; 3, 4]) => 3 4 1 2 Due to the difficulty of defining which axis about which to flip the
matrix |
flipdim (x, dim) | Function File |
Return a copy of x flipped about the dimension dim.
For example
flipdim ([1, 2; 3, 4], 2) => 2 1 4 3 |
rot90 (x, n) | Function File |
Return a copy of x with the elements rotated counterclockwise in
90-degree increments. The second argument is optional, and specifies
how many 90-degree rotations are to be applied (the default value is 1).
Negative values of n rotate the matrix in a clockwise direction.
For example,
rot90 ([1, 2; 3, 4], -1) => 3 1 4 2 rotates the given matrix clockwise by 90 degrees. The following are all
equivalent statements:
rot90 ([1, 2; 3, 4], -1) == rot90 ([1, 2; 3, 4], 3) == rot90 ([1, 2; 3, 4], 7) Due to the difficulty of defining an axis about which to rotate the
matrix |
rotdim (x, n, plane) | Function File |
Return a copy of x with the elements rotated counterclockwise in
90-degree increments. The second argument is optional, and specifies
how many 90-degree rotations are to be applied (the default value is 1).
The third argument is also optional and defines the plane of the
rotation. As such plane is a two element vector containing two
different valid dimensions of the matrix. If plane is not given
Then the first two non-singleton dimensions are used.
Negative values of n rotate the matrix in a clockwise direction.
For example,
rotdim ([1, 2; 3, 4], -1, [1, 2]) => 3 1 4 2 rotates the given matrix clockwise by 90 degrees. The following are all
equivalent statements:
rot90 ([1, 2; 3, 4], -1, [1, 2]) == rot90 ([1, 2; 3, 4], 3, [1, 2]) == rot90 ([1, 2; 3, 4], 7, [1, 2]) |
cat (dim, array1, array2, ..., arrayN) | Built-in Function |
Return the concatenation of N-d array objects, array1,
array2, ..., arrayN along dimension dim.
A = ones (2, 2); B = zeros (2, 2); cat (2, A, B) => ans = 1 1 0 0 1 1 0 0 Alternatively, we can concatenate A and B along the
second dimension the following way:
[A, B]. dim can be larger than the dimensions of the N-d array objects
and the result will thus have dim dimensions as the
following example shows:
cat (4, ones(2, 2), zeros (2, 2)) => ans = ans(:,:,1,1) = 1 1 1 1 ans(:,:,1,2) = 0 0 0 0 |
horzcat (array1, array2, ..., arrayN) | Built-in Function |
Return the horizontal concatenation of N-d array objects, array1, array2, ..., arrayN along dimension 2. |
vertcat (array1, array2, ..., arrayN) | Built-in Function |
Return the vertical concatenation of N-d array objects, array1, array2, ..., arrayN along dimension 1. |
permute (a, perm) | Built-in Function |
Return the generalized transpose for an N-d array object a.
The permutation vector perm must contain the elements
1:ndims(a) (in any order, but each element must appear just once).
|
ipermute (a, iperm) | Built-in Function |
The inverse of the permute function. The expression
ipermute (permute (a, perm), perm)returns the original array a. |
reshape (a, m, n, ...) | Function File |
reshape (a, siz) | Function File |
Return a matrix with the given dimensions whose elements are taken
from the matrix a. The elements of the matrix are access in
column-major order (like Fortran arrays are stored).
For example,
reshape ([1, 2, 3, 4], 2, 2) => 1 3 2 4 Note that the total number of elements in the original matrix must match the total number of elements in the new matrix. A single dimension of the return matrix can be unknown and is flagged by an empty argument. |
y = circshift (x, n) | Function File |
Circularly shifts the values of the array x. n must be
a vector of integers no longer than the number of dimensions in
x. The values of n can be either positive or negative,
which determines the direction in which the values or x are
shifted. If an element of n is zero, then the corresponding
dimension of x will not be shifted. For example
x = [1, 2, 3; 4, 5, 6, 7, 8, 9]; circshift (x, 1) => 7, 8, 9 1, 2, 3 4, 5, 6 circshift (x, -2) => 7, 8, 9 1, 2, 3 4, 5, 6 circshift (x, [0,1]) => 3, 1, 2 6, 4, 5 9, 7, 8 |
y = shiftdim (x, n) | Function File |
[y, ns] = shiftdim (x) | Function File |
Shifts the dimension of x by n, where n must be
an integer scalar. When n is negative, the dimensions of
x are shifted to the left, with the leading dimensions
circulated to the end. If n is positive, then the dimensions
of x are shifted to the right, with the n singleton
dimensions added.
Called with a single argument, For example
x = ones (1, 2, 3); size (shiftdim (x, -1)) => [2, 3, 1] size (shiftdim (x, 1)) => [1, 1, 2, 3] [b, ns] = shiftdim (x); => b = [1, 1, 1; 1, 1, 1] => ns = 1 |
shift (x, b) | Function File |
shift (x, b, dim) | Function File |
If x is a vector, perform a circular shift of length b of
the elements of x.
If x is a matrix, do the same for each column of x. If the optional dim argument is given, operate along this dimension |
[s, i] = sort (x) | Loadable Function |
[s, i] = sort (x, dim) | Loadable Function |
[s, i] = sort (x, mode) | Loadable Function |
[s, i] = sort (x, dim, mode) | Loadable Function |
Return a copy of x with the elements elements arranged in
increasing order. For matrices, sort orders the elements in each
column.
For example,
sort ([1, 2; 2, 3; 3, 1]) => 1 1 2 2 3 3 The [s, i] = sort ([1, 2; 2, 3; 3, 1]) => s = 1 1 2 2 3 3 => i = 1 3 2 1 3 2 If the optional argument dim is given, then the matrix is sorted
along the dimension defined by dim. The optional argument For equal elements, the indices are such that the equal elements are listed in the order that appeared in the original list. The The algorithm used in |
Since the sort
function does not allow sort keys to be specified,
it can't be used to order the rows of a matrix according to the values
of the elements in various columns1
in a single call. Using the second output, however, it is possible to
sort all rows based on the values in a given column. Here's an example
that sorts the rows of a matrix based on the values in the second
column.
a = [1, 2; 2, 3; 3, 1]; [s, i] = sort (a (:, 2)); a (i, :) => 3 1 1 2 2 3
tril (a, k) | Function File |
triu (a, k) | Function File |
Return a new matrix formed by extracting extract the lower (tril )
or upper (triu ) triangular part of the matrix a, and
setting all other elements to zero. The second argument is optional,
and specifies how many diagonals above or below the main diagonal should
also be set to zero.
The default value of k is zero, so that If the value of k is negative, additional elements above (for
The absolute value of k must not be greater than the number of sub- or super-diagonals. For example,
tril (ones (3), -1) => 0 0 0 1 0 0 1 1 0 and
tril (ones (3), 1) => 1 1 0 1 1 1 1 1 1 |
vec (x) | Function File |
Return the vector obtained by stacking the columns of the matrix x one above the other. |
vech (x) | Function File |
Return the vector obtained by eliminating all supradiagonal elements of the square matrix x and stacking the result one column above the other. |
prepad (x, l, c) | Function File |
postpad (x, l, c) | Function File |
postpad (x, l, c, dim) | Function File |
Prepends (appends) the scalar value c to the vector x until it is of length l. If the third argument is not supplied, a value of 0 is used. If If x is a matrix, elements are prepended or removed from each row. If the optional dim argument is given, then operate along this dimension. |
For example, to first sort based on the values in column 1, and then, for any values that are repeated in column 1, sort based on the values found in column 2, etc.