FLIPARRAYV

[GeertD]

FLIPARRAYV: Flip array vertically, top to bottom.

=LAMBDA(A,LET(
   RowsA,ROWS(A),ColsA,COLUMNS(A),
   INDEX(A,SEQUENCE(RowsA,,RowsA,-1),SEQUENCE(,ColsA))
))

DXLR's LAMBDA.LET Library_v00.07.xlsb
	A	B	C	D
1	1	1	1
2	2	2	2
3	3	3	3
4
5	3	3	3
6	2	2	2
7	1	1	1
8
Sandbox_Mr.Excel

Cell Formulas
Range	Formula
A5:C7	A5	=FlipArrayV(A1:C3)
Dynamic array formulas.

 

[Hoover889]

Wouldn't multiplying the array by an exchange matrix be faster? That was my theory when I made my own array flipping functions. (but it does require a helper function)

ExchangeMatrix:

=LAMBDA(n,MAKEARRAY(n,n,LAMBDA(i,j,--(j=(n-i+1))))

ReverseRows:

=LAMBDA(Rng,MMULT(ExchangeMatrix(ROWS(Rng)),Rng)

ReverseCols:

=LAMBDA(Rng,MMULT(Rng,ExchangeMatrix(COLUMNS(Rng)))

 

[tboulden]

Do you get other usage from ExchangeMatrix? I tried mimicking Python numpy.flipud and numpy.fliplr using just MAKEARRAY, logic is similar. If no other uses for ExchangeMatrix, just build the logic into the function?

aFlipUD - vertical

=LAMBDA(array,
    LET(
        rows_,ROWS(array),
        cols_,COLUMNS(array),
        MAKEARRAY(
            rows_,
            cols_,
            LAMBDA(i,j,INDEX(array,rows_-(i-1),j))
        )
    )
)

aFlipLR - horizontal

=LAMBDA(array,
    LET(
        rows_,ROWS(array),
        cols_,COLUMNS(array),
        MAKEARRAY(
            rows_,
            cols_,
            LAMBDA(i,j,INDEX(array,i,cols_-(j-1)))
        )
    )
)

 

[tboulden]

Also forgot, MAKEARRAY wasn't available back in April just yet.

 

[GeertD]

Wouldn't multiplying the array by an exchange matrix be faster? That was my theory when I made my own array flipping functions. (but it does require a helper function)

I don't think so.
My formula is a simple INDEX selection function that is subsequently "broadcast" (MS-speak that I like to call "perpendicular vectorization").
For short: a broadcasted Index-selection approach.
Mind you: there is NO lookup (that's what (x)match does, and I don't use that).
MMULT requires a full matrix multiplication (whether the elements are zero or not).
Although MMULT can be simple to use and very useful, in general that is not the most efficient way of calculating things.
IMO, anyway. of course you can always test it.
Also [tboulden], using MAKEARRAY where you iterate a LAMBDA in which there is an INDEX function...
...sounds a little convoluted to me. No offence.

 

[tboulden]

Also [tboulden], using MAKEARRAY where you iterate a LAMBDA in which there is an INDEX function...
...sounds a little convoluted to me. No offence.

Yeah, I'd love to know the relative efficiencies of various approaches; depending on how MAKEARRAY is implemented, it may just be lifting the function over the row-index and column-index arrays as opposed to "iterating" over them, similar to MAP(array_1,array_2,LAMBDA(x,y,...)), which I think INDEX probably does something like this natively in the first place.

 

[GeertD]

Yeah, I'd love to know the relative efficiencies of various approaches; depending on how MAKEARRAY is implemented, it may just be lifting the function over the row-index and column-index arrays as opposed to "iterating" over them, similar to MAP(array_1,array_2,LAMBDA(x,y,...)), which I think INDEX probably does something like this natively in the first place.

Well, as I understand from both the MR.Excel video and his book "Excel: Dynamic Arrays – StraightToThePoint": "lifting" is what WE do to INDEX (in this case) by vectorizing one of its scalar arguments.
That's as close as "native" as we can get, IMO.