Skip to content
Symi Docs
Rust

The Rust manual covers the recommended facade. The complete native crate is documented in the native Rust API reference.

On this page

Statistics

Symbolic probability distributions, joint laws, and random-variable algebra. A distribution node names a parametrised family; a random variable node names a draw from a distribution. Distinct draws are not independent unless they share an explicit independent-product law. The complete distribution registry lists every accepted family, its ordered parameters, support, and closed-form operations. The canonical names for the gamma and beta families are gamma_distribution and beta_distribution.

distribution#

api::probability::Session method

pub fn distribution(
    &self,
    name: &str,
    parameters: &[Expression],
) -> Result<Expression, ApiError>

Build a distribution node from a family name and its ordered parameter list (e.g. distribution("normal", [mean, standard_deviation])). An unknown name raises an invalid-option error. A parameter count that does not match the family's arity raises a collection-shape error; it does not create an undefined mathematical value.

random_variable#

api::probability::Session method

pub fn random_variable(
    &self,
    name: &str,
    distribution: &Expression,
) -> Result<Expression, ApiError>

Build a random variable named name drawn from distribution. Each call creates a distinct coordinate identity, even when its display name is reused.

multivariate_normal#

api::probability::Session method

pub fn multivariate_normal(
    &self,
    mean: &[Expression],
    covariance: &Matrix,
) -> Result<Expression, ApiError>

Construct an ordinary multivariate normal law from an ordered real mean vector and a symmetric positive-definite covariance matrix.

multinomial_distribution#

api::probability::Session method

pub fn multinomial_distribution(
    &self,
    trial_count: &Expression,
    probabilities: &[Expression],
) -> Result<Expression, ApiError>

Construct a multinomial law from a nonnegative integer trial count and ordered category probabilities summing exactly to one.

dirichlet#

api::probability::Session method

pub fn dirichlet(
    &self,
    parameters: &[Expression],
) -> Result<Expression, ApiError>

Construct a Dirichlet law. Its density is relative to intrinsic simplex measure, not ambient Euclidean Lebesgue measure.

independent_product#

api::probability::Session method

pub fn independent_product(
    &self,
    factors: &[Expression],
) -> Result<Expression, ApiError>

Construct the joint product law that explicitly certifies independence.

discrete_markov_chain#

api::probability::Session method

pub fn discrete_markov_chain(
    &self,
    name: &str,
    states: &[Expression],
    transition_matrix: &Matrix,
    initial_probabilities: &[Expression],
) -> Result<Expression, ApiError>

Construct a finite-state time-homogeneous Markov chain with ordered distinct state labels, an exact row-stochastic transition matrix, and an exact initial row law.

transition_probability#

api::probability::Session method

pub fn transition_probability(
    &self,
    process: &Expression,
    from_state: &Expression,
    to_state: &Expression,
    start_index: &Expression,
    end_index: &Expression,
) -> Result<Expression, ApiError>

Return the exact finite-horizon transition probability for a finite Markov chain. The horizon must be a proved nonnegative integer.

stationary_distributions#

api::probability::Session method

pub fn stationary_distributions(
    &self,
    process: &Expression,
) -> Result<Matrix, ApiError>

Return one row for every extreme stationary law. All stationary laws are the convex combinations of these rows in the process state order.

hitting_probability#

api::probability::Session method

pub fn hitting_probability(
    &self,
    process: &Expression,
    start_state: &Expression,
    target_states: &[Expression],
) -> Result<Expression, ApiError>

Return the exact probability that the chain ever reaches one of the target states from start_state.

expected_hitting_time#

api::probability::Session method

pub fn expected_hitting_time(
    &self,
    process: &Expression,
    start_state: &Expression,
    target_states: &[Expression],
) -> Result<Expression, ApiError>

Return the exact expected time to reach a target state set. The result is positive infinity when the target is not reached almost surely.

affine_process_transformation#

api::probability::Session method

pub fn affine_process_transformation(
    &self,
    name: &str,
    source: &Expression,
    multiplier: &Expression,
    offset: &Expression,
) -> Result<Expression, ApiError>

Construct the pointwise affine image offset + multiplier * source of a certified Gaussian process.

independent_gaussian_process_sum#

api::probability::Session method

pub fn independent_gaussian_process_sum(
    &self,
    name: &str,
    first_source: &Expression,
    second_source: &Expression,
) -> Result<Expression, ApiError>

