Matlab Analyze Data

MathWorksOfficialCreated by MathWorks

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

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

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/matlab/matlab-analyze-data/download

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:

Function	Available From	Purpose
`paddata`, `trimdata`, `resize`	R2023b	Pad, trim, or resize arrays to target length
`smoothdata2`	R2023b	Smooth 2-D gridded data over rectangular windows
`kde`	R2023b	Kernel density estimate for univariate data
`clip`	R2024a	Clamp values to a range
`islocalmax2`, `islocalmin2`	R2024a	Detect local extrema in 2-D gridded data
`summary` (enhanced)	R2024b	Supports arrays (numeric, datetime, duration, logical); adds `Statistics`, `DataVariables`, `Detail` name-value args
`isapprox`	R2024b	Tolerance-aware floating-point comparison (use instead of `==` for computed values)
`isbetween` (numeric)	R2024b	Check elements within a numeric range
`numunique`	R2025a	Count distinct values in a variable
`allbetween`	R2025a	Validate all values are within a range
`allunique`	R2025a	Validate 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

Files

ATTRIBUTION.mdAdded by AutoGineer1.0 KiB
LICENSELicence file added by AutoGineer1.4 KiB
SKILL.md13.0 KiB
manifest.yaml492 B
references/answering-data-questions.md4.8 KiB
references/array-and-grid-data.md19.6 KiB
references/data-cleaning.md10.5 KiB
references/data-transformation.md13.4 KiB
references/data-types.md9.8 KiB
references/eventtables.md12.4 KiB
references/exploration.md10.0 KiB
references/grouping-and-aggregation.md11.3 KiB
references/smoothing-and-trends.md8.4 KiB
references/tables-and-timetables.md19.0 KiB

references/grouping-and-aggregation.md

Grouping and Aggregation

Contents: groupsummary (methods, binning), groupcounts, groupfilter, grouptransform, pivot

Use `groupsummary` for grouping operations, not loops or `accumarray`

G = groupsummary(T,"Category",["min" "mean" "max"],"Value");

% Multiple grouping variables
G = groupsummary(T,["Category" "Region"],"mean","Value");

% Multiple data variables
G = groupsummary(T,"Category","mean",["Sales" "Cost" "Margin"]);

% Custom aggregation with a function handle
G = groupsummary(T,"Category",@(x) quantile(x,[0.25 0.75]),"Value");

% Avoid: Loop over groups
groups = unique(T.Category);
result = table();
for i = 1:numel(groups)
    subset = T(T.Category == groups(i), :);
    result(i,:) = table(groups(i),mean(subset.Value),std(subset.Value));
end

% Avoid: accumarray (cumbersome, does not support tables)
[G,groupNames] = findgroups(T.Category);
means = accumarray(G,T.Value,[],@mean);

When using groupsummary with tabular input, the output table always includes a GroupCount variable, so there is no need to specify a separate count method. If you only need counts, use groupcounts instead.

Note: Do not use "numel" or "counts" as groupsummary method names - these are not valid and will error. Valid built-in method names: "sum", "mean", "median", "mode", "var", "std", "min", "max", "range", "nummissing", "numunique", "nnz", "all".

Prefer string method names over function handles (e.g., "mean" not @mean). Named methods use accelerated code paths and are significantly faster on large datasets.

Methods apply to ALL DataVariables (cartesian product)

When you specify multiple methods and multiple data variables, groupsummary applies every method to every variable. It does NOT map methods 1:1 to variables:

% This applies BOTH sum and mean to BOTH Loss and Customers (4 output columns):
G = groupsummary(T,"Region",["sum" "mean"],["Loss" "Customers"]);
% → Region, GroupCount, sum_Loss, mean_Loss, sum_Customers, mean_Customers

For different methods on different variables, use separate calls:

% Want sum of Loss and mean of Customers? Two calls + join:
G1 = groupsummary(T,"Region","sum","Loss");
G2 = groupsummary(T,"Region","mean","Customers");
G = innerjoin(G1(:,["Region","GroupCount","sum_Loss"]), G2(:,["Region","mean_Customers"]), Keys="Region");

DataVariables: string array vs cell array have different behavior:

% String array — each variable processed independently:
G = groupsummary(T,"Region","mean",["Loss" "Customers"]);

% Cell array — variables are passed together as multiple inputs to a
% bivariate function handle (e.g., weighted mean of Loss weighted by Customers):
G = groupsummary(T,"Region",@(loss,cust) sum(loss.*cust,"omitnan")/sum(cust,"omitnan"), {"Loss","Customers"});

Pitfall: Do not use findgroups+accumarray for aggregation when groupsummary can do the job — groupsummary is simpler, faster, and works directly with tables. Use findgroups alone only when you need group indices without aggregation (e.g., to assign a group ID column).

Variable name inputs must be string arrays, not cell arrays. For grouping variables and data variables passed as names, use string arrays. Cell arrays have different semantics — they pass multiple variables together as separate inputs to a bivariate function handle:

% Correct — string array for grouping and data variable names
G = groupsummary(T,["Category" "Region"],"mean",["Sales" "Cost"]);

% Cell array — different behavior: passes Sales and Cost together to bivariate function
G = groupsummary(T,"Region",@(sales,cost) sum(sales.*cost,"omitnan")/sum(cost,"omitnan"), {"Sales","Cost"});

Names of output variables

Besides the grouping variables and the always-present GroupCount (which are never renamed), each computed statistic becomes its own output variable. By default its name combines the method and the input variable — the sum_Loss, mean_Loss, ... columns seen above. Named methods ("mean", "sum", ...) use the method name as the prefix; function-handle methods instead get a generic numbered prefix (fun1_Loss, fun2_Loss).

Override the naming with VariableNamingRule (R2026b), which takes three values:

"numbered" (default) — method name for named methods; generic numbered prefix (fun1_, fun2_) for function handles.
"methodname" — always derive the prefix from the method name, including for function handles (via func2str, e.g. myFun_Loss instead of fun1_Loss).
"noprefix" — drop the prefix so names match the input variables (Loss). Best when a single method makes the prefix redundant; avoid it when multiple methods would otherwise collide on the same name.

% Single method → the prefix is redundant; keep the input names: Region, GroupCount, Loss, Customers
G = groupsummary(T,"Region","mean",["Loss" "Customers"],VariableNamingRule="noprefix");

For named methods (like the examples above), "numbered" and "methodname" produce identical names — the two differ only for function-handle methods.

On-the-fly binning

groupsummary (and groupcounts, groupfilter, grouptransform) support binning rules as the grouping variable, so you don't need to create a binned column with discretize first. When binning is needed only for a single aggregation — not reused downstream — prefer on-the-fly bin methods to keep the source table free of intermediate columns.

% Bin a numeric variable with custom edges
G = groupsummary(T,"Age",[0 18 35 50 Inf],"mean","Income");

% Equal-width bins
G = groupsummary(T,"Score",10,"mean","Value");   % 10 bins

% Time-based binning — sequential (one bin per calendar period)
G = groupsummary(TT,"Time","month","mean","Temperature");      % Jan 2023, Feb 2023, ...

% Time-based binning — cyclic (collapses across the higher unit to find patterns)
G = groupsummary(TT,"Time","hourofday","mean","Temperature");  % 0-23
G = groupsummary(TT,"Time","dayname","mean","Sales");          % "Monday", "Tuesday", ...

% Multiple datetime bins at once (e.g., day-of-week × quarter pattern)
G = groupsummary(TT,"Time",{"dayname","quarterofyear"},"mean","Loss");

% Mix regular grouping and binning
G = groupsummary(T,{"Region","Age"},{"none",[0 18 35 50 Inf]},"mean","Salary");

Use `groupsummary` not `grpstats`

G = groupsummary(T,"Category",["min" "mean" "max"],"Value");
G = groupsummary(T,"Category",@(x) [min(x,[],"omitnan") mean(x,"omitnan") max(x,[],"omitnan")],"Value");

% Less portable: Statistics Toolbox required
[means,groups] = grpstats(T.Value,T.Category,"mean");

Use `groupcounts` not manual tabulation

G = groupcounts(T,"Category");

% Avoid: Manual counting
categories = unique(T.Category);
counts = zeros(numel(categories),1);
for i = 1:numel(categories)
    counts(i) = sum(T.Category == categories(i));
end

% Less portable: Statistics Toolbox required, does not support tables
counts = tabulate(T.Category);

When using groupcounts or groupsummary, consider:

IncludeMissingGroups=false to exclude groups defined by a missing value (such as NaN for numeric types), which can otherwise dominate results (default: true).
IncludeEmptyGroups=true to include all categories of a categorical variable, even those with no rows (default: false). Useful when you need a complete picture of all possible groups.

Use `groupfilter` to filter rows based on group properties

groupfilter has two distinct use cases:

Use case 1: Keep or remove entire groups based on a group-level condition. For example, keep only categories that have enough observations to be meaningful:

% Keep only groups with at least 10 observations
T = groupfilter(T,"Category",@(x) numel(x) >= 10);

% Keep only groups where the mean value exceeds a threshold
T = groupfilter(T,"Region",@(x) mean(x) > 50,"Sales");

Use case 2: Filter individual rows within each group. For example, remove outliers separately within each group rather than globally:

% Remove per-group outliers (2 std from mean within each group)
T = groupfilter(T,"Category",@(x) ~isoutlier(x,"mean",ThresholdFactor=2),"Value");

% Keep only the top 3 rows per group by Value
T = groupfilter(T,"Category",@topN,"Value");

function tf = topN(x)
    [~,idx] = maxk(x,3,ComparisonMethod="abs");
    tf = false(size(x));
    tf(idx) = true;
end

The key distinction: when the function returns one logical per group, it filters entire groups. When it returns one logical per row, it filters individual rows within each group.

When the filter logic matches a built-in detection function (isoutlier, ismissing, ischange), use it inside the function handle rather than reimplementing the arithmetic. Built-in functions handle edge cases (NaN, constant groups) and accept tuning parameters like ThresholdFactor:

% Recommended: use built-in detection function
T = groupfilter(T,"Category",@(x) ~isoutlier(x),"Value");
T = groupfilter(T,"Category",@(x) ~isoutlier(x,"mean",ThresholdFactor=2),"Value");

% Avoid: reimplementing the detection arithmetic manually
T = groupfilter(T,"Category",@(x) abs(x - mean(x)) < 2*std(x),"Value");

Use `grouptransform` to transform data within each group

grouptransform applies a transformation within each group and returns a same-size table — assign the result back to the table variable (T = grouptransform(T,...)), not to a single column.

Valid built-in methods (exhaustive list): "zscore", "norm", "meancenter", "rescale", "meanfill", "linearfill". Aggregation methods like "sum", "mean", "std" are NOT valid for grouptransform — use groupsummary for aggregation.

% Normalize values within each group (per-group z-score), overwriting original column
T = grouptransform(T,"Category","zscore","Value");

% Add result as a NEW column (keep original intact) with ReplaceValues=false
T = grouptransform(T,"Category","zscore","Value",ReplaceValues=false);
% This appends a column named "zscore_Value" to T (named method → "<method>_<Var>")
% With a function handle, the new column is named "fun_<Var>" (e.g., "fun_Value")

% Custom function handle for operations not in the built-in list:
T = grouptransform(T,"Category",@(x) x / sum(x) * 100,"Value");

ReplaceValues (default: true): By default, grouptransform replaces the input column with the transformed result. Set ReplaceValues=false when you want to keep the original data and add the transformation as a new column — common for z-scores, percentiles, or group-relative metrics where both raw and normalized values are needed.

Use `pivot` not `unstack` workarounds

% Direct pivot (introduced in R2023a)
% Default (no DataVariable/Method) returns counts per group for non-numeric
% data variables and sum for numeric
P = pivot(T, Rows="Category", Columns="Region");

% Aggregate a specific variable with DataVariable and Method
P = pivot(T, Rows="Category", Columns="Region", DataVariable="Sales", Method="sum");

% Avoid: Manual pivot
G = groupsummary(T,["Row" "Col"],"sum","Value");
P = unstack(G,"sum_Value","Col");

For groupsummary, grouptransform, and groupfilter on arrays (grouping vector syntax instead of variable names), see array-and-grid-data.md.

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

2026-11-08

AutoGineer is not affiliated with or endorsed by MathWorks.

Download ZIP

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

From the author

AutoGineer summary

What it does

When to use it

Advantages

Usage examples

Install

Documentation by MathWorks

MATLAB Data Analysis

When to Use

When NOT to Use

Routing: Read references on all relevant topics

Key Functions — Available From

Getting Oriented with Data

Data Types

Tables and Timetables

Eventtables

Data Cleaning

Data Transformation

Grouping and Aggregation

Smoothing, Trends, and Patterns

Array and Grid Data

Answering Questions About Data

Files

references/grouping-and-aggregation.md

Grouping and Aggregation

Use groupsummary for grouping operations, not loops or accumarray

Methods apply to ALL DataVariables (cartesian product)

Names of output variables

On-the-fly binning

Use groupsummary not grpstats

Use groupcounts not manual tabulation

Use groupfilter to filter rows based on group properties

Use grouptransform to transform data within each group

Use pivot not unstack workarounds

Requirements and compatibility

Security

Attribution and licence

Related skills

Research

Last30days

Customer Research

Analytics

Networkx

Exa Search

Download ZIP

Use `groupsummary` for grouping operations, not loops or `accumarray`

Use `groupsummary` not `grpstats`

Use `groupcounts` not manual tabulation

Use `groupfilter` to filter rows based on group properties

Use `grouptransform` to transform data within each group

Use `pivot` not `unstack` workarounds