Skip to main content

mathverse_ai/
tensor.rs

1//! N-dimensional tensor with row-major layout, broadcasting, and math ops.
2
3use std::fmt;
4use mathverse_core::error::{MathError, MathResult};
5
6/// N-dimensional tensor with row-major (C-contiguous) data.
7#[derive(Debug, Clone, PartialEq)]
8pub struct Tensor {
9    /// Tensor shape in row-major order.
10    pub shape: Vec<usize>,
11    /// Flat row-major data buffer.
12    pub data: Vec<f64>,
13}
14
15impl fmt::Display for Tensor {
16    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
17        write!(f, "Tensor(shape={:?}, numel={}, ", self.shape, self.data.len())?;
18        if self.data.len() <= 8 {
19            write!(f, "data={:?})", self.data)?;
20        } else {
21            let min = self.data.iter().cloned().fold(f64::INFINITY, f64::min);
22            let max = self.data.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
23            let mean = self.data.iter().sum::<f64>() / self.data.len() as f64;
24            write!(f, "min={:.4}, max={:.4}, mean={:.4}, first5={:?})", min, max, mean, &self.data[..5])?;
25        }
26        Ok(())
27    }
28}
29
30/// Advance an xorshift64 state; return uniform in [0, 1).
31fn xorshift(state: &mut u64) -> f64 {
32    let mut x = *state;
33    if x == 0 { x = 0xDEAD_BEEF_CAFE_1234; }
34    x ^= x << 13;
35    x ^= x >> 7;
36    x ^= x << 17;
37    *state = x;
38    (x as f64) / (u64::MAX as f64).max(1e-30)
39}
40
41impl Tensor {
42    // -----------------------------------------------------------------------
43    // Constructors
44    // -----------------------------------------------------------------------
45
46    /// Create a tensor from shape + data. Validates numel matches.
47    pub fn new(shape: &[usize], data: &[f64]) -> MathResult<Self> {
48        let numel: usize = shape.iter().product();
49        if data.len() != numel {
50            return Err(MathError::DimensionMismatch);
51        }
52        Ok(Self { shape: shape.to_vec(), data: data.to_vec() })
53    }
54
55    /// Create from shape + owned data.
56    pub fn from_vec(shape: &[usize], data: Vec<f64>) -> MathResult<Self> {
57        let numel: usize = shape.iter().product();
58        if data.len() != numel {
59            return Err(MathError::DimensionMismatch);
60        }
61        Ok(Self { shape: shape.to_vec(), data })
62    }
63
64    /// Zero-filled tensor.
65    pub fn zeros(shape: &[usize]) -> Self {
66        let numel: usize = shape.iter().product();
67        Self { shape: shape.to_vec(), data: vec![0.0; numel] }
68    }
69
70    /// One-filled tensor.
71    pub fn ones(shape: &[usize]) -> Self {
72        let numel: usize = shape.iter().product();
73        Self { shape: shape.to_vec(), data: vec![1.0; numel] }
74    }
75
76    /// Fill with a constant value.
77    pub fn full(shape: &[usize], val: f64) -> Self {
78        let numel: usize = shape.iter().product();
79        Self { shape: shape.to_vec(), data: vec![val; numel] }
80    }
81
82    /// 0-dimensional scalar.
83    pub fn scalar(val: f64) -> Self {
84        Self { shape: vec![], data: vec![val] }
85    }
86
87    /// 1-D range: [start, stop) with step. Negative steps are supported.
88    pub fn arange(start: f64, stop: f64, step: f64) -> MathResult<Self> {
89        if step == 0.0 {
90            return Err(MathError::InvalidArgument("arange: step must be non-zero"));
91        }
92        let mut data = Vec::new();
93        let mut v = start;
94        if step > 0.0 {
95            while v < stop {
96                data.push(v);
97                v += step;
98            }
99        } else {
100            while v > stop {
101                data.push(v);
102                v += step;
103            }
104        }
105        Ok(Self { shape: vec![data.len()], data })
106    }
107
108    /// 1-D linspace.
109    pub fn linspace(start: f64, end: f64, n: usize) -> Self {
110        if n == 0 {
111            return Self { shape: vec![0], data: vec![] };
112        }
113        if n == 1 {
114            return Self { shape: vec![1], data: vec![start] };
115        }
116        let step = (end - start) / (n - 1) as f64;
117        let data: Vec<f64> = (0..n).map(|i| start + i as f64 * step).collect();
118        Self { shape: vec![n], data }
119    }
120
121    /// Pseudo-random normal via xorshift64. Uses persistent thread-local state
122    /// so successive calls produce different values.
123    pub fn randn(shape: &[usize]) -> Self {
124        use std::cell::Cell;
125        // 0 is the "uninitialized" sentinel; first call advances to a non-zero state.
126        thread_local! { static S: Cell<u64> = const { Cell::new(0xDEAD_BEEF_CAFE_1234) }; }
127        let numel: usize = shape.iter().product();
128        let data: Vec<f64> = (0..numel).map(|_| {
129            S.with(|s| {
130                let mut x = s.get();
131                if x == 0 { x = 0xDEAD_BEEF_CAFE_1234; }
132                let u1 = xorshift(&mut x);
133                let u2 = xorshift(&mut x);
134                s.set(x);
135                (-2.0 * u1.max(1e-30).ln()).sqrt() * (2.0 * std::f64::consts::PI * u2).cos()
136            })
137        }).collect();
138        Self { shape: shape.to_vec(), data }
139    }
140
141    /// Pseudo-random normal with explicit seed. Uses a local RNG state so it
142    /// does not interfere with the shared thread-local state used by [`randn`].
143    pub fn randn_seeded(shape: &[usize], seed: u64) -> Self {
144        let mut state = if seed == 0 { 0xDEAD_BEEF_CAFE_1234 } else { seed };
145        let numel: usize = shape.iter().product();
146        let data: Vec<f64> = (0..numel).map(|_| {
147            let u1 = xorshift(&mut state);
148            let u2 = xorshift(&mut state);
149            (-2.0 * u1.max(1e-30).ln()).sqrt() * (2.0 * std::f64::consts::PI * u2).cos()
150        }).collect();
151        Self { shape: shape.to_vec(), data }
152    }
153
154    // -----------------------------------------------------------------------
155    // Properties
156    // -----------------------------------------------------------------------
157
158    /// Number of dimensions.
159    pub fn ndim(&self) -> usize { self.shape.len() }
160
161    /// Total number of elements.
162    pub fn numel(&self) -> usize { self.data.len() }
163
164    /// True if 0-dimensional.
165    pub fn is_scalar(&self) -> bool { self.shape.is_empty() }
166
167    /// Compute strides from shape (row-major).
168    pub fn strides(&self) -> Vec<usize> {
169        let nd = self.shape.len();
170        let mut strides = vec![1usize; nd];
171        for i in (0..nd.saturating_sub(1)).rev() {
172            strides[i] = strides[i + 1] * self.shape[i + 1];
173        }
174        strides
175    }
176
177    /// Multi-index to flat offset.
178    pub fn index_to_flat(&self, coords: &[usize]) -> MathResult<usize> {
179        if coords.len() != self.shape.len() {
180            return Err(MathError::DimensionMismatch);
181        }
182        let strides = self.strides();
183        let mut flat = 0;
184        for (i, (c, s)) in coords.iter().zip(&strides).enumerate() {
185            if *c >= self.shape[i] {
186                return Err(MathError::OutOfRange);
187            }
188            flat += c * s;
189        }
190        Ok(flat)
191    }
192
193    /// Flat offset to multi-index.
194    pub fn flat_to_index(&self, flat: usize) -> MathResult<Vec<usize>> {
195        let strides = self.strides();
196        let mut remaining = flat;
197        let mut coords = vec![0usize; self.shape.len()];
198        for i in 0..self.shape.len() {
199            coords[i] = remaining / strides[i];
200            remaining %= strides[i];
201        }
202        Ok(coords)
203    }
204
205    // -----------------------------------------------------------------------
206    // Element access
207    // -----------------------------------------------------------------------
208
209    /// Get element at multi-index.
210    pub fn get(&self, coords: &[usize]) -> MathResult<f64> {
211        let flat = self.index_to_flat(coords)?;
212        Ok(self.data[flat])
213    }
214
215    /// Get element at flat index.
216    pub fn get_flat(&self, idx: usize) -> f64 {
217        assert!(idx < self.data.len(), "get_flat: index {idx} out of bounds (len {})", self.data.len());
218        self.data[idx]
219    }
220
221    /// Set element at multi-index.
222    pub fn set(&mut self, coords: &[usize], val: f64) -> MathResult<()> {
223        let flat = self.index_to_flat(coords)?;
224        self.data[flat] = val;
225        Ok(())
226    }
227
228    /// Set element at flat index.
229    pub fn set_flat(&mut self, idx: usize, val: f64) {
230        assert!(idx < self.data.len(), "set_flat: index {idx} out of bounds (len {})", self.data.len());
231        self.data[idx] = val;
232    }
233
234    /// Borrow data as slice.
235    pub fn as_slice(&self) -> &[f64] { &self.data }
236
237    /// Consume into Vec.
238    pub fn to_vec(self) -> Vec<f64> { self.data }
239
240    // -----------------------------------------------------------------------
241    // Shape manipulation (data-cloning views)
242    // -----------------------------------------------------------------------
243
244    /// Reshape (numel must match).
245    pub fn reshape(&self, new_shape: &[usize]) -> MathResult<Self> {
246        let new_numel: usize = new_shape.iter().product();
247        if new_numel != self.numel() {
248            return Err(MathError::DimensionMismatch);
249        }
250        Ok(Self { shape: new_shape.to_vec(), data: self.data.clone() })
251    }
252
253    /// Flatten to 1-D.
254    pub fn flatten(&self) -> Self {
255        Self { shape: vec![self.numel()], data: self.data.clone() }
256    }
257
258    /// 2-D transpose.
259    pub fn transpose(&self) -> MathResult<Self> {
260        if self.shape.len() != 2 {
261            return Err(MathError::InvalidArgument("transpose requires 2-D tensor"));
262        }
263        let (rows, cols) = (self.shape[0], self.shape[1]);
264        let mut out = vec![0.0; self.numel()];
265        for i in 0..rows {
266            for j in 0..cols {
267                out[j * rows + i] = self.data[i * cols + j];
268            }
269        }
270        Ok(Self { shape: vec![cols, rows], data: out })
271    }
272
273    /// General axis permutation.
274    pub fn permute(&self, axes: &[usize]) -> MathResult<Self> {
275        if axes.len() != self.shape.len() {
276            return Err(MathError::DimensionMismatch);
277        }
278        let new_shape: Vec<usize> = axes.iter().map(|&a| self.shape[a]).collect();
279        let mut out = vec![0.0; self.numel()];
280        let old_strides = self.strides();
281        let new_strides = {
282            let mut s = vec![1usize; axes.len()];
283            for i in (0..axes.len().saturating_sub(1)).rev() {
284                s[i] = s[i + 1] * new_shape[i + 1];
285            }
286            s
287        };
288        #[allow(clippy::needless_range_loop)]
289        for flat in 0..self.numel() {
290            let mut old_flat = 0;
291            for (i, &a) in axes.iter().enumerate() {
292                let coord = flat / new_strides[i] % new_shape[i];
293                old_flat += coord * old_strides[a];
294            }
295            out[flat] = self.data[old_flat];
296        }
297        Ok(Self { shape: new_shape, data: out })
298    }
299
300    /// Remove size-1 dimensions (or a specific axis).
301    pub fn squeeze(&self, axis: Option<usize>) -> Self {
302        let shape: Vec<usize> = match axis {
303            Some(a) => self.shape.iter().enumerate()
304                .filter(|&(i, &s)| i != a || s != 1)
305                .map(|(_, &s)| s)
306                .collect(),
307            None => self.shape.iter().copied().filter(|&s| s != 1).collect(),
308        };
309        let shape = if shape.is_empty() { vec![1] } else { shape };
310        Self { shape, data: self.data.clone() }
311    }
312
313    /// Add a size-1 dimension at axis.
314    pub fn unsqueeze(&self, axis: usize) -> MathResult<Self> {
315        if axis > self.shape.len() {
316            return Err(MathError::InvalidArgument("unsqueeze: axis out of range"));
317        }
318        let mut shape = self.shape.clone();
319        shape.insert(axis, 1);
320        Ok(Self { shape, data: self.data.clone() })
321    }
322
323    /// Expand to a target shape (broadcast semantics, clones data).
324    pub fn broadcast_to(&self, target_shape: &[usize]) -> MathResult<Self> {
325        let _ = broadcast_shapes(&self.shape, target_shape)?;
326        let out_numel: usize = target_shape.iter().product();
327        let mut out = vec![0.0; out_numel];
328        let target_strides = {
329            let mut s = vec![1usize; target_shape.len()];
330            for i in (0..target_shape.len().saturating_sub(1)).rev() {
331                s[i] = s[i + 1] * target_shape[i + 1];
332            }
333            s
334        };
335        #[allow(clippy::needless_range_loop)]
336        for flat in 0..out_numel {
337            let mut coords = vec![0usize; target_shape.len()];
338            let mut rem = flat;
339            for i in 0..target_shape.len() {
340                coords[i] = rem / target_strides[i];
341                rem %= target_strides[i];
342            }
343            let src_coords: Vec<usize> = if coords.len() >= self.shape.len() {
344                let offset = coords.len() - self.shape.len();
345                coords[offset..].iter().zip(&self.shape)
346                    .map(|(&c, &s)| if s == 1 { 0 } else { c.min(s - 1) })
347                    .collect()
348            } else {
349                let offset = self.shape.len() - coords.len();
350                coords.iter().zip(&self.shape[offset..])
351                    .map(|(&c, &s)| if s == 1 { 0 } else { c.min(s - 1) })
352                    .collect()
353            };
354            let src_flat = self.index_to_flat(&src_coords)?;
355            out[flat] = self.data[src_flat];
356        }
357        Ok(Self { shape: target_shape.to_vec(), data: out })
358    }
359
360    // -----------------------------------------------------------------------
361    // Element-wise arith (broadcast-aware)
362    // -----------------------------------------------------------------------
363
364    /// Element-wise add with broadcasting.
365    pub fn add(&self, other: &Tensor) -> MathResult<Tensor> {
366        let target = broadcast_shapes(&self.shape, &other.shape)?;
367        let a = self.broadcast_to(&target)?;
368        let b = other.broadcast_to(&target)?;
369        let data: Vec<f64> = a.data.iter().zip(&b.data).map(|(x, y)| x + y).collect();
370        Ok(Tensor { shape: target, data })
371    }
372
373    /// Element-wise sub.
374    pub fn sub(&self, other: &Tensor) -> MathResult<Tensor> {
375        let target = broadcast_shapes(&self.shape, &other.shape)?;
376        let a = self.broadcast_to(&target)?;
377        let b = other.broadcast_to(&target)?;
378        let data: Vec<f64> = a.data.iter().zip(&b.data).map(|(x, y)| x - y).collect();
379        Ok(Tensor { shape: target, data })
380    }
381
382    /// Element-wise mul.
383    pub fn mul(&self, other: &Tensor) -> MathResult<Tensor> {
384        let target = broadcast_shapes(&self.shape, &other.shape)?;
385        let a = self.broadcast_to(&target)?;
386        let b = other.broadcast_to(&target)?;
387        let data: Vec<f64> = a.data.iter().zip(&b.data).map(|(x, y)| x * y).collect();
388        Ok(Tensor { shape: target, data })
389    }
390
391    /// Element-wise div (safe: returns NaN for zero denominators instead of corrupting sign).
392    pub fn div(&self, other: &Tensor) -> MathResult<Tensor> {
393        let target = broadcast_shapes(&self.shape, &other.shape)?;
394        let a = self.broadcast_to(&target)?;
395        let b = other.broadcast_to(&target)?;
396        let data: Vec<f64> = a.data.iter().zip(&b.data).map(|(x, y)| {
397            if *y == 0.0 { f64::NAN } else { x / y }
398        }).collect();
399        Ok(Tensor { shape: target, data })
400    }
401
402    /// Add a scalar to every element.
403    #[must_use]
404    pub fn add_scalar(&self, s: f64) -> Tensor {
405        Tensor { shape: self.shape.clone(), data: self.data.iter().map(|x| x + s).collect() }
406    }
407
408    /// Subtract a scalar from every element.
409    #[must_use]
410    pub fn sub_scalar(&self, s: f64) -> Tensor {
411        Tensor { shape: self.shape.clone(), data: self.data.iter().map(|x| x - s).collect() }
412    }
413
414    /// Multiply every element by a scalar.
415    #[must_use]
416    pub fn mul_scalar(&self, s: f64) -> Tensor {
417        Tensor { shape: self.shape.clone(), data: self.data.iter().map(|x| x * s).collect() }
418    }
419
420    /// Divide every element by a scalar (returns NaN for zero denominator).
421    #[must_use]
422    pub fn div_scalar(&self, s: f64) -> Tensor {
423        let denom = if s == 0.0 { f64::NAN } else { s };
424        Tensor { shape: self.shape.clone(), data: self.data.iter().map(|x| x / denom).collect() }
425    }
426
427    /// Negate every element.
428    #[must_use]
429    pub fn neg(&self) -> Tensor {
430        Tensor { shape: self.shape.clone(), data: self.data.iter().map(|x| -x).collect() }
431    }
432
433    /// Absolute value of every element.
434    #[must_use]
435    pub fn abs(&self) -> Tensor {
436        Tensor { shape: self.shape.clone(), data: self.data.iter().map(|x| x.abs()).collect() }
437    }
438
439    /// Square root of every element.
440    #[must_use]
441    pub fn sqrt(&self) -> Tensor {
442        Tensor { shape: self.shape.clone(), data: self.data.iter().map(|x| x.sqrt()).collect() }
443    }
444
445    /// Exponential of every element.
446    #[must_use]
447    pub fn exp(&self) -> Tensor {
448        Tensor { shape: self.shape.clone(), data: self.data.iter().map(|x| x.exp()).collect() }
449    }
450
451    /// Natural logarithm of every element.
452    #[must_use]
453    pub fn ln(&self) -> Tensor {
454        Tensor { shape: self.shape.clone(), data: self.data.iter().map(|x| x.ln()).collect() }
455    }
456
457    /// Raise every element to a floating-point exponent.
458    #[must_use]
459    pub fn powf(&self, e: f64) -> Tensor {
460        Tensor { shape: self.shape.clone(), data: self.data.iter().map(|x| x.powf(e)).collect() }
461    }
462
463    /// Clip values to [lo, hi].
464    #[must_use]
465    pub fn clip(&self, lo: f64, hi: f64) -> Tensor {
466        Tensor { shape: self.shape.clone(), data: self.data.iter().map(|x| x.clamp(lo, hi)).collect() }
467    }
468
469    // -----------------------------------------------------------------------
470    // Reduction ops
471    // -----------------------------------------------------------------------
472
473    /// Sum all elements.
474    pub fn sum(&self) -> f64 { self.data.iter().sum() }
475
476    /// Sum along axis (removes that axis).
477    pub fn sum_axis(&self, axis: usize) -> MathResult<Tensor> {
478        axis_reduce(self, axis, |vals| vals.iter().sum())
479    }
480
481    /// Mean of all elements.
482    pub fn mean(&self) -> f64 { self.sum() / self.numel() as f64 }
483
484    /// Mean along axis.
485    pub fn mean_axis(&self, axis: usize) -> MathResult<Tensor> {
486        let n = self.shape[axis] as f64;
487        axis_reduce(self, axis, |vals| vals.iter().sum::<f64>() / n)
488    }
489
490    /// Max of all elements.
491    pub fn max(&self) -> f64 { self.data.iter().cloned().fold(f64::NEG_INFINITY, f64::max) }
492
493    /// Max along axis.
494    pub fn max_axis(&self, axis: usize) -> MathResult<Tensor> {
495        axis_reduce(self, axis, |vals| vals.iter().cloned().fold(f64::NEG_INFINITY, f64::max))
496    }
497
498    /// Min of all elements.
499    pub fn min(&self) -> f64 { self.data.iter().cloned().fold(f64::INFINITY, f64::min) }
500
501    /// Min along axis.
502    pub fn min_axis(&self, axis: usize) -> MathResult<Tensor> {
503        axis_reduce(self, axis, |vals| vals.iter().cloned().fold(f64::INFINITY, f64::min))
504    }
505
506    /// Argmax along axis (returns flat index per slice).
507    pub fn argmax_axis(&self, axis: usize) -> MathResult<Tensor> {
508        axis_reduce_idx(self, axis, |vals| {
509            vals.iter().enumerate()
510                .max_by(|a, b| a.1.partial_cmp(b.1).unwrap_or(std::cmp::Ordering::Equal))
511                .map(|(i, _)| i).unwrap_or(0)
512        })
513    }
514
515    /// Argmin along axis.
516    pub fn argmin_axis(&self, axis: usize) -> MathResult<Tensor> {
517        axis_reduce_idx(self, axis, |vals| {
518            vals.iter().enumerate()
519                .min_by(|a, b| a.1.partial_cmp(b.1).unwrap_or(std::cmp::Ordering::Equal))
520                .map(|(i, _)| i).unwrap_or(0)
521        })
522    }
523
524    // -----------------------------------------------------------------------
525    // Matrix multiply
526    // -----------------------------------------------------------------------
527
528    /// Matrix multiply: 2-D @ 2-D or batched 3-D @ 3-D.
529    pub fn matmul(&self, other: &Tensor) -> MathResult<Tensor> {
530        match (self.shape.len(), other.shape.len()) {
531            (2, 2) => matmul_2d(self, other),
532            (3, 3) => matmul_batched(self, other),
533            _ => Err(MathError::InvalidArgument("matmul requires 2-D or 3-D tensors")),
534        }
535    }
536
537    // -----------------------------------------------------------------------
538    // Normalization
539    // -----------------------------------------------------------------------
540
541    /// Layer normalization (over last dimension).
542    pub fn layer_norm(&self, eps: f64) -> Tensor {
543        let nd = self.shape.len();
544        let d = self.shape[nd - 1];
545        let mut out = self.data.clone();
546        let outer: usize = self.shape[..nd.saturating_sub(1)].iter().product();
547        for i in 0..outer {
548            let start = i * d;
549            let slice = &self.data[start..start + d];
550            let mu: f64 = slice.iter().sum::<f64>() / d as f64;
551            let var: f64 = slice.iter().map(|x| (x - mu).powi(2)).sum::<f64>() / d as f64;
552            let inv = 1.0 / (var + eps).sqrt();
553            for j in 0..d {
554                out[start + j] = (self.data[start + j] - mu) * inv;
555            }
556        }
557        Tensor { shape: self.shape.clone(), data: out }
558    }
559
560    /// Batch normalization (over first dimension).
561    ///
562    /// For 2-D tensors `[N, features]`, normalizes each feature across the batch.
563    /// For 4-D tensors `[N, C, H, W]`, normalizes per channel across `N, H, W`
564    /// (standard image batch norm behavior).
565    pub fn batch_norm(&self, eps: f64) -> MathResult<Tensor> {
566        if self.shape.len() < 2 {
567            return Err(MathError::InvalidArgument("batch_norm requires >= 2-D tensor"));
568        }
569        let batch = self.shape[0];
570        let mut out = self.data.clone();
571
572        if self.shape.len() == 4 {
573            // [N, C, H, W] — per-channel normalization
574            let (n, c, h, w) = (self.shape[0], self.shape[1], self.shape[2], self.shape[3]);
575            let hw = h * w;
576            let spatial_count = (n * h * w) as f64;
577            for ch in 0..c {
578                let mut sum = 0.0;
579                let mut sum2 = 0.0;
580                for ni in 0..n {
581                    for hi in 0..h {
582                        for wi in 0..w {
583                            let v = self.data[ni * c * hw + ch * hw + hi * w + wi];
584                            sum += v;
585                            sum2 += v * v;
586                        }
587                    }
588                }
589                let mu = sum / spatial_count;
590                let var = sum2 / spatial_count - mu * mu;
591                let inv = 1.0 / (var + eps).sqrt();
592                for ni in 0..n {
593                    for hi in 0..h {
594                        for wi in 0..w {
595                            let idx = ni * c * hw + ch * hw + hi * w + wi;
596                            out[idx] = (self.data[idx] - mu) * inv;
597                        }
598                    }
599                }
600            }
601        } else {
602            // Generic: normalize each flat position across batch
603            let feature_size: usize = self.shape[1..].iter().product();
604            let per_sample = self.numel() / batch;
605            for f in 0..feature_size {
606                let mut sum = 0.0;
607                let mut sum2 = 0.0;
608                for b in 0..batch {
609                    let idx = b * per_sample + f;
610                    let v = self.data[idx];
611                    sum += v;
612                    sum2 += v * v;
613                }
614                let mu = sum / batch as f64;
615                let var = sum2 / batch as f64 - mu * mu;
616                let inv = 1.0 / (var + eps).sqrt();
617                for b in 0..batch {
618                    let idx = b * per_sample + f;
619                    out[idx] = (self.data[idx] - mu) * inv;
620                }
621            }
622        }
623        Ok(Tensor { shape: self.shape.clone(), data: out })
624    }
625
626    /// RMS normalization: x / sqrt(mean(x²) + eps) along last dim.
627    pub fn rms_norm(&self, eps: f64) -> Tensor {
628        let nd = self.shape.len();
629        let d = self.shape[nd - 1];
630        let mut out = self.data.clone();
631        let outer: usize = self.shape[..nd.saturating_sub(1)].iter().product();
632        for i in 0..outer {
633            let start = i * d;
634            let slice = &self.data[start..start + d];
635            let rms = (slice.iter().map(|x| x * x).sum::<f64>() / d as f64 + eps).sqrt();
636            for j in 0..d {
637                out[start + j] = self.data[start + j] / rms;
638            }
639        }
640        Tensor { shape: self.shape.clone(), data: out }
641    }
642
643    // -----------------------------------------------------------------------
644    // Advanced ops
645    // -----------------------------------------------------------------------
646
647    /// Element-wise where: condition ? a : b.
648    pub fn where_tensor(condition: &Tensor, a: &Tensor, b: &Tensor) -> MathResult<Tensor> {
649        let target = broadcast_shapes(&broadcast_shapes(&condition.shape, &a.shape)?, &b.shape)?;
650        let c = condition.broadcast_to(&target)?;
651        let av = a.broadcast_to(&target)?;
652        let bv = b.broadcast_to(&target)?;
653        let data: Vec<f64> = c.data.iter().zip(&av.data).zip(&bv.data)
654            .map(|((&cond, &av), &bv)| if cond > 0.0 { av } else { bv })
655            .collect();
656        Ok(Tensor { shape: target, data })
657    }
658
659    /// Gather along axis: selects from `self` using indices.
660    /// `indices` has same shape as output, values are indices along `axis`.
661    ///
662    /// # Errors
663    ///
664    /// Returns `MathError::OutOfRange` if any index is outside `[0, axis_size)`.
665    pub fn gather(&self, axis: usize, indices: &Tensor) -> MathResult<Tensor> {
666        if axis >= self.shape.len() { return Err(MathError::InvalidArgument("gather: axis out of range")); }
667        let mut out_data = Vec::with_capacity(indices.numel());
668        let axis_size = self.shape[axis];
669        let _outer: usize = self.shape[..axis].iter().product();
670        let inner: usize = self.shape[axis + 1..].iter().product();
671        let iouter: usize = indices.shape[..axis].iter().product();
672        let iinner: usize = indices.shape[axis + 1..].iter().product();
673        for io in 0..iouter {
674            for k in 0..indices.shape[axis] {
675                for ii in 0..iinner {
676                    let idx = io * indices.shape[axis] * iinner + k * iinner + ii;
677                    let gi = indices.data[idx];
678                    if gi < 0.0 || gi.fract() != 0.0 || gi as usize >= axis_size {
679                        return Err(MathError::OutOfRange);
680                    }
681                    let gather_idx = gi as usize;
682                    let src_flat = io * axis_size * inner + gather_idx * inner + ii;
683                    out_data.push(self.data[src_flat]);
684                }
685            }
686        }
687        let out_shape = indices.shape.clone();
688        Ok(Tensor { shape: out_shape, data: out_data })
689    }
690
691    /// Scatter add: adds `src` into a zero tensor at positions given by `indices`.
692    ///
693    /// # Errors
694    ///
695    /// Returns `MathError::OutOfRange` if any index is outside `[0, axis_size)`.
696    pub fn scatter_add(&self, axis: usize, indices: &Tensor, src: &Tensor) -> MathResult<Tensor> {
697        if axis >= self.shape.len() { return Err(MathError::InvalidArgument("scatter_add: axis out of range")); }
698        let mut out = self.clone();
699        let axis_size = self.shape[axis];
700        let _outer: usize = self.shape[..axis].iter().product();
701        let inner: usize = self.shape[axis + 1..].iter().product();
702        let iouter: usize = indices.shape[..axis].iter().product();
703        let iinner: usize = indices.shape[axis + 1..].iter().product();
704        for io in 0..iouter {
705            for k in 0..indices.shape[axis] {
706                for ii in 0..iinner {
707                    let idx = io * indices.shape[axis] * iinner + k * iinner + ii;
708                    let si = indices.data[idx];
709                    if si < 0.0 || si.fract() != 0.0 || si as usize >= axis_size {
710                        return Err(MathError::OutOfRange);
711                    }
712                    let scatter_idx = si as usize;
713                    let src_flat = io * src.shape[axis] * inner + k * inner + ii;
714                    let dst_flat = io * axis_size * inner + scatter_idx * inner + ii;
715                    out.data[dst_flat] += src.data[src_flat];
716                }
717            }
718        }
719        Ok(out)
720    }
721
722    /// Top-k along axis: returns (values, indices) tensors.
723    pub fn topk(&self, k: usize, axis: usize) -> MathResult<(Tensor, Tensor)> {
724        if axis >= self.shape.len() || k > self.shape[axis] {
725            return Err(MathError::InvalidArgument("topk: invalid axis or k"));
726        }
727        let outer: usize = self.shape[..axis].iter().product();
728        let axis_size = self.shape[axis];
729        let inner: usize = self.shape[axis + 1..].iter().product();
730        let mut val_data = Vec::with_capacity(outer * k * inner);
731        let mut idx_data = Vec::with_capacity(outer * k * inner);
732        for io in 0..outer {
733            for ii in 0..inner {
734                let mut pairs: Vec<(f64, usize)> = (0..axis_size).map(|a| {
735                    let flat = io * axis_size * inner + a * inner + ii;
736                    (self.data[flat], a)
737                }).collect();
738                pairs.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap_or(std::cmp::Ordering::Equal));
739                #[allow(clippy::needless_range_loop)]
740                for ki in 0..k {
741                    val_data.push(pairs[ki].0);
742                    idx_data.push(pairs[ki].1 as f64);
743                }
744            }
745        }
746        let mut out_shape = self.shape.clone();
747        out_shape[axis] = k;
748        let idx_shape = out_shape.clone();
749        Ok((Tensor { shape: out_shape, data: val_data }, Tensor { shape: idx_shape, data: idx_data }))
750    }
751
752    /// Concatenate tensors along an axis.
753    pub fn concat(tensors: &[Tensor], axis: usize) -> MathResult<Tensor> {
754        if tensors.is_empty() { return Err(MathError::InvalidArgument("concat: empty input")); }
755        let ndim = tensors[0].shape.len();
756        if axis >= ndim { return Err(MathError::InvalidArgument("concat: axis out of range")); }
757        let mut out_shape = tensors[0].shape.clone();
758        let mut total_axis = 0;
759        for t in tensors {
760            if t.shape.len() != ndim { return Err(MathError::DimensionMismatch); }
761            for (i, (a, b)) in out_shape.iter().zip(&t.shape).enumerate() {
762                if i != axis && a != b { return Err(MathError::DimensionMismatch); }
763            }
764            total_axis += t.shape[axis];
765        }
766        out_shape[axis] = total_axis;
767        let outer: usize = tensors[0].shape[..axis].iter().product();
768        let inner: usize = tensors[0].shape[axis + 1..].iter().product();
769        let mut out_data = Vec::with_capacity(outer * total_axis * inner);
770        for io in 0..outer {
771            for t in tensors {
772                let asize = t.shape[axis];
773                for a in 0..asize {
774                    for ii in 0..inner {
775                        let flat = io * asize * inner + a * inner + ii;
776                        out_data.push(t.data[flat]);
777                    }
778                }
779            }
780        }
781        Ok(Tensor { shape: out_shape, data: out_data })
782    }
783
784    /// Split into chunks along axis. Last chunk absorbs any remainder.
785    pub fn split(&self, num_chunks: usize, axis: usize) -> MathResult<Vec<Tensor>> {
786        if axis >= self.shape.len() { return Err(MathError::InvalidArgument("split: axis out of range")); }
787        if num_chunks == 0 { return Err(MathError::InvalidArgument("split: num_chunks must be > 0")); }
788        let axis_len = self.shape[axis];
789        let chunk_size = axis_len / num_chunks;
790        let remainder = axis_len % num_chunks;
791        let outer: usize = self.shape[..axis].iter().product();
792        let inner: usize = self.shape[axis + 1..].iter().product();
793        let mut result = Vec::with_capacity(num_chunks);
794        let mut offset = 0;
795        for c in 0..num_chunks {
796            let cur_size = if c == num_chunks - 1 { chunk_size + remainder } else { chunk_size };
797            let mut chunk_data = Vec::with_capacity(outer * cur_size * inner);
798            for io in 0..outer {
799                for a in 0..cur_size {
800                    let src_a = offset + a;
801                    for ii in 0..inner {
802                        let flat = io * axis_len * inner + src_a * inner + ii;
803                        chunk_data.push(self.data[flat]);
804                    }
805                }
806            }
807            let mut shape = self.shape.clone();
808            shape[axis] = cur_size;
809            result.push(Tensor { shape, data: chunk_data });
810            offset += cur_size;
811        }
812        Ok(result)
813    }
814
815    /// Dot product (flattened). Errors if the tensors have different sizes.
816    pub fn dot(&self, other: &Tensor) -> MathResult<f64> {
817        if self.numel() != other.numel() {
818            return Err(MathError::DimensionMismatch);
819        }
820        Ok(self.data.iter().zip(&other.data).map(|(a, b)| a * b).sum())
821    }
822
823    /// Cross product (3-vectors only).
824    pub fn cross(&self, other: &Tensor) -> MathResult<Tensor> {
825        if self.numel() != 3 || other.numel() != 3 {
826            return Err(MathError::InvalidArgument("cross: requires 3-element vectors"));
827        }
828        Ok(Tensor {
829            shape: vec![3],
830            data: vec![
831                self.data[1] * other.data[2] - self.data[2] * other.data[1],
832                self.data[2] * other.data[0] - self.data[0] * other.data[2],
833                self.data[0] * other.data[1] - self.data[1] * other.data[0],
834            ],
835        })
836    }
837
838    /// Clamp (alias for clip).
839    #[must_use]
840    pub fn clamp(&self, lo: f64, hi: f64) -> Tensor { self.clip(lo, hi) }
841
842    /// Variance of all elements.
843    #[must_use]
844    pub fn var(&self) -> f64 {
845        let m = self.mean();
846        self.data.iter().map(|x| (x - m).powi(2)).sum::<f64>() / self.numel() as f64
847    }
848
849    /// Variance along axis.
850    pub fn var_axis(&self, axis: usize) -> MathResult<Tensor> {
851        let n = self.shape[axis] as f64;
852        let mean = self.mean_axis(axis)?;
853        // broadcast mean back to self shape for subtraction
854        let mean_expanded = mean.broadcast_to(&self.shape)?;
855        let diff = self.sub(&mean_expanded)?;
856        let sq = diff.mul(&diff)?;
857        axis_reduce(&sq, axis, |vals| vals.iter().sum::<f64>() / n)
858    }
859
860    /// Standard deviation along axis.
861    pub fn std_axis(&self, axis: usize) -> MathResult<Tensor> {
862        let v = self.var_axis(axis)?;
863        Ok(v.sqrt())
864    }
865
866    /// Sort along axis (ascending), returns (sorted_values, original_indices).
867    pub fn sort(&self, axis: usize) -> MathResult<(Tensor, Tensor)> {
868        if axis >= self.shape.len() { return Err(MathError::InvalidArgument("sort: axis out of range")); }
869        let outer: usize = self.shape[..axis].iter().product();
870        let axis_size = self.shape[axis];
871        let inner: usize = self.shape[axis + 1..].iter().product();
872        let mut val_data = Vec::with_capacity(self.numel());
873        let mut idx_data = Vec::with_capacity(self.numel());
874        for io in 0..outer {
875            for ii in 0..inner {
876                let mut pairs: Vec<(f64, usize)> = (0..axis_size).map(|a| {
877                    let flat = io * axis_size * inner + a * inner + ii;
878                    (self.data[flat], a)
879                }).collect();
880                pairs.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal));
881                for &(v, idx) in &pairs {
882                    val_data.push(v);
883                    idx_data.push(idx as f64);
884                }
885            }
886        }
887        Ok((Tensor { shape: self.shape.clone(), data: val_data }, Tensor { shape: self.shape.clone(), data: idx_data }))
888    }
889
890    /// Unique elements (sorted, deduplicated). Exact equality only —
891    /// near-but-not-equal values are kept.
892    #[must_use]
893    pub fn unique(&self) -> Vec<f64> {
894        let mut v: Vec<f64> = self.data.clone();
895        v.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
896        v.dedup();
897        v
898    }
899
900    /// Count non-zero elements.
901    #[must_use]
902    pub fn count_nonzero(&self) -> usize {
903        self.data.iter().filter(|&&x| x.abs() > 1e-15).count()
904    }
905
906    /// Any (true if any element > 0).
907    #[must_use]
908    pub fn any(&self) -> bool { self.data.iter().any(|&x| x > 0.0) }
909
910    /// All (true if all elements > 0).
911    #[must_use]
912    pub fn all(&self) -> bool { self.data.iter().all(|&x| x > 0.0) }
913}
914
915// ---------------------------------------------------------------------------
916// Broadcasting helper: NumPy trailing-dim rules
917// ---------------------------------------------------------------------------
918
919/// Compute the broadcasted shape of `a` and `b` using NumPy trailing-dimension rules.
920pub fn broadcast_shapes(a: &[usize], b: &[usize]) -> MathResult<Vec<usize>> {
921    let nd = a.len().max(b.len());
922    let mut result = vec![0usize; nd];
923    for i in 0..nd {
924        let da = if i + (nd - a.len()) < nd { a[i + (nd - a.len())] } else { 1 };
925        let db = if i + (nd - b.len()) < nd { b[i + (nd - b.len())] } else { 1 };
926        if da == db || da == 1 || db == 1 {
927            result[i] = da.max(db);
928        } else {
929            return Err(MathError::DimensionMismatch);
930        }
931    }
932    Ok(result)
933}
934
935// ---------------------------------------------------------------------------
936// Internal: 2-D matmul
937// ---------------------------------------------------------------------------
938
939fn matmul_2d(a: &Tensor, b: &Tensor) -> MathResult<Tensor> {
940    let (m, k1) = (a.shape[0], a.shape[1]);
941    let (k2, n) = (b.shape[0], b.shape[1]);
942    if k1 != k2 { return Err(MathError::DimensionMismatch); }
943    let mut data = vec![0.0; m * n];
944    for i in 0..m {
945        for p in 0..k1 {
946            let av = a.data[i * k1 + p];
947            for j in 0..n {
948                data[i * n + j] += av * b.data[p * n + j];
949            }
950        }
951    }
952    Ok(Tensor { shape: vec![m, n], data })
953}
954
955fn matmul_batched(a: &Tensor, b: &Tensor) -> MathResult<Tensor> {
956    let (batch, m, k1) = (a.shape[0], a.shape[1], a.shape[2]);
957    let (_, k2, n) = (b.shape[0], b.shape[1], b.shape[2]);
958    if k1 != k2 { return Err(MathError::DimensionMismatch); }
959    let mut data = vec![0.0; batch * m * n];
960    for bi in 0..batch {
961        for i in 0..m {
962            for p in 0..k1 {
963                let av = a.data[bi * m * k1 + i * k1 + p];
964                for j in 0..n {
965                    data[bi * m * n + i * n + j] += av * b.data[bi * k1 * n + p * n + j];
966                }
967            }
968        }
969    }
970    Ok(Tensor { shape: vec![batch, m, n], data })
971}
972
973// ---------------------------------------------------------------------------
974// Internal: axis reduction
975// ---------------------------------------------------------------------------
976
977fn axis_reduce<F>(t: &Tensor, axis: usize, f: F) -> MathResult<Tensor>
978where F: Fn(&[f64]) -> f64
979{
980    if axis >= t.shape.len() {
981        return Err(MathError::InvalidArgument("axis out of range"));
982    }
983    let mut out_shape = t.shape.clone();
984    let axis_size = out_shape[axis];
985    out_shape.remove(axis);
986
987    let outer: usize = t.shape[..axis].iter().product();
988    let inner: usize = t.shape[axis + 1..].iter().product();
989    let mut out_data = Vec::with_capacity(outer * inner);
990
991    for i in 0..outer {
992        for j in 0..inner {
993            let vals: Vec<f64> = (0..axis_size)
994                .map(|k| t.data[i * axis_size * inner + k * inner + j])
995                .collect();
996            out_data.push(f(&vals));
997        }
998    }
999
1000    if out_shape.is_empty() { out_shape.push(1); }
1001    Ok(Tensor { shape: out_shape, data: out_data })
1002}
1003
1004fn axis_reduce_idx<F>(t: &Tensor, axis: usize, f: F) -> MathResult<Tensor>
1005where F: Fn(&[f64]) -> usize
1006{
1007    if axis >= t.shape.len() {
1008        return Err(MathError::InvalidArgument("axis out of range"));
1009    }
1010    let mut out_shape = t.shape.clone();
1011    let axis_size = out_shape[axis];
1012    out_shape.remove(axis);
1013
1014    let outer: usize = t.shape[..axis].iter().product();
1015    let inner: usize = t.shape[axis + 1..].iter().product();
1016    let mut out_data = Vec::with_capacity(outer * inner);
1017
1018    for i in 0..outer {
1019        for j in 0..inner {
1020            let vals: Vec<f64> = (0..axis_size)
1021                .map(|k| t.data[i * axis_size * inner + k * inner + j])
1022                .collect();
1023            out_data.push(f(&vals) as f64);
1024        }
1025    }
1026
1027    if out_shape.is_empty() { out_shape.push(1); }
1028    Ok(Tensor { shape: out_shape, data: out_data })
1029}
1030
1031#[cfg(test)]
1032mod tests {
1033    use super::*;
1034
1035    const E: f64 = 1e-9;
1036
1037    #[test]
1038    fn constructors() {
1039        let t = Tensor::zeros(&[2, 3]);
1040        assert_eq!(t.shape, vec![2, 3]);
1041        assert_eq!(t.numel(), 6);
1042        assert!(t.data.iter().all(|&x| x == 0.0));
1043
1044        let t = Tensor::ones(&[3]);
1045        assert_eq!(t.data, vec![1.0, 1.0, 1.0]);
1046
1047        let t = Tensor::arange(0.0, 4.0, 1.0).unwrap();
1048        assert_eq!(t.data, vec![0.0, 1.0, 2.0, 3.0]);
1049
1050        let t = Tensor::linspace(0.0, 1.0, 5);
1051        assert_eq!(t.shape, vec![5]);
1052        assert!((t.data[2] - 0.5).abs() < E);
1053
1054        let t = Tensor::arange(5.0, 0.0, -1.0).unwrap();
1055        assert_eq!(t.data, vec![5.0, 4.0, 3.0, 2.0, 1.0]);
1056        assert!(Tensor::arange(0.0, 1.0, 0.0).is_err());
1057    }
1058
1059    #[test]
1060    fn randn_is_standard_normal() {
1061        // Box-Muller regression: ~99.9% of a standard normal is within [-3.5, 3.5],
1062        // and sample variance must be ~1 (the broken u2 range gave |x| < ~1.3e-9).
1063        let t = Tensor::randn_seeded(&[200_000], 12345);
1064        let n = t.numel() as f64;
1065        let mean: f64 = t.data.iter().sum::<f64>() / n;
1066        let var: f64 = t.data.iter().map(|x| (x - mean).powi(2)).sum::<f64>() / n;
1067        assert!((mean.abs()) < 0.02, "mean {mean} deviates from 0");
1068        assert!((var - 1.0).abs() < 0.05, "variance {var} deviates from 1");
1069        assert!(t.data.iter().any(|x| x.abs() > 1.0), "no samples beyond 1 sigma");
1070    }
1071
1072    #[test]
1073    fn reshape_and_flatten() {
1074        let t = Tensor::arange(0.0, 6.0, 1.0).unwrap().reshape(&[2, 3]).unwrap();
1075        assert_eq!(t.shape, vec![2, 3]);
1076        assert!((t.get(&[1, 2]).unwrap() - 5.0).abs() < E);
1077        let f = t.flatten();
1078        assert_eq!(f.shape, vec![6]);
1079    }
1080
1081    #[test]
1082    fn transpose_2d() {
1083        let t = Tensor::new(&[2, 3], &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).unwrap();
1084        let t2 = t.transpose().unwrap();
1085        assert_eq!(t2.shape, vec![3, 2]);
1086        assert!((t2.get(&[0, 1]).unwrap() - 4.0).abs() < E);
1087    }
1088
1089    #[test]
1090    fn broadcast_add() {
1091        let a = Tensor::new(&[2, 1], &[1.0, 2.0]).unwrap();
1092        let b = Tensor::new(&[1, 3], &[10.0, 20.0, 30.0]).unwrap();
1093        let c = a.add(&b).unwrap();
1094        assert_eq!(c.shape, vec![2, 3]);
1095        assert!((c.get(&[0, 0]).unwrap() - 11.0).abs() < E);
1096        assert!((c.get(&[1, 2]).unwrap() - 32.0).abs() < E);
1097    }
1098
1099    #[test]
1100    fn matmul_2d_test() {
1101        let a = Tensor::new(&[2, 3], &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).unwrap();
1102        let b = Tensor::new(&[3, 2], &[7.0, 8.0, 9.0, 10.0, 11.0, 12.0]).unwrap();
1103        let c = a.matmul(&b).unwrap();
1104        assert_eq!(c.shape, vec![2, 2]);
1105        // [1,2,3]·[7,9,11] = 7+18+33 = 58
1106        assert!((c.get(&[0, 0]).unwrap() - 58.0).abs() < E);
1107        // [4,5,6]·[8,10,12] = 32+50+72 = 154
1108        assert!((c.get(&[1, 1]).unwrap() - 154.0).abs() < E);
1109    }
1110
1111    #[test]
1112    fn reductions() {
1113        let t = Tensor::new(&[2, 3], &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).unwrap();
1114        assert!((t.sum() - 21.0).abs() < E);
1115        assert!((t.mean() - 3.5).abs() < E);
1116        let s = t.sum_axis(0).unwrap();
1117        assert_eq!(s.shape, vec![3]);
1118        assert!((s.get(&[0]).unwrap() - 5.0).abs() < E); // 1+4
1119        let s2 = t.sum_axis(1).unwrap();
1120        assert_eq!(s2.shape, vec![2]);
1121        assert!((s2.get(&[0]).unwrap() - 6.0).abs() < E); // 1+2+3
1122    }
1123
1124    #[test]
1125    fn normalization() {
1126        let t = Tensor::new(&[2, 3], &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).unwrap();
1127        let ln = t.layer_norm(1e-5);
1128        // Each row should have mean ≈ 0
1129        let m0: f64 = (0..3).map(|j| ln.data[j]).sum::<f64>() / 3.0;
1130        assert!(m0.abs() < 1e-5);
1131    }
1132
1133    #[test]
1134    fn argmax_test() {
1135        let t = Tensor::new(&[2, 3], &[1.0, 5.0, 3.0, 4.0, 2.0, 6.0]).unwrap();
1136        let am = t.argmax_axis(1).unwrap();
1137        assert!((am.data[0] - 1.0).abs() < E); // argmax of [1,5,3] = 1
1138        assert!((am.data[1] - 2.0).abs() < E); // argmax of [4,2,6] = 2
1139    }
1140
1141    #[test]
1142    fn clip_test() {
1143        let t = Tensor::new(&[4], &[1.0, 5.0, -3.0, 2.0]).unwrap();
1144        let c = t.clip(-1.0, 3.0);
1145        assert_eq!(c.data, vec![1.0, 3.0, -1.0, 2.0]);
1146    }
1147
1148    #[test]
1149    fn batch_norm_test() {
1150        let t = Tensor::new(&[4, 2], &[
1151            1.0, 2.0,
1152            3.0, 4.0,
1153            5.0, 6.0,
1154            7.0, 8.0,
1155        ]).unwrap();
1156        let bn = t.batch_norm(1e-5).unwrap();
1157        // Per-feature mean should be ~0
1158        let m0: f64 = (0..4).map(|i| bn.data[i * 2]).sum::<f64>() / 4.0;
1159        assert!(m0.abs() < 1e-5);
1160    }
1161
1162    #[test]
1163    fn rms_norm_test() {
1164        let t = Tensor::new(&[2, 3], &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]).unwrap();
1165        let rn = t.rms_norm(1e-8);
1166        // RMS of each row should be ~1
1167        let rms0: f64 = (0..3).map(|j| rn.data[j].powi(2)).sum::<f64>() / 3.0;
1168        assert!((rms0 - 1.0).abs() < 1e-5);
1169    }
1170
1171    #[test]
1172    fn matmul_3d_batched() {
1173        let a = Tensor::new(&[2, 2, 3], &[
1174            1.0, 2.0, 3.0, 4.0, 5.0, 6.0,
1175            7.0, 8.0, 9.0, 10.0, 11.0, 12.0,
1176        ]).unwrap();
1177        let b = Tensor::new(&[2, 3, 2], &[
1178            1.0, 2.0, 3.0, 4.0, 5.0, 6.0,
1179            1.0, 2.0, 3.0, 4.0, 5.0, 6.0,
1180        ]).unwrap();
1181        let c = a.matmul(&b).unwrap();
1182        assert_eq!(c.shape, vec![2, 2, 2]);
1183        // Batch 0: [1,2,3]·[1,3,5]=1+6+15=22
1184        assert!((c.get(&[0, 0, 0]).unwrap() - 22.0).abs() < E);
1185    }
1186
1187    #[test]
1188    fn permute_test() {
1189        let t = Tensor::new(&[2, 3, 4], &(0..24).map(|x| x as f64).collect::<Vec<_>>()).unwrap();
1190        let p = t.permute(&[2, 0, 1]).unwrap();
1191        assert_eq!(p.shape, vec![4, 2, 3]);
1192        // original [0,1,2] = 2 → permuted [2,0,0] should be 2
1193        assert!((p.get(&[2, 0, 0]).unwrap() - 2.0).abs() < E);
1194    }
1195
1196    #[test]
1197    fn squeeze_unsqueeze() {
1198        let t = Tensor::zeros(&[1, 3, 1]);
1199        let s = t.squeeze(None);
1200        assert_eq!(s.shape, vec![3]);
1201        let u = s.unsqueeze(1).unwrap();
1202        assert_eq!(u.shape, vec![3, 1]);
1203    }
1204}
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217