How to Reverse a Matrix in R

How to reverse a matrix in R?

Try rev with apply:

> a <- matrix(c(1:10,10:1), ncol=2)
> a
      [,1] [,2]
 [1,]    1   10
 [2,]    2    9
 [3,]    3    8
 [4,]    4    7
 [5,]    5    6
 [6,]    6    5
 [7,]    7    4
 [8,]    8    3
 [9,]    9    2
[10,]   10    1
> b <- apply(a, 2, rev)
> b
      [,1] [,2]
 [1,]   10    1
 [2,]    9    2
 [3,]    8    3
 [4,]    7    4
 [5,]    6    5
 [6,]    5    6
 [7,]    4    7
 [8,]    3    8
 [9,]    2    9
[10,]    1   10

How to reverse rows in matrix?

We can combine apply() and rev() to the matrix n and rearrange the entries:

n <- matrix(1:25, 5, byrow = TRUE)
apply(n,2,rev)
#     [,1] [,2] [,3] [,4] [,5]
#[1,]   21   22   23   24   25
#[2,]   16   17   18   19   20
#[3,]   11   12   13   14   15
#[4,]    6    7    8    9   10
#[5,]    1    2    3    4    5

By using apply() with the second parameter (the margin) equal to 2 we loop through all the columns of n, and for each column we apply the function rev(), which reverses the entries of a vector.

A more compact and faster way to obtain the same result is the solution pointed out by @Cath:

n[nrow(n):1,]

This simply reverses the order of the rows in the matrix.

Is there an easy way to flip a matrix (horizontal or vertical)?

I think pracma package could help you

mh <- pracma::fliplr(m)

and

mv <- pracma::flipud(m)

such that

> mh
     [,1] [,2] [,3] [,4]
[1,]   10    7    4    1
[2,]   11    8    5    2
[3,]   12    9    6    3

> mv
     [,1] [,2] [,3] [,4]
[1,]    3    6    9   12
[2,]    2    5    8   11
[3,]    1    4    7   10

Reverse indexing of a matrix in R

Background

I think it will help to examine the effect of the order() and rank() functions on a simple vector. Consider:

x <- c('c','b','d','b','a');
seq_along(x);
## [1] 1 2 3 4 5
order(x);
## [1] 5 2 4 1 3
rank(x); ## default is ties.method='average'
## [1] 4.0 2.5 5.0 2.5 1.0
rank(x,ties.method='first');
## [1] 4 2 5 3 1
rank(x,ties.method='last'); ## available from 3.3.0
## [1] 4 3 5 2 1
rank(x,ties.method='random'); ## we can ignore this one, obviously
## [1] 4 2 5 3 1
rank(x,ties.method='max');
## [1] 4 3 5 3 1
rank(x,ties.method='min');
## [1] 4 2 5 2 1

(I used character values to demonstrate that these principles and algorithms can apply to any (comparable) data type, not just numeric types. But obviously this includes numeric types.)

The order() function returns a vector that is the same length as the input vector. The order values represent a reordering of the input indexes (which are shown above courtesy of seq_along()) in such a way that when the input vector is indexed with the order vector, it will be sorted (according to the chosen sort method, which (if not explicitly overridden by a method argument), is radixsort for integer, logical, and factor, shellsort otherwise, and takes into account the collation order of the current locale for character values when not using radixsort). In other words, for an element of the result vector, its value gives the input index of the element in the input vector that should be moved to that position in order to sort it.

To try to put it even more plainly, an element of the order vector basically says "place the input vector element with this index in my position". Or, in a slightly more generic way (which will dovetail with the parallel description of rank()):

order element: the input vector element with this index sorts into my position.

In a sense, rank() does the inverse of what order() does. Its elements correspond to the elements of the input vector by index, and its values give a representation of the sort order of the corresponding input element (with tiebreaking behavior depending on the ties.method argument; this contrasts with order(), which always preserves the incoming order of ties, equivalent to ties.method='first' for rank()).

To use the same language structure that I just used for order(), which is the plainest manner of expression I can think of:

rank element: the input vector element in my position sorts into this index.

