AutoGineer
Generated banner for Matlab Analyze Data
Generated logo for Matlab Analyze Data

Matlab Analyze Data

MathWorksOfficialCreated by MathWorks

  • Skill
  • Tool integration
  • Data and AI
  • BSD-2-Clause
  • No issues found
Download ZIP

From the author

Analyze data using MATLAB. Use when the task involves tables, timetables, time-series data, numeric arrays, sensor matrices, or gridded data — including but not limited to exploring, row filtering, sorting, cleaning, transforming, aggregating, smoothing, padding, trimming, and answering questions about data. MATLAB provides extensive, easy-to-use built-in functions for these workflows with no additional products required.
— the description by MathWorks

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured approach to data analysis in MATLAB, focusing on modern, idiomatic practices for handling tables, timetables, and numeric arrays. It emphasizes the use of built-in functions for cleaning, transforming, aggregating, and exploring data, while providing guidance on avoiding legacy patterns and common pitfalls. The skill is designed to help users efficiently answer questions about their data by leveraging MATLAB's native capabilities for data manipulation and statistical analysis.

What it does

  • Generates idiomatic MATLAB code for tabular and time-series data analysis.
  • Provides guidance on cleaning data, including handling missing values and outliers.
  • Supports complex data transformations like filtering, sorting, and reshaping.
  • Facilitates grouped statistics and aggregation using modern functions.
  • Offers techniques for smoothing, trend detection, and pattern analysis.
  • Includes best practices for working with numeric arrays and gridded data.

When to use it

  • When you need to explore, clean, or transform tabular or time-series data.
  • When performing statistical aggregations or group-based analysis.
  • When analyzing sensor matrices or gridded numeric data.
  • When you need to detect patterns, trends, or outliers in your datasets.
  • When you need to answer specific questions about data structure or content.

Advantages

  • Promotes the use of modern, performance-optimized MATLAB functions.
  • Reduces bugs by providing clear guidance on handling missing data and types.
  • Ensures consistent and readable code through idiomatic patterns.
  • Provides direct access to documentation for key data analysis functions.
  • Helps avoid common pitfalls associated with legacy MATLAB syntax.

Usage examples

“How do I calculate the mean sales per region from my table T?”
The agent will provide code using groupsummary(T, 'Region', 'mean', 'Sales') to efficiently compute the requested statistics.
“Clean the missing values in my timetable by forward-filling.”
The agent will generate code using fillmissing(TT, 'previous') to handle gaps in the time-series data.
“Find the top 5 rows in my table based on the 'Revenue' column.”
The agent will suggest using topkrows(T, 5, 'Revenue') for a clean and efficient retrieval.
“How do I smooth a noisy signal in a numeric array?”
The agent will recommend using smoothdata(X, 'movmean', windowSize) to apply a moving average filter.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/matlab/matlab-analyze-data/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip matlab-analyze-data.zip -d .agents/skills

Documentation by MathWorks

MATLAB Data Analysis

Generate idiomatic MATLAB code for tabular data analysis tasks using tables and timetables.

When to Use

  • Any task involving tabular data: exploring, cleaning, transforming, or aggregating tables

  • Time-series analysis: resampling, synchronizing, trend detection, smoothing

  • Answering questions about data in tables (top-N, filtering, group comparisons)

  • Data cleaning: missing values, outliers, type conversion, normalization

When NOT to Use

  • The task has no data context (no tables, timetables, arrays, or date/time values to work with)

  • The primary goal is visualization or plotting, not data analysis (use matlab-build-chart instead)

  • The task is purely symbolic math, simulation, or app building

  • Reading or writing files — CSV, Excel, Parquet, MAT-file (use matlab-import-export-data instead)

  • Data doesn't fit in memory or requires out-of-core processing (use matlab-choose-big-data-solution instead)

  • Storing or retrieving passwords, tokens, or API keys (use matlab-secure-credentials instead)

  • Data lives in a relational database (use matlab-use-database or matlab-use-duckdb instead)

  • Building an ML training pipeline from labeled signal files (use matlab-prepare-signal-data instead)

  • Training classifiers or comparing ML model accuracy on tabular data (use matlab-classify-tabular-data instead)

  • Engineering or selecting features to optimize a supervised ML model (use matlab-engineer-tabular-features instead)

  • Code migration or replacing deprecated APIs (use matlab-modernize-code instead)

