numr 0.5.2

High-performance numerical computing with multi-backend GPU acceleration (CPU/CUDA/WebGPU)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

//! CPU implementation of shape operations.

use crate::error::Result;
use crate::ops::ShapeOps;
use crate::ops::impl_generic::{repeat_interleave_impl, unfold_impl};
use crate::runtime::cpu::{
    CpuClient, CpuRuntime,
    helpers::{cat_impl, chunk_impl, pad_impl, repeat_impl, roll_impl, split_impl, stack_impl},
};
use crate::tensor::Tensor;

/// ShapeOps implementation for CPU runtime.
impl ShapeOps<CpuRuntime> for CpuClient {
    fn cat(&self, tensors: &[&Tensor<CpuRuntime>], dim: isize) -> Result<Tensor<CpuRuntime>> {
        cat_impl(self, tensors, dim)
    }

    fn stack(&self, tensors: &[&Tensor<CpuRuntime>], dim: isize) -> Result<Tensor<CpuRuntime>> {
        stack_impl(self, tensors, dim)
    }

    fn split(
        &self,
        tensor: &Tensor<CpuRuntime>,
        split_size: usize,
        dim: isize,
    ) -> Result<Vec<Tensor<CpuRuntime>>> {
        split_impl(tensor, split_size, dim)
    }

    fn chunk(
        &self,
        tensor: &Tensor<CpuRuntime>,
        chunks: usize,
        dim: isize,
    ) -> Result<Vec<Tensor<CpuRuntime>>> {
        chunk_impl(tensor, chunks, dim)
    }

    fn repeat(&self, tensor: &Tensor<CpuRuntime>, repeats: &[usize]) -> Result<Tensor<CpuRuntime>> {
        repeat_impl(self, tensor, repeats)
    }

    fn pad(
        &self,
        tensor: &Tensor<CpuRuntime>,
        padding: &[usize],
        value: f64,
    ) -> Result<Tensor<CpuRuntime>> {
        pad_impl(self, tensor, padding, value)
    }

    fn roll(
        &self,
        tensor: &Tensor<CpuRuntime>,
        shift: isize,
        dim: isize,
    ) -> Result<Tensor<CpuRuntime>> {
        roll_impl(self, tensor, shift, dim)
    }

    fn unfold(
        &self,
        tensor: &Tensor<CpuRuntime>,
        dim: isize,
        size: usize,
        step: usize,
    ) -> Result<Tensor<CpuRuntime>> {
        unfold_impl(self, tensor, dim, size, step)
    }

    fn repeat_interleave(
        &self,
        tensor: &Tensor<CpuRuntime>,
        repeats: usize,
        dim: Option<isize>,
    ) -> Result<Tensor<CpuRuntime>> {
        repeat_interleave_impl(self, tensor, repeats, dim)
    }
}