Of course, this description is only perfectly accurate for ties.method='first'. For the others, the destination index for ties will actually be the reverse of the incoming order (for 'last'), the lowest index of the duplicate set (for 'min'), the highest (for 'max'), the average (for 'average', which is actually the default), or random (for 'random'). But for our purposes, since we need to mirror the proper sort order as per order() (and therefore sort(), which uses order() internally), let's ignore the other cases from this point forward.

I've thought of one final way to articulate the behaviors of the order() and rank() functions: order() defines how to pull elements of the input vector into a sorted order, while rank() defines how to push elements of the input vector into a sorted order.

This is why indexing the input vector with the results of order() is the correct way to sort it. Indexing a vector is inherently a pulling operation. Each respective index vector element effectively pulls the input vector element that is stored at the index given by that index vector element into the position occupied by that index vector element in the index vector.

Of course, the "push vector" produced by rank() cannot be used in the same way as the "pull vector" produced by order() to directly sort the input vector, since indexing is a pull operation. But we can ask, is it in any way possible to use the push vector to sort the input vector? Yes, I've thought of how this can be done. The solution is index-assigning, which is inherently a push operation. Specifically, we can index the input vector with the push vector as the (lvalue) LHS and assign the input vector itself as the RHS.

So, here are the three methods you can use to sort a vector:

x[order(x)];
[1] "a" "b" "b" "c" "d"
sort(x); ## uses order() internally
[1] "a" "b" "b" "c" "d"
y <- x; y[rank(y,ties.method='first')] <- y; y; ## (copied to protect x, but not necessary)
[1] "a" "b" "b" "c" "d"

An interesting property of the rank() function with ties.method='first' is that it is idempotent. This is because, once you've produced a rank vector, ranking it again will not change the result. Think about it: say the first element ranks 4th. Then the first call will produce a 4 in that position. Running rank() again will again find that it ranks 4th. You don't even need to specify ties.method anymore for the subsequent calls to rank, because the values will have become distinct on the first call's (potential) tiebreaking.

rank(x,ties.method='first');
## [1] 4 2 5 3 1
rank(rank(x,ties.method='first'));
## [1] 4 2 5 3 1
rank(rank(rank(x,ties.method='first')));
## [1] 4 2 5 3 1
y <- rank(x,ties.method='first'); for (i in seq_len(1e3L)) y <- rank(y); y;
## [1] 4 2 5 3 1

On the other hand, order() is not idempotent. Repeatedly calling order() has the interesting effect of alternating between the push and pull vectors.

order(x);
## [1] 5 2 4 1 3
order(order(x));
## [1] 4 2 5 3 1
order(order(order(x)));
## [1] 5 2 4 1 3

Think about it: if the last element sorts 1st, then the first call to order() will pull it into the 1st position by placing its index (which is largest of all indexes) into the 1st position. The second call to order() will identify that the element in the 1st position is largest in the entire vector, and thus will pull index 1 into the last position, which is equivalent to ranking the last element with its rank of 1.

Solutions

Based on all of the above, we can devise 3 solutions to your problem of "desorting", if you will.

For input, let's assume that we have (1) the input vector x, (2) its sort order o, and (3) the sorted and possibly transformed vector xs. For output we need to produce the same vector xs but desorted according to o.

Common input:

x <- c('c','b','d','b','a'); ## input vector
o <- order(x); ## order vector
xs <- x[o]; ## sorted vector
xs <- paste0(xs,seq_along(xs)); ## somewhat arbitrary transformation
x;
## [1] "c" "b" "d" "b" "a"
o;
## [1] 5 2 4 1 3
xs;
## [1] "a1" "b2" "b3" "c4" "d5"

Method 1: pull `rank()`

Since the order and rank vectors are effectively inverses of each other (i.e. pull and push vectors), one solution is to compute the rank vector in addition to the order vector o, and use it to desort xs.

xs[rank(x,ties.method='first')];
## [1] "c4" "b2" "d5" "b3" "a1"

Method 2: pull repeated `order()`

Alternatively, instead of computing rank(), we can simply use a repeated order() call on o to generate the same push vector, and use it as above.

