Struct InProcessProvider 

pub struct InProcessProvider { /* private fields */ }

Implementations

impl InProcessProvider

pub fn new() -> Self

Trait Implementations

impl AccelProvider for InProcessProvider

fn device_id(&self) -> u32

fn spawn_handle_concurrency(&self) -> SpawnHandleConcurrency

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

fn gather_linear( &self, source: &GpuTensorHandle, indices: &[u32], output_shape: &[usize], ) -> Result<GpuTensorHandle>

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

fn scatter_linear( &self, target: &GpuTensorHandle, indices: &[u32], values: &GpuTensorHandle, ) -> Result<()>

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

fn precision(&self) -> ProviderPrecision

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

fn device_info_struct(&self) -> ApiDeviceInfo

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

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 sort_rows<'a>( &'a self, handle: &'a GpuTensorHandle, columns: &'a [SortRowsColumnSpec], comparison: SortComparison, ) -> AccelProviderFuture<'a, SortResult>

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 diag_from_vector( &self, vector: &GpuTensorHandle, offset: isize, ) -> Result<GpuTensorHandle>

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

fn diag_extract( &self, matrix: &GpuTensorHandle, offset: isize, ) -> Result<GpuTensorHandle>

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

fn tril<'a>( &'a self, handle: &'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, handle: &'a GpuTensorHandle, offset: isize, ) -> AccelProviderFuture<'a, GpuTensorHandle>

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

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.

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_like(&self, prototype: &GpuTensorHandle) -> Result<GpuTensorHandle>

Allocate a zero-initialised tensor matching the prototype tensor.

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

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

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 linspace( &self, start: f64, stop: f64, count: usize, ) -> Result<GpuTensorHandle>

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

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

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

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

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 set_rng_state(&self, state: u64) -> Result<()>

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

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

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

fn imfilter<'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_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 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_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 elem_ne<'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 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_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_hypot<'a>( &'a self, a: &'a GpuTensorHandle, b: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, 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_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 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_abs<'a>( &'a self, a: &'a GpuTensorHandle, ) -> AccelProviderFuture<'a, GpuTensorHandle>

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

fn unary_log<'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_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_div( &self, a: &GpuTensorHandle, scalar: f64, ) -> Result<GpuTensorHandle>

fn scalar_rsub( &self, a: &GpuTensorHandle, scalar: f64, ) -> Result<GpuTensorHandle>

fn scalar_rdiv( &self, a: &GpuTensorHandle, scalar: f64, ) -> Result<GpuTensorHandle>

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 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 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 diff_dim( &self, handle: &GpuTensorHandle, order: usize, dim: usize, ) -> Result<GpuTensorHandle>

fn gradient_dim( &self, handle: &GpuTensorHandle, dim: usize, spacing: f64, ) -> Result<GpuTensorHandle>

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

fn setdiff<'a>( &'a self, a: &'a GpuTensorHandle, b: &'a GpuTensorHandle, options: &'a SetdiffOptions, ) -> AccelProviderFuture<'a, SetdiffResult>

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

fn dot<'a>( &'a self, lhs: &'a GpuTensorHandle, rhs: &'a GpuTensorHandle, dim: Option<usize>, ) -> AccelProviderFuture<'a, 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_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_dim<'a>( &'a self, a: &'a GpuTensorHandle, dim: usize, ) -> 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 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 cummin_scan( &self, _input: &GpuTensorHandle, _dim: usize, _direction: ProviderScanDirection, _nan_mode: ProviderNanMode, ) -> Result<ProviderCumminResult>

fn find( &self, a: &GpuTensorHandle, limit: Option<usize>, direction: FindDirection, ) -> Result<ProviderFindResult>

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, handle: &'a GpuTensorHandle, options: ProviderQrOptions, ) -> AccelProviderFuture<'a, ProviderQrResult>

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

fn matmul_epilogue<'a>( &'a self, a: &'a GpuTensorHandle, b: &'a GpuTensorHandle, ep: &'a MatmulEpilogue, ) -> AccelProviderFuture<'a, GpuTensorHandle>

Optional: matrix multiplication with an epilogue applied before store.

fn matmul_power_step<'a>( &'a self, lhs: &'a GpuTensorHandle, rhs: &'a GpuTensorHandle, ep: &'a PowerStepEpilogue, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn image_normalize<'a>( &'a self, input: &'a GpuTensorHandle, desc: &'a ImageNormalizeDescriptor, ) -> AccelProviderFuture<'a, GpuTensorHandle>

fn pagefun(&self, _request: &PagefunRequest) -> Result<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 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 sub2ind( &self, dims: &[usize], strides: &[usize], inputs: &[&GpuTensorHandle], scalar_mask: &[bool], len: usize, output_shape: &[usize], ) -> Result<GpuTensorHandle>

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

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 export_wgpu_buffer(&self, _handle: &GpuTensorHandle) -> Option<WgpuBufferRef>

Export a provider-owned WGPU buffer for zero-copy integrations.

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

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

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

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

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

Construct MATLAB-style coordinate grids from axis vectors.

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

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>, ) -> Pin<Box<dyn Future<Output = Result<ProviderPolyfitResult, Error>> + 'a>>

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

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

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

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

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

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