Construct the pointwise sum of two explicitly independent Gaussian processes on the same index domain.

finite_dimensional_random_vector#

api::probability::Session method

pub fn finite_dimensional_random_vector(
    &self,
    process: &Expression,
    indices: &[Expression],
    coordinate_names: &[String],
) -> Result<Expression, ApiError>

Construct the ordered random-vector handle for a finite process slice, using the shared joint-law and conditioning operations.

conditional_process_slice_distribution#

api::probability::Session method

pub fn conditional_process_slice_distribution(
    &self,
    process: &Expression,
    selected_indices: &[Expression],
    conditioning_indices: &[Expression],
    conditioning_values: &[Expression],
) -> Result<Expression, ApiError>

Condition an ordered finite process slice on another ordered slice at explicit values through the shared continuous conditional-law engine. The operation declines or remains unevaluated when the conditioning marginal has no certified density.

independent_process_product#

api::probability::Session method

pub fn independent_process_product(
    &self,
    first_process: &Expression,
    first_indices: &[Expression],
    second_process: &Expression,
    second_indices: &[Expression],
) -> Result<Expression, ApiError>

Construct the explicit block-independent joint law of two finite process slices.

product_copula#

api::probability::Session method

pub fn product_copula(
    &self,
    marginals: &[Expression],
) -> Result<Expression, ApiError>

Construct the product copula of at least two continuous marginals with exact CDF and density descriptors. The result is the certified independent product law.

gaussian_copula#

api::probability::Session method

pub fn gaussian_copula(
    &self,
    marginals: &[Expression],
    correlation: &Matrix,
) -> Result<Expression, ApiError>

Construct a Gaussian copula from continuous marginals and a symmetric positive-semidefinite unit-diagonal correlation matrix. Its density remains unevaluated unless the system gains an exact normal-quantile representation.

archimedean_copula#

api::probability::Session method

pub fn archimedean_copula(
    &self,
    family: &str,
    marginals: &[Expression],
    parameter: &Expression,
) -> Result<Expression, ApiError>

Construct a Clayton, Frank, or Gumbel copula from continuous marginals. The parameter domain is checked exactly; arbitrary generator expressions are not accepted as copulas.

estimate_archimedean_copula_parameter#

api::probability::Session method

pub fn estimate_archimedean_copula_parameter(
    &self,
    family: &str,
    observations: &Matrix,
) -> Result<Expression, ApiError>

Estimate a Clayton or Gumbel parameter by exactly inverting bivariate Kendall's tau. Observations must have exactly two columns and every pairwise order must be exact and strict, so ties and undecidable comparisons decline.

estimate_archimedean_copula_parameter_numeric#

api::probability::Session method

pub fn estimate_archimedean_copula_parameter_numeric(
    &self,
    family: &str,
    observations: &Matrix,
    parameter: &Expression,
    lower: &Expression,
    upper: &Expression,
    options: NumericOptions,
) -> Result<NumericRootFindingResult, ApiError>

Explicitly request bracketed numerical Frank-parameter estimation. A result is returned only when the requested bracket and every needed numerical kernel can be certified; otherwise its typed decline explains why.

quantile_numeric#

api::probability::Session method

pub fn quantile_numeric(
    &self,
    distribution: &Expression,
    probability: &Expression,
    quantile_variable: &Expression,
    lower: &Expression,
    upper: &Expression,
    options: NumericOptions,
) -> Result<NumericRootFindingResult, ApiError>

Explicitly invert a scalar continuous CDF on an exact rational bracket. Symbolic probability operations never invoke this numerical operation implicitly.

order_statistic#

api::probability::Session method

pub fn order_statistic(
    &self,
    base_law: &Expression,
    sample_size: &Expression,
    rank: &Expression,
) -> Result<Expression, ApiError>

Construct the rank order statistic of an i.i.d. sample from a scalar law. Both sample size and rank must be positive exact integers, and rank cannot exceed sample size.

minimum#

api::probability::Session method

pub fn minimum(
    &self,
    base_law: &Expression,
    sample_size: &Expression,
) -> Result<Expression, ApiError>

Construct the smallest member of an i.i.d. sample from a scalar law.

maximum#

api::probability::Session method

pub fn maximum(
    &self,
    base_law: &Expression,
    sample_size: &Expression,
) -> Result<Expression, ApiError>

Construct the largest member of an i.i.d. sample from a scalar law.

random_vector#

api::probability::Session method

