Struct VectorBuilder 

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

Fluent builder for one-dimensional arrays (vectors).

Provides NumPy-like constructors (linspace, arange, logspace) as well as the standard zeros, ones, from_vec, and from_fn constructors.

Examples

use scirs2_core::builders::VectorBuilder;

let v = VectorBuilder::<f64>::linspace(0.0, 1.0, 5);
assert!((v[0] - 0.0).abs() < 1e-12);
assert!((v[4] - 1.0).abs() < 1e-12);

let r = VectorBuilder::<f64>::arange(0.0, 5.0, 1.0);
assert_eq!(r.len(), 5);

Implementations

impl<T> VectorBuilder<T>

where T: Clone + Zero,

pub fn zeros(n: usize) -> Array1<T>

Create a vector of all zeros with n elements.

use scirs2_core::builders::VectorBuilder;

let v = VectorBuilder::<f64>::zeros(5);
assert_eq!(v.len(), 5);
assert_eq!(v[3], 0.0);

pub fn from_vec(data: Vec<T>) -> Array1<T>

Build a vector from a Vec.

use scirs2_core::builders::VectorBuilder;

let v = VectorBuilder::from_vec(vec![1.0_f64, 2.0, 3.0]);
assert_eq!(v[1], 2.0);

impl<T> VectorBuilder<T>

where T: Clone + Zero + One,

pub fn ones(n: usize) -> Array1<T>

Create a vector of all ones with n elements.

use scirs2_core::builders::VectorBuilder;

let v = VectorBuilder::<f64>::ones(4);
assert_eq!(v[2], 1.0);

impl<T> VectorBuilder<T>

where T: Clone,

pub fn from_fn<F>(n: usize, f: F) -> Array1<T>

where F: FnMut(usize) -> T,

Create a vector where element i is produced by f(i).

use scirs2_core::builders::VectorBuilder;

let squares = VectorBuilder::from_fn(5, |i| (i * i) as f64);
assert_eq!(squares[3], 9.0);

pub fn full(n: usize, value: T) -> Array1<T>

Create a vector filled with a constant value.

use scirs2_core::builders::VectorBuilder;

let v = VectorBuilder::full(3, 7_i32);
assert_eq!(v[0], 7);

impl<T> VectorBuilder<T>

where T: Float + Display + Clone + MulAssign,

pub fn linspace(start: T, stop: T, n: usize) -> Array1<T>

Create n evenly spaced values from start to stop (inclusive).

This is the analogue of NumPy’s np.linspace.

use scirs2_core::builders::VectorBuilder;

let v = VectorBuilder::<f64>::linspace(0.0, 4.0, 5);
assert!((v[0] - 0.0).abs() < 1e-12);
assert!((v[2] - 2.0).abs() < 1e-12);
assert!((v[4] - 4.0).abs() < 1e-12);

pub fn arange(start: T, stop: T, step: T) -> Array1<T>

Create values from start up to (but not including) stop with step step.

This is the analogue of NumPy’s np.arange.

use scirs2_core::builders::VectorBuilder;

let v = VectorBuilder::<f64>::arange(0.0, 5.0, 1.0);
assert_eq!(v.len(), 5);
assert!((v[0] - 0.0).abs() < 1e-12);
assert!((v[4] - 4.0).abs() < 1e-12);

// Fractional step
let v2 = VectorBuilder::<f64>::arange(0.0, 1.0, 0.5);
assert_eq!(v2.len(), 2);

pub fn logspace(start: T, stop: T, n: usize) -> Array1<T>

Create n values evenly spaced on a logarithmic scale.

The values span from 10^start to 10^stop (inclusive), analogous to NumPy’s np.logspace(start, stop, n, base=10).

use scirs2_core::builders::VectorBuilder;

// 4 values from 10^0 = 1 to 10^3 = 1000
let v = VectorBuilder::<f64>::logspace(0.0, 3.0, 4);
assert!((v[0] - 1.0).abs() < 1e-10);
assert!((v[3] - 1000.0).abs() < 1e-8);

pub fn rand(n: usize, seed: u64) -> Array1<T>

Create n uniform random values in [0, 1) using a seeded ChaCha8 RNG.

use scirs2_core::builders::VectorBuilder;

let v = VectorBuilder::<f64>::rand(5, 42);
assert_eq!(v.len(), 5);
assert!(v.iter().all(|&x| x >= 0.0 && x < 1.0));

pub fn randn(n: usize, seed: u64) -> Array1<T>

Create n standard-normal random values using a seeded ChaCha8 RNG.

use scirs2_core::builders::VectorBuilder;

let v = VectorBuilder::<f64>::randn(5, 0);
assert_eq!(v.len(), 5);