Rearranging Matrices

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 fliplr only workw with 2-D arrays. To flip N-d arrays use flipdim instead.

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 flipud only work with 2-d arrays. To flip N-d arrays use flipdim instead.

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 rot90 only work with 2-D arrays. To rotate N-d arrays use rotdim instead.

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 shiftdim, removes the leading singleton dimensions returning the number of dimensions removed in the second output argument ns. 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 sort function may also be used to produce a matrix containing the original row indices of the elements in the sorted matrix. For example [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 mode defines the order in which the values will be sorted. Valid values of mode are `ascend' or `descend'. For equal elements the indices are such that the equal elements are listed in the order that appeared in the original list. The sort function may also be used to sort strings and cell arrays of strings it which case the dictionary order of the strings is used. The algorithm used in sort is optimized for the sorting of partially ordered lists.

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 columns¹ 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 triu and tril normally include the main diagonal as part of the result matrix. If the value of k is negative additional elements above (for tril) or below (for triu) the main diagonal are also selected. 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 length (x) > l elements from the beginning (end) of x are removed until a vector of length l is obtained. 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.