hpt 0.1.3

High Performance Tensor (HPT) - A fast, efficient, and user-friendly tensor computation library for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use hpt_allocator::{
    traits::{Allocator, AllocatorOutputRetrive},
    Cpu,
};
use hpt_traits::{ops::binary::FloatBinOps, tensor::CommonBounds};
use hpt_types::{dtype::TypeCommon, type_promote::FloatOutBinary};

use crate::{
    backends::cpu::utils::binary::binary_normal::binary_fn_with_out_simd, tensor_base::_Tensor,
};

type FloatBinaryType<T, B> = <T as FloatOutBinary<B>>::Output;

impl<T, B, A2, const DEVICE: usize> FloatBinOps<_Tensor<B, Cpu, DEVICE, A2>>
    for _Tensor<T, Cpu, DEVICE, A2>
where
    B: CommonBounds,
    T: FloatOutBinary<B> + CommonBounds,
    FloatBinaryType<T, B>: CommonBounds,
    T::Vec: FloatOutBinary<B::Vec, Output = <FloatBinaryType<T, B> as TypeCommon>::Vec>,
    A2: Allocator,
    A2::Output: AllocatorOutputRetrive,
{
    type Output = _Tensor<FloatBinaryType<T, B>, Cpu, DEVICE, A2>;

    type OutputMeta = FloatBinaryType<T, B>;

    type InplaceOutput = _Tensor<FloatBinaryType<T, B>, Cpu, DEVICE, A2>;

    fn hypot<C>(
        &self,
        rhs: C,
    ) -> std::result::Result<Self::Output, hpt_common::error::base::TensorError>
    where
        C: Into<_Tensor<B, Cpu, DEVICE, A2>>,
    {
        binary_fn_with_out_simd(
            self,
            &rhs.into(),
            |a, b| a._hypot(b),
            |a, b| a._hypot(b),
            None::<Self::InplaceOutput>,
        )
    }

    fn hypot_<C, U>(
        &self,
        rhs: C,
        out: U,
    ) -> std::result::Result<Self::Output, hpt_common::error::base::TensorError>
    where
        U: std::borrow::BorrowMut<Self::InplaceOutput>,
        C: Into<_Tensor<B, Cpu, DEVICE, A2>>,
    {
        binary_fn_with_out_simd(
            self,
            &rhs.into(),
            |a, b| a._hypot(b),
            |a, b| a._hypot(b),
            Some(out),
        )
    }

    fn div_<C, U>(
        &self,
        rhs: C,
        out: U,
    ) -> std::result::Result<Self::Output, hpt_common::error::base::TensorError>
    where
        U: std::borrow::BorrowMut<Self::InplaceOutput>,
        C: Into<_Tensor<B, Cpu, DEVICE, A2>>,
    {
        binary_fn_with_out_simd(
            self,
            &rhs.into(),
            |a, b| a._div(b),
            |a, b| a._div(b),
            Some(out),
        )
    }

    fn pow<C>(
        &self,
        rhs: C,
    ) -> std::result::Result<Self::Output, hpt_common::error::base::TensorError>
    where
        C: Into<_Tensor<B, Cpu, DEVICE, A2>>,
    {
        binary_fn_with_out_simd(
            self,
            &rhs.into(),
            |a, b| a._pow(b),
            |a, b| a._pow(b),
            None::<Self::InplaceOutput>,
        )
    }

    fn pow_<C, U>(
        &self,
        rhs: C,
        out: U,
    ) -> std::result::Result<Self::Output, hpt_common::error::base::TensorError>
    where
        U: std::borrow::BorrowMut<Self::InplaceOutput>,
        C: Into<_Tensor<B, Cpu, DEVICE, A2>>,
    {
        binary_fn_with_out_simd(
            self,
            &rhs.into(),
            |a, b| a._pow(b),
            |a, b| a._pow(b),
            Some(out),
        )
    }
}