Add `anova` class object

[pr0m1th3as]

An anova class object with conditional support for tables and categorical arrays from the datatypes package should be implemented. Support for tables and categorical data should be extended to the anova1, anova2, and anovan functions.

This is a rather long term goal and as a relatively large project to implement it could be a candidate GSoC project for 2026.

[AvanishSalunke]

I would like to propose the following for this issue :

• Build a new code file (anova.m) that acts as a simple control center for our analysis.
• This allows us to create, check, and graph ANOVA models as organized objects.

Supporting the following -

Constructor Syntaxes :

The anova constructor is designed to handle the following five specific input :

1. anova(y) : One-way anova where y is a matrix. Columns are treated as factor levels.
2. anova(factors, y) : N-way anova where factors can be numeric vectors, logicals, categorical arrays, or cell arrays of strings.
3. anova(tbl, y) : Hybrid input using a table tbl for predictors and a vector y for the response.
4. anova(tbl, responseVarName) : Pure table input where the response variable is identified by name (string or char).
5. anova(tbl, formula) : Model specification using Wilkinson notation.

Name - value Argument Support :

The constructor uses an input parser to support the following configuration options:

1. CategoricalFactors : Indices or names of factors to explicitly treat as categorical.
2. FactorNames : Custom names for the factors (overriding table headers).
3. ModelSpecification : Defines model complexity (e.g, "linear", "interaction", "full", "quadratic").
4. RandomFactors : Specification of random versus fixed effects.
5. ResponseName : Label for the dependent variable.
6. SumOfSquaresType : Specifies the calculation method ("one", "two", "three", "hierarchical").

Class Properties :

The class exposes the following public properties:

1. Coefficients : Double vector of fitted anova model coefficients.
2. Factors : Table containing names and values of the factors used in the analysis.
3. FactorNames : String vector of factor names.
4. ExpandedFactorNames : String vector corresponding to coefficients (including interaction terms).
5. Formula : Object or string representing the ANOVA model (e.g, LinearFormulaWithNesting).
6. Metrics : Table containing sum of squares, degrees of freedom, mean squares, F-values, and p-values.
7. NumObservations : Integer count of valid observations used.
8. Residuals : Table containing residual values.
9. ResponseName : String name of the response variable.
10. Y : Numeric vector of response data used in the fit.
11. SumOfSquaresType : String specifying the type of sum of squares (e.g., "Type III").
12. CategoricalFactors : Numeric vector of indices treated as categorical.
13. RandomFactors : Numeric vector of indices treated as random.

Object Methods :

The class implements the following methods for post-hoc analysis:

1. stats(obj) : Returns the analysis of variance table.
2. boxchart(obj) : Produces box plots of response data grouped by factors.
3. multcompare(obj) : Performs multiple comparison of means (post-hoc tests).
4. varianceComponent(obj) : Estimates variance components for random effects

[Divansu47]

Subject: Proposal for GSoC 2026: Implementation of anova Class and Datatypes Integration

Hi @pr0m1th3as,

I am interested in working on this issue for GSoC 2026. After reviewing the current implementation of anova1, anova2, and anovan, I understand the necessity of modernizing these functions to support the datatypes package (specifically table and categorical arrays) and encapsulating the results in a dedicated class object.

I have drafted a preliminary architectural plan and a working Proof of Concept (PoC). I would appreciate your feedback on this approach to ensure it aligns with the maintainers' vision.

1. Proposed Architecture
   My goal is to shift the ANOVA workflow from a purely functional return (matrices) to an Object-Oriented approach, similar to modern statistical environments.

The anova Class: I propose creating a classdef that stores the Analysis of Variance results.

Properties: SourceData, ModelString, StatsTable (SS, df, MS, F, p-val).

Methods: disp() (for formatted console output) and plot() (for residual/box plots).

Formula Interface: Integrating a parser to allow inputs like anova1(myTable, 'Yield ~ Variety').

Categorical Support: Adding logic to automatically extract indices and labels from categorical arrays, removing the need for users to manually convert them to dummy variables or indices.

2. Implementation Strategy (Phased)
   Phase 1: Class Definition: Create the base anova class structure to accept statistical data and handle formatted disp().

Phase 2: Wrapper Logic: Refactor anova1 (starting point) to parse inputs. If the input is a table or categorical, normalize it to numeric vectors, pass it to the existing computational kernel, and return an instance of the anova class.

