usearch 2.26.1 → 2.26.2

package/numkong/package.json

@@ -1,6 +1,6 @@
 {
   "name": "numkong",
-  "version": "7.6.0",
+  "version": "7.8.1",
   "description": "Portable mixed-precision math, linear-algebra, & retrieval library with 2000+ SIMD kernels for x86, Arm, RISC-V, LoongArch, Power, & WebAssembly",
   "homepage": "https://github.com/ashvardanian/NumKong",
   "author": "Ash Vardanian",
@@ -72,7 +72,7 @@
     "@playwright/test": "^1.58.0",
     "@types/bindings": "^1.5.5",
     "@types/node": "^24.10.0",
-    "node-gyp": "^11.5.0",
+    "node-gyp": "^13.0.1",
     "playwright": "^1.58.0",
     "http-server": "^14.1.1",
     "esbuild": "^0.25.0",
@@ -98,11 +98,11 @@
     "printWidth": 120
   },
   "optionalDependencies": {
-    "@numkong/darwin-arm64": "7.6.0",
-    "@numkong/darwin-x64": "7.6.0",
-    "@numkong/linux-arm64": "7.6.0",
-    "@numkong/linux-x64": "7.6.0",
-    "@numkong/win32-arm64": "7.6.0",
-    "@numkong/win32-x64": "7.6.0"
+    "@numkong/darwin-arm64": "7.8.1",
+    "@numkong/darwin-x64": "7.8.1",
+    "@numkong/linux-arm64": "7.8.1",
+    "@numkong/linux-x64": "7.8.1",
+    "@numkong/win32-arm64": "7.8.1",
+    "@numkong/win32-x64": "7.8.1"
   }
 }

package/numkong/rust/README.md

@@ -42,7 +42,7 @@ The `parallel` feature is the intended native orchestration layer.
 
 ## Ecosystem Comparison
 