Routing: Read references on all relevant topics

This skill covers core MATLAB functions for tabular, time-series, and array-based data workflows — including numeric arrays, sensor matrices, and gridded data. These functions work natively with table, timetable, and numeric arrays, handle missing data correctly, and are performance-optimized. Prefer the modern functions recommended here (e.g., groupsummary, datetime, fillmissing, smoothdata2) over legacy alternatives (e.g., accumarray, nanmean, datenum). Override only if the user explicitly requests otherwise.

Each section below links to a reference file. ALWAYS read the reference file for every relevant topic before writing code. Reference files contain correct syntax, common pitfalls, and "Avoid" patterns that prevent silent bugs. Skipping the reference risks using a deprecated approach or hitting a known pitfall. After reading, state Reference files read: [list] at the top of your response.

Key Functions — Available From

Most functions in this skill are available in R2023a or earlier. The following require a newer release:

FunctionAvailable FromPurpose
paddata, trimdata, resizeR2023bPad, trim, or resize arrays to target length
smoothdata2R2023bSmooth 2-D gridded data over rectangular windows
kdeR2023bKernel density estimate for univariate data
clipR2024aClamp values to a range
islocalmax2, islocalmin2R2024aDetect local extrema in 2-D gridded data
summary (enhanced)R2024bSupports arrays (numeric, datetime, duration, logical); adds Statistics, DataVariables, Detail name-value args
isapproxR2024bTolerance-aware floating-point comparison (use instead of == for computed values)
isbetween (numeric)R2024bCheck elements within a numeric range
numuniqueR2025aCount distinct values in a variable
allbetweenR2025aValidate all values are within a range
alluniqueR2025aValidate all values are unique

Getting Oriented with Data

When data is already in a workspace variable, start by understanding its structure and contents before writing analysis code.

Topics:

  • Summarizing structure, shape, and variable types

  • Assessing how much data is missing and where

  • Understanding distributions (numeric quartiles, categorical value counts)

  • Finding correlations and relationships between variables

  • Checking for duplicates, unique keys, and cardinality

  • Exploring time range, regularity, and temporal patterns

Functions: summary, head, size, jsonencode, anymissing, allfinite, ismissing, groupcounts, numunique, allunique, kde, corrcoef, pivot, unique, isregular, isuniform, retime

Read: exploration.md

Data Types

Use modern MATLAB types instead of legacy alternatives. Modern types are faster, more readable, and work better with table functions.

Topics:

  • Dates and times (parsing, arithmetic, timezones, extracting year/month/day/hour)

  • Elapsed time and calendar offsets

  • Text data (comparing, searching, splitting, editing strings)

  • Categorical data (ordinal rankings, merging/renaming/reordering levels)

Functions: datetime, dateshift, year, month, day, weekday, quarter, hour, timeofday, ymd, hms, hours, days, minutes, seconds, calmonths, caldays, string, matches, contains, startsWith, extractAfter, extractBefore, replace, erase, strip, split, count, categorical, mergecats, renamecats, removecats, reordercats, countcats

Read: data-types.md

Tables and Timetables

Tables are the primary container for tabular data. Use timetable when the data has timestamps, a time vector, or a known sample rate — it unlocks time-aware operations (automatic spacing-aware smoothing, filling, and resampling).

Topics:

  • Creating and structuring tables (variables vs rows, metadata, properties)

  • Selecting variables by type; dot indexing vs braces vs parentheses

  • Converting variable types after import

  • Working with non-uniformly spaced data (SamplePoints)

  • Resampling, aligning, and synchronizing time series

  • Filtering by date range or time tolerance

  • Converting legacy timeseries objects

Functions: table, timetable, table2timetable, vartype, convertvars, retime, synchronize, lag, timerange, withtol, timeseries2timetable, table2array, array2table

Read: tables-and-timetables.md

Eventtables

Use eventtable when tagging or annotating timetable rows with events, episodes, or phases (sensor anomalies, storms, maintenance windows, alarms). Do NOT add boolean columns, string labels, or categorical state variables to the timetable itself.

Topics:

  • Creating an eventtable from timestamps and labels (instantaneous or interval)

  • Attaching events to a timetable

  • Filtering timetable rows by event properties

  • Extracting events from patterns in data (peaks, threshold crossings)

  • Pushing event data into timetable rows for export or grouping

  • Automatic event overlays in plots

