Reverse

From APL Wiki
Jump to navigation Jump to search

Reverse (, ) is a monadic function which reorders elements of the argument to go in the opposite direction along a specified axis. The name Reverse is typically used for the primitive , which reverses along the last axis, while , which reverses along the first axis, is called "Reverse First", "Reverse-down", or similar. In APLs with function axis, either form may use a specified axis which overrides this default choice of axis. In the leading axis model, specifying an axis is discouraged in favor of using with the Rank operator.

Examples

Reverse flips a matrix horizontally, changing elements to go right to left, and Reverse First flip vertically, so the elements are reordered top to bottom.

      x  10 20 30 ∘.+ 6
      x
11 12 13 14 15 16
21 22 23 24 25 26
31 32 33 34 35 36
      x
16 15 14 13 12 11
26 25 24 23 22 21
36 35 34 33 32 31
      x
31 32 33 34 35 36
21 22 23 24 25 26
11 12 13 14 15 16

Since a vector only has one axis, any form of Reverse will reverse along this axis.

       'Backwards text'
txet sdrawkcaB
      ⊖⌽ 'Backwards text'       ⍝ One reverse undoes the other
Backwards text

Reverse with a specified axis can reverse along any of the three dimensions of the array below.

      a2 3 6⍴⍳36
 1  2  3  4  5  6
 7  8  9 10 11 12
13 14 15 16 17 18

19 20 21 22 23 24
25 26 27 28 29 30
31 32 33 34 35 36
      ([1]a)([2]a)([3]a)
┌─────────────────┬─────────────────┬─────────────────┐
19 20 21 22 23 2413 14 15 16 17 18 6  5  4  3  2  1
25 26 27 28 29 30 7  8  9 10 11 1212 11 10  9  8  7
31 32 33 34 35 36 1  2  3  4  5  618 17 16 15 14 13
                                                   
 1  2  3  4  5  631 32 33 34 35 3624 23 22 21 20 19
 7  8  9 10 11 1225 26 27 28 29 3030 29 28 27 26 25
13 14 15 16 17 1819 20 21 22 23 2436 35 34 33 32 31
└─────────────────┴─────────────────┴─────────────────┘

The Rank operator can also be used to reverse along a particular axis. While Rank has no effect on Reverse (last), Reverse First with rank k reverses the first axis of each k-cell, or the 1+r-k'th axis of a rank-r array.

      2a                     ⍝ Same as ⌽
 5  4  3  2  1  0
11 10  9  8  7  6
17 16 15 14 13 12

23 22 21 20 19 18
29 28 27 26 25 24
35 34 33 32 31 30
      2a                    ⍝ Same as ⌽[2]
12 13 14 15 16 17
 6  7  8  9 10 11
 0  1  2  3  4  5

30 31 32 33 34 35
24 25 26 27 28 29
18 19 20 21 22 23
      (3a)(2a)(1a)
┌─────────────────┬─────────────────┬─────────────────┐
19 20 21 22 23 2413 14 15 16 17 18 6  5  4  3  2  1
25 26 27 28 29 30 7  8  9 10 11 1212 11 10  9  8  7
31 32 33 34 35 36 1  2  3  4  5  618 17 16 15 14 13
                                                   
 1  2  3  4  5  631 32 33 34 35 3624 23 22 21 20 19
 7  8  9 10 11 1225 26 27 28 29 3030 29 28 27 26 25
13 14 15 16 17 1819 20 21 22 23 2436 35 34 33 32 31
└─────────────────┴─────────────────┴─────────────────┘

Reversing a scalar has no effect: there are no axes to reverse along.

      1.1
1.1

Description

In languages with function axis, exactly one argument axis may be specified.

Reversing a scalar always yields that scalar unchanged. Otherwise, Reverse operates on a particular axis of its argument. This axis is the specified axis if one is given, and otherwise the last axis for , or the first axis for .

The result array has the same shape and elements as the argument array, but the elements go in the opposite direction along the reversal axis: the first in the argument is last in the result, and so on. Consequently if the length of this axis is 0 or 1 then reversing has no effect.

APL model

The reverse of a vector x may be written in any APL, assuming ⎕IO0, as x[(¯1+⍴x)-⍳⍴x]. To reverse an arbitrary array Squad indexing with axis (or rank) is helpful.

ReverseAxis  {
    ⎕IO0
    0=≢⍴⍵:                     ⍝ Return a scalar unchanged
      ¯1+≢⍴                  ⍝ Assume last axis
    l                      ⍝ Length of reversed axis
    (l-1+⍳l) []              ⍝ Reverse with indexing
}

External links

Lessons

Documentation


APL built-ins [edit]
Primitive functions
Scalar
Monadic ConjugateNegateSignumNotRollType
Dyadic AddSubtractTimesDivideEqual to (Xnor) ∙ Not Equal to (Xor) ∙ MinimumMaximumComparison functionsComplex
Non-Scalar
Structural ShapeReshapeTallyDepthRavelReverseRazeMixCut (K)PairReplicatePartitioned Enclose
Selection FirstTakeDropUniqueIdentitySelectBracket index
Selector Index generatorInterval IndexIndices
Computational MatchNot MatchNub SieveFormatExecute
Primitive operators Monadic EachReplicateCommuteFunction axis
Dyadic BesideBindReverse Compose
Quad names
Arrays Index originMigration level
Functions
Operators