Stratax Roadmap

Developer roadmap for the current Stratax implementation and its next stages.

Purpose

This roadmap tracks verified library capabilities separately from planned work. A checked item should have a public implementation and automated coverage. Work that is exposed but not yet tested or documented remains explicitly incomplete.

Current Priorities

Add dedicated Python broadcasting regression tests.
Add build, test, and package smoke-test workflows beyond documentation CI.
Resolve public-header and documentation maintenance debt.
Complete the core shape-transformation API.
Establish foundational linear algebra operations before larger numerical modules.

Phases

Phase 1: Core Infrastructure

Buffer

Shape

Row-major stride metadata through Shape::strides()

Slice descriptors

Numeric types and concepts

Exception hierarchy

Configuration constants

Shape, dimension, index, and type validation

Phase 2: Containers

Vector

Matrix

Tensor

Contiguous owning storage

Negative indexing

Copy-based slicing

Creation helpers

Conversion helpers

Phase 3: Generic Operators

Same-shape arithmetic

Array-scalar and scalar-array arithmetic

Broadcasted array arithmetic

Compound and unary arithmetic

Equality and inequality comparison

Index offset calculation

Slicing operations

Integral bitwise operators
Logical operators

Element-wise ordering comparisons

Explicit mixed-value-type promotion policy

Phase 4: Broadcasting

Trailing-dimension compatibility validation

Broadcasted result-shape calculation

Singleton-dimension index projection

Array-array operation dispatch

Array-scalar and scalar-array dispatch

Arithmetic integration

C++ unit coverage

Developer documentation
Python-specific broadcasting tests

Broadcasting behavior documented in the user and Python API guides
Optimized contiguous and repeated-block kernels

Mixed container or result-type policy

Phase 5: Shape Operations

reshape

flatten
ravel

squeeze

expand_dims

transpose

swapaxes

permute_axes

Non-owning views

Phase 6: Reductions

sum

prod

min and max

argmin and argmax

mean

variance and standard deviation

Axis reductions

Negative-axis normalization

keepdims support

C++ and Python bindings

C++ and Python tests

Phase 7: Linear Algebra

Matrix multiplication

Dot product

Cross product

Norms

Determinant

Inverse

Linear solve

LU decomposition

QR decomposition

Cholesky decomposition

Singular value decomposition

Eigenvalues and eigenvectors

Phase 8: Input and Output

Stream printing
CSV I/O

Binary I/O

Serialization policy

Phase 9: Python Bindings

_core extension module

Shape, Vector, Matrix, and Tensor exports

Arithmetic and comparison bindings

Creation helpers

Conversion helpers

Reduction helpers

Negative indexing and copy-based slicing

Reshape and flatten methods

Single public typing stub
Bitwise operator bindings

Python broadcasting regression tests

Package import smoke test in CI

Wheel smoke tests for supported Python versions

Phase 10: C++ Public Facade

Top-level aliases for common array types

Top-level aliases for common algorithms

Module-style creation, conversion, reduction, transform, and slicing namespaces

Broadcasting helpers and grouped namespace

Public exception aliases
Remove duplicated umbrella-header declarations

Add dedicated namespaces as linear algebra, random, statistics, FFT, and I/O land

Phase 11: Testing and CI

C++ unit tests

Python unit tests

Dedicated broadcasting test suite

Documentation check workflow

Documentation deployment workflow

Markdown link checking in CI
C++ build-and-test workflow

Python build-and-test workflow

Windows, Linux, and macOS build matrix

Sanitizer jobs

Release and package smoke tests

Phase 12: Documentation and Examples

Developer docs for implemented core files

Developer docs for containers, algorithms, and operations

Broadcasting developer guide

User guide

Python API reference

C++ and Python examples

Troubleshooting guide

Release checklist

Update README feature/status tables for broadcasting

Update user and Python guides for broadcasting
Refresh architecture documentation to match the current source layout

Complete generated C++ API reference coverage

README badges

Later Numerical Phases

Random number generation and distributions

Statistics

FFT

Calculus

Optimization

Automatic differentiation

Backend and Storage Exploration

SIMD kernels

Multithreaded execution policy

Sparse arrays

GPU backend

Memory-mapped storage

Validation Notes

Checked items represent behavior found in the current public headers and tests.
Broadcasting currently applies to arithmetic; comparison remains exact and shape-sensitive.
Python containers expose double specializations of the C++ containers.
Slicing and reshape return owning results; non-owning views are not implemented.
Empty and zero-dimension behavior has targeted coverage in implemented containers and operations.
Documentation CI exists, but code build/test CI is still pending.

Maintenance Debt

Deduplicate the repeated stratax facade block in include/stratax.h.

Reconcile README, user-guide, and Python-reference broadcasting claims with the implementation.
Refresh architecture notes that still describe validation and Python bindings as future work.

Add Python broadcasting tests before treating cross-language broadcasting as fully verified.

Keep CMake, package, and documented version metadata synchronized for each release.

Implementation Principles

Preserve container storage and shape invariants before adding optimized paths.
Keep generic behavior shared across Vector, Matrix, and Tensor.
Pair each new public feature with focused tests and user-facing documentation.
Prefer clear ownership semantics before introducing views or lazy expressions.
Establish portable build/test CI before expanding the supported backend matrix.