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

Ordinary differential equations

An ordinary differential equation relates an unknown function of one variable to its derivatives. Write the unknown with undefined_function and its derivatives with the derivative method on that handle, both documented in Undefined functions:

Solutions are returned in whatever form the closing route produces: an implicit zero-equated expression with fresh integration constants (first-order routes), or an explicit equal(y(x), …) form (constant-coefficient route).

The expression-returning entries below are compatibility projections. When the data, method, family scope, history, or regularity is part of the question, use the request entries, whose results keep the evidence behind the answer: the method that actually ran, the independent verifier's verdict, the rank verdict behind a complete-family claim, the constants the family treats as free, and a typed decline reason. A request that cannot be answered as stated declines; it is never projected onto a weaker question whose answer is then reported under the stronger one.

Solving a scalar equation#

solve_ordinary_differential_equation#

api::solving::Session method

pub fn solve_ordinary_differential_equation<'a, VariableType>(
    &self,
    equation: &Expression,
    dependent_function_call: &Expression,
    independent_variable: VariableType,
    initial_conditions: Option<&[(Expression, Expression)]>,
) -> Result<Expression, ApiError>
where
    VariableType: Into<VariableLike<'a>>,

Solve an ODE for the unknown function named by dependent_function_call (e.g. y(x)). The classifier ladder covers separable, linear first-order, exact (with integrating factor), Bernoulli, Riccati (with particular solution via the dedicated entry below), Lie-symmetry patterns, Kovacic second-order linear, and constant-coefficient linear of any order. Equations outside the ladder return the unevaluated ordinary_differential_equation placeholder.

initial_conditions is a list of (point, value) pairs meaning y(point) = value. They constrain the request, rather than merely advising a preferred route: Symi fits the generated data and independently replays every supplied condition before returning a particular solution. If it cannot fit and verify those data, it declines instead of returning the unconstrained family. Notes: this compatibility entry can express value data only; use solve_ordinary_differential_equation_request for derivative data. WASM passes a flat interleaved array [point_0, value_0, ...].

solve_ordinary_differential_equation_request#

api::ordinary_differential_equations::Session method

pub fn solve_ordinary_differential_equation_request<'a, VariableType>(
    &self,
    equation: &Expression,
    dependent_function_call: &Expression,
    independent_variable: VariableType,
    scope: DifferentialEquationSolutionScope,
    condition_residuals: &[Expression],
    method: OrdinaryDifferentialEquationMethod,
    regularity: OrdinaryDifferentialEquationRegularity,
) -> Result<OrdinaryDifferentialEquationSolveResult, ApiError>
where
    VariableType: Into<VariableLike<'a>>,

Solve one scalar ODE request. Each condition residual is read as equal to zero and states one value or derivative datum at a coordinate-free point: f(0) states f(0)=0f(0)=0 and f.derivative([1], [0]) - 2 states f′(0)=2f'(0)=2.

  • scope is required: general is the compatibility spelling for general_on_regular_chart, which asks for the complete local family and is answered only when the map from the generated constants to the initial jet has full rank; particular asks for one solution through the data. implicit_local_family additionally requires an established implicit-function chart and never accepts an explicit branch as a substitute.
  • method is automatic, laplace_transform, separable, linear_first_order, exact, bernoulli, constant_coefficient, euler_cauchy, order_reduction, lie_symmetry, or special_function. An explicit method runs only its named route and declines when it does not apply. Automatic compares the certified candidates by expression weight, explicitness, chart obligations, and stable route order. The transform method runs the forward transform, frequency-domain solve, and inversion; it never substitutes another route.
  • regularity is classical, piecewise_classical, or weak. An equation whose coefficient switches at a point (a sign or piecewise coefficient) must be requested as piecewise_classical: its solution is classical on each side and matched in value and slope across the switch, not twice differentiable there.
  • A residual that integrates the unknown (a finite-memory Volterra term) is answered by a memory-state reduction and replayed against the original integral equation. A residual that evaluates the unknown at a lag is refused here, because its history is part of the question: use solve_ordinary_differential_equation_with_history.

Errors: a regularity that does not match the equation, a lag with no history, or an unreadable condition residual is an invalid-argument error naming the offending parameter.

solve_ordinary_differential_equation_with_particular_solution#

api::solving::Session method

pub fn solve_ordinary_differential_equation_with_particular_solution<'a, VariableType>(
    &self,
    equation: &Expression,
    dependent_function_call: &Expression,
    independent_variable: VariableType,
    particular_solution: &Expression,
) -> Result<Expression, ApiError>
where
    VariableType: Into<VariableLike<'a>>,

Riccati-specific entry: with a known particular solution y1y_1, the substitution y=y1+1/vy = y_1 + 1/v reduces the Riccati equation to a linear first-order ODE. Falls back to the unevaluated placeholder when the shape is not Riccati.

solve_ordinary_differential_equation_with_history#

api::ordinary_differential_equations::Session method

pub fn solve_ordinary_differential_equation_with_history<'a, VariableType>(
    &self,
    equation: &Expression,
    dependent_function_call: &Expression,
    independent_variable: VariableType,
    history_value: &Expression,
    history_start: &Expression,
    history_end: &Expression,
) -> Result<OrdinaryDifferentialEquationSolveResult, ApiError>
where
    VariableType: Into<VariableLike<'a>>,

Solve a retarded delay ODE from a constant history on the stated interval [history_start, history_end], which must cover every lag. The interval is never inferred, so a delay equation cannot acquire a history it was not given. The supported class is a scalar first-order linear equation with constant lags and constant history; it is answered by an exact method-of-steps family valid for every time, certified by induction on the step index. One history is one solution, so the request is particular.