xs[order(o)];
## [1] "c4" "b2" "d5" "b3" "a1"

Method 3: push `order()`

I was thinking to myself that, since we already have the order vector o, we really shouldn't have to go to the trouble of computing another order or rank vector. Eventually I realized that the best solution is to use the pull vector o as a push vector. This accomplishes the desorting objective with the least work.

xs[o] <- xs;
xs;
## [1] "c4" "b2" "d5" "b3" "a1"

Benchmarking

library(microbenchmark);

desort.rank <- function(x,o,xs) xs[rank(x,ties.method='first')];
desort.2order <- function(x,o,xs) xs[order(o)];
desort.assign <- function(x,o,xs) { xs[o] <- xs; xs; };

## simple test case
x <- c('c','b','d','b','a');
o <- order(x);
xs <- x[o];
xs <- paste0(xs,seq_along(xs));

ex <- desort.rank(x,o,xs);
identical(ex,desort.2order(x,o,xs));
## [1] TRUE
identical(ex,desort.assign(x,o,xs));
## [1] TRUE

microbenchmark(desort.rank(x,o,xs),desort.2order(x,o,xs),desort.assign(x,o,xs));
## Unit: microseconds
##                     expr     min      lq      mean  median      uq     max neval
##    desort.rank(x, o, xs) 106.487 122.523 132.15393 129.366 139.843 253.171   100
##  desort.2order(x, o, xs)   9.837  12.403  15.66990  13.686  16.251  76.122   100
##  desort.assign(x, o, xs)   1.711   2.567   3.99916   3.421   4.277  17.535   100

## scale test case
set.seed(1L);
NN <- 1e4; NE <- 1e5; x <- sample(seq_len(NN),NE,T);
o <- order(x);
xs <- x[o];
xs <- xs+seq(0L,NE-1L)/NE;

ex <- desort.rank(x,o,xs);
identical(ex,desort.2order(x,o,xs));
## [1] TRUE
identical(ex,desort.assign(x,o,xs));
## [1] TRUE

microbenchmark(desort.rank(x,o,xs),desort.2order(x,o,xs),desort.assign(x,o,xs));
## Unit: milliseconds
##                     expr       min        lq     mean    median        uq       max neval
##    desort.rank(x, o, xs) 36.488185 37.486967 39.89157 38.613191 39.145405 85.849143   100
##  desort.2order(x, o, xs) 16.764414 17.262630 18.10341 17.443527 19.014296 28.338835   100
##  desort.assign(x, o, xs)  1.457014  1.498495  1.82893  1.527363  1.592151  4.255573   100

So, clearly the index-assignment solution is the best.

Demo

Below is a demonstration of how this solution can be used for your sample input.

I honestly think that a simple for-loop over the rows is preferable to an apply() call in this case, since you can modify the matrix in-place. If you need to preserve the sorted intermediate matrix, you can copy it before applying this desorting operation.

## generate input matrix
set.seed(21L); m <- matrix(sample(seq_len(100L)),10L); m;
##       [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
##  [1,]   79   61    1   66   40   39    2   86   44    26
##  [2,]   25   84   49   35   67   32   36   70   50   100
##  [3,]   69    6   90   51   30   92   65   34   68    42
##  [4,]   18   54   72   73   85   75   55   15   27    77
##  [5,]   93   16   23   58    9    7   19   64    8    46
##  [6,]   88    4   60   13   98   47    5   29   56    80
##  [7,]   10   45   43   14   95   11   74   76   83    38
##  [8,]   17   24   57   82   63   28   71   87   53    59
##  [9,]   91   41   81   21   22   94   33   62   12    37
## [10,]   78   52   48   31   89    3   97   20   99    96

## sort each row, capturing sort order in rowwise order matrix
o <- matrix(NA_integer_,nrow(m),ncol(m)); ## preallocate
for (ri in seq_len(nrow(m))) m[ri,] <- m[ri,o[ri,] <- order(m[ri,],decreasing=T)];

## whole-matrix transformation
## embed row index as tenth digit, column index as hundredth (arbitrary)
m <- m+(row(m)-1L)/nrow(m)+(col(m)-1L)/ncol(m)/10;

