From b687fd4e6b3b3828de3700f4cd9d042b1351df05 Mon Sep 17 00:00:00 2001
From: Palash Tyagi <23239946+Magnus167@users.noreply.github.com>
Date: Mon, 4 Aug 2025 19:21:36 +0100
Subject: [PATCH] Add advanced matrix operations and Gaussian Naive Bayes
 examples to documentation

---
 docs/src/compute.md           | 92 +++++++++++++++++++++++++++++++++--
 docs/src/data-manipulation.md | 58 ++++++++++++++++++++++
 docs/src/machine-learning.md  | 70 ++++++++++++++++++++++++++
 3 files changed, 216 insertions(+), 4 deletions(-)

diff --git a/docs/src/compute.md b/docs/src/compute.md
index 6c5e34c..90bdd9c 100644
--- a/docs/src/compute.md
+++ b/docs/src/compute.md
@@ -8,16 +8,51 @@ some basic inferential tests.
 
 ```rust
 # extern crate rustframe;
-use rustframe::compute::stats::{mean, mean_vertical, stddev, median};
+use rustframe::compute::stats::{mean, mean_horizontal, mean_vertical, stddev, median, population_variance, percentile};
 use rustframe::matrix::Matrix;
 
 let m = Matrix::from_vec(vec![1.0, 2.0, 3.0, 4.0], 2, 2);
 assert_eq!(mean(&m), 2.5);
 assert_eq!(stddev(&m), 1.118033988749895);
 assert_eq!(median(&m), 2.5);
+assert_eq!(population_variance(&m), 1.25);
+assert_eq!(percentile(&m, 50.0), 3.0);
 // column averages returned as 1 x n matrix
+let row_means = mean_horizontal(&m);
+assert_eq!(row_means.data(), &[2.0, 3.0]);
 let col_means = mean_vertical(&m);
-assert_eq!(col_means.data(), &[1.5, 3.5]);
+assert_eq!(col_means.data(), & [1.5, 3.5]);
+```
+
+### Axis-specific Operations
+
+Operations can be applied along specific axes (rows or columns):
+
+```rust
+# extern crate rustframe;
+use rustframe::compute::stats::{mean_vertical, mean_horizontal, stddev_vertical, stddev_horizontal};
+use rustframe::matrix::Matrix;
+
+// 3x2 matrix
+let m = Matrix::from_rows_vec(vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0], 3, 2);
+
+// Mean along columns (vertical) - returns 1 x cols matrix
+let col_means = mean_vertical(&m);
+assert_eq!(col_means.shape(), (1, 2));
+assert_eq!(col_means.data(), &[3.0, 4.0]); // [(1+3+5)/3, (2+4+6)/3]
+
+// Mean along rows (horizontal) - returns rows x 1 matrix
+let row_means = mean_horizontal(&m);
+assert_eq!(row_means.shape(), (3, 1));
+assert_eq!(row_means.data(), &[1.5, 3.5, 5.5]); // [(1+2)/2, (3+4)/2, (5+6)/2]
+
+// Standard deviation along columns
+let col_stddev = stddev_vertical(&m);
+assert_eq!(col_stddev.shape(), (1, 2));
+
+// Standard deviation along rows
+let row_stddev = stddev_horizontal(&m);
+assert_eq!(row_stddev.shape(), (3, 1));
 ```
 
 ## Correlation