Nonlinear first-order analysis#

analyze_first_order_nonlinear_equation#

api::ordinary_differential_equations::Session method

pub fn analyze_first_order_nonlinear_equation<'a, VariableType>(
    &self,
    equation: &Expression,
    dependent_function_call: &Expression,
    independent_variable: VariableType,
) -> Result<Option<FirstOrderNonlinearSolutionAnalysis>, ApiError>
where
    VariableType: Into<VariableLike<'a>>,

Classify a supported nonlinear first-order equation without projecting its solution set onto one branch. The returned analysis keeps a regular family, each singular or equilibrium solution, and every certified parameterized branch separate. None means no supported classification closed with its required exact proofs.

find_ordinary_differential_equation_symmetries#

api::ordinary_differential_equations::Session method

pub fn find_ordinary_differential_equation_symmetries<'a, VariableType>(
    &self,
    equation: &Expression,
    dependent_function_call: &Expression,
    independent_variable: VariableType,
) -> Result<OrdinaryDifferentialEquationPointSymmetrySearch, ApiError>
where
    VariableType: Into<VariableLike<'a>>,

Search the fixed, deterministic first-order point-symmetry templates. Every returned generator has an independently proved prolongation residual. A search that finds no generator reports a typed decline instead of treating an empty list as proof that no symmetry exists.

reduce_ordinary_differential_equation_by_symmetry#

api::ordinary_differential_equations::Session method

pub fn reduce_ordinary_differential_equation_by_symmetry<'a, VariableType>(
    &self,
    equation: &Expression,
    dependent_function_call: &Expression,
    independent_variable: VariableType,
    symmetry: &OrdinaryDifferentialEquationPointSymmetry,
) -> Result<Option<FirstOrderNonlinearSolutionBranch>, ApiError>
where
    VariableType: Into<VariableLike<'a>>,

Reduce through a symmetry returned by the same context's verified search. A failed reduction is None; it does not invalidate the independently useful symmetry.

Solving a system#

solve_ordinary_differential_equation_system_request#

api::ordinary_differential_equations::Session method

pub fn solve_ordinary_differential_equation_system_request<'a, VariableType>(
    &self,
    equations: &[Expression],
    dependent_function_calls: &[Expression],
    independent_variable: VariableType,
    condition_residuals: &[Expression],
    method: OrdinaryDifferentialEquationSystemMethod,
) -> Result<OrdinaryDifferentialEquationSystemSolveResult, ApiError>
where
    VariableType: Into<VariableLike<'a>>,

Solve a system of ODEs in one coordinate, one equation per declared unknown. Each condition residual states one datum on exactly one component. method is automatic, sequential (scalar requests solved one at a time, each with its own fresh integration datum; declines when no elimination order exists), or fundamental_matrix (the coupled route through a certified fundamental matrix of the first-order state form). Every returned assignment is verified against every equation and datum. The fundamental-matrix route accepts constant systems, exact scalar-times-fixed and pairwise-commuting variable-coefficient families, and triangular systems whose variation-of- constants integrals close exactly; it declines when a required commutator or integral cannot be proved.

Verifying a supplied solution#

Exact local series#

linear_differential_operator#

api::ordinary_differential_equations::Session method

pub fn linear_differential_operator<'a, VariableType>(
    &self,
    equation: &Expression,
    dependent_function_call: &Expression,
    independent_variable: VariableType,
) -> Result<Option<LinearDifferentialOperator>, ApiError>
where
    VariableType: Into<VariableLike<'a>>,

context.linear_differential_operator(equation, dependent_function_call, independent_variable) extracts a rational-coefficient scalar operator when the residual is linear in the declared unknown. Its coefficients are ascending by derivative order; forcing gives (L[y]=f), and restrictions lists denominators that must remain nonzero on its chart. It returns None when linearity or rational-coefficient extraction cannot be certified.

ordinary_differential_equation_series#

api::ordinary_differential_equations::Session method

pub fn ordinary_differential_equation_series<'a, VariableType>(
    &self,
    equation: &Expression,
    dependent_function_call: &Expression,
    independent_variable: VariableType,
    expansion_point: &Expression,
    initial_derivatives: &[Expression],
) -> Result<Option<OrdinaryDifferentialEquationSeries>, ApiError>
where
    VariableType: Into<VariableLike<'a>>,

context.ordinary_differential_equation_series(equation, dependent_function_call, independent_variable, expansion_point, initial_derivatives) returns an exact formal Taylor series only at a certified ordinary point. The returned record carries normalized initial coefficients, the all-index recurrence, operator chart restrictions, and proof status. It is not a finite polynomial approximation; unsupported, singular, or inadequately initialized problems return None.

LinearDifferentialOperator#

order, coefficients, forcing, and restrictions serialize the normalized operator and its local chart obligations.

api re_export

pub use ordinary_differential_equations::LinearDifferentialOperator;

A serializable rational-coefficient scalar linear differential operator.

Calling forms

Type: api::ordinary_differential_equations::LinearDifferentialOperator

pub struct LinearDifferentialOperator

api::ordinary_differential_equations::LinearDifferentialOperator method

pub fn coefficients(&self) -> Vec<Expression>

Returns coefficients in ascending derivative order.

api::ordinary_differential_equations::LinearDifferentialOperator method

pub fn forcing(&self) -> Expression

Returns the forcing in L[y] = forcing.

api::ordinary_differential_equations::LinearDifferentialOperator method

pub fn order(&self) -> usize

Returns the order of the operator.

api::ordinary_differential_equations::LinearDifferentialOperator method

pub fn restrictions(&self) -> Vec<Expression>