Functions: eventtable, eventfilter, extractevents, syncevents, withtol, stackedplot

Read: eventtables.md

Data Cleaning

Handle missing values and outliers using MATLAB's built-in detection and fill functions. Never compare with == for missing values. Use standardizeMissing to convert sentinel values before filling or removing.

Topics:

  • Detecting missing values (NaN, NaT, missing strings, undefined categoricals)

  • Converting placeholder values ("N/A", -999, "") to standard missing

  • Filling gaps (interpolation, forward-fill, moving window, per-type strategies)

  • Limiting fill across long gaps

  • Skipping missing values in aggregation (mean, std, min, max) — correct calling syntax

  • Detecting, removing, or replacing outliers

  • Checking whether values fall within an expected range; clamping

Functions: ismissing, anymissing, standardizeMissing, fillmissing, rmmissing, isoutlier, rmoutliers, filloutliers, isbetween, allbetween, clip

Read: data-cleaning.md

Data Transformation

Filter, sort, reshape, normalize, bin, join, and manage table variables. Use vectorized operations and built-in functions — not loops over rows or manual if-else chains.

Topics:

  • Filtering rows by condition or value range

  • Sorting and retrieving top/bottom N rows

  • Applying functions across rows or across variables

  • Renaming, reordering, adding, removing, splitting, merging variables

  • Converting types and applying in-place transforms

  • Binning continuous values into categories

  • Normalizing, scaling, z-scoring

  • Reshaping between wide and tall formats (pivot, stack, unstack)

  • Joining/merging tables on key variables

Functions: sortrows, topkrows, rowfun, varfun, convertvars, renamevars, movevars, addvars, removevars, splitvars, mergevars, discretize, normalize, clip, rescale, isapprox, isbetween, pivot, stack, unstack, rows2vars, innerjoin, outerjoin, join

Read: data-transformation.md

Grouping and Aggregation

groupsummary is the go-to for grouped statistics — not findgroups+accumarray or manual loops. Use groupfilter for per-group row filtering, grouptransform for per-group normalization, and pivot for cross-tabulation.

Topics:

  • Computing statistics by group (mean, sum, std, min, max, custom)

  • Binning on the fly (numeric edges, hourly/monthly/seasonal time bins)

  • Handling missing or empty groups

  • Filtering rows based on group-level conditions (e.g., minimum group size)

  • Removing per-group outliers

  • Normalizing within each group (z-score, rescale)

  • Cross-tabulating counts or aggregated values

Functions: groupsummary, groupcounts, groupfilter, grouptransform, pivot, findgroups

Read: grouping-and-aggregation.md

Smoothing, Trends, and Patterns

smoothdata is the unified entry point for smoothing (not smooth, which requires Curve Fitting Toolbox). Use detrend or trenddecomp for trend removal/decomposition, and islocalmax/islocalmin/ischange for pattern detection.

Topics:

  • Smoothing noisy data (moving average, Gaussian, Savitzky-Golay, median)

  • Choosing window size (element count vs duration for time-stamped data)

  • Removing linear or polynomial trends

  • Separating trend from seasonality (seasonal decomposition)

  • Finding peaks, valleys, and local extrema

  • Detecting abrupt changes in mean, variance, or slope

  • Summarizing distributions (bin counts, histograms)

Functions: smoothdata, movmean, movmedian, detrend, trenddecomp, islocalmax, islocalmin, ischange, histcounts, histogram

Read: smoothing-and-trends.md

Array and Grid Data

Use arrays when data is homogeneous numeric AND either naturally 2D/grid, performance-critical, or delivered by upstream tooling. For 2D grids, use dedicated 2D functions — do not loop 1D functions over rows/columns.

Topics:

  • When to stay in arrays vs converting to table

  • Operating along a specific dimension (row-wise vs column-wise)

  • Common pitfalls with dimension arguments in std, var, movstd, movvar

  • Handling NaN in array computations (not automatic)

  • Moving window and cumulative statistics

  • Padding, trimming, or resizing arrays to a target length

  • 2D spatial smoothing, gap filling, and peak detection on grids

  • Grouped operations using a grouping vector

Functions: smoothdata2, fillmissing2, islocalmax2, islocalmin2, paddata, trimdata, resize, mink, maxk, bounds, rms, prctile, quantile, iqr, cumsum, cummax, cummin, cumprod, movmean, movmedian, movsum, movstd, movvar, isuniform, isregular

