tensors-rs 0.1.2

Compact NumPy-like dense tensor primitives for safe numerical Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

//! Compact dense tensor primitives for numerical algorithms.
//!
//! The crate intentionally starts with a small surface area: row-major owned
//! arrays, cheap strided views, checked shape errors, scalar kernels, and
//! matrix primitives that can later delegate to accelerated backends.
//!
//! # Examples
//!
//! Matrix slicing and multiplication:
//!
//! ```
//! use tensors::{Array2, matmul};
//!
//! let a = Array2::from_vec([2, 3], vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0])?;
//! let gram = matmul(a.transpose_view(), a.view())?;
//!
//! assert_eq!(gram.shape(), [3, 3]);
//! assert_eq!(gram[(0, 0)], 17.0);
//! # Ok::<(), tensors::Error>(())
//! ```
//!
//! Lazy preprocessing for PCA-style workflows:
//!
//! ```
//! use tensors::{Array2, LinearOperator, StandardizedOperator, column_means, column_variances};
//!
//! let a = Array2::from_vec([3, 2], vec![1.0, 2.0, 3.0, 6.0, 5.0, 10.0])?;
//! let means = column_means(a.view());
//! let scales = column_variances(a.view(), &means)?
//!     .into_iter()
//!     .map(f64::sqrt)
//!     .collect::<Vec<_>>();
//! let standardized = StandardizedOperator::new(a, means, scales);
//!
//! let mut y = [0.0; 3];
//! standardized.matvec(&[1.0, -1.0], &mut y)?;
//! assert_eq!(y.len(), 3);
//! # Ok::<(), tensors::Error>(())
//! ```
//!
//! Randomized SVD on a dense matrix:
//!
//! ```
//! use tensors::{Array2, RandomizedSvdOptions, randomized_svd};
//!
//! let a = Array2::from_vec([3, 2], vec![3.0, 0.0, 4.0, 0.0, 0.0, 0.0])?;
//! let result = randomized_svd(
//!     &a,
//!     RandomizedSvdOptions {
//!         rank: 1,
//!         oversampling: 1,
//!         power_iterations: 1,
//!         seed: Some(7),
//!         ..RandomizedSvdOptions::default()
//!     },
//! )?;
//!
//! assert_eq!(result.s.len(), 1);
//! # Ok::<(), tensors::Error>(())
//! ```

#![warn(missing_docs)]

mod array2;
mod array3;
mod arrayn;
mod error;
mod linalg;
mod numeric;
mod preprocessing;
mod rand;
mod sparse;
mod view2;
mod view3;
mod workspace;

pub use array2::Array2;
pub use array3::{Array3, Axis3, fold_view, unfold_view};
pub use arrayn::{ArrayN, ArrayViewMutN, ArrayViewN};
pub use error::{Error, Result};
pub use linalg::{
    CenteredOperator, ColumnScaledOperator, EighResult, LinearOperator, QrResult,
    RandomizedSvdOptions, RowScaledOperator, StandardizedOperator, SvdResult, Transpose,
    approx_reconstruction_error, axpy, axpy_f32, axpy_f64, batch_randomized_svd,
    batch_randomized_svd_parallel, dot, dot_f32, dot_f64, eigh_small, explained_variance_ratio,
    gemm, gemm_with_workspace, matmul, norm_l2, norm_l2_f32, norm_l2_f64, pack_block, qr,
    randomized_range_finder, randomized_svd, randomized_svd_with_error, reorthogonalize, svd_small,
    thin_qr, unpack_block,
};
pub use numeric::Float;
pub use preprocessing::{
    center_columns_inplace, center_rows_inplace, centered_columns, centered_rows, column_means,
    column_variances, row_means, row_variances, scale_columns_inplace, scale_rows_inplace,
    standardize_columns_inplace, standardize_rows_inplace,
};
pub use sparse::CsrMatrix;
pub use view2::{ArrayView2, ArrayViewMut2};
pub use view3::{ArrayView3, ArrayViewMut3};
pub use workspace::{ScratchBuffer, Workspace};