Returns denominator expressions that must remain nonzero on the local chart.

OrdinaryDifferentialEquationSeriesRecurrence#

index_start and order identify the recurrence. operator_coefficient_series is the derivative-order concatenation, whose segment lengths are in operator_coefficient_series_lengths; forcing_coefficients gives the shifted forcing series.

api re_export

pub use ordinary_differential_equations::OrdinaryDifferentialEquationSeriesRecurrence;

An all-index Taylor coefficient recurrence serialized as flattened coefficient series.

Calling forms

Type: api::ordinary_differential_equations::OrdinaryDifferentialEquationSeriesRecurrence

pub struct OrdinaryDifferentialEquationSeriesRecurrence

api::ordinary_differential_equations::OrdinaryDifferentialEquationSeriesRecurrence method

pub fn forcing_coefficients(&self) -> Vec<Expression>

Returns the shifted forcing coefficient series.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSeriesRecurrence method

pub fn index_start(&self) -> usize

Returns the first nonnegative recurrence index.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSeriesRecurrence method

pub fn operator_coefficient_series(&self) -> Vec<Expression>

Returns the concatenated shifted coefficient series in derivative-order sequence.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSeriesRecurrence method

pub fn operator_coefficient_series_lengths(&self) -> Vec<usize>

Returns the length of each derivative-order coefficient series in the concatenation.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSeriesRecurrence method

pub fn order(&self) -> usize

Returns the differential-operator order used by this recurrence.

OrdinaryDifferentialEquationSeries#

operator, expansion_point, initial_coefficients, recurrence, and proof_status retain the data and exact certificate of the formal solution.

api re_export

pub use ordinary_differential_equations::OrdinaryDifferentialEquationSeries;

An exact formal local Taylor solution with its initial data and proof-carrying recurrence.

Calling forms

Type: api::ordinary_differential_equations::OrdinaryDifferentialEquationSeries

pub struct OrdinaryDifferentialEquationSeries

api::ordinary_differential_equations::OrdinaryDifferentialEquationSeries method

pub fn expansion_point(&self) -> Expression

Returns the expansion point.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSeries method

pub fn initial_coefficients(&self) -> Vec<Expression>

Returns normalized Taylor data c_k = y^(k)(point) / k!.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSeries method

pub fn operator(&self) -> LinearDifferentialOperator

Returns the normalized linear differential operator defining the local problem.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSeries method

pub fn proof_status(
    &self,
) -> OrdinaryDifferentialEquationSeriesProofStatus

Returns the exact proof status; this object is never a finite polynomial surrogate.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSeries method

pub fn recurrence(&self) -> OrdinaryDifferentialEquationSeriesRecurrence

Returns the all-index recurrence proved by coefficient comparison.

verify_ordinary_differential_equation_system_solution#

api::ordinary_differential_equations::Session method

pub fn verify_ordinary_differential_equation_system_solution<'a, VariableType>(
    &self,
    equations: &[Expression],
    dependent_function_calls: &[Expression],
    independent_variable: VariableType,
    components: &[Expression],
    generated_constants: &[Expression],
    condition_residuals: &[Expression],
) -> Result<OrdinaryDifferentialEquationSystemVerificationReport, ApiError>
where
    VariableType: Into<VariableLike<'a>>,

Check a supplied assignment without solving: no solver runs, so a swapped component or a missing mode is reported against the assignment as given rather than repaired. The report carries verdict, generality (the rank verdict on the map from generated_constants to the initial jet), and required_rank.

Results#

Every request entry above returns one of these records. A record reports the route that actually ran and the independent verifier's verdict alongside the solution, so a caller can tell a proved answer from an unproved one, and carries a typed decline rather than a weaker answer when the request could not be met.

OrdinaryDifferentialEquationSolveResult#

verdict (solved/declined), method, solution, form (explicit/implicit), generated_constants, verification (verified/rejected/inconclusive), generality (full_rank/deficient/inconclusive), decline, and, for a Laplace transform solution, frequency_domain_equation and image.

api re_export

pub use ordinary_differential_equations::OrdinaryDifferentialEquationSolveResult;

A scalar ordinary differential equation outcome that keeps the evidence behind its answer.

Calling forms

Type: api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveResult

pub struct OrdinaryDifferentialEquationSolveResult

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveResult method

pub fn decline(
    &self,
) -> Option<OrdinaryDifferentialEquationSolveDecline>

Returns the typed reason no certified candidate was produced.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveResult method

pub fn form(&self) -> Option<OrdinaryDifferentialEquationSolutionForm>

Returns whether the solution is the value of the unknown or a relation equal to zero.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveResult method

pub fn frequency_domain_equation(&self) -> Option<Expression>

Returns the frequency-domain equation of a Laplace transform solution, read as zero.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveResult method

pub fn generality(
    &self,
) -> Option<OrdinaryDifferentialEquationGeneralityVerdict>

Returns the rank decision behind a complete-family claim, when the request required one.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveResult method

pub fn generated_constants(&self) -> Vec<Expression>

Returns exactly the constants the solution treats as free.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveResult method

pub fn image(&self) -> Option<Expression>

Returns the image of the unknown a Laplace transform solution solved for.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveResult method

pub fn method(&self) -> OrdinaryDifferentialEquationMethod

Returns the method the request actually ran.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveResult method

pub fn solution(&self) -> Option<Expression>

Returns the certified solution expression, which no declined request carries.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveResult method

pub fn verdict(&self) -> OrdinaryDifferentialEquationSolveVerdict

Returns whether the request was solved or declined.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveResult method

pub fn verification(
    &self,
) -> Option<OrdinaryDifferentialEquationVerificationVerdict>

