rot90 — Rotate matrices and N-D arrays by multiples of 90 degrees.

rot90(A) rotates the matrix A by 90 degrees counterclockwise. A second argument specifies additional 90-degree turns (positive values rotate counterclockwise, negative values clockwise). For N-D arrays, only the first two dimensions participate in the rotation; trailing dimensions remain unchanged.

How rot90 works in RunMat

• 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.

How rot90 runs 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

FAQ

What directions does rot90 support?

Numeric rotation counts (integers) and the strings 'clockwise' / 'counterclockwise' are recognised. Any other strings raise an error.

Does rot90 modify dimensions beyond the first two?

No. Only the first two axes participate in the rotation. Other dimensions keep their order and extents unchanged.

What happens for empty matrices?

Empty inputs still swap the first two dimension sizes. For example, a 0×5 matrix becomes 5×0 after a single counterclockwise rotation.

Can I rotate logical, string, or character arrays?

Yes. Logical results remain logical, string arrays preserve their elements, and character matrices rotate their characters exactly like numeric data.

How do large rotation counts behave?

The rotation count is reduced modulo 4. Values such as rot90(A, 37) behave the same as rot90(A, 1).

Is rot90 compatible with complex numbers?

Absolutely. Complex tensors rotate without altering the real or imaginary parts; only the element positions change.

Can providers implement a custom kernel?

Yes. Providers may implement a specialised rot90 kernel. When unavailable, the runtime composes the operation using the permute and flip hooks or falls back to the host implementation.

Related functions to explore

These functions work well alongside rot90. Each page has runnable examples you can try in the browser.

flip, permute, reshape, kron, gpuArray, gather, cat, circshift, diag, fliplr, flipud, horzcat, ipermute, repmat, squeeze, tril, triu, vertcat

Open-source implementation

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

• View rot90.rs on GitHub
• Learn how the 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 — faster, on any GPU, with no license required.

• Simulations that took hours now take minutes. RunMat automatically optimizes your math for GPU execution on Apple, Nvidia, and AMD hardware. No code changes needed.
• Start running code in seconds. Open the browser sandbox or download a single binary. No license server, no IT ticket, no setup.
• A full development environment. GPU-accelerated 2D and 3D plotting, automatic versioning on every save, and a browser IDE you can share with a link.

Getting started · Benchmarks · Pricing