## desort
for (ri in seq_len(nrow(m))) m[ri,o[ri,]] <- m[ri,]; m;
##        [,1]  [,2]  [,3]  [,4]  [,5]  [,6]  [,7]  [,8]  [,9]  [,10]
##  [1,] 79.01 61.03  1.09 66.02 40.05 39.06  2.08 86.00 44.04  26.07
##  [2,] 25.19 84.11 49.15 35.17 67.13 32.18 36.16 70.12 50.14 100.10
##  [3,] 69.22  6.29 90.21 51.25 30.28 92.20 65.24 34.27 68.23  42.26
##  [4,] 18.38 54.36 72.34 73.33 85.30 75.32 55.35 15.39 27.37  77.31
##  [5,] 93.40 16.46 23.44 58.42  9.47  7.49 19.45 64.41  8.48  46.43
##  [6,] 88.51  4.59 60.53 13.57 98.50 47.55  5.58 29.56 56.54  80.52
##  [7,] 10.69 45.64 43.65 14.67 95.60 11.68 74.63 76.62 83.61  38.66
##  [8,] 17.79 24.78 57.75 82.71 63.73 28.77 71.72 87.70 53.76  59.74
##  [9,] 91.81 41.84 81.82 21.88 22.87 94.80 33.86 62.83 12.89  37.85
## [10,] 78.94 52.95 48.96 31.97 89.93  3.99 97.91 20.98 99.90  96.92

Strange behavior of apply/ reverse function in R

apply always puts the result in the first dimension. See ?apply for more information. Assuming this input:

mat <- matrix(1:9, 3, byrow = TRUE)

here are some alternatives:

1) transpose

t(apply(mat, 1, rev))

2) avoid apply with indexing

mat[, 3:1]

3) iapply An idempotent apply was posted here:
https://stat.ethz.ch/pipermail/r-help/2006-January/086064.html
Using that we have:

iapply(mat, 1, rev)

There was also an idempotent apply, iapply, in version 0.8.0 of the reshape package (but not in the latest version of reshape): https://cran.r-project.org/src/contrib/Archive/reshape/

4) rollapply rollapply in the zoo package can be used:

library(zoo)

rollapply(mat, 1, rev, by.column = FALSE)

5) tapply The tapply expression here returns a list giving us the opportunity to put it together in the way we want -- in this case using rbind:

do.call("rbind", tapply(mat, row(mat), rev))

6) multiply by a reverse diagonal matrix Since rev is a linear operator it can be represented by a matrix:

mat %*% apply(diag(3), 1, rev)

mat %*% (row(mat) + col(mat) == 3+1)

Change row order in a matrix/dataframe

There probably are more elegant ways, but this works:

m <- matrix(1:9, ncol=3, byrow=TRUE)

# m[rev(seq_len(nrow(m))), ]  # Initial answer
m[nrow(m):1, ]
     [,1] [,2] [,3]
[1,]    7    8    9
[2,]    4    5    6
[3,]    1    2    3

This works because you are indexing the matrix with a reversed sequence of integers as the row index. nrow(m):1 results in 3 2 1.

How to reverse specific ranges of a vector at the same time in R?

Try

x[unlist(sapply(YY, rev))]

The dependence on YY is implemented here and the orders will vary accordingly whenever YY varies.

Tree list to reverse-lower triangular matrix in R

1) Below the lapply appends n zeros to each component of m and the sapply takes the first n elements of each component of m reshaping the result into a matrix. Finally we reverse the order of the rows of the resulting matrix. This works even if m does not define a triangular matrix:

n <- length(m)
sapply(lapply(m, c, numeric(n)), head, n)[n:1, ]

giving:

     [,1] [,2] [,3] [,4]
[1,]    0    0    0   10
[2,]    0    0    6    9
[3,]    0    3    5    8
[4,]    1    2    4    7

If n can be zero then use rev(seq_len(n)) in place of n:1 .

2) A straight forward sapply also works. It prepends each reversed component of m with the appropriate number of zeros and reshapes into a matrix:

sapply(m, function(v) c(numeric(n - length(v)), rev(v)))

How to Reverse a Matrix in R