Returns the independent verifier's decision on the candidate, when verification ran.

OrdinaryDifferentialEquationSystemSolveResult#

verdict, method, route (sequential, fundamental_matrix, or dependency_blocks), components in declaration order, generated_constants, verification, generality, and decline.

api re_export

pub use ordinary_differential_equations::OrdinaryDifferentialEquationSystemSolveResult;

A system of ordinary differential equations outcome that keeps the evidence behind its answer.

Calling forms

Type: api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemSolveResult

pub struct OrdinaryDifferentialEquationSystemSolveResult

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemSolveResult method

pub fn components(&self) -> Vec<Expression>

Returns one explicit value per declared unknown, in declaration order, when solved.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemSolveResult method

pub fn decline(
    &self,
) -> Option<OrdinaryDifferentialEquationSystemSolveDecline>

Returns the typed reason no certified assignment was produced.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemSolveResult method

pub fn generality(
    &self,
) -> Option<OrdinaryDifferentialEquationGeneralityVerdict>

Returns the rank decision on the constants-to-initial-jet map, when verification ran.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemSolveResult method

pub fn generated_constants(&self) -> Vec<Expression>

Returns exactly the constants the assignment treats as free.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemSolveResult method

pub fn method(&self) -> OrdinaryDifferentialEquationSystemMethod

Returns the method the request actually ran.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemSolveResult method

pub fn route(&self) -> Option<OrdinaryDifferentialEquationSystemRoute>

Returns the route the certified assignment came from.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemSolveResult method

pub fn verdict(&self) -> OrdinaryDifferentialEquationSolveVerdict

Returns whether the system was solved or declined.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemSolveResult method

pub fn verification(
    &self,
) -> Option<OrdinaryDifferentialEquationVerificationVerdict>

Returns the independent verifier's decision on the assignment, when verification ran.

OrdinaryDifferentialEquationSystemVerificationReport#

verdict, generality, and required_rank.

api::ordinary_differential_equations::OrdinaryDifferentialEquationPointSymmetrySearchDecline variant

DeterminingSystemUndecidable,

No finite determining system was available for the supplied equation.

api::ordinary_differential_equations::OrdinaryDifferentialEquationPointSymmetrySearchDecline variant

NoSymmetryProved,

Every template within the deterministic search budget was refuted.

api re_export

pub use ordinary_differential_equations::OrdinaryDifferentialEquationPointSymmetrySearchDecline;

Why a bounded first-order point-symmetry search returned no generator.

Calling forms

Type: api::ordinary_differential_equations::OrdinaryDifferentialEquationPointSymmetrySearchDecline

pub enum OrdinaryDifferentialEquationPointSymmetrySearchDecline

api::ordinary_differential_equations::OrdinaryDifferentialEquationPointSymmetrySearchDecline method

pub fn from_name(name: &str) -> Result<Self, ApiError>

Validates one stable lowercase binding spelling.

api::ordinary_differential_equations::OrdinaryDifferentialEquationPointSymmetrySearchDecline method

pub fn name(self) -> &'static str

Returns the stable lowercase binding spelling.

FirstOrderNonlinearSolutionAnalysis#

regular_family, singular_solutions, and parametric_solutions. Singular and equilibrium branches are individually residual-checked but are not advertised as the regular general family.

api re_export

pub use ordinary_differential_equations::FirstOrderNonlinearSolutionAnalysis;

The certified regular, singular, and parameterized branches of a nonlinear first-order equation.

Calling forms

Type: api::ordinary_differential_equations::FirstOrderNonlinearSolutionAnalysis

pub struct FirstOrderNonlinearSolutionAnalysis

FirstOrderNonlinearSolutionBranch#

form, expression, and generated_constants for one separately certified explicit or implicit branch.

api re_export

pub use ordinary_differential_equations::FirstOrderNonlinearSolutionBranch;

The explicit or implicit form of one separately verified nonlinear first-order branch.

Calling forms

Type: api::ordinary_differential_equations::FirstOrderNonlinearSolutionBranch

pub struct FirstOrderNonlinearSolutionBranch

FirstOrderNonlinearParametricSolution#

parameter, coordinate, value, and generated_constants for one certified parameterization.

api re_export

pub use ordinary_differential_equations::FirstOrderNonlinearParametricSolution;

A verified parameterization of a first-order nonlinear solution branch.

Calling forms

Type: api::ordinary_differential_equations::FirstOrderNonlinearParametricSolution

pub struct FirstOrderNonlinearParametricSolution

OrdinaryDifferentialEquationPointSymmetry#

horizontal_component and vertical_component are the infinitesimal generator components whose prolongation was proved invariant.

api re_export

pub use ordinary_differential_equations::OrdinaryDifferentialEquationPointSymmetry;

One first-order point-symmetry generator independently proved by prolongation.

Calling forms

Type: api::ordinary_differential_equations::OrdinaryDifferentialEquationPointSymmetry

pub struct OrdinaryDifferentialEquationPointSymmetry

OrdinaryDifferentialEquationPointSymmetrySearch#

symmetries and decline. A nonempty symmetry list has no decline; an empty list is accompanied by its typed bounded-search reason.

api re_export

pub use ordinary_differential_equations::OrdinaryDifferentialEquationPointSymmetrySearch;

The bounded point-symmetry search outcome for a first-order ordinary differential equation.

Calling forms

Type: api::ordinary_differential_equations::OrdinaryDifferentialEquationPointSymmetrySearch

pub struct OrdinaryDifferentialEquationPointSymmetrySearch

Request vocabulary#

A request entry names its scope, method, and regularity by one of these values. Naming a method runs that route only: it declines when the route does not apply, rather than falling through to another one.

