area — Create filled area plots in MATLAB and RunMat.

area creates filled area plots from vector or matrix-style inputs. It returns one area handle per plotted series, supports baseline and stacked behaviors, and participates in the shared MATLAB/RunMat plotting handle-property system.

Syntax

h = area(Y)
h = area(Y, LineSpec)
h = area(Y, basevalue)
h = area(Y, Name, Value, ...)
h = area(X, Y)
h = area(X, Y, LineSpec)

h = area(Y)
h = area(Y, LineSpec)
h = area(Y, basevalue)
h = area(Y, Name, Value, ...)
h = area(X, Y)
h = area(X, Y, LineSpec)
h = area(X, Y, basevalue)
h = area(X, Y, Name, Value, ...)
h = area(ax, Y)
h = area(ax, Y, Name, Value, ...)
h = area(ax, Y, basevalue)
h = area(ax, X, Y)
h = area(ax, X, Y, Name, Value, ...)
h = area(ax, X, Y, basevalue)

Inputs

Returns

Errors

How area works

• area(y) uses implicit x-values 1:n, while area(x, y) uses explicit x coordinates.
• If explicit x-values are not increasing, each series is sorted by x before rendering; integer x-values are ordered in their native class before conversion to graphics coordinates.
• Matrix-style y inputs create stacked area series in the MATLAB style.
• Vector y returns one area handle, while matrix y returns a row vector with one handle for each column; every handle works with get and set.
• Baseline and color workflows flow through the shared plotting property model.
• All eight integer classes are accepted for X, Y, BaseValue, and LineWidth; integer plot data crosses one explicit client graphics conversion boundary.
• Compatible floating stacked-series geometry can be emitted directly from GPU buffers on the RunMat acceleration path.

Options

• A positional numeric scalar or 'BaseValue' name-value pair sets the baseline used by area filling.
• 'LineWidth' accepts a positive numeric scalar, including every integer class.
• Color and display-name workflows are available through the returned handle and the shared plotting property path.

Does RunMat run area on the GPU?

The direct RunMat area path emits filled geometry from compatible floating GPU data when X is implicit or a known nondecreasing host vector.

Resident integer data and explicit resident X gather on the client so exact integer ordering and documented sorting occur before conversion.

Baseline semantics, stacked-series behavior, and one-handle-per-series output remain aligned across direct and fallback paths.

GPU memory and residency

The documented GPU-array surface executes on the client, so resident integer X and Y gather with typed storage intact and convert only at the graphics boundary. RunMat preserves floating-point residency on a compatible direct path, including stacked-series geometry generation; other inputs use the semantics-preserving fallback.

Examples

Create a basic filled area plot

x = 0:0.1:1;
area(x, x.^2);

Create stacked area series from a matrix

x = 1:5;
Y = [1 2 1; 2 1 2; 3 2 1; 2 3 2; 1 2 3];
area(x, Y);

Change the baseline and label the series through the handle

x = 0:0.2:2;
h = area(x, sin(x) + 2);
set(h, 'BaseValue', 1, 'DisplayName', 'offset area');
legend;

Stacked energy mix

years = 2018:2025;
solar   = [5  8  12 18 25 33 42 50];
wind    = [10 14 18 22 28 32 36 40];
hydro   = [30 30 29 28 27 27 26 26];
mix = [solar; wind; hydro]';

area(years, mix);
title('Energy Generation Mix');
xlabel('Year');
ylabel('TWh');
legend('Solar', 'Wind', 'Hydro');
grid on;

Compare this result with other chart types in the MATLAB Plot Gallery.

Using area with coding agents

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

FAQ

x = 1:6;
Y = [2 3 1; 1 2 2; 3 1 2; 2 2 3; 1 3 1; 2 1 3];
area(x, Y);
legend('A', 'B', 'C');

area(x, y1);
hold on;
h = area(x, y2);
set(h, 'FaceAlpha', 0.4);

Related Plotting functions

More plotting resources

• Choosing the right plot type
• Styling plots and axes
• Plot replay and export
• Complete plotting guide

Open-source implementation

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

• View the source for area 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