fn peaks(&self, _n: usize) -> Result<GpuTensorHandle, Error>

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, Error>

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 random_integer_like( &self, prototype: &GpuTensorHandle, lower: i64, upper: i64, ) -> Result<GpuTensorHandle, Error>

Allocate a random integer tensor matching the prototype shape.

fn elem_max<'a>( &'a self, _a: &'a GpuTensorHandle, _b: &'a GpuTensorHandle, ) -> Pin<Box<dyn Future<Output = Result<GpuTensorHandle, Error>> + 'a>>

fn elem_min<'a>( &'a self, _a: &'a GpuTensorHandle, _b: &'a GpuTensorHandle, ) -> Pin<Box<dyn Future<Output = Result<GpuTensorHandle, Error>> + 'a>>

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

fn unary_angle<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> Pin<Box<dyn Future<Output = Result<GpuTensorHandle, Error>> + 'a>>

fn unary_imag<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> Pin<Box<dyn Future<Output = Result<GpuTensorHandle, Error>> + 'a>>

fn unary_real<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> Pin<Box<dyn Future<Output = Result<GpuTensorHandle, Error>> + 'a>>

fn unary_conj<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> Pin<Box<dyn Future<Output = Result<GpuTensorHandle, Error>> + 'a>>

fn unary_sign<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> Pin<Box<dyn Future<Output = Result<GpuTensorHandle, Error>> + 'a>>

fn unary_expm1<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> Pin<Box<dyn Future<Output = Result<GpuTensorHandle, Error>> + 'a>>

fn unary_log2<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> Pin<Box<dyn Future<Output = Result<GpuTensorHandle, Error>> + 'a>>

fn unary_log10<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> Pin<Box<dyn Future<Output = Result<GpuTensorHandle, Error>> + 'a>>

fn unary_log1p<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> Pin<Box<dyn Future<Output = Result<GpuTensorHandle, Error>> + 'a>>

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

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

fn sort_dim<'a>( &'a self, _a: &'a GpuTensorHandle, _dim: usize, _order: SortOrder, _comparison: SortComparison, ) -> Pin<Box<dyn Future<Output = Result<SortResult, Error>> + 'a>>

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

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, ) -> Pin<Box<dyn Future<Output = Result<Option<ProviderQrPowerIterResult>, Error>> + 'a>>

fn fft_dim<'a>( &'a self, _handle: &'a GpuTensorHandle, _len: Option<usize>, _dim: usize, ) -> Pin<Box<dyn Future<Output = Result<GpuTensorHandle, Error>> + 'a>>

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, ) -> Pin<Box<dyn Future<Output = Result<GpuTensorHandle, Error>> + 'a>>

fn fft_extract_real<'a>( &'a self, _handle: &'a GpuTensorHandle, ) -> Pin<Box<dyn Future<Output = Result<GpuTensorHandle, Error>> + 'a>>

fn union<'a>( &'a self, _a: &'a GpuTensorHandle, _b: &'a GpuTensorHandle, _options: &'a UnionOptions, ) -> Pin<Box<dyn Future<Output = Result<UnionResult, Error>> + 'a>>

fn ismember<'a>( &'a self, _a: &'a GpuTensorHandle, _b: &'a GpuTensorHandle, _options: &'a IsMemberOptions, ) -> Pin<Box<dyn Future<Output = Result<IsMemberResult, Error>> + 'a>>

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

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

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

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

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

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

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

fn reduce_nnz<'a>( &'a self, _a: &'a GpuTensorHandle, ) -> Pin<Box<dyn Future<Output = Result<GpuTensorHandle, Error>> + 'a>>

fn reduce_nnz_dim<'a>( &'a self, _a: &'a GpuTensorHandle, _dim: usize, ) -> Pin<Box<dyn Future<Output = Result<GpuTensorHandle, Error>> + 'a>>

fn reduce_mean_nd<'a>( &'a self, _a: &'a GpuTensorHandle, _dims_zero_based: &'a [usize], ) -> Pin<Box<dyn Future<Output = Result<GpuTensorHandle, Error>> + 'a>>

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], ) -> Pin<Box<dyn Future<Output = Result<ProviderMoments2, Error>> + 'a>>

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

fn reduce_std<'a>( &'a self, _a: &'a GpuTensorHandle, _normalization: ProviderStdNormalization, _nan_mode: ProviderNanMode, ) -> Pin<Box<dyn Future<Output = Result<GpuTensorHandle, Error>> + 'a>>

fn reduce_std_dim<'a>( &'a self, _a: &'a GpuTensorHandle, _dim: usize, _normalization: ProviderStdNormalization, _nan_mode: ProviderNanMode, ) -> Pin<Box<dyn Future<Output = Result<GpuTensorHandle, Error>> + 'a>>

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

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

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

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.

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

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

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

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, Error>

Generic fused reduction entrypoint.

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 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, Error>

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, Error>

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 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>, Error>

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

impl Default for InProcessProvider

fn default() -> Self

Returns the “default value” for a type.