rot90 — Rotate matrices and N-D arrays by 90-degree increments with MATLAB-compatible direction rules.

rot90(A) rotates A by 90 degrees counterclockwise, and an optional second argument specifies additional quarter-turns (positive for counterclockwise, negative for clockwise). For N-D arrays, rotation is applied to the first two dimensions while trailing dimensions are preserved.

Syntax

B = rot90(A)
B = rot90(A, k_or_direction)

Inputs

Returns

Errors

How rot90 works

• Default behaviour rotates 90 degrees counterclockwise (k = 1).
• rot90(A, K) rotates by K * 90°; the rotation count can be positive, negative, or zero. Any integer multiple of four leaves the input unchanged.
• The direction keywords 'clockwise' and 'counterclockwise' are accepted as an alternative to the numeric argument (case-insensitive).
• Works for numeric tensors, logical masks, complex arrays, string arrays, and character matrices. Scalars are unchanged.
• For empty dimensions the function still swaps the first two extents, so rot90(zeros(0, 3)) returns a 3×0 array.

Does RunMat run rot90 on the GPU?

Providers that implement both permute and flip can realise the rotation without leaving the GPU, preserving residency for downstream operations.

If a dedicated rot90 kernel is exposed the provider may call it instead of composing lower-level hooks.

When no compatible hooks are available, RunMat gathers the tensor once, rotates it on the host, and re-uploads the rotated tensor so subsequent GPU work continues without surprises.

GPU memory and residency

Not usually. The auto-offload planner keeps tensors on the GPU whenever it is profitable. Explicitly creating a gpuArray matches MATLAB syntax, but RunMat will also auto-promote host tensors when the planner determines that rotating them on the device avoids unnecessary transfers. When the active provider lacks native support the runtime downloads the tensor once, rotates on the host, and uploads the rotated tensor back to the GPU so downstream operations continue to benefit from residency information.

Examples

Rotating a matrix 90 degrees counterclockwise

A = [1 2 3; 4 5 6];
B = rot90(A)

Expected output:

B =
     3     6
     2     5
     1     4

Rotating a matrix clockwise using a direction keyword

A = magic(3);
C = rot90(A, 'clockwise')

Expected output:

C =
     6     1     8
     7     5     3
     2     9     4

Applying multiple 90-degree turns with a numeric count

A = reshape(1:9, [3 3]);
B = rot90(A, 2);    % 180-degree rotation

Expected output:

B =
     9     8     7
     6     5     4
     3     2     1

Rotating 3-D data while preserving trailing dimensions

T = reshape(1:12, [2 3 2]);
R = rot90(T);
size(R)

Expected output:

ans =
     3     2     2

Rotating character data to reorganise text

C = ['r','u','n'; 'm','a','t'; ' ','A','I'];
R = rot90(C)

Expected output:

R =
    'ntI'
    'uaA'
    'rm '

Rotating gpuArray data and keeping it on the device

G = gpuArray(reshape(1:9, [3 3]));
H = rot90(G, -1);     % rotate clockwise
isgpuarray(H)

Expected output:

ans = logical 1

Using rot90 with coding agents

Open a RunMat example with live inputs, then ask the agent to explain how rot90 changes the result.

FAQ

Related Array functions

Open-source implementation

Unlike proprietary runtimes, every RunMat function is open-source. Read exactly how rot90 is executed, line by line, in Rust.

• View the source for rot90 in Rust on GitHub
• Learn how the RunMat runtime works
• Found a bug? Open an issue with a minimal reproduction.

About RunMat

RunMat is an open-source runtime that executes MATLAB-syntax code blazing on any GPU. It is licensed under the Apache 2.0 license.

• RunMat automatically optimizes your math for GPU execution on Apple, Nvidia, and AMD hardware. No code changes needed. Simulations that took hours now take minutes.
• Start running code in seconds. RunMat runs in the browser, on the desktop, or from the CLI. No license server, no IT ticket.

Getting started · Benchmarks · Pricing