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

use crate::{backend::Cuda, Tensor};
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};

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>>,
    {
        Ok(self.inner.as_ref().hypot(rhs.into().inner.as_ref())?.into())
    }

    fn hypot_<C, U>(
        &self,
        rhs: C,
        mut 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>,
    {
        Ok(self
            .inner
            .as_ref()
            .hypot_(
                rhs.into().inner.as_ref(),
                out.borrow_mut().inner.as_ref().clone(),
            )?
            .into())
    }

    fn div_<C, U>(
        &self,
        rhs: C,
        mut 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>,
    {
        Ok(self
            .inner
            .as_ref()
            .div_(
                rhs.into().inner.as_ref(),
                out.borrow_mut().inner.as_ref().clone(),
            )?
            .into())
    }

    fn pow<C>(
        &self,
        rhs: C,
    ) -> std::result::Result<Self::Output, hpt_common::error::base::TensorError>
    where
        C: Into<Tensor<B, Cuda, DEVICE, Al>>,
    {
        Ok(self.inner.as_ref().pow(rhs.into().inner.as_ref())?.into())
    }

    fn pow_<C, U>(
        &self,
        rhs: C,
        mut out: U,
    ) -> std::result::Result<Self::Output, hpt_common::error::base::TensorError>
    where
        U: std::borrow::BorrowMut<Self::InplaceOutput>,
        C: Into<Tensor<B, Cuda, DEVICE, Al>>,
    {
        Ok(self
            .inner
            .as_ref()
            .pow_(
                rhs.into().inner.as_ref(),
                out.borrow_mut().inner.as_ref().clone(),
            )?
            .into())
    }
}