-| Feature                      | NumKong                                                                                                             | [nalgebra](https://github.com/dimforge/nalgebra)     | [ndarray](https://github.com/rust-ndarray/ndarray)   |
+| Feature                      | NumKong                                                                                                             | [nalgebra][nalgebra]                                 | [ndarray][ndarray]                                   |
 | ---------------------------- | ------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------- | ---------------------------------------------------- |
 | Operation families           | dots, distances, binary, probability, geospatial, curved, mesh, sparse, MaxSim, elementwise, reductions, cast, trig | linear algebra, decompositions                       | general n-dimensional arithmetic                     |
 | Precision                    | BFloat16 through sub-byte; automatic widening; Kahan summation; 0 ULP in Float32/Float64                            | Float32/Float64 only; no widening; standard accuracy | Float32/Float64 only; no widening; standard accuracy |
@@ -52,6 +52,9 @@ The `parallel` feature is the intended native orchestration layer.
 | Memory model                 | Caller-owned; `Tensor`/`PackedMatrix` support custom allocators                                                     | Heap-allocated matrices; custom storage trait        | Heap-allocated; no custom allocator support          |
 | Host-side parallelism        | row-range partitioning via reusable `ThreadPool`; no hidden threads                                                 | Rayon-based parallelism possible                     | Rayon-based parallelism possible                     |
 
+[nalgebra]: https://github.com/dimforge/nalgebra
+[ndarray]: https://github.com/rust-ndarray/ndarray
+
 NumKong validates `f16` and `bf16` interop against the `half` crate in its own test suite.
 That lets you move between ecosystem-standard half types and NumKong's kernel-facing wrappers without ambiguity.
 
@@ -235,7 +238,8 @@ assert!(jaccard_sets > 0.0 && jaccard_sets < 1.0); // |A ∩ B| / |A ∪ B|
 ```rust
 use numkong::{JensenShannon, KullbackLeibler};
 
-let p = [0.2_f32, 0.3, 0.5], q = [0.1_f32, 0.3, 0.6];
+let p = [0.2_f32, 0.3, 0.5];
+let q = [0.1_f32, 0.3, 0.6];
 let kl_forward = f32::kullbackleibler(&p, &q).unwrap();
 let kl_reverse = f32::kullbackleibler(&q, &p).unwrap();
 assert!(kl_forward != kl_reverse); // KLD is asymmetric
@@ -254,15 +258,19 @@ Outputs are meters.
 use numkong::{Haversine, Vincenty};
 
 // Statue of Liberty (40.6892°N, 74.0445°W) → Big Ben (51.5007°N, 0.1246°W)
-let liberty_lat = [0.7101605100_f64], liberty_lon = [-1.2923203180_f64];
-let big_ben_lat = [0.8988567821_f64], big_ben_lon = [-0.0021746802_f64];
+let liberty_lat = [0.7101605100_f64];
+let liberty_lon = [-1.2923203180_f64];
+let big_ben_lat = [0.8988567821_f64];
+let big_ben_lon = [-0.0021746802_f64];
 let mut distance = [0.0_f64; 1];
 f64::vincenty(&liberty_lat, &liberty_lon, &big_ben_lat, &big_ben_lon, &mut distance).unwrap();  // ≈ 5,589,857 m (ellipsoidal, baseline)
 f64::haversine(&liberty_lat, &liberty_lon, &big_ben_lat, &big_ben_lon, &mut distance).unwrap(); // ≈ 5,543,723 m (spherical, ~46 km less)
 
 // Vincenty in f32 — drifts ~2 m from f64
-let liberty_lat32 = [0.7101605100_f32], liberty_lon32 = [-1.2923203180_f32];
-let big_ben_lat32 = [0.8988567821_f32], big_ben_lon32 = [-0.0021746802_f32];
+let liberty_lat32 = [0.7101605100_f32];
+let liberty_lon32 = [-1.2923203180_f32];
+let big_ben_lat32 = [0.8988567821_f32];
+let big_ben_lon32 = [-0.0021746802_f32];
 let mut distance_f32 = [0.0_f32; 1];
 f32::vincenty(&liberty_lat32, &liberty_lon32, &big_ben_lat32, &big_ben_lon32, &mut distance_f32).unwrap(); // ≈ 5,589,859 m (+2 m drift)
 ```
@@ -466,12 +474,14 @@ Sparse helpers cover both sorted-index intersection and weighted sparse dot prod
 ```rust
 use numkong::{SparseIntersect, SparseDot};
 
-let a_idx = [1_u32, 3, 5, 7], b_idx = [3_u32, 4, 5, 8];
+let a_idx = [1_u32, 3, 5, 7];
+let b_idx = [3_u32, 4, 5, 8];
 let count = u32::sparse_intersection_size(&a_idx, &b_idx);
 assert_eq!(count, 2); // indices 3 and 5
 
-let a_weights = [1.0_f32, 2.0, 3.0, 4.0], b_weights = [5.0_f32, 6.0, 7.0, 8.0];
-let dot = u32::sparse_dot(&a_idx, &b_idx, &a_weights, &b_weights).unwrap();
+let a_weights = [1.0_f32, 2.0, 3.0, 4.0];
+let b_weights = [5.0_f32, 6.0, 7.0, 8.0];
+let dot = u32::sparse_dot(&a_idx, &b_idx, &a_weights, &b_weights);
 assert!(dot > 0.0); // weighted dot over shared indices
 ```
 

package/numkong/rust/cast.rs

@@ -1,9 +1,11 @@
-//! Type casting between scalar formats.
+//! Type casting between scalar formats — slice traits and tensor-shaped wrappers.
 //!
 //! This module provides:
 //!
 //! - [`CastDtype`]: Trait marking types eligible for bulk casting
 //! - [`cast`]: Bulk-converts a slice from one scalar format to another
+//! - [`CastOps`]: Tensor-shaped extension trait — auto-implemented on every
+//!   [`crate::tensor::TensorRef`] so any container can do `tensor.try_cast_dtype::<Destination>()`
 
 use crate::types::{bf16, bf16c, e2m3, e3m2, e4m3, e5m2, f16, f16c, f32c, f64c, StorageElement};
 
@@ -214,6 +216,34 @@ pub fn cast<S: CastDtype, D: CastDtype>(source: &[S], dest: &mut [D]) -> Option<
     Some(())
 }
 