Read: array-and-grid-data.md

Answering Questions About Data

When the task is answering a specific question about data (top-N, filtering, lookups, comparisons), read the strategies reference to avoid common mistakes with sorting direction, missing data, and value interpretation.

Topics:

  • Finding the highest/lowest/top/bottom N entries

  • Looking up values in one column based on ranking in another

  • Accounting for missing or placeholder values in answers

  • Returning raw data values without substitution or mapping

  • Counting rows that match a condition (exact vs partial text matching)

Functions: topkrows, sortrows, groupsummary, standardizeMissing, isapprox, matches, contains, height, nnz

Read: answering-data-questions.md

Copyright 2026 The MathWorks, Inc.

Files

references/eventtables.md

Eventtables

Contents: eventtable construction, attaching to timetables, eventfilter, extractevents, syncevents, withtol integration, interval events

An eventtable is a timetable of events that you attach to a data timetable. Each event has a time (when), optionally a duration (how long), optionally a label (what), and optionally additional data variables. Once attached, the timetable display annotates rows with their associated event labels, and event-aware functions (eventfilter, syncevents, stackedplot) work automatically.

When to use eventtable (not state columns)

Use eventtable whenever information describes something that happened at or during certain times, rather than a continuous measurement. Signals to reach for eventtable:

  • The information comes from a different source than the measured data (e.g., storm reports, maintenance logs, alarm systems, manual annotations)

  • The information is sparse — only a few rows out of many have events

  • Each event carries metadata (type, severity, cause, duration) beyond a simple true/false

  • You need to filter, segment, or compare data by event properties

  • You want timetable display to show annotations automatically

Do NOT add boolean columns (TT.IsStorm), string/categorical labels (TT.EventType), or numeric codes (TT.Phase) to represent events. These anti-patterns:

  • Pollute the timetable with mostly-missing columns

  • Cannot represent overlapping events or events with different metadata schemas

  • Require manual logical indexing instead of eventfilter and withtol

  • Lose the separation between measured data and event metadata

Entering the eventtable ecosystem

Event info either comes from outside the timetable or is a pattern inside it — either way, get it into an eventtable before doing anything else. Match the entry pathway to how the event information reaches you:

  • Raw times/labels as separate vectors or arrays (storm dates + storm types, alarm times, marker timestamps) — build with eventtable(times, EventLabels=labels) and attach via TT.Properties.Events = ET. Do not filter or align these arrays with logical indexing (stormDates >= t0, ismember(TT.Time, stormDates)) — that leaves you outside the eventtable ecosystem and forces manual work later.

  • A separate timetable of events (alarm logs, storm reports, fire warnings) with its own metadata columns — pass the timetable directly to eventtable(...) and set EventEndsVariable if it has end times. Do not build timerange windows from the event times to slice the data timetable — attach and use eventfilter instead.

  • Patterns inside the data timetable itself (peaks, threshold crossings, anomalies) — extract with extractevents, then attach. Do not add a boolean/label column (TT.IsAnomaly = condition) — that gives you a flag, not a reusable event object.

% From vectors — the most common entry point
ET = eventtable(stormDates, EventLabels=stormTypes);
TT.Properties.Events = ET;

% Shorthand when you have times only (default labels)
TT.Properties.Events = eventTimes;

% From a separate timetable of events with a duration column
ET = eventtable(fireWarnings, EventEndsVariable="End");
flightData.Properties.Events = ET;

% From patterns inside the data
negEvents = extractevents(TT, TT.ExcessLOD < 0, EventDataVariables="ExcessLOD");
TT.Properties.Events = negEvents;
Interval events (events with duration)

For events that span a time range (alarms, storm windows, maintenance periods) rather than instants:

% Specify durations at construction
ET = eventtable(startTimes, EventLabels=labels, EventLengths=durations);

% Or add end times as a variable and declare which variable holds them
ET.EventEnds = endTimes;
ET.Properties.EventEndsVariable = "EventEnds";

After attaching, TT display shows event labels in the row margin, and TT.Properties shows the Events field.

Filtering with eventfilter

eventfilter creates a row subscript that selects timetable rows occurring at (instantaneous) or during (interval) events.

EF = eventfilter(TT);

