RunMat
GitHub

View all functions

CategoryArray: Shape
GPUYes

What does the rot90 function do in MATLAB / RunMat?

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 does the rot90 function behave in MATLAB / 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.

rot90 Function GPU Execution Behaviour

When RunMat Accelerate is enabled, the runtime first looks for GPU provider hooks to keep the rotation on the device:

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

Examples of using the rot90 function in MATLAB / RunMat

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

GPU residency in RunMat (Do I need gpuArray?)

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.

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.

See Also

flip, permute, reshape, kron, gpuArray, gather

Source & Feedback