npm - @pikaa-ai/pikaa - Versions diffs - 0.3.1 → 0.3.4 - Mend

@pikaa-ai/pikaa 0.3.1 → 0.3.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1870) hide show

package/skills/matlab/references/mathematics.md DELETED Viewed

@@ -1,208 +0,0 @@
-# Numerical Methods, Tolerances, and Reproducibility
-This reference targets MATLAB R2026a. Confirm every non-base product before
-using toolbox-specific functions.
-## Linear systems and decompositions
-Solve systems; do not form an inverse as an intermediate:
-```matlab
-x = A \ b;
-residual = A*x - b;
-relativeResidual = norm(residual) / ...
-    max(norm(A)*norm(x) + norm(b), realmin(class(A)));
-```
-Check dimensions, rank/conditioning, scaling, symmetry, definiteness, and
-sparsity. A small residual does not guarantee a small forward error for an
-ill-conditioned problem.
-Common base MATLAB operations include:
-- `lu`, `qr`, `chol`, `ldl`, `schur`;
-- `eig`, `svd`, `eigs`, `svds`;
-- `rank`, `cond`, `rcond`, `norm`, `pinv`;
-- `lsqminnorm`, `lsqnonneg`, and backslash least squares.
-Use an economy decomposition where appropriate and request only the spectrum
-needed for large/sparse problems. Eigenvector signs/phases and bases in
-degenerate subspaces are not unique; compare invariant quantities rather than
-raw vectors.
-## Floating-point comparison
-Binary floating point does not represent most decimal fractions exactly.
-Choose tolerances from the model, scale, conditioning, discretization,
-measurement uncertainty, and algorithm—not from a universal constant.
-A robust scalar/elementwise policy often has the form:
-```matlab
-errorMagnitude = abs(actual - expected);
-limit = absoluteTolerance + relativeTolerance .* abs(expected);
-isAcceptable = errorMagnitude <= limit;
-```
-Handle these explicitly:
-- expected values near zero need an absolute tolerance;
-- large expected values often need a relative tolerance;
-- `NaN` equality is a semantic decision (`isequaln` differs from `==`);
-- `Inf` signs should match when infinity is expected;
-- class, size, sparsity, and complex values are part of the contract.
-R2026a documents `isapprox` alongside equality operations. In
-`matlab.unittest`, use `AbsTol`/`RelTol` or
-`AbsoluteTolerance`/`RelativeTolerance`. Record why values are scientifically
-acceptable.
-Do not widen tolerances automatically after an upgrade. First investigate RNG,
-ordering, reduction order, solver defaults/options, data type, threading,
-compiler, library, and release-note changes.
-## Random streams
-Record algorithm and seed, not only a seed:
-```matlab
-rng(1729, "twister");
-stateAtStart = rng;
-samples = randn(1000, 1);
-```
-For local independent streams:
-```matlab
-stream = RandStream("Threefry", Seed=1729);
-stream.Substream = 4;
-samples = randn(stream, 1000, 1);
-```
-Generator availability and bitwise sequences can vary by algorithm/release.
-Avoid `rng("shuffle")` for reproducible work. On parallel workers, time-based
-seeding can collide; use supported independent streams/substreams and record
-worker mapping. Parallel computing requires Parallel Computing Toolbox.
-## Integration, roots, and differential equations
-Base MATLAB provides general numerical methods including:
-- `integral`, `integral2`, `integral3`, `trapz`, `cumtrapz`;
-- `gradient`, `diff`;
-- `fzero`;
-- ODE solvers such as `ode45`, `ode23`, `ode113`, `ode15s`, `ode23s`,
-  `ode23t`, and `ode23tb`;
-- boundary-value solvers such as `bvp4c` and `bvp5c`.
-Define tolerances and failure criteria:
-```matlab
-options = odeset( ...
-    RelTol=1e-7, ...
-    AbsTol=1e-10, ...
-    MaxStep=0.05);
-[t, y] = ode45(@rhs, [0 5], 1, options);
-```
-Solver tolerances control local error estimates, not proof of a globally
-correct model. Check conservation laws, event localization, stiffness,
-step-size convergence, and an independent formulation. R2026a adds an
-automatic-differentiation Jacobian option for the `ode` object; verify the
-specific solver/problem and release notes before using it.
-## Optimization and fitting boundaries
-Base MATLAB includes `fminsearch` and `fminbnd`. These do not replace
-constrained or specialized solvers.
-Examples of separately licensed boundaries:
-| Capability | Representative API | Product to confirm |
-|---|---|---|
-| constrained/nonlinear optimization | `fmincon`, `fminunc`, `lsqnonlin`, `lsqcurvefit` | Optimization Toolbox |
-| global/metaheuristic optimization | `ga`, `particleswarm`, `surrogateopt` | Global Optimization Toolbox |
-| curve fitting objects/apps | `fit`, Curve Fitter | Curve Fitting Toolbox |
-| statistical modeling/distributions | `fitlm`, `fitdist`, `anova`, many tests | Statistics and Machine Learning Toolbox |
-| symbolic algebra | `syms`, `solve`, symbolic differentiation | Symbolic Math Toolbox |
-| signal design/analysis | `fir1`, `filtfilt`, `designfilt`, `spectrogram` | Signal Processing Toolbox |
-| parallel loops/GPU | `parfor`, `parpool`, `gpuArray` | Parallel Computing Toolbox |
-Some base functions have similarly named toolbox alternatives. Check the
-function's current product page and the project dependency report; never infer
-ownership from a code example.
-Optimization reproducibility requires objective/constraint definitions,
-starting points, bounds, solver/options, stopping tolerances, gradients,
-scaling, RNG state for stochastic methods, and exit diagnostics. Compare
-feasibility and optimality measures, not only the objective value.
-## Statistics and signal processing
-Base array summaries include `mean`, `median`, `std`, `var`, `min`, `max`,
-`movmean`, `movmedian`, `cov`, `corrcoef`, `histcounts`, and polynomial
-`polyfit`/`polyval`. Some distribution, model, hypothesis-test, robust,
-classification, and specialized plotting APIs require Statistics and Machine
-Learning Toolbox.
-For FFT work:
-```matlab
-n = numel(x);
-Y = fft(x);
-frequency = (0:n-1).' * (sampleRate/n);
-```
-Document sample rate, units, window, detrending, normalization, one- versus
-two-sided spectrum, zero padding, and endpoint convention. `fft` and `conv` are
-base MATLAB; many filter-design and spectral-estimation functions are Signal
-Processing Toolbox.
-## Verification patterns
-Use several layers:
-1. **Dimensional/invariant checks**: sizes, units, conservation, monotonicity,
-   positivity, symmetry.
-2. **Analytic cases**: small problems with known solutions.
-3. **Refinement studies**: mesh, step, quadrature, or tolerance convergence.
-4. **Independent implementation**: alternative solver or formulation.
-5. **Condition/sensitivity analysis**: perturb inputs and options.
-6. **Release comparison**: compare scientifically meaningful observables with
-   a documented tolerance.
-7. **Performance measurement**: after correctness, measure representative
-   workloads with `timeit`.
-Do not claim bitwise reproducibility across releases, hardware, thread counts,
-GPU/CPU, or external libraries unless it was actually tested and documented.
-## Reproducibility record
-At minimum capture:
-- MATLAB release/update or Octave version;
-- OS and architecture, only as named fields;
-- required products and license status separately;
-- source/input hashes and schema versions;
-- numeric classes and shapes;
-- RNG algorithm, seed, substream, and parallel mapping;
-- solver names/options/tolerances and stopping diagnostics;
-- expected invariants and acceptance tolerances;
-- output format/version and graphics export settings.
-Use `scripts/reproducibility_report.py` to hash only named local artifacts. It
-does not inspect the broad environment.
-## Sources (verified 2026-07-23)
-- [Linear Algebra](https://www.mathworks.com/help/matlab/linear-algebra.html)
-- [`mldivide`](https://www.mathworks.com/help/matlab/ref/double.mldivide.html)
-- [`eq` floating-point guidance and `isapprox`](https://www.mathworks.com/help/matlab/ref/double.eq.html)
-- [`AbsoluteTolerance`](https://www.mathworks.com/help/matlab/ref/matlab.unittest.constraints.absolutetolerance-class.html)
-- [`RelativeTolerance`](https://www.mathworks.com/help/matlab/ref/matlab.unittest.constraints.relativetolerance-class.html)
-- [`rng`](https://www.mathworks.com/help/matlab/ref/rng.html)
-- [`RandStream`](https://www.mathworks.com/help/matlab/ref/randstream.html)
-- [ODE Solvers](https://www.mathworks.com/help/matlab/ordinary-differential-equations.html)
-- [Optimization](https://www.mathworks.com/help/matlab/optimization.html)
-- [MATLAB product list and pricing/licensing](https://www.mathworks.com/pricing-licensing.html)
-- [MATLAB R2026a release notes](https://www.mathworks.com/help/matlab/release-notes.html)

package/skills/matlab/references/matrices-arrays.md DELETED Viewed

@@ -1,228 +0,0 @@
-# Arrays, Indexing, Data Types, and Performance
-This reference targets MATLAB R2026a. Verify GNU Octave behavior separately.
-## Array model
-MATLAB is 1-based and column-major. Most numeric literals are `double`.
-Orientation and trailing singleton dimensions matter.
-```matlab
-row = 1:5;                 % 1-by-5
-column = (1:5).';          % 5-by-1, nonconjugate transpose
-A = reshape(1:12, 3, 4);   % values fill down columns
-sameShape = zeros(size(A), "like", A);
-singleData = zeros(100, 1, "single");
-logicalMask = false(size(A));
-```
-Use `.'` for a plain transpose and `'` for a conjugate transpose. Use
-`size(A,dim)`, `numel`, and `ndims`; avoid `length` when a specific dimension
-is intended.
-### Core storage choices
-| Type | Use | Caution |
-|---|---|---|
-| dense numeric/logical array | homogeneous computation | implicit conversion and memory |
-| sparse numeric/logical array | low-density 2-D matrices | not every operation preserves sparsity |
-| string array | text with missing values | differs from character arrays |
-| categorical | finite labels and ordering | undefined category is missing |
-| cell array | heterogeneous containers | `{}` versus `()` semantics |
-| structure | named heterogeneous fields | structure arrays complicate shape |
-| table | named, equal-height variables | `()` versus `{}` versus dot indexing |
-| timetable | table with row times | time zone, sorting, duplicates, alignment |
-| datetime/duration | time points/elapsed time | time zones and calendar duration differ |
-Choose integer classes for storage or exact integer semantics, not as a drop-in
-for floating computation. Integer overflow and mixed-class operations need
-explicit tests. Preserve units in names or metadata.
-## Indexing
-```matlab
-value = A(2, 3);       % row 2, column 3
-linear = A(5);         % column-major linear index
-row = A(2, :);
-lastRows = A(max(1,end-2):end, :);
-positive = A(A > 0);
-A(A < 0) = 0;
-[r, c] = ind2sub(size(A), linearIndex);
-linearIndex = sub2ind(size(A), r, c);
-```
-Prefer logical indexing for selection and `find` only when numeric indices are
-needed. Verify mask shape. Deleting with `A(index)=[]` changes shape and can be
-ambiguous for multidimensional arrays.
-### Cell, structure, and table indexing
-```matlab
-C = {42, "sample"; [1 2], datetime("today")};
-cellContainer = C(1, :);  % still a cell array
-cellContent = C{1, 1};    % contained value
-S.SampleID = "S01";
-name = S.("SampleID");
-tableSlice = T(1:10, ["Time" "Value"]); % table
-numericValues = T{:, "Value"};          % underlying content
-oneVariable = T.Value;                  % variable content
-```
-Curly extraction from a table succeeds only when selected variable contents
-can concatenate. Preserve table form when variable names and metadata matter.
-## Operators and implicit expansion
-| Operation | Matrix | Element-wise |
-|---|---|---|
-| multiply | `A*B` | `A.*B` |
-| divide | `A/B`, `A\B` | `A./B`, `A.\B` |
-| power | `A^n` | `A.^n` |
-Addition, subtraction, comparisons, and many element-wise functions use
-compatible-size implicit expansion. Since R2016b, a column and row can create
-an outer result:
-```matlab
-x = (1:3).';
-y = 10:10:40;
-outerSum = x + y;   % 3-by-4
-```
-Before relying on expansion, assert intended orientation:
-```matlab
-assert(iscolumn(x));
-assert(isrow(y));
-```
-Do not use `repmat` solely to emulate supported implicit expansion, but use it
-when an explicitly materialized tiled array is actually needed.
-## Missing and nonfinite values
-Standard missing values are type-specific:
-- `NaN`: `double`, `single`, `duration`, `calendarDuration`
-- `NaT`: `datetime`
-- `<missing>`: `string`
-- `<undefined>`: `categorical`
-- `''` inside a cell array of character vectors
-Integer and logical arrays have no standard missing value. A sentinel such as
-`-99` is a data contract, not a MATLAB default.
-```matlab
-missingMask = ismissing(T);
-anyMissing = anymissing(T);
-clean = rmmissing(T);
-filled = fillmissing(T, "linear", DataVariables="Value");
-```
-Define whether `Inf` is valid separately; it is not a standard missing
-floating-point value. `isfinite` distinguishes finite values. `ismissing`
-ignores timetable row times, so validate row times explicitly.
-## Tables and timetables
-Every table variable has the same row count but can have a different type and
-width. Timetables add row times.
-```matlab
-T = table(sampleID, group, value, ...
-    VariableNames=["SampleID" "Group" "Value"]);
-TT = timetable(time, value, quality, ...
-    VariableNames=["Value" "Quality"]);
-TT = sortrows(TT);
-hourly = retime(TT, "hourly", "mean");
-aligned = synchronize(TT1, TT2, "intersection");
-```
-Before time alignment:
-1. normalize or record time zones;
-2. define duplicate-time policy;
-3. sort row times;
-4. choose union/intersection and interpolation/aggregation deliberately;
-5. record daylight-saving and calendar assumptions.
-Direct calculations on tables/timetables are supported for compatible
-variables, but mixed nonnumeric variables can invalidate an operation.
-Selecting numeric variables first is often clearer:
-```matlab
-numericT = T(:, vartype("numeric"));
-```
-## Concatenation and reshaping
-```matlab
-wide = [A B];
-tall = [A; B];
-flat = A(:);
-B = reshape(A, [], 4);
-C = permute(X, [2 1 3]);
-```
-Concatenated dimensions and classes must be compatible. `squeeze` can remove
-different dimensions depending on input shape; avoid it in APIs whose output
-rank must be stable.
-## Performance without folklore
-1. Write the clearest correct array code.
-2. Use representative data and `timeit`; use the profiler for call-level
-   diagnosis.
-3. Preallocate when a loop's output shape is known.
-4. Vectorize operations that map naturally to array kernels.
-5. Keep a loop when vectorization creates large temporaries or obscures logic.
-6. Preserve sparsity and data class where appropriate.
-7. Benchmark each supported release/platform; R2026a includes implementation
-   speedups that can change old trade-offs.
-```matlab
-y = zeros(size(x), "like", x);
-for k = 1:numel(x)
-    y(k) = localTransform(x(k));
-end
-```
-Avoid growing arrays in a loop. However, do not preallocate the wrong class or
-shape. `zeros(size(x),"like",x)` is usually safer than an unqualified `zeros`.
-Parallel arrays, GPU arrays, tall arrays, `parfor`, and distributed arrays
-require specific products and supported functions. They also change ordering,
-reduction, RNG, and tolerance concerns. Do not suggest them merely because a
-loop exists.
-## Numerical review checklist
-- [ ] Shapes and orientation are asserted where expansion matters.
-- [ ] Matrix versus element-wise operators are intentional.
-- [ ] Conjugation behavior is intentional.
-- [ ] Indexing preserves expected rank and container type.
-- [ ] Missing, nonfinite, and sentinel policies are explicit.
-- [ ] Table variable names/types and timetable time zones are preserved.
-- [ ] Integer overflow and mixed-class conversion are tested.
-- [ ] Sparse inputs remain sparse where required.
-- [ ] Preallocation and vectorization are measured, not assumed.
-- [ ] Memory estimates include temporaries and expanded outputs.
-## Sources (verified 2026-07-23)
-- [Array Indexing](https://www.mathworks.com/help/matlab/math/array-indexing.html)
-- [Compatible Array Sizes for Basic Operations](https://www.mathworks.com/help/matlab/matlab_prog/compatible-array-sizes-for-basic-operations.html)
-- [MATLAB Data Types](https://www.mathworks.com/help/matlab/data-types.html)
-- [Tables](https://www.mathworks.com/help/matlab/tables.html)
-- [Timetables](https://www.mathworks.com/help/matlab/timetables.html)
-- [`ismissing`](https://www.mathworks.com/help/matlab/ref/ismissing.html)
-- [Missing Data in MATLAB](https://www.mathworks.com/help/matlab/data_analysis/missing-data-in-matlab.html)
-- [Vectorization](https://www.mathworks.com/help/matlab/matlab_prog/vectorization.html)
-- [Preallocation](https://www.mathworks.com/help/matlab/matlab_prog/preallocating-arrays.html)
-- [`timeit`](https://www.mathworks.com/help/matlab/ref/timeit.html)
-- [Profile MATLAB Code](https://www.mathworks.com/help/matlab/matlab_prog/profiling-for-improving-performance.html)

package/skills/matlab/references/octave-compatibility.md DELETED Viewed

@@ -1,212 +0,0 @@
-# GNU Octave 11.3.0 Compatibility
-GNU Octave 11.3.0 is the current stable release as of 2026-07-23 (released
-2026-06-01). It is free software under GPLv3+. MATLAB R2026a is proprietary.
-Do not describe Octave as MATLAB, a licensed toolbox substitute, or a
-drop-in guarantee.
-## Compatibility policy
-Use three labels:
-- **portable subset**: tested in both exact target versions;
-- **MATLAB-only**: depends on MATLAB syntax, objects, projects, products, or
-  deployment;
-- **Octave-only**: uses Octave syntax, packages, BIST, or runtime behavior.
-Source resemblance is not enough. Compare outputs with scientific tolerances,
-edge cases, warnings, graphics, performance, and file round trips.
-## Current release changes
-Octave 11 introduced improved `classdef` support, broadcasting for sparse,
-diagonal, and permutation matrices, more MATLAB-compatible `nanflag`/`vecdim`
-behavior, and many function/performance changes. It is still not fully
-compatible. NEWS-11 also records behavior changes that can break older Octave
-code, including stricter accepted types for several statistics functions.
-Read both the current manual and NEWS before migrating to 11.3.0. The online
-`latest` manual reviewed on this date identifies its generated content as
-11.1.0 while the project download/news page identifies 11.3.0 as current;
-consult NEWS-11 for the maintenance-release delta.
-## Command-line differences
-Reviewed Octave argv usually includes:
-```text
-["octave", "--no-init-all", "--no-history", "--quiet", "--no-gui", "main.m"]
-```
-The bundled planner returns argv but never executes it.
-Current manual behavior:
-- `--eval`/`-e` evaluates code and exits unless `--persist` is set;
-- a filename executes and exits;
-- `--no-gui` selects CLI;
-- `--no-window-system` disables graphics/window-system use;
-- `--no-init-all`/`--norc` skips system and user initialization;
-- `--path` adds a function path;
-- `--quiet` suppresses greeting; `--no-history` avoids history writes.
-Octave startup can execute site/version files, user configuration,
-project-local `.octaverc`, and MATLAB-compatible `startup.m`. Skipping all
-startup files can improve reproducibility but can also remove expected package
-or path setup. Review the plan.
-MATLAB uses `-batch`, has different startup processing, and has no Octave
-`--no-init-all` option. Never pass the same flags to both.
-## Syntax: portable versus Octave-only
-Prefer:
-- `%` comments;
-- `...` continuation;
-- `end` block terminators;
-- explicit `x = x + 1`;
-- intermediate variables before indexing a function result;
-- short-circuit `&&`/`||` for scalar conditions;
-- ordinary `.m` functions with matching filenames.
-Avoid these Octave-only extensions in portable code:
-- `#` comments;
-- `endif`, `endfor`, `endfunction`;
-- `++`, `--`, `+=`, and related compound assignment;
-- `do ... until`;
-- indexing directly into an expression result;
-- backslash line continuation;
-- Octave package/BIST directives in MATLAB production files unless isolated.
-Both support implicit expansion/broadcasting in many modern cases, but special
-classes and edge cases differ. Octave 11 expanded broadcasting for special
-matrix types. Test orientation, sparse output, empty dimensions, and mixed
-classes in both.
-## MATLAB features with no assumed Octave equivalent
-The current Octave manual does not establish drop-in equivalents for:
-- MATLAB `arguments` blocks and all validators/name-value semantics;
-- `table`/`timetable` workflows and their R2026a JSON conversions;
-- MATLAB Projects, dependency analyzer, Project Upgrade, or project-aware
-  `runtests`;
-- `matlab.unittest`, MATLAB Test, Code Quality Dashboard;
-- live scripts `.mlx`, App Designer `.mlapp`, `.fig` object compatibility;
-- Simulink and MathWorks toolbox APIs;
-- MATLAB Engine API for Python, MATLAB Compiler/Runtime, MATLAB Coder, or
-  MathWorks deployment products;
-- full MATLAB `classdef`, events/listeners, serialization, and metaclass
-  behavior.
-Use feature detection and separate adapters only after testing. Do not silently
-replace a missing MATLAB toolbox function with a similarly named Octave
-package function.
-## Packages versus toolboxes
-Octave packages are distributed separately from core Octave. MATLAB toolboxes
-are separately licensed MathWorks products. APIs, algorithms, defaults,
-validation, object models, and release schedules differ.
-Never run `pkg install`, load an untrusted package, or alter `.octaverc`
-automatically. Package installation can fetch/build/execute code. Record exact
-package name/version/source/checksum and obtain approval.
-`pkg load` mutates the function path and can shadow core or project functions.
-Test `which`/resolution only in a trusted approved runtime.
-## Tests
-Octave's built-in self-test system scans `%!` blocks and uses `test`. It is not
-`matlab.unittest`.
-```matlab
-%!test
-%! observed = hypot(3, 4);
-%! assert(observed, 5, 1e-12);
-```
-Portable production functions and runtime-specific test harnesses should be
-separate when test syntax differs. The nonexecuting planner can prepare an
-Octave BIST argv, but an approved runtime is required to run it.
-## MAT and HDF5 compatibility
-Octave 11 supports writing MATLAB v4, v6, and v7 binary formats. It **does not
-implement saving MATLAB v7.3**.
-Octave can save its own HDF5 representation when built with HDF5. Its `load
--hdf5` has limited ability to read MATLAB v7.3, mainly for supported numeric
-content; many types are unsupported. An Octave HDF5 file is not automatically
-a MATLAB v7.3 file.
-Octave's current manual states that `classdef` objects are saved as structures
-in supporting formats and are not restored as `classdef` objects. This differs
-substantially from MATLAB object serialization.
-Never load untrusted MAT/HDF5 files in either runtime. Use the bundled bounded
-technical inventory first, then escalate object/opaque/function/external-link
-content.
-For portable simple data, use MATLAB v7 only after testing classes, shapes,
-text, sparse/complex values, and metadata. Prefer schema-documented
-language-neutral formats where feasible.
-## Graphics
-Basic calls such as `plot`, labels, legends, images, surfaces, and `print` are
-similar, but renderers, fonts, properties, layout, transparency, callbacks,
-and export formats differ.
-Do not assume Octave implements R2026a `exportgraphics`, SVG/HTML web canvas,
-`tiledlayout`, UI objects, or property behavior. Build a small compatibility
-test and compare exported dimensions, font embedding, vector/raster content,
-colors, and clipping.
-Octave 11 NEWS documents graphics compatibility changes such as colorbar and
-event-field behavior. Review NEWS for each update.
-## Numerical differences
-Even when both runtimes call similarly named LAPACK/BLAS-backed functions,
-results can differ because of:
-- linked libraries, versions, threads, and architecture;
-- solver implementation/default/tolerance changes;
-- sparse ordering and pivot choices;
-- random generator algorithms and streams;
-- toolbox/package algorithms;
-- floating reduction order;
-- unsupported or converted classes.
-Compare residuals, invariants, objective/feasibility, and domain observables.
-Do not demand identical eigenvector signs, cluster bases, or bitwise
-floating-point output without a justified contract.
-## Portability checklist
-- [ ] Exact MATLAB and Octave versions recorded.
-- [ ] Core versus toolbox/package requirements separated.
-- [ ] Only portable syntax used in shared source.
-- [ ] Shapes, missing values, strings, and implicit expansion tested.
-- [ ] RNG algorithm/seed behavior tested separately.
-- [ ] Numerical tolerances justified.
-- [ ] MAT/HDF5 round trips cover every used class.
-- [ ] Graphics compared from exported files.
-- [ ] Runtime-specific tests and deployment kept separate.
-- [ ] No package installation or code execution occurred implicitly.
-## Sources (verified 2026-07-23)
-- [GNU Octave home/current release](https://octave.org/)
-- [GNU Octave 11 release notes](https://octave.org/NEWS-11.html)
-- [GNU Octave current manual](https://docs.octave.org/latest/)
-- [Command-Line Options](https://docs.octave.org/latest/Command-Line-Options.html)
-- [Startup Files](https://docs.octave.org/latest/Startup-Files.html)
-- [Simple File I/O and MAT v7.3 limitation](https://docs.octave.org/latest/Simple-File-I_002fO.html)
-- [`classdef` compatibility status](https://docs.octave.org/latest/classdef-Classes.html)
-- [Test Functions](https://docs.octave.org/latest/Test-Functions.html)
-- [GNU GPL](https://octave.org/license.html)