% All rows at/during any event
TT(EF,:)

% Filter by event label
TT(EF.EventLabels == "Flood",:)

% Filter by any event data variable (dot-notation)
TT(EF.Severity == "High",:)
TT(EF.EngineNumber == 4,:)

eventfilter is distinct from rowfilter. rowfilter filters rows of a table/timetable by its own variables; eventfilter filters timetable rows by properties of attached events.

% rowfilter: filter by the timetable's own variables
TT(rowfilter(TT).Value > 100,:)

% eventfilter: filter by attached event properties
TT(eventfilter(TT).EventLabels == "Storm",:)
With timerange and withtol

Combine eventfilter with timerange to scope the timetable to a window defined by events, or with withtol to match rows within a tolerance of event times:

EF = eventfilter(TT);

% Rows within a time tolerance of event times (± 5 seconds)
TT(withtol(EF, seconds(5)),:)

% Use events as timerange boundaries — "from event A through event B"
% Each endpoint must match exactly one event in the attached eventtable
TR = timerange(EF.EventLabels == "Thunderstorm Wind", EF.EventLabels == "Hail", "closed");
TT(TR,:)

Extracting events from data

Use extractevents when the events are patterns in your timetable (threshold crossings, peaks, anomalies) rather than an external list. This is the correct approach when you identify interesting rows and want to mark them for future event-based analysis — do NOT add a boolean column like TT.IsAnomaly = condition because that only gives you a flag, not a reusable event object you can attach, filter by properties, or display as annotations.

% By logical condition — extract rows where ExcessLOD is negative
negEvents = extractevents(TT, TT.ExcessLOD < 0, EventDataVariables="ExcessLOD");

% By row indices with labels
peaks = find(islocalmax(TT.Smoothed));
troughs = find(islocalmin(TT.Smoothed));
labels = categorical([zeros(size(peaks)); ones(size(troughs))], [0 1], ["peak" "trough"]);
ET = extractevents(TT, [peaks; troughs], EventLabels=labels);

% Two-output form: also returns a timetable with event-source variables removed
[ET, TT2] = extractevents(TT, condition, EventDataVariables="SrcVar");

% After extracting, attach back to the timetable for event-based workflows
TT.Properties.Events = negEvents;
TT(eventfilter(TT),:)           % now you can use eventfilter on extracted events

Leaving the eventtable ecosystem

syncevents flattens event data into timetable variables — converting events back into a state representation. Use it only when the next step cannot see attached event data:

  • Writing to disk or converting the type: writetimetable, writetable, timetable2table, or handing off to Python/Excel. Properties.Events doesn't survive any of these — flatten first with syncevents, then export.

  • Passing event metadata as a grouping key to groupsummary (and similar functions that require the grouping variable to be a real timetable variable, not attached event data).

% Export: flatten selected event variables, then write
TT_export = syncevents(TT, EventDataVariables="EventLabels");
writetimetable(TT_export, "weather_storms.csv");

% Group by event label: syncevents first, then groupsummary on the new variable
TT_flat = syncevents(TT, EventDataVariables="EventLabels");
groupsummary(TT_flat, "EventLabels", "mean", "MAX_TEMP");

For instantaneous events, only matching rows are filled with event data (others get missing values). For interval events, all rows within each interval are filled with that event's data.

For everything else — filtering, comparison, visualization — keep events attached and use eventfilter / stackedplot. Do not syncevents first and then filter on the new variables; that skips the eventfilter ecosystem.

% Avoid: flatten, then filter on the new column
TT2 = syncevents(TT, EventDataVariables="EventLabels");
stormRows = TT2(TT2.EventLabels == "Storm",:);

% Avoid: flatten, then build subsets by label
TT2 = syncevents(TT, EventDataVariables="EventLabels");
hailRows = TT2(TT2.EventLabels == "Hail",:);
tornadoRows = TT2(TT2.EventLabels == "Tornado",:);

% Use instead: eventfilter on the attached events
TT(eventfilter(TT).EventLabels == "Storm",:)
TT(eventfilter(TT).EventLabels == "Hail",:)
TT(eventfilter(TT).EventLabels == "Tornado",:)

Visualizing data with attached events

stackedplot is event-aware. When you call it on a timetable that has events attached, it automatically overlays them — vertical lines for instantaneous events, shaded regions for interval events — labeled with the event labels. No manual patch, xline, or subplot plumbing needed.