+// region: Tensor-shaped cast (moved from crate::tensor)
+
+use crate::tensor::{try_reborrow_tensor_into, Global, Tensor, TensorError, TensorRef};
+
+/// Extension trait: type casting for any [`TensorRef`] implementor.
+pub trait CastOps<Source: Clone + CastDtype, const MAX_RANK: usize>:
+    TensorRef<Source, MAX_RANK>
+{
+    fn try_cast_dtype<Destination: Clone + CastDtype>(
+        &self,
+    ) -> Result<Tensor<Destination, Global, MAX_RANK>, TensorError> {
+        self.view().try_cast_dtype()
+    }
+}
+
+impl<Source: Clone + CastDtype, const R: usize, C: TensorRef<Source, R>> CastOps<Source, R> for C {}
+
+impl<Source: Clone + CastDtype, const MAX_RANK: usize> Tensor<Source, Global, MAX_RANK> {
+    pub fn try_cast_dtype_into<Destination: Clone + CastDtype>(
+        &self,
+        out: &mut Tensor<Destination, Global, MAX_RANK>,
+    ) -> Result<(), TensorError> {
+        try_reborrow_tensor_into(self, out, |view, span| view.try_cast_dtype_into(span))
+    }
+}
+
+// endregion: Tensor-shaped cast
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -311,4 +341,25 @@ mod tests {
         assert_eq!(narrowed[1].re.to_f32(), bf16::from_f32(-3.5).to_f32());
         assert_eq!(narrowed[1].im.to_f32(), bf16::from_f32(4.25).to_f32());
     }
+
+    #[test]
+    fn cast_via_tensor_view_round_trip() {
+        // Exercises `CastOps::try_cast_dtype` on a strided `TensorView`,
+        // mirroring how callers reach the trait through the tensor-shaped wrapper.
+        use crate::tensor::{SliceRange, Tensor};
+        let data: Vec<f32> = (0..12).map(|i| i as f32).collect();
+        let source = Tensor::<f32>::try_from_slice(&data, &[3, 4]).unwrap();
+        let even_columns = source
+            .slice(&[SliceRange::full(), SliceRange::range_step(0, 4, 2)])
+            .unwrap();
+
+        let widened = even_columns.try_cast_dtype::<f64>().unwrap();
+        assert_eq!(widened.shape(), &[3, 2]);
+        assert_eq!(widened.as_slice(), &[0.0, 2.0, 4.0, 6.0, 8.0, 10.0]);
+
+        let complexified = even_columns.try_cast_dtype::<f32c>().unwrap();
+        assert_eq!(complexified.shape(), &[3, 2]);
+        assert_eq!(complexified.as_slice()[0], f32c::from_real_imag(0.0, 0.0));
+        assert_eq!(complexified.as_slice()[5], f32c::from_real_imag(10.0, 0.0));
+    }
 }

package/numkong/rust/each.rs

@@ -1,13 +1,18 @@
-//! Elementwise operations and trigonometry.
+//! Elementwise operations and trigonometry — slice traits and tensor-shaped wrappers.
 //!
 //! This module provides:
 //!
-//! - [`EachSin`], [`EachCos`], [`EachATan`]: Trigonometric functions
-//! - [`EachScale`]: Linear scaling (alpha * x + beta)
-//! - [`EachSum`]: Elementwise addition of two vectors
-//! - [`EachBlend`]: Weighted blend of two vectors
-//! - [`EachFMA`]: Fused multiply-add (a * alpha + b * beta)
-//! - [`Trigonometry`]: Blanket trait combining `EachSin + EachCos + EachATan`
+//! - Slice-level traits:
+//!   - [`EachScale`]: Linear scaling (alpha * x + beta)
+//!   - [`EachSum`]: Elementwise addition of two vectors
+//!   - [`EachBlend`]: Weighted blend of two vectors
+//!   - [`EachFMA`]: Fused multiply-add (a * alpha + b * beta)
+//!   - [`EachSin`], [`EachCos`], [`EachATan`]: Trigonometric functions
+//!   - [`Trigonometry`]: Blanket trait combining `EachSin + EachCos + EachATan`
+//! - Tensor-shaped extension traits (auto-implemented on every [`crate::tensor::TensorRef`]):
+//!   - [`ScaleOps`], [`SumOps`], [`BlendOps`], [`FmaOps`]: Tensor wrappers around the slice traits
+//!   - [`TrigSinOps`], [`TrigCosOps`], [`TrigAtanOps`]: Tensor wrappers around the trig traits
+//!   - [`AllCloseOps`]: Tolerance-based equality for any [`crate::tensor::TensorRef`]
 //!
 //! # In-Place vs Allocating Semantics
 //!
