1use std::fmt;
4use mathverse_core::error::{MathError, MathResult};
5
6#[derive(Debug, Clone, PartialEq)]
8pub struct Tensor {
9 pub shape: Vec<usize>,
11 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
30fn 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 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 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 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 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 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 pub fn scalar(val: f64) -> Self {
84 Self { shape: vec![], data: vec![val] }
85 }
86
87 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 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 pub fn randn(shape: &[usize]) -> Self {
124 use std::cell::Cell;
125 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 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 pub fn ndim(&self) -> usize { self.shape.len() }
160
161 pub fn numel(&self) -> usize { self.data.len() }
163
164 pub fn is_scalar(&self) -> bool { self.shape.is_empty() }
166
167 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 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 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 pub fn get(&self, coords: &[usize]) -> MathResult<f64> {
211 let flat = self.index_to_flat(coords)?;
212 Ok(self.data[flat])
213 }
214
215 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 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 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 pub fn as_slice(&self) -> &[f64] { &self.data }
236
237 pub fn to_vec(self) -> Vec<f64> { self.data }
239
240 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 pub fn flatten(&self) -> Self {
255 Self { shape: vec![self.numel()], data: self.data.clone() }
256 }
257
258 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 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 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 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 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 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 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 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 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 #[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 #[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 #[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 #[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 #[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 #[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 #[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 #[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 #[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 #[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 #[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 pub fn sum(&self) -> f64 { self.data.iter().sum() }
475
476 pub fn sum_axis(&self, axis: usize) -> MathResult<Tensor> {
478 axis_reduce(self, axis, |vals| vals.iter().sum())
479 }
480
481 pub fn mean(&self) -> f64 { self.sum() / self.numel() as f64 }
483
484 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 pub fn max(&self) -> f64 { self.data.iter().cloned().fold(f64::NEG_INFINITY, f64::max) }
492
493 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 pub fn min(&self) -> f64 { self.data.iter().cloned().fold(f64::INFINITY, f64::min) }
500
501 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 #[must_use]
840 pub fn clamp(&self, lo: f64, hi: f64) -> Tensor { self.clip(lo, hi) }
841
842 #[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 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 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 pub fn std_axis(&self, axis: usize) -> MathResult<Tensor> {
862 let v = self.var_axis(axis)?;
863 Ok(v.sqrt())
864 }
865
866 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 #[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 #[must_use]
902 pub fn count_nonzero(&self) -> usize {
903 self.data.iter().filter(|&&x| x.abs() > 1e-15).count()
904 }
905
906 #[must_use]
908 pub fn any(&self) -> bool { self.data.iter().any(|&x| x > 0.0) }
909
910 #[must_use]
912 pub fn all(&self) -> bool { self.data.iter().all(|&x| x > 0.0) }
913}
914
915pub 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
935fn 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
973fn 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 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 assert!((c.get(&[0, 0]).unwrap() - 58.0).abs() < E);
1107 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); let s2 = t.sum_axis(1).unwrap();
1120 assert_eq!(s2.shape, vec![2]);
1121 assert!((s2.get(&[0]).unwrap() - 6.0).abs() < E); }
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 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); assert!((am.data[1] - 2.0).abs() < E); }
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 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 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 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 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