OrdinaryDifferentialEquationMethod#

The route a scalar ordinary differential equation request must take.

Cases: Automatic, LaplaceTransform, Separable, LinearFirstOrder, Exact, Bernoulli, ConstantCoefficient, EulerCauchy, OrderReduction, LieSymmetry, SpecialFunction.

api::ordinary_differential_equations::OrdinaryDifferentialEquationMethod variant

Automatic,

Lets the classification ladder choose any route it can certify.

api::ordinary_differential_equations::OrdinaryDifferentialEquationMethod variant

Bernoulli,

Requires the Bernoulli route.

api::ordinary_differential_equations::OrdinaryDifferentialEquationMethod variant

ConstantCoefficient,

Requires the constant-coefficient linear route.

api::ordinary_differential_equations::OrdinaryDifferentialEquationMethod variant

EulerCauchy,

Requires the Euler-Cauchy route.

api::ordinary_differential_equations::OrdinaryDifferentialEquationMethod variant

Exact,

Requires the exact-equation route.

api::ordinary_differential_equations::OrdinaryDifferentialEquationMethod variant

Kovacic,

Requires the bounded rational-coefficient Liouvillian route.

api::ordinary_differential_equations::OrdinaryDifferentialEquationMethod variant

LaplaceTransform,

Requires the Laplace transform composition and declines when it does not apply.

api::ordinary_differential_equations::OrdinaryDifferentialEquationMethod variant

LieSymmetry,

Requires the supported Lie-symmetry route.

api::ordinary_differential_equations::OrdinaryDifferentialEquationMethod variant

LinearFirstOrder,

Requires the first-order linear route.

api::ordinary_differential_equations::OrdinaryDifferentialEquationMethod variant

OrderReduction,

Requires the supported order-reduction route.

api re_export

pub use ordinary_differential_equations::OrdinaryDifferentialEquationMethod;

The route a scalar ordinary differential equation request must take.

Calling forms

Type: api::ordinary_differential_equations::OrdinaryDifferentialEquationMethod

pub enum OrdinaryDifferentialEquationMethod

api::ordinary_differential_equations::OrdinaryDifferentialEquationMethod variant

Separable,

Requires the separable-equation route.

api::ordinary_differential_equations::OrdinaryDifferentialEquationMethod variant

SpecialFunction,

Requires the supported special-function route.

api::ordinary_differential_equations::OrdinaryDifferentialEquationMethod method

pub fn from_name(name: &str) -> Result<Self, ApiError>

Validates one stable lowercase host spelling.

api::ordinary_differential_equations::OrdinaryDifferentialEquationMethod method

pub fn name(self) -> &'static str

Returns the stable lowercase binding spelling.

OrdinaryDifferentialEquationSystemMethod#

The route a system of ordinary differential equations must take.

Cases: Automatic, FundamentalMatrix, Sequential.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemMethod variant

Automatic,

Lets the dispatcher choose any route it can certify.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemMethod variant

FundamentalMatrix,

Requires the coupled route through a certified fundamental matrix of the state form.

api re_export

pub use ordinary_differential_equations::OrdinaryDifferentialEquationSystemMethod;

The route a system of ordinary differential equations must take.

Calling forms

Type: api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemMethod

pub enum OrdinaryDifferentialEquationSystemMethod

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemMethod variant

Sequential,

Requires scalar requests solved one at a time, each with its own fresh integration datum.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemMethod method

pub fn from_name(name: &str) -> Result<Self, ApiError>

Validates one stable lowercase host spelling.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemMethod method

pub fn name(self) -> &'static str

Returns the stable lowercase binding spelling.

OrdinaryDifferentialEquationRegularity#

The differentiability a scalar ordinary differential equation answer must have.

Cases: Classical, PiecewiseClassical, Weak.

api::ordinary_differential_equations::OrdinaryDifferentialEquationRegularity variant

Classical,

Classically differentiable to the order of the equation throughout.

api re_export

pub use ordinary_differential_equations::OrdinaryDifferentialEquationRegularity;

The differentiability a scalar ordinary differential equation answer must have.

Calling forms

Type: api::ordinary_differential_equations::OrdinaryDifferentialEquationRegularity

pub enum OrdinaryDifferentialEquationRegularity

api::ordinary_differential_equations::OrdinaryDifferentialEquationRegularity variant

PiecewiseClassical,

Classical on each side of a coefficient switch and matched across it, so the answer solves the equation away from the switch and in the weak sense at it.

api::ordinary_differential_equations::OrdinaryDifferentialEquationRegularity variant

Weak,

Requires only the integral, weak solution identity at interfaces.

api::ordinary_differential_equations::OrdinaryDifferentialEquationRegularity method

pub fn from_name(name: &str) -> Result<Self, ApiError>

Validates one stable lowercase host spelling.

api::ordinary_differential_equations::OrdinaryDifferentialEquationRegularity method

pub fn name(self) -> &'static str

Returns the stable lowercase binding spelling.

Outcome vocabulary#

A result reports its outcome through these values. generality is the rank decision behind a complete-family claim and is separate from verification, the independent verifier's decision about the solution itself: a solution can be verified and still not be the general family.

OrdinaryDifferentialEquationSolveVerdict#

Whether a scalar ordinary differential equation request was solved.

Cases: Declined, Solved.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveVerdict variant

Declined,

No certified candidate was produced.

api re_export

pub use ordinary_differential_equations::OrdinaryDifferentialEquationSolveVerdict;

Whether a scalar ordinary differential equation request was solved.

Calling forms

Type: api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveVerdict

