coeus-ops 0.14.0

Numerical tensor operators for Coeus.
Documentation
use super::super::unfold_fold;
use super::super::CpuBackend;
use crate::backend_ops::traits::UnfoldFoldOps;
use coeus_core::{CpuAddressableStorage, CpuAddressableStorageMut, Layout, Scalar, Storage};
use leto_ops::Scalar as LetoScalar;

// SAFETY: Overwrite methods initialize every logical output on success; accumulation methods require initialized outputs.
unsafe impl<T: Scalar + LetoScalar, B: CpuBackend> UnfoldFoldOps<T> for B
where
    B::DeviceBuffer<T>: coeus_core::CpuAddressableStorage<T> + CpuAddressableStorageMut<T>,
{
    #[inline]
    fn unfold1d(
        &self,
        input: &Self::DeviceBuffer<T>,
        input_layout: &Layout,
        kernel_size: usize,
        stride: usize,
        padding: usize,
        dilation: usize,
        output: &mut Self::DeviceBuffer<T>,
        output_layout: &Layout,
    ) -> Result<(), Self::Error> {
        unfold_fold::validation::unfold1d(
            input_layout,
            input.len(),
            kernel_size,
            stride,
            padding,
            dilation,
            output_layout,
            output.len(),
        )?;
        unfold_fold::unfold1d(
            input.as_slice(),
            input_layout,
            kernel_size,
            stride,
            padding,
            dilation,
            output.as_mut_slice()?,
            output_layout,
        )?;
        Ok(())
    }

    #[inline]
    fn fold1d(
        &self,
        input: &Self::DeviceBuffer<T>,
        input_layout: &Layout,
        output_size: usize,
        kernel_size: usize,
        stride: usize,
        padding: usize,
        dilation: usize,
        output: &mut Self::DeviceBuffer<T>,
        output_layout: &Layout,
    ) -> Result<(), Self::Error> {
        unfold_fold::validation::fold1d(
            input_layout,
            input.len(),
            output_size,
            kernel_size,
            stride,
            padding,
            dilation,
            output_layout,
            output.len(),
        )?;
        unfold_fold::fold1d(
            input.as_slice(),
            input_layout,
            output_size,
            kernel_size,
            stride,
            padding,
            dilation,
            output.as_mut_slice()?,
            output_layout,
        )?;
        Ok(())
    }

    #[inline]
    fn unfold2d(
        &self,
        input: &Self::DeviceBuffer<T>,
        input_layout: &Layout,
        kernel_h: usize,
        kernel_w: usize,
        stride_h: usize,
        stride_w: usize,
        padding_h: usize,
        padding_w: usize,
        dilation_h: usize,
        dilation_w: usize,
        output: &mut Self::DeviceBuffer<T>,
        output_layout: &Layout,
    ) -> Result<(), Self::Error> {
        unfold_fold::validation::unfold2d(
            input_layout,
            input.len(),
            kernel_h,
            kernel_w,
            stride_h,
            stride_w,
            padding_h,
            padding_w,
            dilation_h,
            dilation_w,
            output_layout,
            output.len(),
        )?;
        unfold_fold::unfold2d(
            input.as_slice(),
            input_layout,
            kernel_h,
            kernel_w,
            stride_h,
            stride_w,
            padding_h,
            padding_w,
            dilation_h,
            dilation_w,
            output.as_mut_slice()?,
            output_layout,
        )?;
        Ok(())
    }

    #[inline]
    fn fold2d(
        &self,
        input: &Self::DeviceBuffer<T>,
        input_layout: &Layout,
        output_h: usize,
        output_w: usize,
        kernel_h: usize,
        kernel_w: usize,
        stride_h: usize,
        stride_w: usize,
        padding_h: usize,
        padding_w: usize,
        dilation_h: usize,
        dilation_w: usize,
        output: &mut Self::DeviceBuffer<T>,
        output_layout: &Layout,
    ) -> Result<(), Self::Error> {
        unfold_fold::validation::fold2d(
            input_layout,
            input.len(),
            output_h,
            output_w,
            kernel_h,
            kernel_w,
            stride_h,
            stride_w,
            padding_h,
            padding_w,
            dilation_h,
            dilation_w,
            output_layout,
            output.len(),
        )?;
        unfold_fold::fold2d(
            input.as_slice(),
            input_layout,
            output_h,
            output_w,
            kernel_h,
            kernel_w,
            stride_h,
            stride_w,
            padding_h,
            padding_w,
            dilation_h,
            dilation_w,
            output.as_mut_slice()?,
            output_layout,
        )?;
        Ok(())
    }
}