pub fn random_vector(
    &self,
    coordinate_names: &[String],
    joint_distribution: &Expression,
) -> Result<Expression, ApiError>

Construct an ordered vector of fresh coordinate handles for a joint law.

joint_distribution#

api::probability::Session method

pub fn joint_distribution(
    &self,
    random_vector: &Expression,
) -> Result<Expression, ApiError>

Return a random vector's joint law.

component#

api::probability::Session method

pub fn component(
    &self,
    random_vector: &Expression,
    position: usize,
) -> Result<Expression, ApiError>

Select one coordinate by zero-based position.

marginal#

api::probability::Session method

pub fn marginal(
    &self,
    joint_distribution: &Expression,
    positions: &[usize],
) -> Result<Expression, ApiError>

Return the distinct ordered coordinate projection of a joint law.

permute#

api::probability::Session method

pub fn permute(
    &self,
    joint_distribution: &Expression,
    permutation: &[usize],
) -> Result<Expression, ApiError>

Reorder every coordinate by a permutation.

joint_density#

api::probability::Session method

pub fn joint_density(
    &self,
    joint_distribution: &Expression,
    points: &[Expression],
) -> Result<Expression, ApiError>

Evaluate an ordinary joint density at an ordered point. Laws without an ordinary density retain an unevaluated query.

intrinsic_simplex_density#

api::probability::Session method

pub fn intrinsic_simplex_density(
    &self,
    joint_distribution: &Expression,
    points: &[Expression],
) -> Result<Expression, ApiError>

Evaluate a Dirichlet density relative to its intrinsic simplex measure.

joint_probability_mass_function#

api::probability::Session method

pub fn joint_probability_mass_function(
    &self,
    joint_distribution: &Expression,
    points: &[Expression],
) -> Result<Expression, ApiError>

Evaluate a joint point mass at an ordered point.

joint_cumulative_distribution#

api::probability::Session method

pub fn joint_cumulative_distribution(
    &self,
    joint_distribution: &Expression,
    points: &[Expression],
) -> Result<Expression, ApiError>

Evaluate the lower-orthant cumulative distribution at an ordered point.

joint_rectangle_probability#

api::probability::Session method

pub fn joint_rectangle_probability(
    &self,
    joint_distribution: &Expression,
    lower_bounds: &[Expression],
    upper_bounds: &[Expression],
) -> Result<Expression, ApiError>

Evaluate the ordered rectangle probability (lower, upper].

joint_support#

api::probability::Session method

pub fn joint_support(
    &self,
    joint_distribution: &Expression,
) -> Result<Expression, ApiError>

Return the exact support of a joint law when available.

joint_raw_moment#

api::probability::Session method

pub fn joint_raw_moment(
    &self,
    joint_distribution: &Expression,
    orders: &[Expression],
) -> Result<Expression, ApiError>

Return an exact multi-index raw moment when known.

joint_mean#

api::probability::Session method

pub fn joint_mean(
    &self,
    joint_distribution: &Expression,
) -> Result<Vec<Expression>, ApiError>

Return the ordered exact mean entries of a joint law.

joint_covariance_matrix#

api::probability::Session method

pub fn joint_covariance_matrix(
    &self,
    joint_distribution: &Expression,
) -> Result<Matrix, ApiError>

Return the exact covariance matrix of a joint law.

joint_correlation_matrix#

api::probability::Session method

pub fn joint_correlation_matrix(
    &self,
    joint_distribution: &Expression,
) -> Result<Matrix, ApiError>

Return the correlation matrix when coordinate variances are proved positive.

density#

api::probability::Session method

pub fn density(
    &self,
    random_variable: &Expression,
    point: &Expression,
) -> Result<Expression, ApiError>

Probability density (continuous families) or probability mass (discrete families) of random_variable evaluated at point. Falls back to an unevaluated structural form when no closed form exists.

cumulative_distribution#

api::probability::Session method

pub fn cumulative_distribution(
    &self,
    random_variable: &Expression,
    point: &Expression,
) -> Result<Expression, ApiError>

Cumulative distribution function of random_variable evaluated at point.

expectation#

api::probability::Session method

pub fn expectation(
    &self,
    target: &Expression,
    random_variables: &[Expression],
) -> Result<Expression, ApiError>

Expectation of target over the listed independent random variables. Linearity and the constant-factor lift are applied; bare and power-of-random-variable leaves consume the distribution's mean and raw moments.

variance#

api::probability::Session method