pub enum OrdinaryDifferentialEquationSolveVerdict

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveVerdict variant

Solved,

A candidate was produced and independently verified against the request.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveVerdict method

pub fn name(self) -> &'static str

Returns the stable lowercase binding spelling.

OrdinaryDifferentialEquationSystemRoute#

The route a solved system of ordinary differential equations actually ran.

Cases: DependencyBlocks, FundamentalMatrix, Sequential.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemRoute variant

CompanionReduction,

The system was reduced to a scalar equation by a certified cyclic coordinate.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemRoute variant

DependencyBlocks,

The system was split into dependency blocks, each solved through its fitting route.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemRoute variant

FundamentalMatrix,

The system was solved through the certified fundamental matrix of its state form.

api re_export

pub use ordinary_differential_equations::OrdinaryDifferentialEquationSystemRoute;

The route a solved system of ordinary differential equations actually ran.

Calling forms

Type: api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemRoute

pub enum OrdinaryDifferentialEquationSystemRoute

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemRoute variant

Sequential,

The system was reduced to scalar requests solved in an elimination order.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemRoute method

pub fn name(self) -> &'static str

Returns the stable lowercase binding spelling.

OrdinaryDifferentialEquationSolutionForm#

Whether a returned ordinary differential equation solution gives the unknown or a relation.

Cases: Explicit, Implicit.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolutionForm variant

Explicit,

The solution expression is the value of the unknown function.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolutionForm variant

Implicit,

The solution expression is a relation read as equal to zero.

api re_export

pub use ordinary_differential_equations::OrdinaryDifferentialEquationSolutionForm;

Whether a returned ordinary differential equation solution gives the unknown or a relation.

Calling forms

Type: api::ordinary_differential_equations::OrdinaryDifferentialEquationSolutionForm

pub enum OrdinaryDifferentialEquationSolutionForm

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolutionForm method

pub fn name(self) -> &'static str

Returns the stable lowercase binding spelling.

OrdinaryDifferentialEquationVerificationVerdict#

The exact decision an independent ordinary differential equation verifier reached.

Cases: Inconclusive, Rejected, Verified.

api::ordinary_differential_equations::OrdinaryDifferentialEquationVerificationVerdict variant

Inconclusive,

A residual or datum could not be decided exactly.

api re_export

pub use ordinary_differential_equations::OrdinaryDifferentialEquationVerificationVerdict;

The exact decision an independent ordinary differential equation verifier reached.

Calling forms

Type: api::ordinary_differential_equations::OrdinaryDifferentialEquationVerificationVerdict

pub enum OrdinaryDifferentialEquationVerificationVerdict

api::ordinary_differential_equations::OrdinaryDifferentialEquationVerificationVerdict variant

Rejected,

A residual or datum was proved not to vanish.

api::ordinary_differential_equations::OrdinaryDifferentialEquationVerificationVerdict variant

Verified,

Every residual and datum was proved to vanish.

api::ordinary_differential_equations::OrdinaryDifferentialEquationVerificationVerdict method

pub fn name(self) -> &'static str

Returns the stable lowercase binding spelling.

OrdinaryDifferentialEquationGeneralityVerdict#

The exact rank decision behind a complete-family claim.

Cases: Deficient, FullRank, Inconclusive.

api::ordinary_differential_equations::OrdinaryDifferentialEquationGeneralityVerdict variant

Deficient,

That map provably has less than the required rank.

api::ordinary_differential_equations::OrdinaryDifferentialEquationGeneralityVerdict variant

FullRank,

The map from the generated constants to the initial jet has the full required rank.

api::ordinary_differential_equations::OrdinaryDifferentialEquationGeneralityVerdict variant

Inconclusive,

The rank could not be decided exactly.

api re_export

pub use ordinary_differential_equations::OrdinaryDifferentialEquationGeneralityVerdict;

The exact rank decision behind a complete-family claim.

Calling forms

Type: api::ordinary_differential_equations::OrdinaryDifferentialEquationGeneralityVerdict

pub enum OrdinaryDifferentialEquationGeneralityVerdict

api::ordinary_differential_equations::OrdinaryDifferentialEquationGeneralityVerdict method

pub fn name(self) -> &'static str

Returns the stable lowercase binding spelling.

Declines#

A request that cannot be met carries one of these reasons instead of a weaker answer. The reason names the step that did not close, so a decline can be acted on rather than merely retried.

OrdinaryDifferentialEquationSolveDecline#

Why a scalar ordinary differential equation request produced no certified candidate.

Cases: AccumulatedOccurrenceNotSupported, CandidateNotVerified, ConditionsNotFitted, DelayFamilyNotAvailable, DelayFamilyNotCertified, DisplacedOccurrenceNotSupported, DistributionalForcingNotSupported, GeneralFamilyNotEstablished, GeneralFamilyRankUndecided, NoRouteRecognizedTheEquation, SwitchedCoefficientsNotSolved, TransformDidNotReachTheFrequencyDomain, TransformInversionDeclined, TransformRequiresCompleteOriginData, TransformRequiresScalarSignature, TransformedEquationNotSolvable, UnprovedDomain, UnprovedResidual, UnsupportedClass, VolterraEndpointDataIncompatible, VolterraEndpointDataMissing, VolterraKernelNotSupported.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline variant

AccumulatedOccurrenceNotSupported,

The residual integrates the unknown in a way the requested route cannot carry.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline variant

CandidateNotVerified,

A fitted candidate did not survive independent verification.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline variant

ConditionsNotFitted,

The condition search found no assignment satisfying every datum.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline variant

DelayFamilyNotAvailable,

The method of steps has no exact global family for this delay equation.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline variant

DelayFamilyNotCertified,

The exact global family of a delay request did not survive its own certificate.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline variant

DisplacedOccurrenceNotSupported,

The residual evaluates the unknown at a displacement the requested route cannot carry.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline variant

DistributionalForcingNotSupported,

Distributional forcing has no certified jump-aware route for this residual.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline variant

GeneralFamilyNotEstablished,

The complete family was requested and the candidate's data map is not full rank.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline variant

GeneralFamilyRankUndecided,

The complete family was requested and the rank of the data map was undecided.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline variant

NoRouteRecognizedTheEquation,

No route in the classification ladder recognised the equation.

api re_export

pub use ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline;

Why a scalar ordinary differential equation request produced no certified candidate.

Calling forms

Type: api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline

pub enum OrdinaryDifferentialEquationSolveDecline

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline variant

SwitchedCoefficientsNotSolved,

The residual switches at a point and the interval-by-interval route declined it.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline variant

TransformDidNotReachTheFrequencyDomain,

The forward transform left the unknown function in the frequency-domain equation.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline variant

TransformInversionDeclined,

The inversion did not return to the time domain.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline variant

TransformRequiresCompleteOriginData,

The transform route needs the complete initial jet at the origin.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline variant

TransformRequiresScalarSignature,

The transform route needs a one-argument unknown function.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline variant

TransformedEquationNotSolvable,

The frequency-domain equation could not be solved for the image.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline variant

UnprovedDomain,

The candidate's stated region or implicit chart could not be established.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline variant

UnprovedResidual,

The candidate's residual could not be established exactly.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline variant

UnsupportedClass,

The requested solution class is not the class the certified candidate has.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline variant

VolterraEndpointDataIncompatible,

The endpoint equation did not determine the derived initial derivative.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline variant

VolterraEndpointDataMissing,

A Volterra equation needs a value datum at its integral lower endpoint.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline variant

VolterraKernelNotSupported,

The accumulated term is not a supported finite-memory Volterra kernel.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSolveDecline method

pub fn name(self) -> &'static str

Returns the stable lowercase binding spelling.

OrdinaryDifferentialEquationSystemSolveDecline#

Why a system of ordinary differential equations produced no certified assignment.

Cases: ComponentRequestDeclined, ComponentSolutionIsNotExplicit, ConditionsDoNotDetermineTheConstants, ForcingHasNoExactParticularState, FundamentalMatrixUnavailable, NoSequentialOrderingExists, SolutionNotVerified, StateFormUnavailable.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemSolveDecline variant

CompanionReductionUnavailable,

No certified cyclic-coordinate reduction to a scalar equation was available.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemSolveDecline variant

ComponentRequestDeclined,

A scalar component request declined.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemSolveDecline variant

ComponentSolutionIsNotExplicit,

A component solution was not explicit, so it cannot be substituted onward.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemSolveDecline variant

ConditionsDoNotDetermineTheConstants,

The declared data do not determine the constants through an invertible exact linear map.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemSolveDecline variant

ForcingHasNoExactParticularState,

The forcing term has no exact particular state vector by variation of constants.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemSolveDecline variant

FundamentalMatrixUnavailable,

The state form has no fundamental matrix this boundary can certify.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemSolveDecline variant

NoSequentialOrderingExists,

No ordering of the equations reduces the system to a sequence of scalar requests.

api re_export

pub use ordinary_differential_equations::OrdinaryDifferentialEquationSystemSolveDecline;

Why a system of ordinary differential equations produced no certified assignment.

Calling forms

Type: api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemSolveDecline

pub enum OrdinaryDifferentialEquationSystemSolveDecline

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemSolveDecline variant

SolutionNotVerified,

The complete assignment did not survive independent verification.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemSolveDecline variant

StateFormUnavailable,

The system does not reduce to a regular first-order state form.

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemSolveDecline method

pub fn name(self) -> &'static str

Returns the stable lowercase binding spelling.

OrdinaryDifferentialEquationPointSymmetrySearchDecline#

Why the bounded first-order point-symmetry search returned no generator.

Cases: NoSymmetryProved, DeterminingSystemUndecidable.

Additional API#

api::ordinary_differential_equations#

api module

pub mod ordinary_differential_equations;

Context-safe ordinary differential equation requests, systems, and their evidence.

solve_ordinary_differential_equation_by_laplace_transform#

api::solving::Session method

pub fn solve_ordinary_differential_equation_by_laplace_transform<'a, VariableType>(
    &self,
    equation: &Expression,
    dependent_function_call: &Expression,
    independent_variable: VariableType,
    condition_residuals: &[Expression],
) -> Result<Expression, ApiError>
where
    VariableType: Into<VariableLike<'a>>,

Solve an ordinary differential equation through the Laplace transform workflow.

solve_ordinary_differential_equation_with_conditions#

api::solving::Session method

pub fn solve_ordinary_differential_equation_with_conditions<'a, VariableType>(
    &self,
    equation: &Expression,
    dependent_function_call: &Expression,
    independent_variable: VariableType,
    condition_residuals: &[Expression],
) -> Result<Expression, ApiError>
where
    VariableType: Into<VariableLike<'a>>,

Solve an ordinary differential equation through order-carrying condition residuals.

FirstOrderNonlinearParametricSolution#

FirstOrderNonlinearParametricSolution.coordinate#

api::ordinary_differential_equations::FirstOrderNonlinearParametricSolution method

pub fn coordinate(&self) -> Expression

Returns the independent coordinate as a function of the parameter.

FirstOrderNonlinearParametricSolution.generated_constants#

api::ordinary_differential_equations::FirstOrderNonlinearParametricSolution method

pub fn generated_constants(&self) -> Vec<Expression>

Returns the integration constants of the parameterized branch.

FirstOrderNonlinearParametricSolution.parameter#

api::ordinary_differential_equations::FirstOrderNonlinearParametricSolution method

pub fn parameter(&self) -> Expression

Returns the parameter symbol.

FirstOrderNonlinearParametricSolution.value#

api::ordinary_differential_equations::FirstOrderNonlinearParametricSolution method

pub fn value(&self) -> Expression

Returns the dependent value as a function of the parameter.

FirstOrderNonlinearSolutionAnalysis#

FirstOrderNonlinearSolutionAnalysis.parametric_solutions#

api::ordinary_differential_equations::FirstOrderNonlinearSolutionAnalysis method

pub fn parametric_solutions(
    &self,
) -> Vec<FirstOrderNonlinearParametricSolution>

Returns verified parameterized branches.

FirstOrderNonlinearSolutionAnalysis.regular_family#

api::ordinary_differential_equations::FirstOrderNonlinearSolutionAnalysis method

pub fn regular_family(
    &self,
) -> Option<FirstOrderNonlinearSolutionBranch>

Returns the regular one-parameter family, when one was proved.

FirstOrderNonlinearSolutionAnalysis.singular_solutions#

api::ordinary_differential_equations::FirstOrderNonlinearSolutionAnalysis method

pub fn singular_solutions(
    &self,
) -> Vec<FirstOrderNonlinearSolutionBranch>

Returns verified singular or equilibrium branches distinct from the regular family.

FirstOrderNonlinearSolutionBranch#

FirstOrderNonlinearSolutionBranch.expression#

api::ordinary_differential_equations::FirstOrderNonlinearSolutionBranch method

pub fn expression(&self) -> Expression

Returns the branch value or its residual relation.

FirstOrderNonlinearSolutionBranch.form#

api::ordinary_differential_equations::FirstOrderNonlinearSolutionBranch method

pub fn form(&self) -> OrdinaryDifferentialEquationSolutionForm

Returns whether this branch gives a value or an implicit relation.

FirstOrderNonlinearSolutionBranch.generated_constants#

api::ordinary_differential_equations::FirstOrderNonlinearSolutionBranch method

pub fn generated_constants(&self) -> Vec<Expression>

Returns the free constants generated for this branch.

OrdinaryDifferentialEquationPointSymmetry#

OrdinaryDifferentialEquationPointSymmetry.horizontal_component#

api::ordinary_differential_equations::OrdinaryDifferentialEquationPointSymmetry method

pub fn horizontal_component(&self) -> Expression

Returns the horizontal generator component.

OrdinaryDifferentialEquationPointSymmetry.vertical_component#

api::ordinary_differential_equations::OrdinaryDifferentialEquationPointSymmetry method

pub fn vertical_component(&self) -> Expression

Returns the vertical generator component.

OrdinaryDifferentialEquationPointSymmetrySearch#

OrdinaryDifferentialEquationPointSymmetrySearch.decline#

api::ordinary_differential_equations::OrdinaryDifferentialEquationPointSymmetrySearch method

pub fn decline(
    &self,
) -> Option<OrdinaryDifferentialEquationPointSymmetrySearchDecline>

Returns the typed reason no generator was proved.

OrdinaryDifferentialEquationPointSymmetrySearch.symmetries#

api::ordinary_differential_equations::OrdinaryDifferentialEquationPointSymmetrySearch method

pub fn symmetries(
    &self,
) -> Vec<OrdinaryDifferentialEquationPointSymmetry>

Returns every independently verified generator found within the fixed search budget.

OrdinaryDifferentialEquationSeriesProofStatus#

api re_export

pub use ordinary_differential_equations::OrdinaryDifferentialEquationSeriesProofStatus;

The proof status of a local ordinary differential equation series.

Calling forms

Type: api::ordinary_differential_equations::OrdinaryDifferentialEquationSeriesProofStatus

pub enum OrdinaryDifferentialEquationSeriesProofStatus

OrdinaryDifferentialEquationSeriesProofStatus.ExactFormalRecurrenceCertified#

api::ordinary_differential_equations::OrdinaryDifferentialEquationSeriesProofStatus variant

ExactFormalRecurrenceCertified,

An all-index formal coefficient recurrence was proved from the differential equation.

OrdinaryDifferentialEquationSeriesProofStatus.name#

api::ordinary_differential_equations::OrdinaryDifferentialEquationSeriesProofStatus method

pub fn name(self) -> &'static str

Returns the stable lowercase binding spelling.

OrdinaryDifferentialEquationSystemVerificationReport#

api re_export

pub use ordinary_differential_equations::OrdinaryDifferentialEquationSystemVerificationReport;

Independent exact evidence about a supplied assignment for a system of ordinary differential equations.

Calling forms

Type: api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemVerificationReport

pub struct OrdinaryDifferentialEquationSystemVerificationReport

OrdinaryDifferentialEquationSystemVerificationReport.generality#

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemVerificationReport method

pub fn generality(
    &self,
) -> OrdinaryDifferentialEquationGeneralityVerdict

Returns the rank decision on the map from the constants to the initial jet.

OrdinaryDifferentialEquationSystemVerificationReport.required_rank#

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemVerificationReport method

pub fn required_rank(&self) -> usize

Returns the dimension a complete family of the system must span.

OrdinaryDifferentialEquationSystemVerificationReport.verdict#

api::ordinary_differential_equations::OrdinaryDifferentialEquationSystemVerificationReport method

pub fn verdict(&self) -> OrdinaryDifferentialEquationVerificationVerdict

Returns the decision on every equation residual and every datum.