Phase 3: Extension: Extend this logic to anova2 and anovan (N-way), ensuring the class object can handle multiple factors dynamically.

3. Proof of Concept
   I have prototyped the input parsing logic to demonstrate how we can handle Formula Strings within the existing ecosystem.

MATLAB
function obj = anova1_extended(varargin)
    % ANOVA1_EXTENDED: Proposed wrapper handling Table and Formula inputs
    % Usage: anova1_extended(TableData, 'Response ~ Group')

    args = varargin;
    y = [];
    group = [];
    
    % --- Input Parsing Logic ---
    if isobject(args{1}) && strcmp(class(args{1}), 'table')
        tbl = args{1};
        if length(args) >= 2 && ischar(args{2})
            % Case: input is (Table, 'y ~ x')
            formula = args{2};
            [y, group] = parse_formula(tbl, formula);
        else
            error('When input is a Table, a formula string is required.');
        end
    else
        % Fallback to standard numeric input behavior
        y = args{1};
        if length(args) > 1, group = args{2}; end
    end
    
    % --- Validating Categorical Data ---
    if isa(group, 'categorical')
        % Convert categorical labels to indices for the math kernel
        % In the full project, we would preserve labels for the final plot
        group = double(group); 
    end
    
    % --- Call Computational Kernel (Placeholder) ---
    % In the real project, this calls the underlying stat calculations
    stats_struct = perform_anova_math(y, group);
    
    % --- Instantiate and Return the New Class ---
    obj = anova_object(stats_struct, 'One-Way ANOVA');
end

function [y_data, group_data] = parse_formula(tbl, formula_str)
    % Helper to parse 'ResponseVar ~ GroupVar'
    
    % Split string at the tilde
    parts = strsplit(formula_str, '~');
    if length(parts) ~= 2
        error('Formula must be in the format "Response ~ Predictor"');
    end
    
    lhs = strtrim(parts{1}); % Response Variable Name
    rhs = strtrim(parts{2}); % Group Variable Name
    
    % Validate variable existence in table
    if ~ismember(lhs, tbl.Properties.VariableNames) || ...
       ~ismember(rhs, tbl.Properties.VariableNames)
        error('Variables specified in formula not found in table.');
    end
    
    % Extract data
    y_data = tbl.(lhs);
    group_data = tbl.(rhs);
end

4. Compatibility
   To maintain backward compatibility for users relying on raw matrix outputs, I propose implementing a double() method in the anova class, or a flag in the function arguments, allowing legacy scripts to run without breaking.

I am eager to contribute to GNU Octave and would appreciate any thoughts on this structure.

Best regards,
Divansu Mishra

[pr0m1th3as]

@Divansu47 TYN

[Rybachyk]

Subject: GSoC 2026 Inquiry: Implementation of anova classdef for statistics package

Hi @pr0m1th3as

I am Oleksandr Rybachyk, and I am writing to express my strong interest in the GSoC project: "Add anova object to the statistics package".

I have been exploring the statistics repository and the existing implementations of anova1, anova2, and anovan. I believe that moving towards an Object-Oriented approach using classdef is essential for better integration with the datatypes package (tables and categorical arrays).

My Background & Warm-up Task:
I have already started familiarizing myself with the Octave contribution process. For my warm-up task,I suggested a bug fix, which can be found here: https://savannah.gnu.org/bugs/index.php?68062.

My Proposed Approach:
I aim to create a robust anova class that not only stores results but also provides a user-friendly interface:

Class Structure: Create classdef anova with properties like SourceData, Model, and a Table containing SS, df, MS, F, and p-values.

Formula Interface: Implement a parser to support the Response ~ Predictor syntax, which is standard in R and modern MATLAB.

Methods: Implement disp() for pretty-printing the ANOVA table and plot() for visual analysis (e.g., boxplots of residuals).

Compatibility: Ensure that the new class can still interact with legacy code by providing methods to export data back to standard matrices if needed.

Preliminary Implementation Idea (PoC):
I am working on a wrapper that detects if the input is a table. If so, it uses a formula parser to extract variables before passing them to the core math engine.

I would appreciate any feedback on whether this architectural direction aligns with the current goals of the statistics package maintainers. Are there any specific edge cases in anovan that I should prioritize?

Best regards,
Oleksandr Rybachyk