pub fn variance(
    &self,
    target: &Expression,
    random_variables: &[Expression],
) -> Result<Expression, ApiError>

Variance of target over the listed independent random variables.

covariance#

api::probability::Session method

pub fn covariance(
    &self,
    left: &Expression,
    right: &Expression,
    random_variables: &[Expression],
) -> Result<Expression, ApiError>

Covariance of left and right over the listed independent random variables; zero for independent operands.

probability#

api::probability::Session method

pub fn probability(
    &self,
    predicate: &Expression,
    random_variables: &[Expression],
) -> Result<Expression, ApiError>

Probability that predicate (a tail comparison such as X > t) holds over the listed independent random variables.

moment#

api::probability::Session method

pub fn moment(
    &self,
    random_variable: &Expression,
    order: &Expression,
) -> Result<Expression, ApiError>

The order-th raw moment E[X^order] of random_variable.

cumulant#

api::probability::Session method

pub fn cumulant(
    &self,
    random_variable: &Expression,
    order: &Expression,
) -> Result<Expression, ApiError>

The order-th cumulant of random_variable.

moment_generating_function#

api::probability::Session method

pub fn moment_generating_function<'a, VariableType>(
    &self,
    random_variable: &Expression,
    auxiliary_variable: VariableType,
) -> Result<Expression, ApiError>
where
    VariableType: Into<VariableLike<'a>>,

Closed-form moment generating function M_X(t) of random_variable in the named auxiliary variable, when elementary; otherwise an unevaluated structural form.

characteristic_function#

api::probability::Session method

pub fn characteristic_function<'a, VariableType>(
    &self,
    random_variable: &Expression,
    auxiliary_variable: VariableType,
) -> Result<Expression, ApiError>
where
    VariableType: Into<VariableLike<'a>>,

Closed-form characteristic function φX(t)\varphi_X(t) of random_variable in the named auxiliary variable, when elementary; otherwise an unevaluated structural form.

Example#

Build a random variable and read its density, mean, and variance.

Rust
use symi::api::prelude::*;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let session = Session::new();
    let standard_normal =
        session.distribution("normal", &[session.integer(0), session.integer(1)])?;
    let measurement = session.random_variable("X", &standard_normal)?;

    println!("{}", session.density(&measurement, &session.symbol("t"))?);
    println!("{}", session.expectation(&measurement, &[measurement.clone()])?);
    println!("{}", session.variance(&measurement, &[measurement.clone()])?);
    Ok(())
}

Additional API#

affine_transformation#

api::probability::Session method

pub fn affine_transformation(
    &self,
    source: &Expression,
    scale: &Expression,
    shift: &Expression,
) -> Result<Expression, ApiError>

Construct the exact affine pushforward scale * source + shift.

affine_vector_transformation#

api::probability::Session method

pub fn affine_vector_transformation(
    &self,
    source: &Expression,
    matrix: &Matrix,
    shift: &[Expression],
) -> Result<Expression, ApiError>

Construct the exact affine pushforward matrix * source + shift of a random vector.

bernoulli_process#

api::probability::Session method

pub fn bernoulli_process(
    &self,
    name: &str,
    success_probability: &Expression,
) -> Result<Expression, ApiError>

Construct an i.i.d. Bernoulli process with a proved unit-interval probability.

brownian_bridge#

api::probability::Session method

pub fn brownian_bridge(
    &self,
    name: &str,
    horizon: &Expression,
) -> Result<Expression, ApiError>

Construct a standard zero-endpoint Brownian bridge on a proved-positive horizon.

conditional_covariance#

api::probability::Session method

pub fn conditional_covariance(
    &self,
    left: &Expression,
    right: &Expression,
    condition: &Expression,
    random_vector: &Expression,
) -> Result<Expression, ApiError>

Return the exact covariance of two targets conditional on a positive-mass discrete event.

conditional_covariance_given#

api::probability::Session method

pub fn conditional_covariance_given(
    &self,
    left_position: usize,
    right_position: usize,
    random_vector: &Expression,
    selected_positions: &[usize],
    conditioning_positions: &[usize],
    conditioning_values: &[Expression],
) -> Result<Expression, ApiError>

Return an exact conditional covariance for two selected coordinates when their density-conditioned law has certified second moments.

conditional_density_distribution#

api::probability::Session method

pub fn conditional_density_distribution(
    &self,
    random_vector: &Expression,
    selected_positions: &[usize],
    conditioning_positions: &[usize],
    conditioning_values: &[Expression],
) -> Result<Expression, ApiError>