@@ -49,18 +84,67 @@ let pdf = normal_pdf(x, 0.0, 1.0);
 assert_eq!(pdf.data().len(), 2);
 ```
 
-### More Compute Examples
+### Additional Distributions
+
+Rustframe provides several other probability distributions:
+
+```rust
+# extern crate rustframe;
+use rustframe::compute::stats::distributions::{normal_cdf, binomial_pmf, binomial_cdf, poisson_pmf};
+use rustframe::matrix::Matrix;
+
+// Normal distribution CDF
+let x = Matrix::from_vec(vec![0.0, 1.0], 1, 2);
+let cdf = normal_cdf(x, 0.0, 1.0);
+assert_eq!(cdf.data().len(), 2);
+
+// Binomial distribution PMF
+// Probability of k successes in n trials with probability p
+let k = Matrix::from_vec(vec![0_u64, 1, 2, 3], 1, 4);
+let pmf = binomial_pmf(3, k.clone(), 0.5);
+assert_eq!(pmf.data().len(), 4);
+
+// Binomial distribution CDF
+let cdf = binomial_cdf(3, k, 0.5);
+assert_eq!(cdf.data().len(), 4);
+
+// Poisson distribution PMF
+// Probability of k events with rate parameter lambda
+let k = Matrix::from_vec(vec![0_u64, 1, 2], 1, 3);
+let pmf = poisson_pmf(2.0, k);
+assert_eq!(pmf.data().len(), 3);
+```
+
+### Inferential Statistics
+
+Rustframe provides several inferential statistical tests:
 
 ```rust
 # extern crate rustframe;
 use rustframe::matrix::Matrix;
-use rustframe::compute::stats::inferential::t_test;
+use rustframe::compute::stats::inferential::{t_test, chi2_test, anova};
 
+// Two-sample t-test
 let sample1 = Matrix::from_vec(vec![1.0, 2.0, 3.0, 4.0, 5.0], 1, 5);
 let sample2 = Matrix::from_vec(vec![6.0, 7.0, 8.0, 9.0, 10.0], 1, 5);
 let (t_statistic, p_value) = t_test(&sample1, &sample2);
 assert!((t_statistic + 5.0).abs() < 1e-5);
 assert!(p_value > 0.0 && p_value < 1.0);
+
+// Chi-square test of independence
+let observed = Matrix::from_vec(vec![12.0, 5.0, 8.0, 10.0], 2, 2);
+let (chi2_statistic, p_value) = chi2_test(&observed);
+assert!(chi2_statistic > 0.0);
+assert!(p_value > 0.0 && p_value < 1.0);
+
+// One-way ANOVA
+let group1 = Matrix::from_vec(vec![1.0, 2.0, 3.0], 1, 3);
+let group2 = Matrix::from_vec(vec![2.0, 3.0, 4.0], 1, 3);
+let group3 = Matrix::from_vec(vec![3.0, 4.0, 5.0], 1, 3);
+let groups = vec![&group1, &group2, &group3];
+let (f_statistic, p_value) = anova(groups);
+assert!(f_statistic > 0.0);
+assert!(p_value > 0.0 && p_value < 1.0);
 ```
 
 With the basics covered, explore predictive models in the
diff --git a/docs/src/data-manipulation.md b/docs/src/data-manipulation.md
index 7264b62..31f91c9 100644
--- a/docs/src/data-manipulation.md
+++ b/docs/src/data-manipulation.md
@@ -95,5 +95,63 @@ let equals = data1 == data1.clone();
 assert_eq!(equals, true);
 ```
 