% Attach events, then plot — overlays are automatic
TT.Properties.Events = ET;
stackedplot(TT)

% Plot specific variables only
stackedplot(TT, ["OilPressure" "Vibration"])

% Suppress the event overlay if you don't want it
stackedplot(TT, EventsVisible="off")

This is the right way to visualize sensor data around alarms, storms, maintenance windows, or any other interval/instant events. The annotations come from the attached eventtable — if you change the events (filter, add new ones, swap labels), the next stackedplot call reflects them.

Avoid

Do not add state columns to represent events

When you have event information (timestamps with labels, severities, durations), attach it via eventtable — do not embed it as timetable variables:

% Avoid: boolean state column
TT.IsStorm = ismember(TT.Time, stormDates);

% Avoid: categorical/string state column
TT.StormType = repmat(missing, height(TT), 1);
TT.StormType(ismember(TT.Time, stormDates)) = stormTypes;

% Avoid: multiple state columns for event metadata
TT.EventActive = false(height(TT), 1);
TT.EventSeverity = strings(height(TT), 1);

% Use instead: eventtable (keeps events separate, enables eventfilter/withtol)
ET = eventtable(stormDates, EventLabels=stormTypes);
TT.Properties.Events = ET;
Do not manually construct logical masks on timestamps to find event rows

When events are attached, use eventfilter — do not build logical index vectors from timestamp comparisons:

% Avoid: logical mask for point events
mask = TT.Time == stormDates(1) | TT.Time == stormDates(2) | TT.Time == stormDates(3);
TT(mask,:)

% Avoid: manual >= / <= for interval events
mask = false(height(TT), 1);
for i = 1:numel(starts)
    mask = mask | (TT.Time >= starts(i) & TT.Time <= ends(i));
end
TT(mask,:)

% Avoid: isbetween loop for interval events
mask = false(height(TT), 1);
for i = 1:numel(starts)
    mask = mask | isbetween(TT.Time, starts(i), ends(i));
end
TT(mask,:)

% Use instead: eventfilter (handles point and interval events, property filtering)
EF = eventfilter(TT);
TT(EF,:)                           % all event rows
TT(EF.EventLabels == "Storm",:)    % filtered by label
Do not use isbetween for approximate event matching
% Avoid: manual tolerance window with isbetween
tol = seconds(5);
for i = 1:numel(eventTimes)
    idx = isbetween(TT.Time, eventTimes(i)-tol, eventTimes(i)+tol);
    nearby = TT(idx,:);
end

% Use instead: withtol (declarative, handles multiple events at once)
EF = eventfilter(TT);
TT(withtol(EF, seconds(5)),:)
Do not build manual event overlays on plots

When events are attached, stackedplot draws the overlay automatically — do not construct it by hand with subplot + plot + patch/xline:

% Avoid: manual subplot loop with patch overlays for each event
figure;
for i = 1:numel(vars)
    subplot(numel(vars),1,i);
    plot(TT.Time, TT.(vars{i})); hold on;
    yl = ylim;
    for j = 1:height(ET)
        patch([ET.Start(j) ET.End(j) ET.End(j) ET.Start(j)], ...
              [yl(1) yl(1) yl(2) yl(2)], 'r', 'FaceAlpha', 0.15);
    end
end

% Avoid: xline for each instantaneous event
plot(TT.Time, TT.Value); hold on;
for i = 1:numel(eventTimes)
    xline(eventTimes(i), '--r', labels(i));
end

% Use instead: attach events, then stackedplot
TT.Properties.Events = ET;
stackedplot(TT)

Key behaviors

  • An eventtable is a timetable. Functions like retime, sortrows, head, tail, and direct subsetting (ET(ET.EventLabels == "peak",:)) work on it.

  • Adding rows to an eventtable by datetime subscript: ET(newTime,:) = {label, endTime}.

  • Adding variables to an attached eventtable: TT.Properties.Events.NewVar = data.

Copyright 2026 The MathWorks, Inc.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs an API key

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
MathWorks
Publisher
MathWorks (Official)
Source
matlab/matlab-agentic-toolkit · skills-catalog/matlab-data-import-and-analysis/matlab-analyze-data · commit 2a7f215
Licence
BSD 2-Clause License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE.md)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by MathWorks or MathWorks.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download matlab-analyze-data.zip