matten 0.45.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
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Tests for the RFC-038 selection reductions (`argmin`/`argmax`).
//!
//! These validate the design spec: flat row-major index, first-occurrence tie-break,
//! and the NaN/dynamic policy (selection branch → `InvalidArgument`/panic on NaN).

use crate::Tensor;

#[test]
fn argmin_argmax_basic() {
    let t = Tensor::from_vec(vec![3.0, 1.0, 5.0, 2.0]);
    assert_eq!(t.argmin(), 1);
    assert_eq!(t.argmax(), 2);
}

#[test]
fn ties_return_first_occurrence() {
    assert_eq!(Tensor::from_vec(vec![1.0, 1.0, 3.0]).argmin(), 0);
    assert_eq!(Tensor::from_vec(vec![5.0, 5.0, 2.0]).argmax(), 0);
}

#[test]
fn index_is_flat_row_major() {
    // 2x3; smallest (0.0) at flat index 4, largest (9.0) at flat index 1.
    let t = Tensor::new(vec![2.0, 9.0, 3.0, 1.0, 0.0, 4.0], &[2, 3]);
    assert_eq!(t.argmin(), 4);
    assert_eq!(t.argmax(), 1);
}

#[test]
fn scalar_returns_zero() {
    assert_eq!(Tensor::scalar(7.0).argmin(), 0);
    assert_eq!(Tensor::scalar(7.0).argmax(), 0);
}

#[test]
fn try_forms_reject_nan() {
    let t = Tensor::from_vec(vec![1.0, f64::NAN, 3.0]);
    assert!(matches!(
        t.try_argmin().unwrap_err(),
        crate::MattenError::InvalidArgument {
            operation: "argmin",
            ..
        }
    ));
    assert!(matches!(
        t.try_argmax().unwrap_err(),
        crate::MattenError::InvalidArgument {
            operation: "argmax",
            ..
        }
    ));
}

#[test]
#[should_panic(expected = "undefined for tensors containing NaN")]
fn argmin_panics_on_nan() {
    let _ = Tensor::from_vec(vec![1.0, f64::NAN]).argmin();
}

// ── empty-tensor semantics (RFC-105) ─────────────────────────────────────
//
// Before this RFC, argmin/argmax on an empty tensor panicked with a raw
// Rust slice index error ("index out of bounds: the len is 0 but the index
// is 0"), not a matten error -- defeating the try_ form entirely. The
// fixture MUST be reached via slicing; no constructor accepts a zero-sized
// dimension.

fn empty_2x3() -> Tensor {
    Tensor::new(vec![1., 2., 3., 4., 5., 6.], &[2, 3])
        .slice()
        .range(0..0)
        .all()
        .build()
        .unwrap()
}

#[test]
fn try_argmin_argmax_are_err_on_empty() {
    let t = empty_2x3();

    let err = t.try_argmin().unwrap_err();
    assert!(matches!(
        err,
        crate::MattenError::InvalidArgument {
            operation: "argmin",
            ..
        }
    ));
    assert_eq!(
        err.to_string(),
        "matten invalid argument error in argmin: self: argmin is undefined for an empty tensor"
    );

    let err = t.try_argmax().unwrap_err();
    assert!(matches!(
        err,
        crate::MattenError::InvalidArgument {
            operation: "argmax",
            ..
        }
    ));
    assert_eq!(
        err.to_string(),
        "matten invalid argument error in argmax: self: argmax is undefined for an empty tensor"
    );
}

// The captured message is asserted, not merely that a panic occurred --
// the defect was WHICH panic: a raw index panic versus a diagnosis.
#[test]
#[should_panic(expected = "argmin is undefined for an empty tensor")]
fn argmin_panics_with_the_sentence_on_empty_not_an_index_panic() {
    let _ = empty_2x3().argmin();
}

#[test]
#[should_panic(expected = "argmax is undefined for an empty tensor")]
fn argmax_panics_with_the_sentence_on_empty_not_an_index_panic() {
    let _ = empty_2x3().argmax();
}

// ── dynamic rejection ──────────────────────────────────────────────────────

#[cfg(feature = "dynamic")]
mod dynamic_rejection {
    use crate::Tensor;
    use crate::dynamic::Element;

    fn dyn1() -> Tensor {
        Tensor::from_elements(vec![Element::Int(1), Element::Int(2)], &[2])
    }

    #[test]
    fn argmax_panics_on_dynamic() {
        assert!(std::panic::catch_unwind(|| dyn1().argmax()).is_err());
    }

    #[test]
    fn try_argmin_unsupported_on_dynamic() {
        assert!(matches!(
            dyn1().try_argmin().unwrap_err(),
            crate::MattenError::Unsupported {
                operation: "argmin",
                ..
            }
        ));
    }
}