+### Advanced Matrix Operations
+
+Matrices support a variety of advanced operations:
+
+```rust
+# extern crate rustframe;
+use rustframe::matrix::{Matrix, SeriesOps};
+
+// Matrix multiplication (dot product)
+let a = Matrix::from_vec(vec![1.0, 2.0, 3.0, 4.0], 2, 2);
+let b = Matrix::from_vec(vec![5.0, 6.0, 7.0, 8.0], 2, 2);
+let product = a.matrix_mul(&b);
+assert_eq!(product.data(), vec![23.0, 34.0, 31.0, 46.0]);
+
+// Transpose
+let m = Matrix::from_vec(vec![1.0, 2.0, 3.0, 4.0], 2, 2);
+let transposed = m.transpose();
+assert_eq!(transposed.data(), vec![1.0, 3.0, 2.0, 4.0]);
+
+// Map function over all elements
+let m = Matrix::from_vec(vec![1.0, 2.0, 3.0, 4.0], 2, 2);
+let squared = m.map(|x| x * x);
+assert_eq!(squared.data(), vec![1.0, 4.0, 9.0, 16.0]);
+
+// Zip two matrices with a function
+let a = Matrix::from_vec(vec![1.0, 2.0, 3.0, 4.0], 2, 2);
+let b = Matrix::from_vec(vec![5.0, 6.0, 7.0, 8.0], 2, 2);
+let zipped = a.zip(&b, |x, y| x + y);
+assert_eq!(zipped.data(), vec![6.0, 8.0, 10.0, 12.0]);
+```
+
+### Matrix Reductions
+
+Matrices support various reduction operations:
+
+```rust
+# extern crate rustframe;
+use rustframe::matrix::{Matrix, SeriesOps};
+
+let m = Matrix::from_rows_vec(vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0], 3, 2);
+
+// Sum along columns (vertical)
+let col_sums = m.sum_vertical();
+assert_eq!(col_sums, vec![9.0, 12.0]); // [1+3+5, 2+4+6]
+
+// Sum along rows (horizontal)
+let row_sums = m.sum_horizontal();
+assert_eq!(row_sums, vec![3.0, 7.0, 11.0]); // [1+2, 3+4, 5+6]
+
+// Cumulative sum along columns
+let col_cumsum = m.cumsum_vertical();
+assert_eq!(col_cumsum.data(), vec![1.0, 4.0, 9.0, 2.0, 6.0, 12.0]);
+
+// Cumulative sum along rows
+let row_cumsum = m.cumsum_horizontal();
+assert_eq!(row_cumsum.data(), vec![1.0, 3.0, 5.0, 3.0, 7.0, 11.0]);
+```
+
 With the basics covered, continue to the [compute features](./compute.md)
 chapter for statistics and analytics.
diff --git a/docs/src/machine-learning.md b/docs/src/machine-learning.md
index ccbec53..b245b6e 100644
--- a/docs/src/machine-learning.md
+++ b/docs/src/machine-learning.md
@@ -72,5 +72,75 @@ let transformed = pca.transform(&data);
 assert_eq!(transformed.cols(), 1);
 ```
 
+### Gaussian Naive Bayes
+
+Gaussian Naive Bayes classifier for continuous features:
+
+```rust
+# extern crate rustframe;
+use rustframe::compute::models::gaussian_nb::GaussianNB;
+use rustframe::matrix::Matrix;
+
+// Training data with 2 features
+let x = Matrix::from_rows_vec(vec![
+    1.0, 2.0,
+    2.0, 3.0,
+    3.0, 4.0,
+    4.0, 5.0
+], 4, 2);
+
+// Class labels (0 or 1)
+let y = Matrix::from_vec(vec![0.0, 0.0, 1.0, 1.0], 4, 1);
+
+// Train the model
+let mut model = GaussianNB::new(1e-9, true);
+model.fit(&x, &y);
+
+// Make predictions
+let predictions = model.predict(&x);
+assert_eq!(predictions.rows(), 4);
+```
+
+### Dense Neural Networks
+
+Simple fully connected neural network:
+
+```rust
+# extern crate rustframe;
+use rustframe::compute::models::dense_nn::{DenseNN, DenseNNConfig, ActivationKind, InitializerKind, LossKind};
+use rustframe::matrix::Matrix;
+
+// Training data with 2 features
+let x = Matrix::from_rows_vec(vec![
+    0.0, 0.0,
+    0.0, 1.0,
+    1.0, 0.0,
+    1.0, 1.0
+], 4, 2);
+
+// XOR target outputs
+let y = Matrix::from_vec(vec![0.0, 1.0, 1.0, 0.0], 4, 1);
+
+// Create a neural network with 2 hidden layers
+let config = DenseNNConfig {
+    input_size: 2,
+    hidden_layers: vec![4, 4],
+    output_size: 1,
+    activations: vec![ActivationKind::Sigmoid, ActivationKind::Sigmoid, ActivationKind::Sigmoid],
+    initializer: InitializerKind::Uniform(0.5),
+    loss: LossKind::MSE,
+    learning_rate: 0.1,
+    epochs: 1000,
+};
+let mut model = DenseNN::new(config);
+
+// Train the model
+model.train(&x, &y);
+
+// Make predictions
+let predictions = model.predict(&x);
+assert_eq!(predictions.rows(), 4);
+```
+
 For helper functions and upcoming modules, visit the
 [utilities](./utilities.md) section.