Construct a density-based conditional law for selected continuous coordinates at explicit coordinate values.

conditional_distribution#

api::probability::Session method

pub fn conditional_distribution(
    &self,
    random_vector: &Expression,
    condition: &Expression,
) -> Result<Expression, ApiError>

Restrict a finite discrete joint law to an event with proved positive mass.

conditional_expectation#

api::probability::Session method

pub fn conditional_expectation(
    &self,
    target: &Expression,
    condition: &Expression,
    random_vector: &Expression,
) -> Result<Expression, ApiError>

Return the exact expectation of a target conditional on a positive-mass discrete event.

conditional_expectation_given#

api::probability::Session method

pub fn conditional_expectation_given(
    &self,
    target_position: usize,
    random_vector: &Expression,
    selected_positions: &[usize],
    conditioning_positions: &[usize],
    conditioning_values: &[Expression],
) -> Result<Expression, ApiError>

Return an exact conditional expectation for one selected coordinate when its density-conditioned law has a certified moment.

conditional_moment#

api::probability::Session method

pub fn conditional_moment(
    &self,
    target: &Expression,
    order: &Expression,
    condition: &Expression,
    random_vector: &Expression,
) -> Result<Expression, ApiError>

Return the exact raw moment of a target conditional on a positive-mass discrete event.

conditional_probability#

api::probability::Session method

pub fn conditional_probability(
    &self,
    event: &Expression,
    condition: &Expression,
    random_vector: &Expression,
) -> Result<Expression, ApiError>

Return the exact probability of an event conditional on a positive-mass discrete event.

conditional_variance#

api::probability::Session method

pub fn conditional_variance(
    &self,
    target: &Expression,
    condition: &Expression,
    random_vector: &Expression,
) -> Result<Expression, ApiError>

Return the exact variance of a target conditional on a positive-mass discrete event.

conditional_variance_given#

api::probability::Session method

pub fn conditional_variance_given(
    &self,
    target_position: usize,
    random_vector: &Expression,
    selected_positions: &[usize],
    conditioning_positions: &[usize],
    conditioning_values: &[Expression],
) -> Result<Expression, ApiError>

Return an exact conditional variance for one selected coordinate when its density-conditioned law has a certified second moment.

correlation#

api::probability::Session method

pub fn correlation(
    &self,
    left: &Expression,
    right: &Expression,
) -> Result<Expression, ApiError>

Return the correlation of two components belonging to one explicit joint space.

finite_dimensional_law#

api::probability::Session method

pub fn finite_dimensional_law(
    &self,
    process: &Expression,
    indices: &[Expression],
) -> Result<Expression, ApiError>

Return the exact finite-dimensional law for ordered process indices.

finite_membership_event#

api::probability::Session method

pub fn finite_membership_event(
    &self,
    element: &Expression,
    members: &[Expression],
) -> Result<Expression, ApiError>

Construct the Boolean event that an expression belongs to a finite list of values.

gaussian_process#

api::probability::Session method

pub fn gaussian_process(
    &self,
    name: &str,
    mean_index: &Expression,
    mean: &Expression,
    first_covariance_index: &Expression,
    second_covariance_index: &Expression,
    covariance: &Expression,
    certificate: GaussianKernelCertificate,
) -> Result<Expression, ApiError>

Construct a real-valued Gaussian process from hygienic mean and covariance templates.

group_multinomial_categories#

api::probability::Session method

pub fn group_multinomial_categories(
    &self,
    joint_distribution: &Expression,
    category_groups: &[&[usize]],
) -> Result<Expression, ApiError>

Combine disjoint multinomial category groups into their exact aggregate law.

iid_discrete_process#

api::probability::Session method

pub fn iid_discrete_process(
    &self,
    name: &str,
    marginal_law: &Expression,
) -> Result<Expression, ApiError>

Construct an i.i.d. discrete sequence with one fresh process identity.

increment_covariance#

api::probability::Session method

pub fn increment_covariance(
    &self,
    process: &Expression,
    first_start: &Expression,
    first_end: &Expression,
    second_start: &Expression,
    second_end: &Expression,
) -> Result<Expression, ApiError>

Return the exact covariance of two supported process increments.

increment_distribution#

api::probability::Session method

pub fn increment_distribution(
    &self,
    process: &Expression,
    start: &Expression,
    end: &Expression,
) -> Result<Expression, ApiError>

