Trait AccelProvider 

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

    // Provided methods
    fn device_id(&self) -> u32 { ... }
    fn spawn_handle_concurrency(&self) -> SpawnHandleConcurrency { ... }
    fn export_context(
        &self,
        _kind: AccelContextKind,
    ) -> Option<AccelContextHandle> { ... }
    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 zeros_with_storage(
        &self,
        shape: &[usize],
        storage: GpuTensorStorage,
    ) -> 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 ndgrid(
        &self,
        _request: &ProviderNdgridRequest<'_>,
    ) -> Result<ProviderNdgridResult> { ... }
    fn black_scholes_price(
        &self,
        _request: &ProviderBlackScholesPriceRequest<'_>,
    ) -> Result<ProviderBlackScholesPriceResult> { ... }
    fn adam_update(
        &self,
        _request: &ProviderAdamUpdateRequest<'_>,
    ) -> Result<ProviderAdamUpdateResult> { ... }
    fn crossentropy_terms(
        &self,
        _request: &ProviderCrossentropyRequest<'_>,
    ) -> Result<ProviderCrossentropyResult> { ... }
    fn diag_from_vector(
        &self,
        _vector: &GpuTensorHandle,
        _offset: isize,
    ) -> Result<GpuTensorHandle> { ... }
    fn diag_from_vector_sized(
        &self,
        _vector: &GpuTensorHandle,
        _offset: isize,
        _rows: usize,
        _cols: usize,
    ) -> Result<GpuTensorHandle> { ... }
    fn diag_extract(
        &self,
        _matrix: &GpuTensorHandle,
        _offset: isize,
    ) -> Result<GpuTensorHandle> { ... }
    fn tril<'a>(
        &'a self,
        _matrix: &'a GpuTensorHandle,
        _offset: isize,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn triu<'a>(
        &'a self,
        _matrix: &'a GpuTensorHandle,
        _offset: isize,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn polyval(
        &self,
        _coefficients: &GpuTensorHandle,
        _points: &GpuTensorHandle,
        _options: &ProviderPolyvalOptions,
    ) -> Result<GpuTensorHandle> { ... }
    fn polyfit<'a>(
        &'a self,
        _x: &'a GpuTensorHandle,
        _y: &'a GpuTensorHandle,
        _degree: usize,
        _weights: Option<&'a GpuTensorHandle>,
    ) -> AccelProviderFuture<'a, ProviderPolyfitResult> { ... }
    fn polyder_single<'a>(
        &'a self,
        _polynomial: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn polyder_product<'a>(
        &'a self,
        _p: &'a GpuTensorHandle,
        _q: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn polyder_quotient<'a>(
        &'a self,
        _u: &'a GpuTensorHandle,
        _v: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, 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 random_exponential(
        &self,
        _mu: f64,
        _shape: &[usize],
    ) -> Result<GpuTensorHandle> { ... }
    fn random_normrnd(
        &self,
        _mu: f64,
        _sigma: f64,
        _shape: &[usize],
    ) -> Result<GpuTensorHandle> { ... }
    fn random_unifrnd(
        &self,
        _a: f64,
        _b: f64,
        _shape: &[usize],
    ) -> 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 peaks(&self, _n: usize) -> Result<GpuTensorHandle> { ... }
    fn peaks_xy(
        &self,
        _x: &GpuTensorHandle,
        _y: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn hann_window(
        &self,
        _len: usize,
        _periodic: bool,
    ) -> Result<GpuTensorHandle> { ... }
    fn hamming_window(
        &self,
        _len: usize,
        _periodic: bool,
    ) -> Result<GpuTensorHandle> { ... }
    fn blackman_window(
        &self,
        _len: usize,
        _periodic: bool,
    ) -> Result<GpuTensorHandle> { ... }
    fn imfilter<'a>(
        &'a self,
        _image: &'a GpuTensorHandle,
        _kernel: &'a GpuTensorHandle,
        _options: &'a ImfilterOptions,
    ) -> AccelProviderFuture<'a, 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<'a>(
        &'a self,
        _matrix: &'a GpuTensorHandle,
        _second: Option<&'a GpuTensorHandle>,
        _weights: Option<&'a GpuTensorHandle>,
        _options: &'a CovarianceOptions,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn corrcoef<'a>(
        &'a self,
        _matrix: &'a GpuTensorHandle,
        _options: &'a CorrcoefOptions,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn covariance_to_correlation(
        &self,
        _matrix: &GpuTensorHandle,
    ) -> Result<ProviderCovarianceToCorrelationResult> { ... }
    fn linspace(
        &self,
        _start: f64,
        _stop: f64,
        _count: usize,
    ) -> Result<GpuTensorHandle> { ... }
    fn elem_add<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _b: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn elem_mul<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _b: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn elem_max<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _b: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn elem_min<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _b: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn elem_sub<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _b: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn elem_div<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _b: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn elem_pow<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _b: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn complex_from_real<'a>(
        &'a self,
        _real: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn complex_from_real_imag<'a>(
        &'a self,
        _real: &'a GpuTensorHandle,
        _imag: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn modulate_constellation<'a>(
        &'a self,
        _request: ProviderModulationRequest<'a>,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn modulate_bits_constellation<'a>(
        &'a self,
        _request: ProviderBitModulationRequest<'a>,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn elem_hypot<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _b: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn elem_ge<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _b: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn elem_le<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _b: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn elem_lt<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _b: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn elem_gt<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _b: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn elem_eq<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _b: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn elem_ne<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _b: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, 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<'a>(
        &'a self,
        _y: &'a GpuTensorHandle,
        _x: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_sin<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_sinc<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_gamma<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_gammaln<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_erf<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_erfcinv<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_factorial<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_asinh<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_sinh<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_cosh<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_asin<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_acos<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_acosh<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_tan<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_tanh<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_atan<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_atanh<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_ceil<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_floor<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_round<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn round_digits<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _digits: i32,
        _significant: bool,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_fix<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_cos<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_angle<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_imag<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_real<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_conj<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_abs<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_sign<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_heaviside<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_exp<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_expm1<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_log<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_log2<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_log10<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_log1p<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_sqrt<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_double<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_single<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_pow2<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unary_nextpow2<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, 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<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _dim: usize,
        _order: SortOrder,
        _comparison: SortComparison,
    ) -> AccelProviderFuture<'a, SortResult> { ... }
    fn sort_rows<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _columns: &'a [SortRowsColumnSpec],
        _comparison: SortComparison,
    ) -> AccelProviderFuture<'a, SortResult> { ... }
    fn matmul<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _b: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn syrk(&self, _a: &GpuTensorHandle) -> Result<GpuTensorHandle> { ... }
    fn pagefun(&self, _request: &PagefunRequest) -> Result<GpuTensorHandle> { ... }
    fn matmul_epilogue<'a>(
        &'a self,
        a: &'a GpuTensorHandle,
        b: &'a GpuTensorHandle,
        epilogue: &'a MatmulEpilogue,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn image_normalize<'a>(
        &'a self,
        _input: &'a GpuTensorHandle,
        _desc: &'a ImageNormalizeDescriptor,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn matmul_power_step<'a>(
        &'a self,
        _lhs: &'a GpuTensorHandle,
        _rhs: &'a GpuTensorHandle,
        _epilogue: &'a PowerStepEpilogue,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn linsolve<'a>(
        &'a self,
        _lhs: &'a GpuTensorHandle,
        _rhs: &'a GpuTensorHandle,
        _options: &'a ProviderLinsolveOptions,
    ) -> AccelProviderFuture<'a, ProviderLinsolveResult> { ... }
    fn inv<'a>(
        &'a self,
        _matrix: &'a GpuTensorHandle,
        _options: ProviderInvOptions,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn pinv<'a>(
        &'a self,
        _matrix: &'a GpuTensorHandle,
        _options: ProviderPinvOptions,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn cond<'a>(
        &'a self,
        _matrix: &'a GpuTensorHandle,
        _norm: ProviderCondNorm,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn norm<'a>(
        &'a self,
        _tensor: &'a GpuTensorHandle,
        _order: ProviderNormOrder,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn interp1<'a>(
        &'a self,
        _request: &'a ProviderInterp1Request<'a>,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn rank<'a>(
        &'a self,
        _matrix: &'a GpuTensorHandle,
        _tolerance: Option<f64>,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn rcond<'a>(
        &'a self,
        _matrix: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn mldivide<'a>(
        &'a self,
        _lhs: &'a GpuTensorHandle,
        _rhs: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn mrdivide<'a>(
        &'a self,
        _lhs: &'a GpuTensorHandle,
        _rhs: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn eig<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _compute_left: bool,
    ) -> AccelProviderFuture<'a, ProviderEigResult> { ... }
    fn lu<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, ProviderLuResult> { ... }
    fn chol<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _lower: bool,
    ) -> AccelProviderFuture<'a, ProviderCholResult> { ... }
    fn qr<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _options: ProviderQrOptions,
    ) -> AccelProviderFuture<'a, ProviderQrResult> { ... }
    fn take_matmul_sources(
        &self,
        _product: &GpuTensorHandle,
    ) -> Option<(GpuTensorHandle, GpuTensorHandle)> { ... }
    fn qr_power_iter<'a>(
        &'a self,
        product: &'a GpuTensorHandle,
        _product_lhs: Option<&'a GpuTensorHandle>,
        q_handle: &'a GpuTensorHandle,
        options: &'a ProviderQrOptions,
    ) -> AccelProviderFuture<'a, 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<'a>(
        &'a self,
        _b: &'a GpuTensorHandle,
        _a: &'a GpuTensorHandle,
        _x: &'a GpuTensorHandle,
        _options: ProviderIirFilterOptions,
    ) -> AccelProviderFuture<'a, ProviderIirFilterResult> { ... }
    fn uniform_spectral_estimate<'a>(
        &'a self,
        _request: &'a ProviderSpectralRequest<'a>,
    ) -> AccelProviderFuture<'a, ProviderSpectralResult> { ... }
    fn signal_envelope<'a>(
        &'a self,
        _request: &'a ProviderEnvelopeRequest<'a>,
    ) -> AccelProviderFuture<'a, ProviderEnvelopeResult> { ... }
    fn signal_hilbert<'a>(
        &'a self,
        _request: &'a ProviderHilbertRequest<'a>,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    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 gradient_dim(
        &self,
        _handle: &GpuTensorHandle,
        _dim: usize,
        _spacing: f64,
    ) -> Result<GpuTensorHandle> { ... }
    fn gradient_dim_with_coordinates(
        &self,
        _handle: &GpuTensorHandle,
        _dim: usize,
        _coordinates: &GpuTensorHandle,
    ) -> Result<GpuTensorHandle> { ... }
    fn fft_dim<'a>(
        &'a self,
        _handle: &'a GpuTensorHandle,
        _len: Option<usize>,
        _dim: usize,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn ifft_dim<'a>(
        &'a self,
        _handle: &'a GpuTensorHandle,
        _len: Option<usize>,
        _dim: usize,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn fft_extract_real<'a>(
        &'a self,
        _handle: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn unique<'a>(
        &'a self,
        _handle: &'a GpuTensorHandle,
        _options: &'a UniqueOptions,
    ) -> AccelProviderFuture<'a, UniqueResult> { ... }
    fn union<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _b: &'a GpuTensorHandle,
        _options: &'a UnionOptions,
    ) -> AccelProviderFuture<'a, UnionResult> { ... }
    fn setdiff<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _b: &'a GpuTensorHandle,
        _options: &'a SetdiffOptions,
    ) -> AccelProviderFuture<'a, SetdiffResult> { ... }
    fn ismember<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _b: &'a GpuTensorHandle,
        _options: &'a IsMemberOptions,
    ) -> AccelProviderFuture<'a, 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 cross(
        &self,
        _lhs: &GpuTensorHandle,
        _rhs: &GpuTensorHandle,
        _dim: Option<usize>,
    ) -> Result<GpuTensorHandle> { ... }
    fn reduce_sum<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_sum_dim<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _dim: usize,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn dot<'a>(
        &'a self,
        _lhs: &'a GpuTensorHandle,
        _rhs: &'a GpuTensorHandle,
        _dim: Option<usize>,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_nnz<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_nnz_dim<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _dim: usize,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_prod<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_prod_dim<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _dim: usize,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_mean<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_mean_nd<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _dims_zero_based: &'a [usize],
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_moments_nd<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _dims_zero_based: &'a [usize],
    ) -> AccelProviderFuture<'a, ProviderMoments2> { ... }
    fn reduce_mean_dim<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _dim: usize,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_std<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _normalization: ProviderStdNormalization,
        _nan_mode: ProviderNanMode,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_std_dim<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _dim: usize,
        _normalization: ProviderStdNormalization,
        _nan_mode: ProviderNanMode,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_any<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _omit_nan: bool,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_any_dim<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _dim: usize,
        _omit_nan: bool,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_all<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _omit_nan: bool,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_all_dim<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _dim: usize,
        _omit_nan: bool,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_median<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_median_dim<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _dim: usize,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn mode_values<'a>(
        &'a self,
        _request: &'a ProviderModeRequest<'a>,
    ) -> AccelProviderFuture<'a, ProviderModeResult> { ... }
    fn moving_window<'a>(
        &'a self,
        _request: &'a ProviderMovingWindowRequest<'a>,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_min<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_min_dim<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _dim: usize,
    ) -> AccelProviderFuture<'a, ReduceDimResult> { ... }
    fn reduce_max<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_max_dim<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _dim: usize,
    ) -> AccelProviderFuture<'a, ReduceDimResult> { ... }
    fn cumsum_scan(
        &self,
        _input: &GpuTensorHandle,
        _dim: usize,
        _direction: ProviderScanDirection,
        _nan_mode: ProviderNanMode,
    ) -> Result<GpuTensorHandle> { ... }
    fn trapz_dim(
        &self,
        _input: &GpuTensorHandle,
        _dim: usize,
        _spacing: ProviderTrapezoidSpacing<'_>,
    ) -> Result<GpuTensorHandle> { ... }
    fn cumtrapz_dim(
        &self,
        _input: &GpuTensorHandle,
        _dim: usize,
        _spacing: ProviderTrapezoidSpacing<'_>,
    ) -> 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 fused_elementwise_multi(
        &self,
        _shader: &str,
        _inputs: &[GpuTensorHandle],
        _output_shape: &[usize],
        _len: usize,
        _num_outputs: usize,
    ) -> Result<Vec<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<'a>(
        &'a self,
        _matrix: &'a GpuTensorHandle,
        _kind: ProviderHermitianKind,
        _tolerance: f64,
    ) -> AccelProviderFuture<'a, bool> { ... }
    fn bandwidth(&self, _matrix: &GpuTensorHandle) -> Result<ProviderBandwidth> { ... }
    fn sym_rcm<'a>(
        &'a self,
        _matrix: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, 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<'a>(&'a self, h: &'a GpuTensorHandle) -> AccelDownloadFuture<'a>

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