@@ -43,6 +48,9 @@
 //! assert_eq!(output, [2.5, 4.5, 6.5, 8.5]);
 //! ```
 
+use crate::tensor::{
+    try_reborrow_tensor_inplace, try_reborrow_tensor_into, Global, Tensor, TensorError, TensorRef,
+};
 use crate::types::{bf16, bf16c, e2m3, e3m2, e4m3, e5m2, f16, f16c, f32c, f64c, StorageElement};
 
 #[link(name = "numkong")]
@@ -2403,6 +2411,395 @@ impl EachFMA for bf16c {
 pub trait Trigonometry: EachSin + EachCos + EachATan {}
 impl<Scalar: EachSin + EachCos + EachATan> Trigonometry for Scalar {}
 
+// region: Tensor-shaped trigonometry (moved from crate::tensor)
+
+/// Extension trait: element-wise sine for any [`TensorRef`] implementor.
+pub trait TrigSinOps<Scalar: Clone + EachSin, const MAX_RANK: usize>:
+    TensorRef<Scalar, MAX_RANK>
+{
+    fn try_sin(&self) -> Result<Tensor<Scalar, Global, MAX_RANK>, TensorError> {
+        self.view().try_sin()
+    }
+}
+
+impl<Scalar: Clone + EachSin, const R: usize, C: TensorRef<Scalar, R>> TrigSinOps<Scalar, R> for C {}
+
+/// Extension trait: element-wise cosine for any [`TensorRef`] implementor.
+pub trait TrigCosOps<Scalar: Clone + EachCos, const MAX_RANK: usize>:
+    TensorRef<Scalar, MAX_RANK>
+{
+    fn try_cos(&self) -> Result<Tensor<Scalar, Global, MAX_RANK>, TensorError> {
+        self.view().try_cos()
+    }
+}
+
+impl<Scalar: Clone + EachCos, const R: usize, C: TensorRef<Scalar, R>> TrigCosOps<Scalar, R> for C {}
+
+/// Extension trait: element-wise arctangent for any [`TensorRef`] implementor.
+pub trait TrigAtanOps<Scalar: Clone + EachATan, const MAX_RANK: usize>:
+    TensorRef<Scalar, MAX_RANK>
+{
+    fn try_atan(&self) -> Result<Tensor<Scalar, Global, MAX_RANK>, TensorError> {
+        self.view().try_atan()
+    }
+}
+
+impl<Scalar: Clone + EachATan, const R: usize, C: TensorRef<Scalar, R>> TrigAtanOps<Scalar, R>
+    for C
+{
+}
+
+impl<Scalar: Clone + EachSin, const MAX_RANK: usize> Tensor<Scalar, Global, MAX_RANK> {
+    /// Element-wise sine: result\[i\] = sin(self\[i\])
+    pub fn sin(&self) -> Result<Tensor<Scalar, Global, MAX_RANK>, TensorError> {
+        self.view().try_sin()
+    }
+
+    /// Element-wise sine in-place (infallible — self vs self always matches).
+    pub fn sin_inplace(&mut self) {
+        try_reborrow_tensor_inplace(self, |view, span| view.try_sin_into(span))
+            .expect("inplace trig op on self cannot fail")
+    }
+
+    pub fn try_sin_inplace(&mut self) -> Result<(), TensorError> {
+        self.sin_inplace();
+        Ok(())
+    }
+}
+
+impl<Scalar: Clone + EachCos, const MAX_RANK: usize> Tensor<Scalar, Global, MAX_RANK> {
+    /// Element-wise cosine: result\[i\] = cos(self\[i\])
+    pub fn cos(&self) -> Result<Tensor<Scalar, Global, MAX_RANK>, TensorError> {
+        self.view().try_cos()
+    }
+
+    /// Element-wise cosine in-place (infallible — self vs self always matches).
+    pub fn cos_inplace(&mut self) {
+        try_reborrow_tensor_inplace(self, |view, span| view.try_cos_into(span))
+            .expect("inplace trig op on self cannot fail")
+    }
+
+    pub fn try_cos_inplace(&mut self) -> Result<(), TensorError> {
+        self.cos_inplace();
+        Ok(())
+    }
+}
+
+impl<Scalar: Clone + EachATan, const MAX_RANK: usize> Tensor<Scalar, Global, MAX_RANK> {
+    /// Element-wise arctangent: result\[i\] = atan(self\[i\])
+    pub fn atan(&self) -> Result<Tensor<Scalar, Global, MAX_RANK>, TensorError> {
+        self.view().try_atan()
+    }
+
+    /// Element-wise arctangent in-place (infallible — self vs self always matches).
+    pub fn atan_inplace(&mut self) {
+        try_reborrow_tensor_inplace(self, |view, span| view.try_atan_into(span))
+            .expect("inplace trig op on self cannot fail")
+    }
+
+    pub fn try_atan_inplace(&mut self) -> Result<(), TensorError> {
+        self.atan_inplace();
+        Ok(())
+    }
+}
+
+// endregion: Tensor-shaped trigonometry
+
+// region: Tensor-shaped tolerance equality (moved from crate::tensor)
+
+use crate::types::{is_close, FloatConvertible, NumberLike};
+
+/// Extension trait: tolerance-based equality for any [`TensorRef`] implementor.
+///
+/// Uses the formula `|a - b| <= atol + rtol * |b|` per element.
+/// Returns `false` if shapes differ.
+pub trait AllCloseOps<Scalar: FloatConvertible, const MAX_RANK: usize>:
+    TensorRef<Scalar, MAX_RANK>
+where
+    Scalar::DimScalar: NumberLike,
+{
+    fn allclose(
+        &self,
+        other: &(impl TensorRef<Scalar, MAX_RANK> + ?Sized),
+        atol: f64,
+        rtol: f64,
+    ) -> bool {
+        let a = self.view();
+        let b = other.view();
+        a.ndim() == b.ndim()
+            && a.shape() == b.shape()
+            && a.iter()
+                .dims()
+                .zip(b.iter().dims())
+                .all(|(x, y)| is_close((*x).to_f64(), (*y).to_f64(), atol, rtol))
+    }
+}
+
+impl<C, Scalar: FloatConvertible, const R: usize> AllCloseOps<Scalar, R> for C
+where
+    C: TensorRef<Scalar, R>,
+    Scalar::DimScalar: NumberLike,
+{
+}
+
+// endregion: Tensor-shaped tolerance equality
+
+// region: Tensor-shaped scale / sum / blend / fma (moved from crate::tensor)
+
+/// Extension trait: scalar arithmetic for any [`TensorRef`] implementor.
+pub trait ScaleOps<Scalar: Clone + EachScale, const MAX_RANK: usize>:
+    TensorRef<Scalar, MAX_RANK>
+where
+    Scalar::Scalar: From<f32> + core::ops::Mul<Output = Scalar::Scalar> + Copy,
+{
+    fn try_add_scalar(
+        &self,
+        scalar: Scalar::Scalar,
+    ) -> Result<Tensor<Scalar, Global, MAX_RANK>, TensorError> {
+        self.view().try_add_scalar(scalar)
+    }
+
+    fn try_sub_scalar(
+        &self,
+        scalar: Scalar::Scalar,
+    ) -> Result<Tensor<Scalar, Global, MAX_RANK>, TensorError> {
+        self.view().try_sub_scalar(scalar)
+    }
+
+    fn try_mul_scalar(
+        &self,
+        scalar: Scalar::Scalar,
+    ) -> Result<Tensor<Scalar, Global, MAX_RANK>, TensorError> {
+        self.view().try_mul_scalar(scalar)
+    }
+}
+
+impl<Scalar: Clone + EachScale, const R: usize, C: TensorRef<Scalar, R>> ScaleOps<Scalar, R> for C where
+    Scalar::Scalar: From<f32> + core::ops::Mul<Output = Scalar::Scalar> + Copy
+{
+}
+
+impl<Scalar: Clone + EachScale, const MAX_RANK: usize> Tensor<Scalar, Global, MAX_RANK>
+where
+    Scalar::Scalar: From<f32> + core::ops::Mul<Output = Scalar::Scalar> + Copy,
+{
+    pub fn try_add_scalar_into(
+        &self,
+        scalar: Scalar::Scalar,
+        out: &mut Tensor<Scalar, Global, MAX_RANK>,
+    ) -> Result<(), TensorError> {
+        try_reborrow_tensor_into(self, out, |view, span| {
+            view.try_add_scalar_into(scalar, span)
+        })
+    }
+
+    pub fn try_sub_scalar_into(
+        &self,
+        scalar: Scalar::Scalar,
+        out: &mut Tensor<Scalar, Global, MAX_RANK>,
+    ) -> Result<(), TensorError> {
+        try_reborrow_tensor_into(self, out, |view, span| {
+            view.try_sub_scalar_into(scalar, span)
+        })
+    }
+
+    pub fn try_mul_scalar_into(
+        &self,
+        scalar: Scalar::Scalar,
+        out: &mut Tensor<Scalar, Global, MAX_RANK>,
+    ) -> Result<(), TensorError> {
+        try_reborrow_tensor_into(self, out, |view, span| {
+            view.try_mul_scalar_into(scalar, span)
+        })
+    }
+
+    pub fn try_add_scalar_inplace(&mut self, scalar: Scalar::Scalar) -> Result<(), TensorError> {
+        self.add_scalar_inplace(scalar);
+        Ok(())
+    }
+
+    pub fn try_sub_scalar_inplace(&mut self, scalar: Scalar::Scalar) -> Result<(), TensorError> {
+        self.sub_scalar_inplace(scalar);
+        Ok(())
+    }
+
+    pub fn try_mul_scalar_inplace(&mut self, scalar: Scalar::Scalar) -> Result<(), TensorError> {
+        self.mul_scalar_inplace(scalar);
+        Ok(())
+    }
+
+    /// Element-wise add scalar in-place (infallible — self vs self always matches).
+    pub fn add_scalar_inplace(&mut self, scalar: Scalar::Scalar) {
+        try_reborrow_tensor_inplace(self, |view, span| view.try_add_scalar_into(scalar, span))
+            .expect("inplace scalar op on self cannot fail")
+    }
+
+    /// Element-wise subtract scalar in-place (infallible — self vs self always matches).
+    pub fn sub_scalar_inplace(&mut self, scalar: Scalar::Scalar) {
+        try_reborrow_tensor_inplace(self, |view, span| view.try_sub_scalar_into(scalar, span))
+            .expect("inplace scalar op on self cannot fail")
+    }
+
+    /// Element-wise multiply scalar in-place (infallible — self vs self always matches).
+    pub fn mul_scalar_inplace(&mut self, scalar: Scalar::Scalar) {
+        try_reborrow_tensor_inplace(self, |view, span| view.try_mul_scalar_into(scalar, span))
+            .expect("inplace scalar op on self cannot fail")
+    }
+}
+
+impl<Scalar: Clone + EachScale, const MAX_RANK: usize> core::ops::AddAssign<Scalar::Scalar>
+    for Tensor<Scalar, Global, MAX_RANK>
+where
+    Scalar::Scalar: From<f32> + core::ops::Mul<Output = Scalar::Scalar> + Copy,
+{
+    fn add_assign(&mut self, scalar: Scalar::Scalar) {
+        self.add_scalar_inplace(scalar);
+    }
+}
+
+impl<Scalar: Clone + EachScale, const MAX_RANK: usize> core::ops::SubAssign<Scalar::Scalar>
+    for Tensor<Scalar, Global, MAX_RANK>
+where
+    Scalar::Scalar: From<f32> + core::ops::Mul<Output = Scalar::Scalar> + Copy,
+{
+    fn sub_assign(&mut self, scalar: Scalar::Scalar) {
+        self.sub_scalar_inplace(scalar);
+    }
+}
+
+impl<Scalar: Clone + EachScale, const MAX_RANK: usize> core::ops::MulAssign<Scalar::Scalar>
+    for Tensor<Scalar, Global, MAX_RANK>
+where
+    Scalar::Scalar: From<f32> + core::ops::Mul<Output = Scalar::Scalar> + Copy,
+{
+    fn mul_assign(&mut self, scalar: Scalar::Scalar) {
+        self.mul_scalar_inplace(scalar);
+    }
+}
+
+/// Extension trait: element-wise addition for any [`TensorRef`] implementor.
+pub trait SumOps<Scalar: Clone + EachSum, const MAX_RANK: usize>:
+    TensorRef<Scalar, MAX_RANK>
+{
+    fn try_add_tensor(
+        &self,
+        other: &(impl TensorRef<Scalar, MAX_RANK> + ?Sized),
+    ) -> Result<Tensor<Scalar, Global, MAX_RANK>, TensorError> {
+        self.view().try_add_tensor(&other.view())
+    }
+}
+
+impl<Scalar: Clone + EachSum, const R: usize, C: TensorRef<Scalar, R>> SumOps<Scalar, R> for C {}
+
+impl<Scalar: Clone + EachSum, const MAX_RANK: usize> Tensor<Scalar, Global, MAX_RANK> {
+    pub fn try_add_tensor_into(
+        &self,
+        other: &Tensor<Scalar, Global, MAX_RANK>,
+        out: &mut Tensor<Scalar, Global, MAX_RANK>,
+    ) -> Result<(), TensorError> {
+        try_reborrow_tensor_into(self, out, |view, span| {
+            view.try_add_tensor_into(&other.view(), span)
+        })
+    }
+
+    pub fn try_add_tensor_inplace(
+        &mut self,
+        other: &Tensor<Scalar, Global, MAX_RANK>,
+    ) -> Result<(), TensorError> {
+        try_reborrow_tensor_inplace(self, |view, span| {
+            view.try_add_tensor_into(&other.view(), span)
+        })
+    }
+}
+
+/// Extension trait: element-wise subtraction for any [`TensorRef`] implementor.
+pub trait BlendOps<Scalar: Clone + EachBlend, const MAX_RANK: usize>:
+    TensorRef<Scalar, MAX_RANK>
+where
+    Scalar::Scalar: From<f32> + Copy,
+{
+    fn try_sub_tensor(
+        &self,
+        other: &(impl TensorRef<Scalar, MAX_RANK> + ?Sized),
+    ) -> Result<Tensor<Scalar, Global, MAX_RANK>, TensorError> {
+        self.view().try_sub_tensor(&other.view())
+    }
+}
+
+impl<Scalar: Clone + EachBlend, const R: usize, C: TensorRef<Scalar, R>> BlendOps<Scalar, R> for C where
+    Scalar::Scalar: From<f32> + Copy
+{
+}
+
+impl<Scalar: Clone + EachBlend, const MAX_RANK: usize> Tensor<Scalar, Global, MAX_RANK>
+where
+    Scalar::Scalar: From<f32> + Copy,
+{
+    pub fn try_sub_tensor_into(
+        &self,
+        other: &Tensor<Scalar, Global, MAX_RANK>,
+        out: &mut Tensor<Scalar, Global, MAX_RANK>,
+    ) -> Result<(), TensorError> {
+        try_reborrow_tensor_into(self, out, |view, span| {
+            view.try_sub_tensor_into(&other.view(), span)
+        })
+    }
+
+    pub fn try_sub_tensor_inplace(
+        &mut self,
+        other: &Tensor<Scalar, Global, MAX_RANK>,
+    ) -> Result<(), TensorError> {
+        try_reborrow_tensor_inplace(self, |view, span| {
+            view.try_sub_tensor_into(&other.view(), span)
+        })
+    }
+}
+
+/// Extension trait: element-wise multiplication for any [`TensorRef`] implementor.
+pub trait FmaOps<Scalar: Clone + EachFMA, const MAX_RANK: usize>:
+    TensorRef<Scalar, MAX_RANK>
+where
+    Scalar::Scalar: From<f32> + Copy,
+{
+    fn try_mul_tensor(
+        &self,
+        other: &(impl TensorRef<Scalar, MAX_RANK> + ?Sized),
+    ) -> Result<Tensor<Scalar, Global, MAX_RANK>, TensorError> {
+        self.view().try_mul_tensor(&other.view())
+    }
+}
+
+impl<Scalar: Clone + EachFMA, const R: usize, C: TensorRef<Scalar, R>> FmaOps<Scalar, R> for C where
+    Scalar::Scalar: From<f32> + Copy
+{
+}
+
+impl<Scalar: Clone + EachFMA, const MAX_RANK: usize> Tensor<Scalar, Global, MAX_RANK>
+where
+    Scalar::Scalar: From<f32> + Copy,
+{
+    pub fn try_mul_tensor_into(
+        &self,
+        other: &Tensor<Scalar, Global, MAX_RANK>,
+        out: &mut Tensor<Scalar, Global, MAX_RANK>,
+    ) -> Result<(), TensorError> {
+        try_reborrow_tensor_into(self, out, |view, span| {
+            view.try_mul_tensor_into(&other.view(), span)
+        })
+    }
+
+    pub fn try_mul_tensor_inplace(
+        &mut self,
+        other: &Tensor<Scalar, Global, MAX_RANK>,
+    ) -> Result<(), TensorError> {
+        try_reborrow_tensor_inplace(self, |view, span| {
+            view.try_mul_tensor_into(&other.view(), span)
+        })
+    }
+}
+
+// endregion: Tensor-shaped scale / sum / blend / fma
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -2718,4 +3115,80 @@ mod tests {
     }
 
     // endregion
+
+    // region: tensor-shaped wrappers (ScaleOps / SumOps / TrigSinOps)
+
+    #[test]
+    fn tensor_add_tensor_via_sum_ops() {
+        use crate::tensor::{SliceRange, Tensor};
+        let data: Vec<f32> = (0..12).map(|i| i as f32).collect();
+        let left = Tensor::<f32>::try_from_slice(&data, &[3, 4]).unwrap();
+        let right = Tensor::<f32>::try_full(&[3, 4], 2.0).unwrap();
+
+        let left_even = left
+            .slice(&[SliceRange::full(), SliceRange::range_step(0, 4, 2)])
+            .unwrap();
+        let right_even = right
+            .slice(&[SliceRange::full(), SliceRange::range_step(0, 4, 2)])
+            .unwrap();
+
+        let added = left_even.try_add_tensor(&right_even).unwrap();
+        assert_eq!(added.shape(), &[3, 2]);
+        assert_eq!(added.as_slice(), &[2.0, 4.0, 6.0, 8.0, 10.0, 12.0]);
+    }
+
+    #[test]
+    fn tensor_add_tensor_into_owning_destination() {
+        use crate::tensor::Tensor;
+        let data: Vec<f32> = (0..12).map(|i| i as f32).collect();
+        let left = Tensor::<f32>::try_from_slice(&data, &[3, 4]).unwrap();
+        let right = Tensor::<f32>::try_full(&[3, 4], 2.0).unwrap();
+
+        let mut out = Tensor::<f32>::try_full(&[3, 4], 0.0).unwrap();
+        left.try_add_tensor_into(&right, &mut out).unwrap();
+        assert_eq!(out.as_slice()[0], 2.0);
+        assert_eq!(out.as_slice()[11], 13.0);
+    }
+
+    #[test]
+    fn tensor_mul_scalar_via_scale_ops() {
+        use crate::tensor::{SliceRange, Tensor};
+        let data: Vec<f32> = (0..12).map(|i| i as f32).collect();
+        let source = Tensor::<f32>::try_from_slice(&data, &[3, 4]).unwrap();
+        let even = source
+            .slice(&[SliceRange::full(), SliceRange::range_step(0, 4, 2)])
+            .unwrap();
+        let scaled = even.try_mul_scalar(0.5).unwrap();
+        assert_eq!(scaled.as_slice(), &[0.0, 1.0, 2.0, 3.0, 4.0, 5.0]);
+    }
+
+    #[test]
+    fn tensor_add_scalar_inplace_via_scale_ops() {
+        use crate::tensor::Tensor;
+        let data: Vec<f32> = (0..12).map(|i| i as f32).collect();
+        let mut tensor = Tensor::<f32>::try_from_slice(&data, &[3, 4]).unwrap();
+        tensor.try_add_scalar_inplace(1.0).unwrap();
+        assert_eq!(tensor.as_slice()[0], 1.0);
+        assert_eq!(tensor.as_slice()[11], 12.0);
+    }
+
+    #[test]
+    fn tensor_sin_into_via_trig_sin_ops() {
+        use crate::tensor::{SliceRange, Tensor};
+        let data: Vec<f32> = (0..12).map(|i| i as f32).collect();
+        let source = Tensor::<f32>::try_from_slice(&data, &[3, 4]).unwrap();
+        let even = source
+            .slice(&[SliceRange::full(), SliceRange::range_step(0, 4, 2)])
+            .unwrap();
+        let mut sin_out = Tensor::<f32>::try_full(&[3, 2], 0.0).unwrap();
+        {
+            let mut span = sin_out.span();
+            even.try_sin_into(&mut span).unwrap();
+        }
+        assert_eq!(sin_out.shape(), &[3, 2]);
+        // First element is sin(0) which is exactly 0.
+        assert!((sin_out.as_slice()[0] - 0.0).abs() < 1e-6);
+    }
+
+    // endregion
 }