Return the exact law of a supported process increment over a proved ordered interval.

increments_are_independent#

api::probability::Session method

pub fn increments_are_independent(
    &self,
    process: &Expression,
    first_start: &Expression,
    first_end: &Expression,
    second_start: &Expression,
    second_end: &Expression,
) -> Result<TruthValue, ApiError>

Decide whether two supported Wiener increments are independent.

independent_convolution#

api::probability::Session method

pub fn independent_convolution(
    &self,
    first_law: &Expression,
    second_law: &Expression,
) -> Result<Expression, ApiError>

Construct the law of the sum of two independently constructed scalar laws.

independent_discrete_process#

api::probability::Session method

pub fn independent_discrete_process(
    &self,
    name: &str,
    marginal_law: &Expression,
) -> Result<Expression, ApiError>

Construct a discrete independent-sequence process with a fresh process identity.

is_independent#

api::probability::Session method

pub fn is_independent(
    &self,
    joint_distribution: &Expression,
    left_positions: &[usize],
    right_positions: &[usize],
) -> Result<TruthValue, ApiError>

Decide whether two disjoint coordinate sets are independent in one explicit joint law.

joint_characteristic_function#

api::probability::Session method

pub fn joint_characteristic_function(
    &self,
    joint_distribution: &Expression,
    frequencies: &[Expression],
) -> Result<Expression, ApiError>

Return the exact Gaussian characteristic function at an ordered real frequency vector.

poisson_counting_process#

api::probability::Session method

pub fn poisson_counting_process(
    &self,
    name: &str,
    rate: &Expression,
) -> Result<Expression, ApiError>

Construct a homogeneous Poisson counting process with a proved positive real rate.

api::probability#

api module

pub mod probability;

Distribution and statistics operations of the native API.

process_covariance#

api::probability::Session method

pub fn process_covariance(
    &self,
    left_process_value: &Expression,
    right_process_value: &Expression,
) -> Result<Expression, ApiError>

Return the exact covariance of two coordinates from the same stochastic process.

process_mean#

api::probability::Session method

pub fn process_mean(
    &self,
    process_value: &Expression,
) -> Result<Expression, ApiError>

Return the exact mean of one indexed stochastic-process coordinate.

process_probability_mass#

api::probability::Session method

pub fn process_probability_mass(
    &self,
    process: &Expression,
    indices: &[Expression],
    points: &[Expression],
) -> Result<Expression, ApiError>

Return the exact point-event probability for an ordered finite process slice.

process_value#

api::probability::Session method

pub fn process_value(
    &self,
    process: &Expression,
    index: &Expression,
) -> Result<Expression, ApiError>

Construct the scalar coordinate at a proved index in the process descriptor's domain.

process_variance#

api::probability::Session method

pub fn process_variance(
    &self,
    process_value: &Expression,
) -> Result<Expression, ApiError>

Return the exact variance of one indexed stochastic-process coordinate.

random_walk#

api::probability::Session method

pub fn random_walk(
    &self,
    name: &str,
    initial_value: &Expression,
    increment_law: &Expression,
) -> Result<Expression, ApiError>

Construct a random walk from its exact initial value and common increment law.

semidefinite_gaussian_rank#

api::probability::Session method

pub fn semidefinite_gaussian_rank(
    &self,
    joint_distribution: &Expression,
) -> Result<usize, ApiError>

Return the covariance rank of a semidefinite Gaussian finite-dimensional law.

transformed_distribution#

api::probability::Session method

pub fn transformed_distribution(
    &self,
    source: &Expression,
    mapping: &Expression,
) -> Result<Expression, ApiError>

Construct an exact scalar pushforward with its source and mapping retained.

wiener_process#

api::probability::Session method

pub fn wiener_process(
    &self,
    name: &str,
    initial_value: &Expression,
    drift: &Expression,
    scale: &Expression,
) -> Result<Expression, ApiError>

Construct a Wiener process with exact initial value, drift, and nonnegative scale.

GaussianKernelCertificate#

Type

pub enum GaussianKernelCertificate

The globally valid kernel theorem selected for a Gaussian-process descriptor.

GaussianKernelCertificate.Candidate#

api::probability::GaussianKernelCertificate variant

Candidate,

Retain a symmetric user proposal without asserting global positive semidefiniteness.

GaussianKernelCertificate.Constant#

api::probability::GaussianKernelCertificate variant

Constant,

Certify a nonnegative constant covariance kernel.