fn device_info(&self) -> String

Provided Methods

fn device_id(&self) -> u32

fn spawn_handle_concurrency(&self) -> SpawnHandleConcurrency

Declares provider policy for sharing GpuTensorHandle values across spawned async boundaries.

Default is conservative rejection. Providers that can safely support cross-task sharing should override this.

fn export_context(&self, _kind: AccelContextKind) -> Option<AccelContextHandle>

Export a shared GPU context handle, allowing downstream systems (plotting, visualization) to reuse the same device/queue without copying tensor data back to the host.

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

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

Indices address MATLAB logical elements, not raw provider storage lanes. Providers that store complex values as interleaved lanes must copy both lanes for each selected element and preserve the source storage kind on the output handle.

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

Scatter logical elements from values into target at the provided zero-based linear indices.

Indices address MATLAB logical elements, not raw provider storage lanes. Providers must ensure values has one logical element per index, copy all lanes for the handle storage kind, and update target in place without changing its shape or storage.

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 zeros_with_storage( &self, shape: &[usize], storage: GpuTensorStorage, ) -> Result<GpuTensorHandle>

Allocate a zero-initialised tensor with the provided shape and storage layout.

shape is the logical MATLAB shape. Providers must allocate enough raw lanes for the requested storage kind, e.g. two interleaved numeric lanes per logical element for complex tensors.

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 ndgrid( &self, _request: &ProviderNdgridRequest<'_>, ) -> Result<ProviderNdgridResult>

Construct MATLAB-style N-D coordinate grids from resident GPU axis vectors.

fn black_scholes_price( &self, _request: &ProviderBlackScholesPriceRequest<'_>, ) -> Result<ProviderBlackScholesPriceResult>

Compute vectorized Black-Scholes European call and put prices on resident GPU inputs.

fn adam_update( &self, _request: &ProviderAdamUpdateRequest<'_>, ) -> Result<ProviderAdamUpdateResult>

Apply the Adam optimizer update to resident parameter and state tensors.

fn crossentropy_terms( &self, _request: &ProviderCrossentropyRequest<'_>, ) -> Result<ProviderCrossentropyResult>

Compute per-element cross-entropy loss terms for resident prediction and target tensors.

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_from_vector_sized( &self, _vector: &GpuTensorHandle, _offset: isize, _rows: usize, _cols: usize, ) -> Result<GpuTensorHandle>

Construct a diagonal matrix with an explicit shape from a vector-like tensor. offset matches MATLAB semantics; values that do not fit inside the requested rectangle are ignored.

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<'a>( &'a self, _matrix: &'a GpuTensorHandle, _offset: isize, ) -> AccelProviderFuture<'a, GpuTensorHandle>

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

fn triu<'a>( &'a self, _matrix: &'a GpuTensorHandle, _offset: isize, ) -> AccelProviderFuture<'a, 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<'a>( &'a self, _x: &'a GpuTensorHandle, _y: &'a GpuTensorHandle, _degree: usize, _weights: Option<&'a GpuTensorHandle>, ) -> AccelProviderFuture<'a, ProviderPolyfitResult>

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

fn polyder_single<'a>( &'a self, _polynomial: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

Differentiate a polynomial represented as a vector of coefficients.

fn polyder_product<'a>( &'a self, _p: &'a GpuTensorHandle, _q: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

Apply the product rule to polynomials p and q.

fn polyder_quotient<'a>( &'a self, _u: &'a GpuTensorHandle, _v: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, 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 random_exponential( &self, _mu: f64, _shape: &[usize], ) -> Result<GpuTensorHandle>

Exponentially-distributed random values with mean mu.

fn random_normrnd( &self, _mu: f64, _sigma: f64, _shape: &[usize], ) -> Result<GpuTensorHandle>

Normal random values with mean mu and standard deviation sigma.

fn random_unifrnd( &self, _a: f64, _b: f64, _shape: &[usize], ) -> Result<GpuTensorHandle>

Uniform random values on the interval [a, b).

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 peaks(&self, _n: usize) -> Result<GpuTensorHandle>

Evaluate the peaks test surface on an n×n grid spanning [-3,3]×[-3,3]. Returns the Z matrix (n×n) as a GPU tensor.

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

Evaluate the peaks formula element-wise on caller-supplied GPU coordinate tensors. X and Y must have the same shape. Returns a Z tensor of the same shape.

fn hann_window(&self, _len: usize, _periodic: bool) -> Result<GpuTensorHandle>

fn hamming_window( &self, _len: usize, _periodic: bool, ) -> Result<GpuTensorHandle>

fn blackman_window( &self, _len: usize, _periodic: bool, ) -> Result<GpuTensorHandle>

fn imfilter<'a>( &'a self, _image: &'a GpuTensorHandle, _kernel: &'a GpuTensorHandle, _options: &'a ImfilterOptions, ) -> AccelProviderFuture<'a, 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<'a>( &'a self, _matrix: &'a GpuTensorHandle, _second: Option<&'a GpuTensorHandle>, _weights: Option<&'a GpuTensorHandle>, _options: &'a CovarianceOptions, ) -> AccelProviderFuture<'a, GpuTensorHandle>

Compute a covariance matrix across the columns of matrix.

fn corrcoef<'a>( &'a self, _matrix: &'a GpuTensorHandle, _options: &'a CorrcoefOptions, ) -> AccelProviderFuture<'a, GpuTensorHandle>

Compute a correlation coefficient matrix across the columns of matrix.

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

Convert a resident covariance matrix into correlation and sigma outputs.

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

fn elem_add<'a>( &'a self, _a: &'a GpuTensorHandle, _b: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn elem_mul<'a>( &'a self, _a: &'a GpuTensorHandle, _b: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn elem_max<'a>( &'a self, _a: &'a GpuTensorHandle, _b: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn elem_min<'a>( &'a self, _a: &'a GpuTensorHandle, _b: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn elem_sub<'a>( &'a self, _a: &'a GpuTensorHandle, _b: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn elem_div<'a>( &'a self, _a: &'a GpuTensorHandle, _b: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn elem_pow<'a>( &'a self, _a: &'a GpuTensorHandle, _b: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn complex_from_real<'a>( &'a self, _real: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

Construct complex-interleaved GPU storage from a real-valued tensor, using zero for the imaginary lane.

fn complex_from_real_imag<'a>( &'a self, _real: &'a GpuTensorHandle, _imag: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

Construct complex-interleaved GPU storage from real and imaginary tensors.

Implementations should support equal shapes and scalar expansion for either operand, matching MATLAB’s complex(real, imag) size rules.

fn modulate_constellation<'a>( &'a self, _request: ProviderModulationRequest<'a>, ) -> AccelProviderFuture<'a, GpuTensorHandle>

Map a resident real-valued symbol tensor through a complex constellation table and return complex-interleaved GPU storage.

fn modulate_bits_constellation<'a>( &'a self, _request: ProviderBitModulationRequest<'a>, ) -> AccelProviderFuture<'a, GpuTensorHandle>

Group a resident real/logical bit tensor into symbols, map through a complex constellation table, and return complex-interleaved GPU storage.

fn elem_hypot<'a>( &'a self, _a: &'a GpuTensorHandle, _b: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn elem_ge<'a>( &'a self, _a: &'a GpuTensorHandle, _b: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn elem_le<'a>( &'a self, _a: &'a GpuTensorHandle, _b: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn elem_lt<'a>( &'a self, _a: &'a GpuTensorHandle, _b: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn elem_gt<'a>( &'a self, _a: &'a GpuTensorHandle, _b: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn elem_eq<'a>( &'a self, _a: &'a GpuTensorHandle, _b: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn elem_ne<'a>( &'a self, _a: &'a GpuTensorHandle, _b: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, 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<'a>( &'a self, _y: &'a GpuTensorHandle, _x: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_sin<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_sinc<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_gamma<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_gammaln<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_erf<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_erfcinv<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_factorial<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_asinh<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_sinh<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_cosh<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_asin<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_acos<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_acosh<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_tan<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_tanh<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_atan<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_atanh<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_ceil<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_floor<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_round<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn round_digits<'a>( &'a self, _a: &'a GpuTensorHandle, _digits: i32, _significant: bool, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_fix<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_cos<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_angle<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_imag<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_real<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_conj<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_abs<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_sign<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_heaviside<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_exp<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_expm1<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_log<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_log2<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_log10<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_log1p<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_sqrt<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_double<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_single<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_pow2<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn unary_nextpow2<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, 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<'a>( &'a self, _a: &'a GpuTensorHandle, _dim: usize, _order: SortOrder, _comparison: SortComparison, ) -> AccelProviderFuture<'a, SortResult>

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

fn matmul<'a>( &'a self, _a: &'a GpuTensorHandle, _b: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

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

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

fn matmul_epilogue<'a>( &'a self, a: &'a GpuTensorHandle, b: &'a GpuTensorHandle, epilogue: &'a MatmulEpilogue, ) -> AccelProviderFuture<'a, 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<'a>( &'a self, _input: &'a GpuTensorHandle, _desc: &'a ImageNormalizeDescriptor, ) -> AccelProviderFuture<'a, GpuTensorHandle>

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

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

fn inv<'a>( &'a self, _matrix: &'a GpuTensorHandle, _options: ProviderInvOptions, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn pinv<'a>( &'a self, _matrix: &'a GpuTensorHandle, _options: ProviderPinvOptions, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn cond<'a>( &'a self, _matrix: &'a GpuTensorHandle, _norm: ProviderCondNorm, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn norm<'a>( &'a self, _tensor: &'a GpuTensorHandle, _order: ProviderNormOrder, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn interp1<'a>( &'a self, _request: &'a ProviderInterp1Request<'a>, ) -> AccelProviderFuture<'a, GpuTensorHandle>

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

fn rcond<'a>( &'a self, _matrix: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn mldivide<'a>( &'a self, _lhs: &'a GpuTensorHandle, _rhs: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn mrdivide<'a>( &'a self, _lhs: &'a GpuTensorHandle, _rhs: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

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

fn lu<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, ProviderLuResult>

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

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

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

fn qr_power_iter<'a>( &'a self, product: &'a GpuTensorHandle, _product_lhs: Option<&'a GpuTensorHandle>, q_handle: &'a GpuTensorHandle, options: &'a ProviderQrOptions, ) -> AccelProviderFuture<'a, 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<'a>( &'a self, _b: &'a GpuTensorHandle, _a: &'a GpuTensorHandle, _x: &'a GpuTensorHandle, _options: ProviderIirFilterOptions, ) -> AccelProviderFuture<'a, ProviderIirFilterResult>

fn uniform_spectral_estimate<'a>( &'a self, _request: &'a ProviderSpectralRequest<'a>, ) -> AccelProviderFuture<'a, ProviderSpectralResult>

fn signal_envelope<'a>( &'a self, _request: &'a ProviderEnvelopeRequest<'a>, ) -> AccelProviderFuture<'a, ProviderEnvelopeResult>

fn signal_hilbert<'a>( &'a self, _request: &'a ProviderHilbertRequest<'a>, ) -> AccelProviderFuture<'a, GpuTensorHandle>

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 gradient_dim( &self, _handle: &GpuTensorHandle, _dim: usize, _spacing: f64, ) -> Result<GpuTensorHandle>

fn gradient_dim_with_coordinates( &self, _handle: &GpuTensorHandle, _dim: usize, _coordinates: &GpuTensorHandle, ) -> Result<GpuTensorHandle>

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

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

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

fn fft_extract_real<'a>( &'a self, _handle: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

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

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

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

fn ismember<'a>( &'a self, _a: &'a GpuTensorHandle, _b: &'a GpuTensorHandle, _options: &'a IsMemberOptions, ) -> AccelProviderFuture<'a, 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 cross( &self, _lhs: &GpuTensorHandle, _rhs: &GpuTensorHandle, _dim: Option<usize>, ) -> Result<GpuTensorHandle>

Compute the cross product of 3-element vectors along a matching dimension.

fn reduce_sum<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn reduce_sum_dim<'a>( &'a self, _a: &'a GpuTensorHandle, _dim: usize, ) -> AccelProviderFuture<'a, GpuTensorHandle>

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

fn reduce_nnz<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn reduce_nnz_dim<'a>( &'a self, _a: &'a GpuTensorHandle, _dim: usize, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn reduce_prod<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn reduce_prod_dim<'a>( &'a self, _a: &'a GpuTensorHandle, _dim: usize, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn reduce_mean<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

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

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

fn reduce_moments_nd<'a>( &'a self, _a: &'a GpuTensorHandle, _dims_zero_based: &'a [usize], ) -> AccelProviderFuture<'a, 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<'a>( &'a self, _a: &'a GpuTensorHandle, _dim: usize, ) -> AccelProviderFuture<'a, GpuTensorHandle>

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

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

fn reduce_any<'a>( &'a self, _a: &'a GpuTensorHandle, _omit_nan: bool, ) -> AccelProviderFuture<'a, GpuTensorHandle>

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

fn reduce_all<'a>( &'a self, _a: &'a GpuTensorHandle, _omit_nan: bool, ) -> AccelProviderFuture<'a, GpuTensorHandle>

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

fn reduce_median<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn reduce_median_dim<'a>( &'a self, _a: &'a GpuTensorHandle, _dim: usize, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn mode_values<'a>( &'a self, _request: &'a ProviderModeRequest<'a>, ) -> AccelProviderFuture<'a, ProviderModeResult>

fn moving_window<'a>( &'a self, _request: &'a ProviderMovingWindowRequest<'a>, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn reduce_min<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

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

fn reduce_max<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

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

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

fn trapz_dim( &self, _input: &GpuTensorHandle, _dim: usize, _spacing: ProviderTrapezoidSpacing<'_>, ) -> Result<GpuTensorHandle>

fn cumtrapz_dim( &self, _input: &GpuTensorHandle, _dim: usize, _spacing: ProviderTrapezoidSpacing<'_>, ) -> 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 fused_elementwise_multi( &self, _shader: &str, _inputs: &[GpuTensorHandle], _output_shape: &[usize], _len: usize, _num_outputs: usize, ) -> Result<Vec<GpuTensorHandle>>

Execute a single fused elementwise kernel that writes num_outputs output buffers in one dispatch. The shader is expected to declare output0, output1, … output{N-1} storage bindings (at binding indices inputs.len() through inputs.len() + num_outputs - 1) and a uniform params binding at inputs.len() + num_outputs.

Providers that do not override this method fall back to calling fused_elementwise once per output, which preserves correctness at the cost of the O(N²) dispatch overhead this method is designed to eliminate.

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<'a>( &'a self, _matrix: &'a GpuTensorHandle, _kind: ProviderHermitianKind, _tolerance: f64, ) -> AccelProviderFuture<'a, 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<'a>( &'a self, _matrix: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, 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.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors