Struct MatrixBuilder 

pub struct MatrixBuilder<T>(/* private fields */);

Fluent builder for two-dimensional matrices.

All methods are associated functions (no new() required), making them trivially discoverable via IDE autocomplete when typing MatrixBuilder::.

Type Parameter

T must be numeric. Common choices: f64, f32, i32, i64, u64.

Examples

use scirs2_core::builders::MatrixBuilder;

// Identity matrix
let eye = MatrixBuilder::<f64>::eye(3);
assert_eq!(eye[[0, 0]], 1.0);
assert_eq!(eye[[0, 1]], 0.0);

// Zeros / ones
let z = MatrixBuilder::<f64>::zeros(2, 3);
let o = MatrixBuilder::<f64>::ones(2, 3);

// From closure — computed element-by-element
let computed = MatrixBuilder::from_fn(3, 3, |r, c| (r * 3 + c) as f64);
assert_eq!(computed[[1, 2]], 5.0);

Implementations

impl<T> MatrixBuilder<T>

where T: Clone + Zero,

pub fn zeros(rows: usize, cols: usize) -> Array2<T>

Create a matrix of all zeros with shape (rows, cols).

use scirs2_core::builders::MatrixBuilder;

let m = MatrixBuilder::<f64>::zeros(3, 4);
assert_eq!(m.shape(), &[3, 4]);
assert_eq!(m[[0, 0]], 0.0);

pub fn from_vec(data: Vec<T>, rows: usize, cols: usize) -> CoreResult<Array2<T>>

Build a matrix from a flat Vec of elements in row-major order.

Returns an error if the number of elements does not match rows * cols.

use scirs2_core::builders::MatrixBuilder;

let m = MatrixBuilder::from_vec(vec![1.0f64, 2.0, 3.0, 4.0], 2, 2)
    .expect("element count matches");
assert_eq!(m[[0, 0]], 1.0);
assert_eq!(m[[1, 1]], 4.0);

impl<T> MatrixBuilder<T>

where T: Clone + Zero + One,

pub fn eye(n: usize) -> Array2<T>

Create a square identity matrix of size n × n.

use scirs2_core::builders::MatrixBuilder;

let eye = MatrixBuilder::<f64>::eye(3);
assert_eq!(eye[[2, 2]], 1.0);
assert_eq!(eye[[0, 1]], 0.0);

pub fn ones(rows: usize, cols: usize) -> Array2<T>

Create a matrix of all ones with shape (rows, cols).

use scirs2_core::builders::MatrixBuilder;

let m = MatrixBuilder::<f64>::ones(2, 3);
assert_eq!(m[[1, 2]], 1.0);

impl<T> MatrixBuilder<T>

where T: Clone,

pub fn full(rows: usize, cols: usize, value: T) -> Array2<T>

Create a matrix filled with a single constant value.

use scirs2_core::builders::MatrixBuilder;

let m = MatrixBuilder::full(3, 3, 7_i32);
assert_eq!(m[[0, 0]], 7);
assert_eq!(m[[2, 2]], 7);

pub fn from_fn<F>(rows: usize, cols: usize, f: F) -> Array2<T>

where F: FnMut(usize, usize) -> T,

Create a matrix where each element is produced by calling f(row, col).

use scirs2_core::builders::MatrixBuilder;

let m = MatrixBuilder::from_fn(3, 3, |r, c| (r * 3 + c) as f64);
assert_eq!(m[[0, 0]], 0.0);
assert_eq!(m[[2, 2]], 8.0);

impl<T> MatrixBuilder<T>

where T: Float + Clone,

pub fn rand(rows: usize, cols: usize, seed: u64) -> Array2<T>

Create a matrix populated with uniform random values in [0, 1) using a seeded ChaCha8 RNG for reproducibility.

The seed parameter lets callers produce deterministic results in tests and benchmarks while still getting varied values in production by passing different seeds.

use scirs2_core::builders::MatrixBuilder;

let m = MatrixBuilder::<f64>::rand(3, 3, 42);
assert_eq!(m.shape(), &[3, 3]);
// All values should be in [0, 1)
assert!(m.iter().all(|&v| v >= 0.0 && v < 1.0));

pub fn randn(rows: usize, cols: usize, seed: u64) -> Array2<T>

Create a matrix populated with standard normal (N(0, 1)) random values.

use scirs2_core::builders::MatrixBuilder;

let m = MatrixBuilder::<f64>::randn(4, 4, 0);
assert_eq!(m.shape(), &[4, 4]);