Trait AccelProvider 

pub trait AccelProvider: Send + Sync {
    // Required methods
    fn upload(&self, host: &HostTensorView<'_>) -> Result<GpuTensorHandle>;
    fn download(&self, h: &GpuTensorHandle) -> Result<HostTensorOwned>;
    fn free(&self, h: &GpuTensorHandle) -> Result<()>;
    fn device_info(&self) -> String;

    // Provided methods
    fn device_id(&self) -> u32 { ... }
    fn gather_linear(
        &self,
        _source: &GpuTensorHandle,
        _indices: &[u32],
        _output_shape: &[usize],
    ) -> Result<GpuTensorHandle> { ... }
    fn scatter_linear(
        &self,
        _target: &GpuTensorHandle,
        _indices: &[u32],
        _values: &GpuTensorHandle,
    ) -> Result<()> { ... }
    fn device_info_struct(&self) -> ApiDeviceInfo { ... }
    fn precision(&self) -> ProviderPrecision { ... }
    fn read_scalar(
        &self,
        _h: &GpuTensorHandle,
        _linear_index: usize,
    ) -> Result<f64> { ... }
    fn zeros(&self, _shape: &[usize]) -> Result<GpuTensorHandle> { ... }
    fn ones(&self, _shape: &[usize]) -> Result<GpuTensorHandle> { ... }
    fn zeros_like(&self, prototype: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn fill(&self, shape: &[usize], value: f64) -> Result<GpuTensorHandle> { ... }
    fn fill_like(
        &self,
        prototype: &GpuTensorHandle,
        value: f64,
    ) -> Result<GpuTensorHandle> { ... }
    fn ones_like(&self, prototype: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn eye(&self, _shape: &[usize]) -> Result<GpuTensorHandle> { ... }
    fn eye_like(&self, prototype: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn meshgrid(
        &self,
        _axes: &[MeshgridAxisView<'_>],
    ) -> Result<ProviderMeshgridResult> { ... }
    fn diag_from_vector(
        &self,
        _vector: &GpuTensorHandle,
        _offset: isize,
    ) -> Result<GpuTensorHandle> { ... }
    fn diag_extract(
        &self,
        _matrix: &GpuTensorHandle,
        _offset: isize,
    ) -> Result<GpuTensorHandle> { ... }
    fn tril(
        &self,
        _matrix: &GpuTensorHandle,
        _offset: isize,
    ) -> Result<GpuTensorHandle> { ... }
    fn triu(
        &self,
        _matrix: &GpuTensorHandle,
        _offset: isize,
    ) -> Result<GpuTensorHandle> { ... }
    fn polyval(
        &self,
        _coefficients: &GpuTensorHandle,
        _points: &GpuTensorHandle,
        _options: &ProviderPolyvalOptions,
    ) -> Result<GpuTensorHandle> { ... }
    fn polyfit(
        &self,
        _x: &GpuTensorHandle,
        _y: &GpuTensorHandle,
        _degree: usize,
        _weights: Option<&GpuTensorHandle>,
    ) -> Result<ProviderPolyfitResult> { ... }
    fn polyder_single(
        &self,
        _polynomial: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn polyder_product(
        &self,
        _p: &GpuTensorHandle,
        _q: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn polyder_quotient(
        &self,
        _u: &GpuTensorHandle,
        _v: &GpuTensorHandle,
    ) -> Result<ProviderPolyderQuotient> { ... }
    fn polyint(
        &self,
        _polynomial: &GpuTensorHandle,
        _constant: f64,
    ) -> Result<GpuTensorHandle> { ... }
    fn random_uniform(&self, _shape: &[usize]) -> Result<GpuTensorHandle> { ... }
    fn random_uniform_like(
        &self,
        prototype: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn random_normal(&self, _shape: &[usize]) -> Result<GpuTensorHandle> { ... }
    fn random_normal_like(
        &self,
        prototype: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn stochastic_evolution(
        &self,
        _state: &GpuTensorHandle,
        _drift: f64,
        _scale: f64,
        _steps: u32,
    ) -> Result<GpuTensorHandle> { ... }
    fn set_rng_state(&self, _state: u64) -> Result<()> { ... }
    fn fspecial(&self, _request: &FspecialRequest) -> Result<GpuTensorHandle> { ... }
    fn imfilter(
        &self,
        _image: &GpuTensorHandle,
        _kernel: &GpuTensorHandle,
        _options: &ImfilterOptions,
    ) -> Result<GpuTensorHandle> { ... }
    fn random_integer_range(
        &self,
        _lower: i64,
        _upper: i64,
        _shape: &[usize],
    ) -> Result<GpuTensorHandle> { ... }
    fn random_integer_like(
        &self,
        prototype: &GpuTensorHandle,
        lower: i64,
        upper: i64,
    ) -> Result<GpuTensorHandle> { ... }
    fn random_permutation(
        &self,
        _n: usize,
        _k: usize,
    ) -> Result<GpuTensorHandle> { ... }
    fn random_permutation_like(
        &self,
        _prototype: &GpuTensorHandle,
        n: usize,
        k: usize,
    ) -> Result<GpuTensorHandle> { ... }
    fn covariance(
        &self,
        _matrix: &GpuTensorHandle,
        _second: Option<&GpuTensorHandle>,
        _weights: Option<&GpuTensorHandle>,
        _options: &CovarianceOptions,
    ) -> Result<GpuTensorHandle> { ... }
    fn corrcoef(
        &self,
        _matrix: &GpuTensorHandle,
        _options: &CorrcoefOptions,
    ) -> Result<GpuTensorHandle> { ... }
    fn linspace(
        &self,
        _start: f64,
        _stop: f64,
        _count: usize,
    ) -> Result<GpuTensorHandle> { ... }
    fn elem_add(
        &self,
        _a: &GpuTensorHandle,
        _b: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn elem_mul(
        &self,
        _a: &GpuTensorHandle,
        _b: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn elem_max(
        &self,
        _a: &GpuTensorHandle,
        _b: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn elem_min(
        &self,
        _a: &GpuTensorHandle,
        _b: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn elem_sub(
        &self,
        _a: &GpuTensorHandle,
        _b: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn elem_div(
        &self,
        _a: &GpuTensorHandle,
        _b: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn elem_pow(
        &self,
        _a: &GpuTensorHandle,
        _b: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn elem_hypot(
        &self,
        _a: &GpuTensorHandle,
        _b: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn elem_ge(
        &self,
        _a: &GpuTensorHandle,
        _b: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn elem_le(
        &self,
        _a: &GpuTensorHandle,
        _b: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn elem_lt(
        &self,
        _a: &GpuTensorHandle,
        _b: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn elem_gt(
        &self,
        _a: &GpuTensorHandle,
        _b: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn elem_eq(
        &self,
        _a: &GpuTensorHandle,
        _b: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn elem_ne(
        &self,
        _a: &GpuTensorHandle,
        _b: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn logical_and(
        &self,
        _a: &GpuTensorHandle,
        _b: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn logical_or(
        &self,
        _a: &GpuTensorHandle,
        _b: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn logical_xor(
        &self,
        _a: &GpuTensorHandle,
        _b: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn logical_not(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn logical_islogical(&self, a: &GpuTensorHandle) -> Result<bool> { ... }
    fn logical_isreal(&self, _a: &GpuTensorHandle) -> Result<bool> { ... }
    fn logical_isfinite(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn logical_isnan(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn logical_isinf(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn elem_atan2(
        &self,
        _y: &GpuTensorHandle,
        _x: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn unary_sin(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_gamma(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_factorial(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_asinh(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_sinh(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_cosh(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_asin(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_acos(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_acosh(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_tan(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_tanh(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_atan(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_atanh(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_ceil(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_floor(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_round(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_fix(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_cos(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_angle(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_imag(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_real(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_conj(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_abs(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_sign(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_exp(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_expm1(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_log(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_log2(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_log10(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_log1p(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_sqrt(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_double(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_single(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn unary_pow2(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn pow2_scale(
        &self,
        _mantissa: &GpuTensorHandle,
        _exponent: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn scalar_rsub(
        &self,
        _a: &GpuTensorHandle,
        _scalar: f64,
    ) -> Result<GpuTensorHandle> { ... }
    fn scalar_rdiv(
        &self,
        _a: &GpuTensorHandle,
        _scalar: f64,
    ) -> Result<GpuTensorHandle> { ... }
    fn scalar_add(
        &self,
        _a: &GpuTensorHandle,
        _scalar: f64,
    ) -> Result<GpuTensorHandle> { ... }
    fn scalar_sub(
        &self,
        _a: &GpuTensorHandle,
        _scalar: f64,
    ) -> Result<GpuTensorHandle> { ... }
    fn scalar_mul(
        &self,
        _a: &GpuTensorHandle,
        _scalar: f64,
    ) -> Result<GpuTensorHandle> { ... }
    fn scalar_max(
        &self,
        _a: &GpuTensorHandle,
        _scalar: f64,
    ) -> Result<GpuTensorHandle> { ... }
    fn scalar_min(
        &self,
        _a: &GpuTensorHandle,
        _scalar: f64,
    ) -> Result<GpuTensorHandle> { ... }
    fn scalar_div(
        &self,
        _a: &GpuTensorHandle,
        _scalar: f64,
    ) -> Result<GpuTensorHandle> { ... }
    fn sort_dim(
        &self,
        _a: &GpuTensorHandle,
        _dim: usize,
        _order: SortOrder,
        _comparison: SortComparison,
    ) -> Result<SortResult> { ... }
    fn sort_rows(
        &self,
        _a: &GpuTensorHandle,
        _columns: &[SortRowsColumnSpec],
        _comparison: SortComparison,
    ) -> Result<SortResult> { ... }
    fn matmul(
        &self,
        _a: &GpuTensorHandle,
        _b: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn syrk(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn pagefun(&self, _request: &PagefunRequest) -> Result<GpuTensorHandle> { ... }
    fn matmul_epilogue(
        &self,
        a: &GpuTensorHandle,
        b: &GpuTensorHandle,
        epilogue: &MatmulEpilogue,
    ) -> Result<GpuTensorHandle> { ... }
    fn image_normalize(
        &self,
        _input: &GpuTensorHandle,
        _desc: &ImageNormalizeDescriptor,
    ) -> Result<GpuTensorHandle> { ... }
    fn matmul_power_step(
        &self,
        _lhs: &GpuTensorHandle,
        _rhs: &GpuTensorHandle,
        _epilogue: &PowerStepEpilogue,
    ) -> Result<GpuTensorHandle> { ... }
    fn linsolve(
        &self,
        _lhs: &GpuTensorHandle,
        _rhs: &GpuTensorHandle,
        _options: &ProviderLinsolveOptions,
    ) -> Result<ProviderLinsolveResult> { ... }
    fn inv(
        &self,
        _matrix: &GpuTensorHandle,
        _options: ProviderInvOptions,
    ) -> Result<GpuTensorHandle> { ... }
    fn pinv(
        &self,
        _matrix: &GpuTensorHandle,
        _options: ProviderPinvOptions,
    ) -> Result<GpuTensorHandle> { ... }
    fn cond(
        &self,
        _matrix: &GpuTensorHandle,
        _norm: ProviderCondNorm,
    ) -> Result<GpuTensorHandle> { ... }
    fn norm(
        &self,
        _tensor: &GpuTensorHandle,
        _order: ProviderNormOrder,
    ) -> Result<GpuTensorHandle> { ... }
    fn rank(
        &self,
        _matrix: &GpuTensorHandle,
        _tolerance: Option<f64>,
    ) -> Result<GpuTensorHandle> { ... }
    fn rcond(&self, _matrix: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn mldivide(
        &self,
        _lhs: &GpuTensorHandle,
        _rhs: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn mrdivide(
        &self,
        _lhs: &GpuTensorHandle,
        _rhs: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn eig(
        &self,
        _a: &GpuTensorHandle,
        _compute_left: bool,
    ) -> Result<ProviderEigResult> { ... }
    fn lu(&self, _a: &GpuTensorHandle) -> Result<ProviderLuResult> { ... }
    fn chol(
        &self,
        _a: &GpuTensorHandle,
        _lower: bool,
    ) -> Result<ProviderCholResult> { ... }
    fn qr(
        &self,
        _a: &GpuTensorHandle,
        _options: ProviderQrOptions,
    ) -> Result<ProviderQrResult> { ... }
    fn take_matmul_sources(
        &self,
        _product: &GpuTensorHandle,
    ) -> Option<(GpuTensorHandle, GpuTensorHandle)> { ... }
    fn qr_power_iter(
        &self,
        product: &GpuTensorHandle,
        _product_lhs: Option<&GpuTensorHandle>,
        q_handle: &GpuTensorHandle,
        options: &ProviderQrOptions,
    ) -> Result<Option<ProviderQrPowerIterResult>> { ... }
    fn transpose(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn conv1d(
        &self,
        _signal: &GpuTensorHandle,
        _kernel: &GpuTensorHandle,
        _options: ProviderConv1dOptions,
    ) -> Result<GpuTensorHandle> { ... }
    fn conv2d(
        &self,
        _signal: &GpuTensorHandle,
        _kernel: &GpuTensorHandle,
        _mode: ProviderConvMode,
    ) -> Result<GpuTensorHandle> { ... }
    fn iir_filter(
        &self,
        _b: &GpuTensorHandle,
        _a: &GpuTensorHandle,
        _x: &GpuTensorHandle,
        _options: ProviderIirFilterOptions,
    ) -> Result<ProviderIirFilterResult> { ... }
    fn permute(
        &self,
        _handle: &GpuTensorHandle,
        _order: &[usize],
    ) -> Result<GpuTensorHandle> { ... }
    fn flip(
        &self,
        _handle: &GpuTensorHandle,
        _axes: &[usize],
    ) -> Result<GpuTensorHandle> { ... }
    fn circshift(
        &self,
        _handle: &GpuTensorHandle,
        _shifts: &[isize],
    ) -> Result<GpuTensorHandle> { ... }
    fn diff_dim(
        &self,
        _handle: &GpuTensorHandle,
        _order: usize,
        _dim: usize,
    ) -> Result<GpuTensorHandle> { ... }
    fn fft_dim(
        &self,
        _handle: &GpuTensorHandle,
        _len: Option<usize>,
        _dim: usize,
    ) -> Result<GpuTensorHandle> { ... }
    fn ifft_dim(
        &self,
        _handle: &GpuTensorHandle,
        _len: Option<usize>,
        _dim: usize,
    ) -> Result<GpuTensorHandle> { ... }
    fn unique(
        &self,
        _handle: &GpuTensorHandle,
        _options: &UniqueOptions,
    ) -> Result<UniqueResult> { ... }
    fn union(
        &self,
        _a: &GpuTensorHandle,
        _b: &GpuTensorHandle,
        _options: &UnionOptions,
    ) -> Result<UnionResult> { ... }
    fn setdiff(
        &self,
        _a: &GpuTensorHandle,
        _b: &GpuTensorHandle,
        _options: &SetdiffOptions,
    ) -> Result<SetdiffResult> { ... }
    fn ismember(
        &self,
        _a: &GpuTensorHandle,
        _b: &GpuTensorHandle,
        _options: &IsMemberOptions,
    ) -> Result<IsMemberResult> { ... }
    fn reshape(
        &self,
        handle: &GpuTensorHandle,
        new_shape: &[usize],
    ) -> Result<GpuTensorHandle> { ... }
    fn cat(
        &self,
        _dim: usize,
        _inputs: &[GpuTensorHandle],
    ) -> Result<GpuTensorHandle> { ... }
    fn repmat(
        &self,
        _handle: &GpuTensorHandle,
        _reps: &[usize],
    ) -> Result<GpuTensorHandle> { ... }
    fn kron(
        &self,
        _a: &GpuTensorHandle,
        _b: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn reduce_sum(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn reduce_sum_dim(
        &self,
        _a: &GpuTensorHandle,
        _dim: usize,
    ) -> Result<GpuTensorHandle> { ... }
    fn dot(
        &self,
        _lhs: &GpuTensorHandle,
        _rhs: &GpuTensorHandle,
        _dim: Option<usize>,
    ) -> Result<GpuTensorHandle> { ... }
    fn reduce_nnz(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn reduce_nnz_dim(
        &self,
        _a: &GpuTensorHandle,
        _dim: usize,
    ) -> Result<GpuTensorHandle> { ... }
    fn reduce_prod(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn reduce_prod_dim(
        &self,
        _a: &GpuTensorHandle,
        _dim: usize,
    ) -> Result<GpuTensorHandle> { ... }
    fn reduce_mean(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn reduce_mean_nd(
        &self,
        _a: &GpuTensorHandle,
        _dims_zero_based: &[usize],
    ) -> Result<GpuTensorHandle> { ... }
    fn reduce_moments_nd(
        &self,
        _a: &GpuTensorHandle,
        _dims_zero_based: &[usize],
    ) -> Result<ProviderMoments2> { ... }
    fn reduce_mean_dim(
        &self,
        _a: &GpuTensorHandle,
        _dim: usize,
    ) -> Result<GpuTensorHandle> { ... }
    fn reduce_std(
        &self,
        _a: &GpuTensorHandle,
        _normalization: ProviderStdNormalization,
        _nan_mode: ProviderNanMode,
    ) -> Result<GpuTensorHandle> { ... }
    fn reduce_std_dim(
        &self,
        _a: &GpuTensorHandle,
        _dim: usize,
        _normalization: ProviderStdNormalization,
        _nan_mode: ProviderNanMode,
    ) -> Result<GpuTensorHandle> { ... }
    fn reduce_any(
        &self,
        _a: &GpuTensorHandle,
        _omit_nan: bool,
    ) -> Result<GpuTensorHandle> { ... }
    fn reduce_any_dim(
        &self,
        _a: &GpuTensorHandle,
        _dim: usize,
        _omit_nan: bool,
    ) -> Result<GpuTensorHandle> { ... }
    fn reduce_all(
        &self,
        _a: &GpuTensorHandle,
        _omit_nan: bool,
    ) -> Result<GpuTensorHandle> { ... }
    fn reduce_all_dim(
        &self,
        _a: &GpuTensorHandle,
        _dim: usize,
        _omit_nan: bool,
    ) -> Result<GpuTensorHandle> { ... }
    fn reduce_median(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn reduce_median_dim(
        &self,
        _a: &GpuTensorHandle,
        _dim: usize,
    ) -> Result<GpuTensorHandle> { ... }
    fn reduce_min(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn reduce_min_dim(
        &self,
        _a: &GpuTensorHandle,
        _dim: usize,
    ) -> Result<ReduceDimResult> { ... }
    fn reduce_max(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn reduce_max_dim(
        &self,
        _a: &GpuTensorHandle,
        _dim: usize,
    ) -> Result<ReduceDimResult> { ... }
    fn cumsum_scan(
        &self,
        _input: &GpuTensorHandle,
        _dim: usize,
        _direction: ProviderScanDirection,
        _nan_mode: ProviderNanMode,
    ) -> Result<GpuTensorHandle> { ... }
    fn cumprod_scan(
        &self,
        _input: &GpuTensorHandle,
        _dim: usize,
        _direction: ProviderScanDirection,
        _nan_mode: ProviderNanMode,
    ) -> Result<GpuTensorHandle> { ... }
    fn cummin_scan(
        &self,
        _input: &GpuTensorHandle,
        _dim: usize,
        _direction: ProviderScanDirection,
        _nan_mode: ProviderNanMode,
    ) -> Result<ProviderCumminResult> { ... }
    fn cummax_scan(
        &self,
        _input: &GpuTensorHandle,
        _dim: usize,
        _direction: ProviderScanDirection,
        _nan_mode: ProviderNanMode,
    ) -> Result<ProviderCummaxResult> { ... }
    fn find(
        &self,
        _a: &GpuTensorHandle,
        _limit: Option<usize>,
        _direction: FindDirection,
    ) -> Result<ProviderFindResult> { ... }
    fn fused_elementwise(
        &self,
        _shader: &str,
        _inputs: &[GpuTensorHandle],
        _output_shape: &[usize],
        _len: usize,
    ) -> Result<GpuTensorHandle> { ... }
    fn map_nan_to_zero(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn not_nan_mask(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn fused_reduction(
        &self,
        _shader: &str,
        _inputs: &[GpuTensorHandle],
        _output_shape: &[usize],
        _reduce_len: usize,
        _num_slices: usize,
        _workgroup_size: u32,
        _flavor: ReductionFlavor,
    ) -> Result<GpuTensorHandle> { ... }
    fn warmup(&self) { ... }
    fn fused_cache_counters(&self) -> (u64, u64) { ... }
    fn last_warmup_millis(&self) -> Option<u64> { ... }
    fn telemetry_snapshot(&self) -> ProviderTelemetry { ... }
    fn reset_telemetry(&self) { ... }
    fn default_reduction_workgroup_size(&self) -> u32 { ... }
    fn two_pass_threshold(&self) -> usize { ... }
    fn reduction_two_pass_mode(&self) -> ReductionTwoPassMode { ... }
    fn scatter_column(
        &self,
        _matrix: &GpuTensorHandle,
        _col_index: usize,
        _values: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn scatter_row(
        &self,
        _matrix: &GpuTensorHandle,
        _row_index: usize,
        _values: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn sub2ind(
        &self,
        _dims: &[usize],
        _strides: &[usize],
        _inputs: &[&GpuTensorHandle],
        _scalar_mask: &[bool],
        _len: usize,
        _output_shape: &[usize],
    ) -> Result<GpuTensorHandle> { ... }
    fn supports_ind2sub(&self) -> bool { ... }
    fn ind2sub(
        &self,
        _dims: &[usize],
        _strides: &[usize],
        _indices: &GpuTensorHandle,
        _total: usize,
        _len: usize,
        _output_shape: &[usize],
    ) -> Result<Vec<GpuTensorHandle>> { ... }
    fn issymmetric(
        &self,
        _matrix: &GpuTensorHandle,
        _kind: ProviderSymmetryKind,
        _tolerance: f64,
    ) -> Result<bool> { ... }
    fn ishermitian(
        &self,
        _matrix: &GpuTensorHandle,
        _kind: ProviderHermitianKind,
        _tolerance: f64,
    ) -> Result<bool> { ... }
    fn bandwidth(&self, _matrix: &GpuTensorHandle) -> Result<ProviderBandwidth> { ... }
    fn sym_rcm(&self, _matrix: &GpuTensorHandle) -> Result<Vec<usize>> { ... }
}

Device/provider interface that backends implement and register into the runtime layer

Required Methods

fn upload(&self, host: &HostTensorView<'_>) -> Result<GpuTensorHandle>

fn download(&self, h: &GpuTensorHandle) -> Result<HostTensorOwned>

fn free(&self, h: &GpuTensorHandle) -> Result<()>

fn device_info(&self) -> String

Provided Methods

fn device_id(&self) -> u32

fn gather_linear( &self, _source: &GpuTensorHandle, _indices: &[u32], _output_shape: &[usize], ) -> Result<GpuTensorHandle>

Gather elements from source at the provided zero-based linear indices, materialising a dense tensor with the specified output_shape.

fn scatter_linear( &self, _target: &GpuTensorHandle, _indices: &[u32], _values: &GpuTensorHandle, ) -> Result<()>

Scatter the contents of values into target at the provided zero-based linear indices.

The provider must ensure values.len() == indices.len() and update target in place.

fn device_info_struct(&self) -> ApiDeviceInfo

Structured device information (optional to override). Default adapts from device_info().

fn precision(&self) -> ProviderPrecision

fn read_scalar(&self, _h: &GpuTensorHandle, _linear_index: usize) -> Result<f64>

Read a single scalar at linear index from a device tensor, returning it as f64.

fn zeros(&self, _shape: &[usize]) -> Result<GpuTensorHandle>

Allocate a zero-initialised tensor with the provided shape on the device.

fn ones(&self, _shape: &[usize]) -> Result<GpuTensorHandle>

Allocate a one-initialised tensor with the provided shape on the device.

fn zeros_like(&self, prototype: &GpuTensorHandle) -> Result<GpuTensorHandle>

Allocate a zero-initialised tensor matching the prototype tensor.

fn fill(&self, shape: &[usize], value: f64) -> Result<GpuTensorHandle>

Allocate a tensor filled with a constant value on the device.

fn fill_like( &self, prototype: &GpuTensorHandle, value: f64, ) -> Result<GpuTensorHandle>

Allocate a tensor filled with a constant value, matching a prototype’s residency.

fn ones_like(&self, prototype: &GpuTensorHandle) -> Result<GpuTensorHandle>

Allocate a one-initialised tensor matching the prototype tensor.

fn eye(&self, _shape: &[usize]) -> Result<GpuTensorHandle>

Allocate an identity tensor with ones along the leading diagonal of the first two axes.

fn eye_like(&self, prototype: &GpuTensorHandle) -> Result<GpuTensorHandle>

Allocate an identity tensor matching the prototype tensor’s shape.

fn meshgrid( &self, _axes: &[MeshgridAxisView<'_>], ) -> Result<ProviderMeshgridResult>

Construct MATLAB-style coordinate grids from axis vectors.

fn diag_from_vector( &self, _vector: &GpuTensorHandle, _offset: isize, ) -> Result<GpuTensorHandle>

Construct a diagonal matrix from a vector-like tensor. offset matches MATLAB semantics.

fn diag_extract( &self, _matrix: &GpuTensorHandle, _offset: isize, ) -> Result<GpuTensorHandle>

Extract a diagonal from a matrix-like tensor. The result is always a column vector.

fn tril( &self, _matrix: &GpuTensorHandle, _offset: isize, ) -> Result<GpuTensorHandle>

Apply a lower-triangular mask to the first two dimensions of a tensor.

fn triu( &self, _matrix: &GpuTensorHandle, _offset: isize, ) -> Result<GpuTensorHandle>

Apply an upper-triangular mask to the first two dimensions of a tensor.

fn polyval( &self, _coefficients: &GpuTensorHandle, _points: &GpuTensorHandle, _options: &ProviderPolyvalOptions, ) -> Result<GpuTensorHandle>

Evaluate a polynomial expressed by coefficients at each element in points.

fn polyfit( &self, _x: &GpuTensorHandle, _y: &GpuTensorHandle, _degree: usize, _weights: Option<&GpuTensorHandle>, ) -> Result<ProviderPolyfitResult>

Fit a polynomial of degree degree to (x, y) samples. Optional weights must match x.

fn polyder_single( &self, _polynomial: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

Differentiate a polynomial represented as a vector of coefficients.

fn polyder_product( &self, _p: &GpuTensorHandle, _q: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

Apply the product rule to polynomials p and q.

fn polyder_quotient( &self, _u: &GpuTensorHandle, _v: &GpuTensorHandle, ) -> Result<ProviderPolyderQuotient>

Apply the quotient rule to polynomials u and v.

fn polyint( &self, _polynomial: &GpuTensorHandle, _constant: f64, ) -> Result<GpuTensorHandle>

Integrate a polynomial represented as a vector of coefficients and append a constant term.

fn random_uniform(&self, _shape: &[usize]) -> Result<GpuTensorHandle>

Allocate a tensor filled with random values drawn from U(0, 1).

fn random_uniform_like( &self, prototype: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

Allocate a tensor filled with random values matching the prototype shape.

fn random_normal(&self, _shape: &[usize]) -> Result<GpuTensorHandle>

Allocate a tensor filled with standard normal (mean 0, stddev 1) random values.

fn random_normal_like( &self, prototype: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

Allocate a tensor of standard normal values matching a prototype’s shape.

fn stochastic_evolution( &self, _state: &GpuTensorHandle, _drift: f64, _scale: f64, _steps: u32, ) -> Result<GpuTensorHandle>

fn set_rng_state(&self, _state: u64) -> Result<()>

Set the provider RNG state to align with the host RNG.

fn fspecial(&self, _request: &FspecialRequest) -> Result<GpuTensorHandle>

Generate a 2-D correlation kernel matching MATLAB’s fspecial builtin.

fn imfilter( &self, _image: &GpuTensorHandle, _kernel: &GpuTensorHandle, _options: &ImfilterOptions, ) -> Result<GpuTensorHandle>

Apply an N-D correlation/convolution with padding semantics matching MATLAB’s imfilter.

fn random_integer_range( &self, _lower: i64, _upper: i64, _shape: &[usize], ) -> Result<GpuTensorHandle>

Allocate a tensor filled with random integers over an inclusive range.

fn random_integer_like( &self, prototype: &GpuTensorHandle, lower: i64, upper: i64, ) -> Result<GpuTensorHandle>

Allocate a random integer tensor matching the prototype shape.

fn random_permutation(&self, _n: usize, _k: usize) -> Result<GpuTensorHandle>

Allocate a random permutation of 1..=n, returning the first k elements.

fn random_permutation_like( &self, _prototype: &GpuTensorHandle, n: usize, k: usize, ) -> Result<GpuTensorHandle>

Allocate a random permutation matching the prototype residency.

fn covariance( &self, _matrix: &GpuTensorHandle, _second: Option<&GpuTensorHandle>, _weights: Option<&GpuTensorHandle>, _options: &CovarianceOptions, ) -> Result<GpuTensorHandle>

Compute a covariance matrix across the columns of matrix.

fn corrcoef( &self, _matrix: &GpuTensorHandle, _options: &CorrcoefOptions, ) -> Result<GpuTensorHandle>

Compute a correlation coefficient matrix across the columns of matrix.

fn linspace( &self, _start: f64, _stop: f64, _count: usize, ) -> Result<GpuTensorHandle>

fn elem_add( &self, _a: &GpuTensorHandle, _b: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

fn elem_mul( &self, _a: &GpuTensorHandle, _b: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

fn elem_max( &self, _a: &GpuTensorHandle, _b: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

fn elem_min( &self, _a: &GpuTensorHandle, _b: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

fn elem_sub( &self, _a: &GpuTensorHandle, _b: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

fn elem_div( &self, _a: &GpuTensorHandle, _b: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

fn elem_pow( &self, _a: &GpuTensorHandle, _b: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

fn elem_hypot( &self, _a: &GpuTensorHandle, _b: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

fn elem_ge( &self, _a: &GpuTensorHandle, _b: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

fn elem_le( &self, _a: &GpuTensorHandle, _b: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

fn elem_lt( &self, _a: &GpuTensorHandle, _b: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

fn elem_gt( &self, _a: &GpuTensorHandle, _b: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

fn elem_eq( &self, _a: &GpuTensorHandle, _b: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

fn elem_ne( &self, _a: &GpuTensorHandle, _b: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

fn logical_and( &self, _a: &GpuTensorHandle, _b: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

fn logical_or( &self, _a: &GpuTensorHandle, _b: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

fn logical_xor( &self, _a: &GpuTensorHandle, _b: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

fn logical_not(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn logical_islogical(&self, a: &GpuTensorHandle) -> Result<bool>

fn logical_isreal(&self, _a: &GpuTensorHandle) -> Result<bool>

fn logical_isfinite(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn logical_isnan(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn logical_isinf(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn elem_atan2( &self, _y: &GpuTensorHandle, _x: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

fn unary_sin(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_gamma(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_factorial(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_asinh(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_sinh(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_cosh(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_asin(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_acos(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_acosh(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_tan(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_tanh(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_atan(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_atanh(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_ceil(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_floor(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_round(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_fix(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_cos(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_angle(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_imag(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_real(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_conj(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_abs(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_sign(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_exp(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_expm1(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_log(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_log2(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_log10(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_log1p(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_sqrt(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_double(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_single(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn unary_pow2(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn pow2_scale( &self, _mantissa: &GpuTensorHandle, _exponent: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

fn scalar_rsub( &self, _a: &GpuTensorHandle, _scalar: f64, ) -> Result<GpuTensorHandle>

fn scalar_rdiv( &self, _a: &GpuTensorHandle, _scalar: f64, ) -> Result<GpuTensorHandle>

fn scalar_add( &self, _a: &GpuTensorHandle, _scalar: f64, ) -> Result<GpuTensorHandle>

fn scalar_sub( &self, _a: &GpuTensorHandle, _scalar: f64, ) -> Result<GpuTensorHandle>

fn scalar_mul( &self, _a: &GpuTensorHandle, _scalar: f64, ) -> Result<GpuTensorHandle>

fn scalar_max( &self, _a: &GpuTensorHandle, _scalar: f64, ) -> Result<GpuTensorHandle>

fn scalar_min( &self, _a: &GpuTensorHandle, _scalar: f64, ) -> Result<GpuTensorHandle>

fn scalar_div( &self, _a: &GpuTensorHandle, _scalar: f64, ) -> Result<GpuTensorHandle>

fn sort_dim( &self, _a: &GpuTensorHandle, _dim: usize, _order: SortOrder, _comparison: SortComparison, ) -> Result<SortResult>

fn sort_rows( &self, _a: &GpuTensorHandle, _columns: &[SortRowsColumnSpec], _comparison: SortComparison, ) -> Result<SortResult>

fn matmul( &self, _a: &GpuTensorHandle, _b: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

fn syrk(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn pagefun(&self, _request: &PagefunRequest) -> Result<GpuTensorHandle>

fn matmul_epilogue( &self, a: &GpuTensorHandle, b: &GpuTensorHandle, epilogue: &MatmulEpilogue, ) -> Result<GpuTensorHandle>

Optional: matrix multiplication with an epilogue applied before store.

The default implementation falls back to matmul when the epilogue is effectively a no-op (alpha=1, beta=0, no row/col scales), and otherwise returns Err.

fn image_normalize( &self, _input: &GpuTensorHandle, _desc: &ImageNormalizeDescriptor, ) -> Result<GpuTensorHandle>

fn matmul_power_step( &self, _lhs: &GpuTensorHandle, _rhs: &GpuTensorHandle, _epilogue: &PowerStepEpilogue, ) -> Result<GpuTensorHandle>

fn linsolve( &self, _lhs: &GpuTensorHandle, _rhs: &GpuTensorHandle, _options: &ProviderLinsolveOptions, ) -> Result<ProviderLinsolveResult>

fn inv( &self, _matrix: &GpuTensorHandle, _options: ProviderInvOptions, ) -> Result<GpuTensorHandle>

fn pinv( &self, _matrix: &GpuTensorHandle, _options: ProviderPinvOptions, ) -> Result<GpuTensorHandle>

fn cond( &self, _matrix: &GpuTensorHandle, _norm: ProviderCondNorm, ) -> Result<GpuTensorHandle>

fn norm( &self, _tensor: &GpuTensorHandle, _order: ProviderNormOrder, ) -> Result<GpuTensorHandle>

fn rank( &self, _matrix: &GpuTensorHandle, _tolerance: Option<f64>, ) -> Result<GpuTensorHandle>

fn rcond(&self, _matrix: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn mldivide( &self, _lhs: &GpuTensorHandle, _rhs: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

fn mrdivide( &self, _lhs: &GpuTensorHandle, _rhs: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

fn eig( &self, _a: &GpuTensorHandle, _compute_left: bool, ) -> Result<ProviderEigResult>

fn lu(&self, _a: &GpuTensorHandle) -> Result<ProviderLuResult>

fn chol(&self, _a: &GpuTensorHandle, _lower: bool) -> Result<ProviderCholResult>

fn qr( &self, _a: &GpuTensorHandle, _options: ProviderQrOptions, ) -> Result<ProviderQrResult>

fn take_matmul_sources( &self, _product: &GpuTensorHandle, ) -> Option<(GpuTensorHandle, GpuTensorHandle)>

fn qr_power_iter( &self, product: &GpuTensorHandle, _product_lhs: Option<&GpuTensorHandle>, q_handle: &GpuTensorHandle, options: &ProviderQrOptions, ) -> Result<Option<ProviderQrPowerIterResult>>

fn transpose(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn conv1d( &self, _signal: &GpuTensorHandle, _kernel: &GpuTensorHandle, _options: ProviderConv1dOptions, ) -> Result<GpuTensorHandle>

fn conv2d( &self, _signal: &GpuTensorHandle, _kernel: &GpuTensorHandle, _mode: ProviderConvMode, ) -> Result<GpuTensorHandle>

fn iir_filter( &self, _b: &GpuTensorHandle, _a: &GpuTensorHandle, _x: &GpuTensorHandle, _options: ProviderIirFilterOptions, ) -> Result<ProviderIirFilterResult>

fn permute( &self, _handle: &GpuTensorHandle, _order: &[usize], ) -> Result<GpuTensorHandle>

Reorder tensor dimensions according to order, expressed as zero-based indices.

fn flip( &self, _handle: &GpuTensorHandle, _axes: &[usize], ) -> Result<GpuTensorHandle>

fn circshift( &self, _handle: &GpuTensorHandle, _shifts: &[isize], ) -> Result<GpuTensorHandle>

fn diff_dim( &self, _handle: &GpuTensorHandle, _order: usize, _dim: usize, ) -> Result<GpuTensorHandle>

fn fft_dim( &self, _handle: &GpuTensorHandle, _len: Option<usize>, _dim: usize, ) -> Result<GpuTensorHandle>

Perform an in-place FFT along a zero-based dimension, optionally padding/truncating to len.

fn ifft_dim( &self, _handle: &GpuTensorHandle, _len: Option<usize>, _dim: usize, ) -> Result<GpuTensorHandle>

fn unique( &self, _handle: &GpuTensorHandle, _options: &UniqueOptions, ) -> Result<UniqueResult>

fn union( &self, _a: &GpuTensorHandle, _b: &GpuTensorHandle, _options: &UnionOptions, ) -> Result<UnionResult>

fn setdiff( &self, _a: &GpuTensorHandle, _b: &GpuTensorHandle, _options: &SetdiffOptions, ) -> Result<SetdiffResult>

fn ismember( &self, _a: &GpuTensorHandle, _b: &GpuTensorHandle, _options: &IsMemberOptions, ) -> Result<IsMemberResult>

fn reshape( &self, handle: &GpuTensorHandle, new_shape: &[usize], ) -> Result<GpuTensorHandle>

fn cat( &self, _dim: usize, _inputs: &[GpuTensorHandle], ) -> Result<GpuTensorHandle>

Concatenate the provided tensors along the 1-based dimension dim.

fn repmat( &self, _handle: &GpuTensorHandle, _reps: &[usize], ) -> Result<GpuTensorHandle>

fn kron( &self, _a: &GpuTensorHandle, _b: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

Compute the Kronecker product of two tensors, matching MATLAB semantics.

fn reduce_sum(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn reduce_sum_dim( &self, _a: &GpuTensorHandle, _dim: usize, ) -> Result<GpuTensorHandle>

fn dot( &self, _lhs: &GpuTensorHandle, _rhs: &GpuTensorHandle, _dim: Option<usize>, ) -> Result<GpuTensorHandle>

fn reduce_nnz(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn reduce_nnz_dim( &self, _a: &GpuTensorHandle, _dim: usize, ) -> Result<GpuTensorHandle>

fn reduce_prod(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn reduce_prod_dim( &self, _a: &GpuTensorHandle, _dim: usize, ) -> Result<GpuTensorHandle>

fn reduce_mean(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn reduce_mean_nd( &self, _a: &GpuTensorHandle, _dims_zero_based: &[usize], ) -> Result<GpuTensorHandle>

Reduce mean across multiple zero-based dimensions in one device pass.

fn reduce_moments_nd( &self, _a: &GpuTensorHandle, _dims_zero_based: &[usize], ) -> Result<ProviderMoments2>

Reduce moments across multiple zero-based dimensions in one device pass. Returns mean (E[x]) and mean of squares (E[x^2]).

fn reduce_mean_dim( &self, _a: &GpuTensorHandle, _dim: usize, ) -> Result<GpuTensorHandle>

fn reduce_std( &self, _a: &GpuTensorHandle, _normalization: ProviderStdNormalization, _nan_mode: ProviderNanMode, ) -> Result<GpuTensorHandle>

fn reduce_std_dim( &self, _a: &GpuTensorHandle, _dim: usize, _normalization: ProviderStdNormalization, _nan_mode: ProviderNanMode, ) -> Result<GpuTensorHandle>

fn reduce_any( &self, _a: &GpuTensorHandle, _omit_nan: bool, ) -> Result<GpuTensorHandle>

fn reduce_any_dim( &self, _a: &GpuTensorHandle, _dim: usize, _omit_nan: bool, ) -> Result<GpuTensorHandle>

fn reduce_all( &self, _a: &GpuTensorHandle, _omit_nan: bool, ) -> Result<GpuTensorHandle>

fn reduce_all_dim( &self, _a: &GpuTensorHandle, _dim: usize, _omit_nan: bool, ) -> Result<GpuTensorHandle>

fn reduce_median(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn reduce_median_dim( &self, _a: &GpuTensorHandle, _dim: usize, ) -> Result<GpuTensorHandle>

fn reduce_min(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn reduce_min_dim( &self, _a: &GpuTensorHandle, _dim: usize, ) -> Result<ReduceDimResult>

fn reduce_max(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

fn reduce_max_dim( &self, _a: &GpuTensorHandle, _dim: usize, ) -> Result<ReduceDimResult>

fn cumsum_scan( &self, _input: &GpuTensorHandle, _dim: usize, _direction: ProviderScanDirection, _nan_mode: ProviderNanMode, ) -> Result<GpuTensorHandle>

fn cumprod_scan( &self, _input: &GpuTensorHandle, _dim: usize, _direction: ProviderScanDirection, _nan_mode: ProviderNanMode, ) -> Result<GpuTensorHandle>

fn cummin_scan( &self, _input: &GpuTensorHandle, _dim: usize, _direction: ProviderScanDirection, _nan_mode: ProviderNanMode, ) -> Result<ProviderCumminResult>

fn cummax_scan( &self, _input: &GpuTensorHandle, _dim: usize, _direction: ProviderScanDirection, _nan_mode: ProviderNanMode, ) -> Result<ProviderCummaxResult>

fn find( &self, _a: &GpuTensorHandle, _limit: Option<usize>, _direction: FindDirection, ) -> Result<ProviderFindResult>

fn fused_elementwise( &self, _shader: &str, _inputs: &[GpuTensorHandle], _output_shape: &[usize], _len: usize, ) -> Result<GpuTensorHandle>

fn map_nan_to_zero(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

Build a numeric tensor where NaNs in a are replaced with 0.0 (device side).

fn not_nan_mask(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle>

Build a numeric mask tensor with 1.0 where value is not NaN and 0.0 where value is NaN.

fn fused_reduction( &self, _shader: &str, _inputs: &[GpuTensorHandle], _output_shape: &[usize], _reduce_len: usize, _num_slices: usize, _workgroup_size: u32, _flavor: ReductionFlavor, ) -> Result<GpuTensorHandle>

Generic fused reduction entrypoint.

The shader is expected to implement a column-major reduction across reduce_len with num_slices independent slices (e.g., columns). Providers should create a uniform buffer compatible with the expected Params/MParams struct in the shader and dispatch num_slices workgroups with workgroup_size threads, or an equivalent strategy.

fn warmup(&self)

Optionally pre-compile commonly used pipelines to amortize first-dispatch costs.

fn fused_cache_counters(&self) -> (u64, u64)

Returns (cache_hits, cache_misses) for fused pipeline cache, if supported.

fn last_warmup_millis(&self) -> Option<u64>

Returns the duration of the last provider warmup in milliseconds, if known.

fn telemetry_snapshot(&self) -> ProviderTelemetry

Returns a snapshot of provider telemetry counters if supported.

fn reset_telemetry(&self)

Reset all telemetry counters maintained by the provider, if supported.

fn default_reduction_workgroup_size(&self) -> u32

Default reduction workgroup size the provider prefers.

fn two_pass_threshold(&self) -> usize

Threshold above which provider will prefer two-pass reduction.

fn reduction_two_pass_mode(&self) -> ReductionTwoPassMode

Current two-pass mode preference (auto/forced on/off).

fn scatter_column( &self, _matrix: &GpuTensorHandle, _col_index: usize, _values: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

Fast-path: write a GPU column in a matrix from a GPU vector, returning a new handle. Expected: values.shape == [rows, 1] (or [rows]) and col_index < cols.

fn scatter_row( &self, _matrix: &GpuTensorHandle, _row_index: usize, _values: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

Fast-path: write a GPU row in a matrix from a GPU vector, returning a new handle. Expected: values.shape == [1, cols] (or [cols]) and row_index < rows.

fn sub2ind( &self, _dims: &[usize], _strides: &[usize], _inputs: &[&GpuTensorHandle], _scalar_mask: &[bool], _len: usize, _output_shape: &[usize], ) -> Result<GpuTensorHandle>

fn supports_ind2sub(&self) -> bool

Returns true if the provider offers a device-side ind2sub implementation.

fn ind2sub( &self, _dims: &[usize], _strides: &[usize], _indices: &GpuTensorHandle, _total: usize, _len: usize, _output_shape: &[usize], ) -> Result<Vec<GpuTensorHandle>>

Convert linear indices into per-dimension subscripts on the device.

fn issymmetric( &self, _matrix: &GpuTensorHandle, _kind: ProviderSymmetryKind, _tolerance: f64, ) -> Result<bool>

Determine if a matrix is symmetric (or skew-symmetric) without gathering it to the host.

fn ishermitian( &self, _matrix: &GpuTensorHandle, _kind: ProviderHermitianKind, _tolerance: f64, ) -> Result<bool>

Determine if a matrix is Hermitian (or skew-Hermitian) without gathering it to the host.

fn bandwidth(&self, _matrix: &GpuTensorHandle) -> Result<ProviderBandwidth>

Inspect the bandwidth of a matrix without gathering it back to the host.

fn sym_rcm(&self, _matrix: &GpuTensorHandle) -> Result<Vec<usize>>

Compute the symmetric reverse Cuthill-McKee permutation for the matrix.

Implementations may execute on the device or gather to the host. The permutation should be returned as zero-based indices.

Implementors