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

use cudarc::driver::DeviceRepr;
use hpt_allocator::traits::{Allocator, AllocatorOutputRetrive};
use hpt_traits::{ops::binary::FloatBinOps, tensor::CommonBounds};
use hpt_types::{cuda_types::scalar::Scalar, dtype::CudaType, type_promote::FloatOutBinary};

use crate::{
    backend::Cuda, backends::cuda::utils::binary::binary_normal::binary_fn_with_out_simd,
    tensor_base::_Tensor,
};

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

impl<T, B, const DEVICE: usize, Al> FloatBinOps<_Tensor<B, Cuda, DEVICE, Al>>
    for _Tensor<T, Cuda, DEVICE, Al>
where
    B: CommonBounds + DeviceRepr + CudaType,
    T: FloatOutBinary<B> + CommonBounds + DeviceRepr + CudaType,
    FloatBinaryType<T, B>: CommonBounds + DeviceRepr + CudaType,
    Scalar<T>: FloatOutBinary<Scalar<B>, Output = Scalar<FloatBinaryType<T, B>>>,
    Al: Allocator,
    Al::Output: AllocatorOutputRetrive,
{
    type Output = _Tensor<FloatBinaryType<T, B>, Cuda, DEVICE, Al>;

    type OutputMeta = FloatBinaryType<T, B>;

    type InplaceOutput = _Tensor<FloatBinaryType<T, B>, Cuda, DEVICE, Al>;

    fn hypot<C>(
        &self,
        rhs: C,
    ) -> std::result::Result<Self::Output, hpt_common::error::base::TensorError>
    where
        C: Into<_Tensor<B, Cuda, DEVICE, Al>>,
    {
        binary_fn_with_out_simd(
            "hypot",
            self,
            &rhs.into(),
            |out, a, b| out.assign(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
        C: Into<_Tensor<B, Cuda, DEVICE, Al>>,
        U: std::borrow::BorrowMut<Self::InplaceOutput>,
    {
        binary_fn_with_out_simd(
            "hypot",
            self,
            &rhs.into(),
            |out, a, b| out.assign(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
        C: Into<_Tensor<B, Cuda, DEVICE, Al>>,
        U: std::borrow::BorrowMut<Self::InplaceOutput>,
    {
        binary_fn_with_out_simd(
            "div",
            self,
            &rhs.into(),
            |out, a, b| out.assign(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, Cuda, DEVICE, Al>>,
    {
        binary_fn_with_out_simd(
            "pow",
            self,
            &rhs.into(),
            |out, a, b| out.assign(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
        C: Into<_Tensor<B, Cuda, DEVICE, Al>>,
        U: std::borrow::BorrowMut<Self::InplaceOutput>,
    {
        binary_fn_with_out_simd(
            "pow",
            self,
            &rhs.into(),
            |out, a, b| out.assign(a._pow(b)),
            Some(out),
        )
    }
}