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 upload_numeric(
        &self,
        host: &HostNumericTensorView<'_>,
    ) -> Result<GpuTensorHandle> { ... }
    fn download_numeric<'a>(
        &'a self,
        h: &'a GpuTensorHandle,
    ) -> AccelNumericDownloadFuture<'a> { ... }
    fn upload_integer(
        &self,
        _host: &HostIntegerTensorView<'_>,
    ) -> Result<GpuTensorHandle> { ... }
    fn download_integer<'a>(
        &'a self,
        _h: &'a GpuTensorHandle,
    ) -> AccelIntegerDownloadFuture<'a> { ... }
    fn device_id(&self) -> u32 { ... }
    fn spawn_handle_concurrency(&self) -> SpawnHandleConcurrency { ... }
    fn capability_snapshot(&self) -> ProviderCapabilitySnapshot { ... }
    fn query_feasibility(
        &self,
        query: &ProviderFeasibilityQuery,
    ) -> ProviderFeasibility { ... }
    fn estimate_cost(
        &self,
        _query: &ProviderCostQuery,
    ) -> Option<ProviderCostEstimate> { ... }
    fn placement_resources(&self) -> ProviderResourceSnapshot { ... }
    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 zeros_integer_like(
        &self,
        _prototype: &GpuTensorHandle,
        _shape: &[usize],
    ) -> 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_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_rem<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _b: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn elem_mod<'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 activation_elu<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _alpha: f64,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn activation_softmax_rows<'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 reduce_integer_sum_native<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_integer_sum_native_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_integer_prod_native<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_integer_prod_native_dim<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _dim: usize,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_integer_mean_native<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_integer_mean_native_dim<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _dim: usize,
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn reduce_integer_mean_native_dims<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _dims_zero_based: &'a [usize],
    ) -> AccelProviderFuture<'a, GpuTensorHandle> { ... }
    fn cast_to_integer<'a>(
        &'a self,
        _a: &'a GpuTensorHandle,
        _target: IntegerElementType,
    ) -> 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 integer_cumsum_scan(
        &self,
        _input: &GpuTensorHandle,
        _dim: usize,
        _direction: ProviderScanDirection,
    ) -> 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 integer_cumprod_scan(
        &self,
        _input: &GpuTensorHandle,
        _dim: usize,
        _direction: ProviderScanDirection,
    ) -> Result<GpuTensorHandle> { ... }
    fn cummin_scan(
        &self,
        _input: &GpuTensorHandle,
        _dim: usize,
        _direction: ProviderScanDirection,
        _nan_mode: ProviderNanMode,
    ) -> Result<ProviderCumminResult> { ... }
    fn integer_cummin_scan(
        &self,
        _input: &GpuTensorHandle,
        _dim: usize,
        _direction: ProviderScanDirection,
    ) -> Result<ProviderCumminResult> { ... }
    fn cummax_scan(
        &self,
        _input: &GpuTensorHandle,
        _dim: usize,
        _direction: ProviderScanDirection,
        _nan_mode: ProviderNanMode,
    ) -> Result<ProviderCummaxResult> { ... }
    fn integer_cummax_scan(
        &self,
        _input: &GpuTensorHandle,
        _dim: usize,
        _direction: ProviderScanDirection,
    ) -> 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 upload_numeric( &self, host: &HostNumericTensorView<'_>, ) -> Result<GpuTensorHandle>

Upload one native numeric payload through the shared all-class transfer contract. Providers should override this method as they adopt native single and complex integer storage. The default adapter preserves exact existing double and real-integer routes and rejects every representation those routes cannot express.

fn download_numeric<'a>( &'a self, h: &'a GpuTensorHandle, ) -> AccelNumericDownloadFuture<'a>

Download one native numeric payload through the shared all-class transfer contract. The default adapter keeps exact real-integer and native-double downloads available while refusing to present widened single data as native f32.

fn upload_integer( &self, _host: &HostIntegerTensorView<'_>, ) -> Result<GpuTensorHandle>

Upload exact native integer storage without converting through f64. Providers that do not expose native integer buffers must reject this operation rather than silently changing the value class or precision.

fn download_integer<'a>( &'a self, _h: &'a GpuTensorHandle, ) -> AccelIntegerDownloadFuture<'a>

Download exact native integer storage without converting through f64.

fn device_id(&self) -> u32

Returns the stable identifier used to route this provider’s handles. Distinct concurrently registered provider instances must return distinct identifiers; reusing an identifier would make handle ownership ambiguous.

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 capability_snapshot(&self) -> ProviderCapabilitySnapshot

Returns a versioned, side-effect-free description of the provider surfaces placement may consider. The default advertises only the mandatory floating-point transfer boundary.

fn query_feasibility( &self, query: &ProviderFeasibilityQuery, ) -> ProviderFeasibility

Determines whether a representation-specific operation can execute without attempting allocation, compilation, transfer, or dispatch.

fn estimate_cost( &self, _query: &ProviderCostQuery, ) -> Option<ProviderCostEstimate>

Returns a side-effect-free component cost estimate for an already feasible operation. Providers may return None until they have a trustworthy prior or observation; placement then supplies a bounded low-confidence policy prior rather than probing by execution.

fn placement_resources(&self) -> ProviderResourceSnapshot

Returns a side-effect-free resource snapshot for placement admission. Providers with allocator/queue telemetry should override this default; the conservative snapshot exposes declared capacity when available, leaves unknown queue state explicit, and never probes the device.

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 zeros_integer_like( &self, _prototype: &GpuTensorHandle, _shape: &[usize], ) -> Result<GpuTensorHandle>

Allocate an exact native-integer zero buffer using the element class of prototype. Implementations must reject non-native-integer prototypes rather than allocating a floating compatibility buffer.

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_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_rem<'a>( &'a self, _a: &'a GpuTensorHandle, _b: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

Compute an exact MATLAB-style remainder for compatible native integer tensors.

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

Compute an exact MATLAB-style modulus for compatible native integer tensors.

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 activation_elu<'a>( &'a self, _a: &'a GpuTensorHandle, _alpha: f64, ) -> AccelProviderFuture<'a, GpuTensorHandle>

Apply an exponential linear unit activation with the supplied alpha.

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

Normalize each row of a real two-dimensional tensor with stable softmax.

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 reduce_integer_sum_native<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

Reduce a native integer gpuArray while preserving its exact element class. This is intentionally separate from reduce_sum, whose MATLAB default output semantics are floating point for integer inputs.

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

Dimension form of Self::reduce_integer_sum_native.

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_integer_prod_native<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

Reduce a native integer gpuArray by product while preserving its exact element class, distinct from MATLAB’s default floating-point output.

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

Dimension form of Self::reduce_integer_prod_native.

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

Compute MATLAB’s explicit native-output mean for a native integer gpuArray. Providers must avoid floating-point accumulation so int64 and uint64 values remain exact before the final class-preserving rounding.

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

Dimension form of Self::reduce_integer_mean_native.

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

Multi-dimension form of Self::reduce_integer_mean_native. All requested zero-based dimensions must be reduced in one logical pass so native integer output rounds only once.

fn cast_to_integer<'a>( &'a self, _a: &'a GpuTensorHandle, _target: IntegerElementType, ) -> AccelProviderFuture<'a, GpuTensorHandle>

Convert a real gpuArray to exact native integer storage while preserving device residency. Floating-point inputs use MATLAB-compatible saturating rounding; native integer inputs use exact class-to-class clamping.

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 integer_cumsum_scan( &self, _input: &GpuTensorHandle, _dim: usize, _direction: ProviderScanDirection, ) -> 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 integer_cumprod_scan( &self, _input: &GpuTensorHandle, _dim: usize, _direction: ProviderScanDirection, ) -> Result<GpuTensorHandle>

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

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

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

fn integer_cummax_scan( &self, _input: &GpuTensorHandle, _dim: usize, _direction: ProviderScanDirection, ) -> 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