{"id":"b0837f9c-341d-43f5-bbce-331f817beec8","shortId":"hmbSZa","kind":"skill","title":"matlab-performance-optimizer","tagline":"Optimize MATLAB code for better performance through vectorization, memory management, and profiling. Use when user requests optimization, mentions slow code, performance issues, speed improvements, or asks to make code faster or more efficient.","description":"# MATLAB Performance Optimizer\n\nThis skill provides comprehensive guidelines for optimizing MATLAB code performance. Apply vectorization techniques, memory optimization strategies, and profiling tools to make code faster and more efficient.\n\n## When to Use This Skill\n\n- Optimizing slow or inefficient MATLAB code\n- Converting loops to vectorized operations\n- Reducing memory usage\n- Improving algorithm performance\n- When user mentions: slow, performance, optimize, speed up, efficient, memory\n- Profiling code to find bottlenecks\n- Parallelizing computations\n\n## Core Optimization Principles\n\n### 1. Vectorization (Most Important)\n\n**Replace loops with vectorized operations whenever possible.**\n\n**SLOW - Using loops:**\n```matlab\n% Slow approach\nn = 1000000;\nresult = zeros(n, 1);\nfor i = 1:n\n    result(i) = sin(i) * cos(i);\nend\n```\n\n**FAST - Vectorized:**\n```matlab\n% Fast approach\nn = 1000000;\ni = (1:n).';\nresult = sin(i) .* cos(i);\n```\n\n### 2. Preallocate Arrays\n\n**Always preallocate arrays before loops.**\n\n**SLOW - Growing arrays:**\n```matlab\n% Very slow - array grows each iteration\nresult = [];\nfor i = 1:10000\n    result(end+1) = i^2;\nend\n```\n\n**FAST - Preallocated:**\n```matlab\n% Fast - preallocated array\nn = 10000;\nresult = zeros(n, 1);\nfor i = 1:n\n    result(i) = i^2;\nend\n```\n\n### 3. Use Built-in Functions\n\n**MATLAB built-in functions are highly optimized.**\n\n**SLOW - Manual implementation:**\n```matlab\n% Slow\nsum_val = 0;\nfor i = 1:length(x)\n    sum_val = sum_val + x(i);\nend\n```\n\n**FAST - Built-in function:**\n```matlab\n% Fast\nsum_val = sum(x);\n```\n\n## Vectorization Techniques\n\n### Element-wise Operations\n\nUse `.*`, `./`, `.^` for element-wise operations:\n\n```matlab\n% Instead of this:\nfor i = 1:length(x)\n    y(i) = x(i)^2 + 2*x(i) + 1;\nend\n\n% Do this:\ny = x.^2 + 2*x + 1;\n```\n\n### Logical Indexing\n\nReplace conditional loops with logical indexing:\n\n```matlab\n% Instead of this:\ncount = 0;\nfor i = 1:length(data)\n    if data(i) > threshold\n        count = count + 1;\n        filtered(count) = data(i);\n    end\nend\nfiltered = filtered(1:count);\n\n% Do this:\nfiltered = data(data > threshold);\n```\n\n### Matrix Operations\n\nUse matrix multiplication instead of nested loops:\n\n```matlab\n% Instead of this:\nC = zeros(size(A, 1), size(B, 2));\nfor i = 1:size(A, 1)\n    for j = 1:size(B, 2)\n        for k = 1:size(A, 2)\n            C(i,j) = C(i,j) + A(i,k) * B(k,j);\n        end\n    end\nend\n\n% Do this:\nC = A * B;\n```\n\n### Cumulative Operations\n\nUse `cumsum`, `cumprod`, `cummax`, `cummin`:\n\n```matlab\n% Instead of this:\nrunning_sum = zeros(size(data));\nrunning_sum(1) = data(1);\nfor i = 2:length(data)\n    running_sum(i) = running_sum(i-1) + data(i);\nend\n\n% Do this:\nrunning_sum = cumsum(data);\n```\n\n## Memory Optimization\n\n### Use Appropriate Data Types\n\n```matlab\n% Instead of default double (8 bytes)\ndata = rand(1000, 1000);  % 8 MB\n\n% Use single precision when appropriate (4 bytes)\ndata = single(rand(1000, 1000));  % 4 MB\n\n% Use integers when applicable\nindices = uint32(1:1000000);  % 4 MB instead of 8 MB\n```\n\n### Sparse Matrices\n\nFor matrices with mostly zeros:\n\n```matlab\n% Dense matrix (wastes memory)\nA = zeros(10000, 10000);\nA(1:100, 1:100) = rand(100);  % 800 MB\n\n% Sparse matrix (efficient)\nA = sparse(10000, 10000);\nA(1:100, 1:100) = rand(100);  % Only stores non-zeros\n```\n\n### Clear Unused Variables\n\n```matlab\n% Process large data\nlargeData = loadData();\nprocessedData = processData(largeData);\n\n% Clear when no longer needed\nclear largeData;\n\n% Continue with processed data\nresults = analyze(processedData);\n```\n\n### In-Place Operations\n\n```matlab\n% Instead of creating copies\nA = A + 5;  % In-place when possible\n\n% Avoid unnecessary copies\nB = A;      % Creates copy if A is modified later\nB = A + 0;  % Forces copy\n```\n\n## Profiling and Benchmarking\n\n### Using the Profiler\n\n```matlab\n% Profile code execution\nprofile on\nmyFunction(inputs);\nprofile viewer\nprofile off\n```\n\nThe profiler shows:\n- Time spent in each function\n- Number of calls to each function\n- Lines that take the most time\n\n### Timing Comparisons\n\n```matlab\n% Time single execution\ntic;\nresult = myFunction(data);\nelapsedTime = toc;\n\n% Benchmark with timeit (more accurate)\ntimeit(@() myFunction(data))\n\n% Compare multiple approaches\ntime1 = timeit(@() approach1(data));\ntime2 = timeit(@() approach2(data));\nfprintf('Approach 1: %.6f s\\nApproach 2: %.6f s\\n', time1, time2);\n```\n\n## Common Optimization Patterns\n\n### Pattern 1: Replace find with Logical Indexing\n\n```matlab\n% SLOW\nindices = find(x > 5);\ny = x(indices);\n\n% FAST\ny = x(x > 5);\n```\n\n### Pattern 2: Use Implicit Expansion Instead of repmat\n\n```matlab\n% SLOW - repmat to match dimensions\nA = rand(1000, 5);\nB = rand(1, 5);\nC = A - repmat(B, size(A, 1), 1);\n\n% FAST - implicit expansion (R2016b+)\nC = A - B;\n```\n\n### Pattern 3: Avoid Repeated Calculations\n\n```matlab\n% SLOW - recalculates each iteration\nfor i = 1:n\n    result(i) = data(i) / sqrt(sum(data.^2));\nend\n\n% FAST - calculate once\nnorm_factor = sqrt(sum(data.^2));\nfor i = 1:n\n    result(i) = data(i) / norm_factor;\nend\n\n% EVEN FASTER - vectorize\nresult = data / sqrt(sum(data.^2));\n```\n\n### Pattern 4: Efficient String Operations\n\n```matlab\n% SLOW - concatenating in loop\nstr = '';\nfor i = 1:1000\n    str = [str, sprintf('Line %d\\n', i)];\nend\n\n% FAST - cell array + join\nlines = cell(1000, 1);\nfor i = 1:1000\n    lines{i} = sprintf('Line %d', i);\nend\nstr = strjoin(lines, '\\n');\n\n% FASTEST - vectorized sprintf\nstr = sprintf('Line %d\\n', 1:1000);\n```\n\n### Pattern 5: Use Table for Mixed Data Types\n\n```matlab\n% Instead of separate arrays\nnames = cell(1000, 1);\nages = zeros(1000, 1);\nscores = zeros(1000, 1);\n\n% Use table\ndata = table(names, ages, scores);\n% Faster access and better organization\n```\n\n## Algorithm-Specific Optimizations\n\n### Convolution and Filtering\n\n```matlab\n% Use built-in functions\nfiltered = conv(signal, kernel, 'same');\nfiltered = filter(b, a, signal);\n\n% For 2D\nfiltered = conv2(image, kernel, 'same');\nfiltered = imfilter(image, kernel);\n\n% FFT-based for large kernels (zero-pad for linear convolution)\nnfft = length(signal) + length(kernel) - 1;\nfiltered = ifft(fft(signal, nfft) .* fft(kernel, nfft));\n```\n\n### Distance Calculations\n\n```matlab\n% Instead of nested loops for pairwise distances\n% SLOW\nn = size(points, 1);\ndistances = zeros(n, n);\nfor i = 1:n\n    for j = 1:n\n        distances(i,j) = norm(points(i,:) - points(j,:));\n    end\nend\n\n% FAST - vectorized\ndistances = pdist2(points, points);\n```\n\n### Sorting and Searching\n\n```matlab\n% Presort for multiple searches\nsortedData = sort(data);\n\n% Binary search on sorted data\nidx = find(sortedData >= value, 1, 'first');\n\n% Use ismember for set operations\n[isPresent, locations] = ismember(searchValues, data);\n\n% Use unique for removing duplicates\nuniqueData = unique(data);\n```\n\n## Parallel Computing\n\n### Simple Parallel Loops (parfor)\n\n```matlab\n% Convert for to parfor for independent iterations\nparfor i = 1:n\n    results(i) = expensiveFunction(data(i));\nend\n```\n\n**Requirements for parfor:**\n- Iterations must be independent\n- Loop variable must be consecutive integers\n- Variables must be classified as loop, sliced, broadcast, or reduction\n\n### Parallel Array Operations\n\n```matlab\n% Create parallel pool\nparpool('local', 4);  % 4 workers\n\n% Use parfeval for asynchronous parallel execution\nfutures = parfeval(@expensiveFunction, 1, data);\nresult = fetchOutputs(futures);\n\n% GPU arrays for massive parallelization\ngpuData = gpuArray(data);\nresult = arrayfun(@myFunction, gpuData);\nresult = gather(result);  % Bring back to CPU\n```\n\n## Advanced Optimizations\n\n### MEX Functions for Critical Sections\n\nConvert performance-critical code to C/C++:\n\n```matlab\n% Create MEX file for bottleneck function\n% Write myFunction.c, then compile:\n% mex myFunction.c\n\n% Call like regular MATLAB function\nresult = myFunction(inputs);\n```\n\n### Persistent Variables for Cached Results\n\n```matlab\nfunction result = expensiveComputation(input)\n    persistent cachedData cachedInput\n\n    if isequal(input, cachedInput)\n        % Return cached result\n        result = cachedData;\n        return;\n    end\n\n    % Compute and cache\n    result = computeExpensiveOperation(input);\n    cachedData = result;\n    cachedInput = input;\nend\n```\n\n### JIT Acceleration Best Practices\n\nMATLAB's JIT (Just-In-Time) compiler optimizes:\n- Simple for-loops with scalar operations\n- Functions without dynamic features\n\n**JIT-friendly code:**\n```matlab\nfunction result = jitFriendly(n)\n    result = 0;\n    for i = 1:n\n        result = result + i;\n    end\nend\n```\n\n**JIT-unfriendly code (avoid):**\n```matlab\nfunction result = jitUnfriendly(n)\n    result = 0;\n    for i = 1:n\n        eval(['x' num2str(i) ' = i;']);  % Dynamic code\n    end\nend\n```\n\n## Performance Checklist\n\nBefore finalizing optimized code, verify:\n- [ ] Loops are vectorized where possible\n- [ ] Arrays are preallocated before loops\n- [ ] Built-in functions used instead of manual implementations\n- [ ] Logical indexing used instead of find + indexing\n- [ ] Appropriate data types used (single vs double, integers)\n- [ ] Sparse matrices used for sparse data\n- [ ] Repeated calculations moved outside loops\n- [ ] String concatenation uses efficient methods\n- [ ] Code profiled to identify actual bottlenecks\n- [ ] Matrix operations used instead of element-wise loops\n- [ ] Parallel computing considered for independent operations\n- [ ] Memory-intensive operations optimized\n- [ ] Caching implemented for repeated expensive calls\n\n## Profiling Workflow\n\n1. **Measure First**: Profile before optimizing\n   ```matlab\n   profile on\n   myScript;\n   profile viewer\n   ```\n\n2. **Identify Bottlenecks**: Focus on functions taking most time\n\n3. **Optimize**: Apply appropriate techniques\n\n4. **Measure Again**: Verify improvement\n   ```matlab\n   % Before\n   time_before = timeit(@() myFunction(data));\n\n   % After optimization\n   time_after = timeit(@() myFunctionOptimized(data));\n\n   fprintf('Speedup: %.2fx\\n', time_before/time_after);\n   ```\n\n5. **Iterate**: Repeat for remaining bottlenecks\n\n## Common Performance Pitfalls\n\n### Pitfall 1: Premature Optimization\n- Profile first, optimize second\n- Focus on actual bottlenecks, not assumptions\n\n### Pitfall 2: Over-vectorization\n- Sometimes loops are clearer and fast enough\n- Balance readability with performance\n\n### Pitfall 3: Ignoring Memory Access Patterns\n```matlab\n% SLOW - inner loop over columns (row-major traversal in column-major MATLAB)\nfor i = 1:rows\n    for j = 1:cols\n        A(i,j) = process(i, j);\n    end\nend\n\n% FAST - inner loop over rows (column-major traversal, contiguous memory)\nfor j = 1:cols\n    for i = 1:rows\n        A(i,j) = process(i, j);\n    end\nend\n\n% FASTEST - vectorized\n[I, J] = ndgrid(1:rows, 1:cols);\nA = process(I, J);\n```\n\n### Pitfall 4: Unnecessary Data Type Conversions\n```matlab\n% SLOW - repeated conversions\nfor i = 1:n\n    x = double(data(i));\n    result(i) = sin(x);\nend\n\n% FAST - convert once\nx = double(data);\nresult = sin(x);\n```\n\n## Optimization Examples\n\n### Example 1: Image Processing\n\n```matlab\n% SLOW\n[rows, cols] = size(image);\noutput = zeros(rows, cols);\nfor i = 2:rows-1\n    for j = 2:cols-1\n        output(i,j) = mean(image(i-1:i+1, j-1:j+1), 'all');\n    end\nend\n\n% FAST\nkernel = ones(3,3) / 9;\noutput = conv2(image, kernel, 'same');\n```\n\n### Example 2: Statistical Analysis\n\n```matlab\n% SLOW\nn = size(data, 1);\nmeans = zeros(n, 1);\nfor i = 1:n\n    means(i) = mean(data(i, :));\nend\n\n% FAST\nmeans = mean(data, 2);\n```\n\n### Example 3: Time Series Processing\n\n```matlab\n% SLOW\nn = length(signal);\nmovingAvg = zeros(size(signal));\nwindow = 10;\nfor i = window:n\n    movingAvg(i) = mean(signal(i-window+1:i));\nend\n\n% FAST - trailing window: [window-1 past samples, 0 future samples]\nmovingAvg = movmean(signal, [window-1 0]);\n```\n\n## Troubleshooting Performance\n\n**Issue**: Code still slow after vectorization\n- **Solution**: Profile to find new bottlenecks; consider algorithm complexity\n\n**Issue**: Out of memory errors\n- **Solution**: Use smaller data types, process in chunks, use sparse matrices\n\n**Issue**: parfor slower than for loop\n- **Solution**: Check if overhead outweighs benefits; ensure iterations are expensive enough\n\n**Issue**: GPU computation slower than CPU\n- **Solution**: Data transfer overhead may exceed computation time; use for large arrays\n\n## Additional Resources\n\n- Use `profile viewer` to analyze performance\n- Use `memory` to check memory usage\n- Use `doc` with: `timeit`, `tic/toc`, `parfor`, `gpuArray`, `sparse`\n- Check MATLAB Performance and Memory documentation","tags":["matlab","performance","optimizer","skills","agent-skill","agent-skills","agentic-ai","agents","claude","claude-api","claude-code","claude-desktop"],"capabilities":["skill","source-matlab","skill-matlab-performance-optimizer","topic-agent-skill","topic-agent-skills","topic-agentic-ai","topic-agents","topic-claude","topic-claude-api","topic-claude-code","topic-claude-desktop","topic-claude-skills","topic-matlab","topic-matlab-skills"],"categories":["skills"],"synonyms":[],"warnings":[],"endpointUrl":"https://skills.sh/matlab/skills/matlab-performance-optimizer","protocol":"skill","transport":"skills-sh","auth":{"type":"none","details":{"cli":"npx skills add matlab/skills","source_repo":"https://github.com/matlab/skills","install_from":"skills.sh"}},"qualityScore":"0.482","qualityRationale":"deterministic score 0.48 from registry signals: · indexed on github topic:agent-skills · 65 github stars · SKILL.md body (12,542 chars)","verified":false,"liveness":"unknown","lastLivenessCheck":null,"agentReviews":{"count":0,"score_avg":null,"cost_usd_avg":null,"success_rate":null,"latency_p50_ms":null,"narrative_summary":null,"summary_updated_at":null},"enrichmentModel":"deterministic:skill-github:v1","enrichmentVersion":1,"enrichedAt":"2026-04-22T00:55:57.501Z","embedding":null,"createdAt":"2026-04-18T22:14:23.651Z","updatedAt":"2026-04-22T00:55:57.501Z","lastSeenAt":"2026-04-22T00:55:57.501Z","tsv":"'+1':183,1571,1575,1646 '-1':425,1557,1562,1569,1573,1653,1663 '0':229,305,583,1212,1233,1656,1664 '1':109,131,134,151,179,198,201,232,271,282,291,308,317,326,351,357,360,363,369,411,413,474,499,501,515,517,657,671,711,719,720,740,762,793,810,813,834,852,856,860,924,947,954,958,996,1032,1084,1215,1236,1338,1399,1451,1455,1478,1482,1497,1499,1517,1540,1599,1603,1606 '10':1634 '100':500,502,504,516,518,520 '1000':450,451,464,465,707,794,809,814,835,851,855,859 '10000':180,194,496,497,512,513 '1000000':127,149,475 '2':158,185,206,278,279,288,289,354,366,372,416,661,692,749,759,779,1350,1413,1555,1560,1591,1618 '2d':897 '2fx':1385 '3':208,729,1359,1429,1582,1583,1620 '4':459,466,476,781,1072,1073,1364,1506 '5':563,682,690,708,712,837,1389 '6f':658,662 '8':446,452,480 '800':505 '9':1584 'acceler':1179 'access':869,1432 'accur':640 'actual':1308,1408 'addit':1733 'advanc':1108 'age':853,866 'algorithm':87,874,1680 'algorithm-specif':873 'alway':161 'analysi':1593 'analyz':550,1739 'appli':51,1361 'applic':471 'approach':125,147,646,656 'approach1':649 'approach2':653 'appropri':438,458,1280,1362 'array':160,163,168,172,192,805,848,1064,1090,1259,1732 'arrayfun':1098 'ask':30 'assumpt':1411 'asynchron':1078 'avoid':569,730,1226 'b':353,365,382,392,572,581,709,716,727,893 'back':1105 'balanc':1424 'base':909 'before/time_after':1388 'benchmark':588,636 'benefit':1709 'best':1180 'better':9,871 'binari':987 'bottleneck':103,1127,1309,1352,1394,1409,1678 'bring':1104 'broadcast':1060 'built':211,216,244,883,1265 'built-in':210,215,243,882,1264 'byte':447,460 'c':347,373,376,390,713,725 'c/c':1121 'cach':1146,1161,1169,1330 'cacheddata':1154,1164,1173 'cachedinput':1155,1159,1175 'calcul':732,752,934,1295 'call':614,1135,1335 'cell':804,808,850 'check':1705,1744,1755 'checklist':1248 'chunk':1694 'classifi':1056 'clear':526,538,543 'clearer':1420 'code':7,24,33,49,62,77,100,594,1119,1205,1225,1244,1252,1304,1668 'col':1456,1479,1500,1546,1552,1561 'column':1439,1446,1471 'column-major':1445,1470 'common':667,1395 'compar':644 'comparison':625 'compil':1132,1189 'complex':1681 'comprehens':44 'comput':105,1017,1167,1320,1717,1727 'computeexpensiveoper':1171 'concaten':787,1300 'condit':295 'consecut':1051 'consid':1321,1679 'contigu':1474 'continu':545 'conv':887 'conv2':899,1586 'convers':1510,1514 'convert':78,1023,1115,1529 'convolut':877,918 'copi':560,571,575,585 'core':106 'cos':140,156 'count':304,315,316,319,327 'cpu':1107,1720 'creat':559,574,1067,1123 'critic':1113,1118 'cummax':398 'cummin':399 'cumprod':397 'cumsum':396,433 'cumul':393 'd':799,819,832 'data':310,312,320,331,332,408,412,418,426,434,439,448,461,532,548,633,643,650,654,744,748,758,766,775,778,842,863,986,991,1007,1015,1037,1085,1096,1281,1293,1375,1382,1508,1521,1533,1598,1611,1617,1690,1722 'default':444 'dens':490 'dimens':704 'distanc':933,942,948,960,972 'doc':1748 'document':1760 'doubl':445,1286,1520,1532 'duplic':1012 'dynam':1200,1243 'effici':37,66,97,509,782,1302 'elapsedtim':634 'element':256,262,1316 'element-wis':255,261,1315 'end':142,182,186,207,241,283,322,323,385,386,387,428,750,770,802,821,968,969,1039,1166,1177,1220,1221,1245,1246,1463,1464,1490,1491,1527,1577,1578,1613,1648 'enough':1423,1714 'ensur':1710 'error':1686 'eval':1238 'even':771 'exampl':1538,1539,1590,1619 'exceed':1726 'execut':595,629,1080 'expans':695,723 'expens':1334,1713 'expensivecomput':1151 'expensivefunct':1036,1083 'factor':755,769 'fast':143,146,187,190,242,248,686,721,751,803,970,1422,1465,1528,1579,1614,1649 'faster':34,63,772,868 'fastest':826,1492 'featur':1201 'fetchoutput':1087 'fft':908,927,930 'fft-base':907 'file':1125 'filter':318,324,325,330,879,886,891,892,898,903,925 'final':1250 'find':102,673,680,993,1278,1676 'first':997,1340,1403 'focus':1353,1406 'for-loop':1192 'forc':584 'fprintf':655,1383 'friend':1204 'function':213,218,246,611,617,885,1111,1128,1139,1149,1198,1207,1228,1267,1355 'futur':1081,1088,1657 'gather':1102 'gpu':1089,1716 'gpuarray':1095,1753 'gpudata':1094,1100 'grow':167,173 'guidelin':45 'high':220 'i-window':1643 'identifi':1307,1351 'idx':992 'ifft':926 'ignor':1430 'imag':900,905,1541,1548,1567,1587 'imfilt':904 'implement':224,1272,1331 'implicit':694,722 'import':112 'improv':28,86,1368 'in-plac':552,564 'independ':1028,1046,1323 'index':293,299,676,1274,1279 'indic':472,679,685 'ineffici':75 'inner':1436,1466 'input':599,1142,1152,1158,1172,1176 'instead':266,301,339,344,401,442,478,557,696,845,936,1269,1276,1313 'integ':469,1052,1287 'intens':1327 'isequ':1157 'ismemb':999,1005 'ispres':1003 'issu':26,1667,1682,1698,1715 'iter':175,737,1029,1043,1390,1711 'j':362,375,378,384,957,962,967,1454,1459,1462,1477,1486,1489,1495,1504,1559,1565,1572,1574 'jit':1178,1184,1203,1223 'jit-friend':1202 'jit-unfriend':1222 'jitfriend':1209 'jitunfriend':1230 'join':806 'just-in-tim':1185 'k':368,381,383 'kernel':889,901,906,912,923,931,1580,1588 'larg':531,911,1731 'largedata':533,537,544 'later':580 'length':233,272,309,417,920,922,1627 'like':1136 'line':618,798,807,815,818,824,831 'linear':917 'loaddata':534 'local':1071 'locat':1004 'logic':292,298,675,1273 'longer':541 'loop':79,114,122,165,296,342,789,939,1020,1047,1058,1194,1254,1263,1298,1318,1418,1437,1467,1703 'major':1442,1447,1472 'make':32,61 'manag':14 'manual':223,1271 'massiv':1092 'match':703 'matlab':2,6,38,48,76,123,145,169,189,214,225,247,265,300,343,400,441,489,529,556,592,626,677,699,733,785,844,880,935,979,1022,1066,1122,1138,1148,1182,1206,1227,1344,1369,1434,1448,1511,1543,1594,1624,1756 'matlab-performance-optim':1 'matric':483,485,1289,1697 'matrix':334,337,491,508,1310 'may':1725 'mb':453,467,477,481,506 'mean':1566,1600,1608,1610,1615,1616,1641 'measur':1339,1365 'memori':13,54,84,98,435,493,1326,1431,1475,1685,1742,1745,1759 'memory-intens':1325 'mention':22,91 'method':1303 'mex':1110,1124,1133 'mix':841 'modifi':579 'most':487 'move':1296 'movingavg':1629,1639,1659 'movmean':1660 'multipl':338,645,982 'must':1044,1049,1054 'myfunct':598,632,642,1099,1141,1374 'myfunction.c':1130,1134 'myfunctionoptim':1381 'myscript':1347 'n':126,130,135,148,152,193,197,202,664,741,763,800,825,833,944,950,951,955,959,1033,1210,1216,1231,1237,1386,1518,1596,1602,1607,1626,1638 'name':849,865 'napproach':660 'ndgrid':1496 'need':542 'nest':341,938 'new':1677 'nfft':919,929,932 'non':524 'non-zero':523 'norm':754,768,963 'num2str':1240 'number':612 'one':1581 'oper':82,117,258,264,335,394,555,784,1002,1065,1197,1311,1324,1328 'optim':4,5,21,40,47,55,72,94,107,221,436,668,876,1109,1190,1251,1329,1343,1360,1377,1401,1404,1537 'organ':872 'output':1549,1563,1585 'outsid':1297 'outweigh':1708 'over-vector':1414 'overhead':1707,1724 'pad':915 'pairwis':941 'parallel':104,1016,1019,1063,1068,1079,1093,1319 'parfev':1076,1082 'parfor':1021,1026,1030,1042,1699,1752 'parpool':1070 'past':1654 'pattern':669,670,691,728,780,836,1433 'pdist2':973 'perform':3,10,25,39,50,88,93,1117,1247,1396,1427,1666,1740,1757 'performance-crit':1116 'persist':1143,1153 'pitfal':1397,1398,1412,1428,1505 'place':554,566 'point':946,964,966,974,975 'pool':1069 'possibl':119,568,1258 'practic':1181 'prealloc':159,162,188,191,1261 'precis':456 'prematur':1400 'presort':980 'principl':108 'process':530,547,1460,1487,1502,1542,1623,1692 'processdata':536 'processeddata':535,551 'profil':16,58,99,586,591,593,596,600,602,605,1305,1336,1341,1345,1348,1402,1674,1736 'provid':43 'r2016b':724 'rand':449,463,503,519,706,710 'readabl':1425 'recalcul':735 'reduc':83 'reduct':1062 'regular':1137 'remain':1393 'remov':1011 'repeat':731,1294,1333,1391,1513 'replac':113,294,672 'repmat':698,701,715 'request':20 'requir':1040 'resourc':1734 'result':128,136,153,176,181,195,203,549,631,742,764,774,1034,1086,1097,1101,1103,1140,1147,1150,1162,1163,1170,1174,1208,1211,1217,1218,1229,1232,1523,1534 'return':1160,1165 'row':1441,1452,1469,1483,1498,1545,1551,1556 'row-major':1440 'run':404,409,419,422,431 'sampl':1655,1658 'scalar':1196 'score':857,867 'search':978,983,988 'searchvalu':1006 'second':1405 'section':1114 'separ':847 'seri':1622 'set':1001 'show':606 'signal':888,895,921,928,1628,1632,1642,1661 'simpl':1018,1191 'sin':138,154,1525,1535 'singl':455,462,628,1284 'size':349,352,358,364,370,407,717,945,1547,1597,1631 'skill':42,71 'skill-matlab-performance-optimizer' 'slice':1059 'slow':23,73,92,120,124,166,171,222,226,678,700,734,786,943,1435,1512,1544,1595,1625,1670 'slower':1700,1718 'smaller':1689 'solut':1673,1687,1704,1721 'sometim':1417 'sort':976,985,990 'sorteddata':984,994 'source-matlab' 'spars':482,507,511,1288,1292,1696,1754 'specif':875 'speed':27,95 'speedup':1384 'spent':608 'sprintf':797,817,828,830 'sqrt':746,756,776 'statist':1592 'still':1669 'store':522 'str':790,795,796,822,829 'strategi':56 'string':783,1299 'strjoin':823 'sum':227,235,237,249,251,405,410,420,423,432,747,757,777 'tabl':839,862,864 'take':620,1356 'techniqu':53,254,1363 'threshold':314,333 'tic':630 'tic/toc':1751 'time':607,623,624,627,1188,1358,1371,1378,1387,1621,1728 'time1':647,665 'time2':651,666 'timeit':638,641,648,652,1373,1380,1750 'toc':635 'tool':59 'topic-agent-skill' 'topic-agent-skills' 'topic-agentic-ai' 'topic-agents' 'topic-claude' 'topic-claude-api' 'topic-claude-code' 'topic-claude-desktop' 'topic-claude-skills' 'topic-matlab' 'topic-matlab-skills' 'trail':1650 'transfer':1723 'travers':1443,1473 'troubleshoot':1665 'type':440,843,1282,1509,1691 'uint32':473 'unfriend':1224 'uniqu':1009,1014 'uniquedata':1013 'unnecessari':570,1507 'unus':527 'usag':85,1746 'use':17,69,121,209,259,336,395,437,454,468,589,693,838,861,881,998,1008,1075,1268,1275,1283,1290,1301,1312,1688,1695,1729,1735,1741,1747 'user':19,90 'val':228,236,238,250 'valu':995 'variabl':528,1048,1053,1144 'vector':12,52,81,110,116,144,253,773,827,971,1256,1416,1493,1672 'verifi':1253,1367 'viewer':601,1349,1737 'vs':1285 'wast':492 'whenev':118 'window':1633,1637,1645,1651,1652,1662 'wise':257,263,1317 'without':1199 'worker':1074 'workflow':1337 'write':1129 'x':234,239,252,273,276,280,287,290,681,684,688,689,1239,1519,1526,1531,1536 'y':274,286,683,687 'zero':129,196,348,406,488,495,525,854,858,914,949,1550,1601,1630 'zero-pad':913","prices":[{"id":"6fc02463-016b-4bdd-8e23-f702d6f0f793","listingId":"b0837f9c-341d-43f5-bbce-331f817beec8","amountUsd":"0","unit":"free","nativeCurrency":null,"nativeAmount":null,"chain":null,"payTo":null,"paymentMethod":"skill-free","isPrimary":true,"details":{"org":"matlab","category":"skills","install_from":"skills.sh"},"createdAt":"2026-04-18T22:14:23.651Z"}],"sources":[{"listingId":"b0837f9c-341d-43f5-bbce-331f817beec8","source":"github","sourceId":"matlab/skills/matlab-performance-optimizer","sourceUrl":"https://github.com/matlab/skills/tree/main/skills/matlab-performance-optimizer","isPrimary":false,"firstSeenAt":"2026-04-18T22:14:23.651Z","lastSeenAt":"2026-04-22T00:55:57.501Z"}],"details":{"listingId":"b0837f9c-341d-43f5-bbce-331f817beec8","quickStartSnippet":null,"exampleRequest":null,"exampleResponse":null,"schema":null,"openapiUrl":null,"agentsTxtUrl":null,"citations":[],"useCases":[],"bestFor":[],"notFor":[],"kindDetails":{"org":"matlab","slug":"matlab-performance-optimizer","github":{"repo":"matlab/skills","stars":65,"topics":["agent-skill","agent-skills","agentic-ai","agents","claude","claude-api","claude-code","claude-desktop","claude-skills","matlab","matlab-skills"],"license":"other","html_url":"https://github.com/matlab/skills","pushed_at":"2026-03-20T00:56:44Z","description":"A collection of Agent Skills for MATLAB development. Skills are specialized instruction sets that extend a coding agent's capabilities for specific tasks, automatically activating when needed.","skill_md_sha":"35ef2f48eda0ea2d063c18d7596a1ccfb3ced82a","skill_md_path":"skills/matlab-performance-optimizer/SKILL.md","default_branch":"main","skill_tree_url":"https://github.com/matlab/skills/tree/main/skills/matlab-performance-optimizer"},"layout":"multi","source":"github","category":"skills","frontmatter":{"name":"matlab-performance-optimizer","license":"MathWorks BSD-3-Clause (see LICENSE)","description":"Optimize MATLAB code for better performance through vectorization, memory management, and profiling. Use when user requests optimization, mentions slow code, performance issues, speed improvements, or asks to make code faster or more efficient."},"skills_sh_url":"https://skills.sh/matlab/skills/matlab-performance-optimizer"},"updatedAt":"2026-04-22T00:55:57.501Z"}}