matten 0.2.0

A family car multidimensional array (tensor) library for small numerical trials / PoCs.
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

//! Integration smoke tests: exercise the public crate surface as a user would.

use matten::{MattenError, Tensor};

#[test]
fn public_construction_and_inspection() {
    let t = Tensor::new(vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0], &[2, 3]);
    assert_eq!(t.shape(), &[2, 3]);
    assert_eq!(t.len(), 6);
    assert_eq!(t.ndim(), 2);
}

#[test]
fn boundary_construction_is_recoverable() {
    let result = Tensor::try_new(vec![1.0, 2.0], &[3]);
    assert!(matches!(result, Err(MattenError::Shape { .. })));
}

#[test]
fn fill_constructors_are_public() {
    let z = Tensor::zeros(&[3, 3]);
    let o = Tensor::ones(&[3, 3]);
    let f = Tensor::full(&[3, 3], 2.0);
    assert_eq!(z.len(), 9);
    assert_eq!(o.len(), 9);
    assert_eq!(f.len(), 9);
    assert!(o.as_slice().iter().all(|&v| v == 1.0));
}

#[test]
fn from_and_into_roundtrip() {
    let original = vec![1.0_f64, 2.0, 3.0, 4.0];
    let t: Tensor = original.clone().into();
    let back: Vec<f64> = t.into();
    assert_eq!(back, original);
}

#[test]
fn nested_row_construction() {
    let t: Tensor = vec![vec![1.0, 2.0], vec![3.0, 4.0]].into();
    assert_eq!(t.shape(), &[2, 2]);
    let rows: Vec<Vec<f64>> = t.try_into().unwrap();
    assert_eq!(rows[0], &[1.0, 2.0]);
    assert_eq!(rows[1], &[3.0, 4.0]);
}

#[test]
fn arange_basic() {
    let t = Tensor::arange(0.0, 3.0, 1.0);
    assert_eq!(t.as_slice(), &[0.0, 1.0, 2.0]);
}

#[test]
fn try_arange_bad_step() {
    assert!(Tensor::try_arange(0.0, 5.0, 0.0).is_err());
}