Skip to content
Symi Docs
WASM / JavaScript

Signatures in the WASM / JavaScript view are TypeScript. Where the JavaScript facade wraps an operation its form is listed first; the other calling forms are the raw wasm-bindgen exports.

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:

JavaScript
const context = new symi.Context();
const x = context.symbol("x");
const y = context.undefinedFunction("y");
const yOfX = y.call([x]);
const equation = y.derivative([1], [x]).subtract(yOfX);
const solution = context.solveOrdinaryDifferentialEquation(equation, yOfX, "x");

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#

Raw WebAssembly: Default context

solveOrdinaryDifferentialEquation(
    equation: Expression,
    dependent_function_call: Expression,
    independent_variable: string,
    initial_conditions?: Expression[] | null,
): Expression
Calling forms

Raw WebAssembly: Explicit context: Context.solveOrdinaryDifferentialEquation

solveOrdinaryDifferentialEquation(
    equation: Expression,
    dependent_function_call: Expression,
    independent_variable: string,
    initial_conditions?: Expression[] | null,
): Expression

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#

Raw WebAssembly: Default context

solveOrdinaryDifferentialEquationRequest(
    equation: Expression,
    dependent_function_call: Expression,
    independent_variable: string,
    scope: string,
    condition_residuals?: Expression[] | null,
    method?: string | null,
    regularity?: string | null,
): OrdinaryDifferentialEquationSolveResult
Calling forms

Raw WebAssembly: Explicit context: Context.solveOrdinaryDifferentialEquationRequest

solveOrdinaryDifferentialEquationRequest(
    equation: Expression,
    dependent_function_call: Expression,
    independent_variable: string,
    scope: string,
    condition_residuals?: Expression[] | null,
    method?: string | null,
    regularity?: string | null,
): OrdinaryDifferentialEquationSolveResult

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#

Raw WebAssembly: Default context

solveOrdinaryDifferentialEquationWithParticularSolution(
    equation: Expression,
    dependent_function_call: Expression,
    independent_variable: string,
    particular_solution: Expression,
): Expression
Calling forms

Raw WebAssembly: Explicit context: Context.solveOrdinaryDifferentialEquationWithParticularSolution

solveOrdinaryDifferentialEquationWithParticularSolution(
    equation: Expression,
    dependent_function_call: Expression,
    independent_variable: string,
    particular_solution: Expression,
): Expression

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#

Raw WebAssembly: Default context

solveOrdinaryDifferentialEquationWithHistory(
    equation: Expression,
    dependent_function_call: Expression,
    independent_variable: string,
    history_value: Expression,
    history_start: Expression,
    history_end: Expression,
): OrdinaryDifferentialEquationSolveResult
Calling forms

Raw WebAssembly: Explicit context: Context.solveOrdinaryDifferentialEquationWithHistory

solveOrdinaryDifferentialEquationWithHistory(
    equation: Expression,
    dependent_function_call: Expression,
    independent_variable: string,
    history_value: Expression,
    history_start: Expression,
    history_end: Expression,
): OrdinaryDifferentialEquationSolveResult

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#

Raw WebAssembly: Default context

analyzeFirstOrderNonlinearEquation(): FirstOrderNonlinearSolutionAnalysis | undefined
Calling forms

Raw WebAssembly: Explicit context: Context.analyzeFirstOrderNonlinearEquation

analyzeFirstOrderNonlinearEquation(
    equation: Expression,
    dependent_function_call: Expression,
    independent_variable: string,
): FirstOrderNonlinearSolutionAnalysis | undefined

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#

Raw WebAssembly: Default context

findOrdinaryDifferentialEquationSymmetries(): OrdinaryDifferentialEquationPointSymmetrySearch
Calling forms

Raw WebAssembly: Explicit context: Context.findOrdinaryDifferentialEquationSymmetries

findOrdinaryDifferentialEquationSymmetries(
    equation: Expression,
    dependent_function_call: Expression,
    independent_variable: string,
): OrdinaryDifferentialEquationPointSymmetrySearch

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#

Raw WebAssembly: Default context

reduceOrdinaryDifferentialEquationBySymmetry(): FirstOrderNonlinearSolutionBranch | undefined
Calling forms

Raw WebAssembly: Explicit context: Context.reduceOrdinaryDifferentialEquationBySymmetry

reduceOrdinaryDifferentialEquationBySymmetry(
    equation: Expression,
    dependent_function_call: Expression,
    independent_variable: string,
    symmetry: OrdinaryDifferentialEquationPointSymmetry,
): FirstOrderNonlinearSolutionBranch | undefined

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#

Raw WebAssembly: Default context

solveOrdinaryDifferentialEquationSystemRequest(
    equations: Expression[],
    dependent_function_calls: Expression[],
    independent_variable: string,
    condition_residuals?: Expression[] | null,
    method?: string | null,
): OrdinaryDifferentialEquationSystemSolveResult
Calling forms

Raw WebAssembly: Explicit context: Context.solveOrdinaryDifferentialEquationSystemRequest

solveOrdinaryDifferentialEquationSystemRequest(
    equations: Expression[],
    dependent_function_calls: Expression[],
    independent_variable: string,
    condition_residuals?: Expression[] | null,
    method?: string | null,
): OrdinaryDifferentialEquationSystemSolveResult

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#

Raw WebAssembly: Default context

linearDifferentialOperator(): LinearDifferentialOperator | undefined
Calling forms

Raw WebAssembly: Explicit context: Context.linearDifferentialOperator

linearDifferentialOperator(
    equation: Expression,
    dependent_function_call: Expression,
    independent_variable: string,
): LinearDifferentialOperator | undefined

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#

Raw WebAssembly: Default context

ordinaryDifferentialEquationSeries(): OrdinaryDifferentialEquationSeries | undefined
Calling forms

Raw WebAssembly: Explicit context: Context.ordinaryDifferentialEquationSeries

ordinaryDifferentialEquationSeries(
    equation: Expression,
    dependent_function_call: Expression,
    independent_variable: string,
    expansion_point: Expression,
    initial_derivatives: Expression[],
): OrdinaryDifferentialEquationSeries | undefined

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.

Raw WebAssembly: LinearDifferentialOperator property

readonly coefficients: Expression[]

Coefficients in ascending derivative order.

Raw WebAssembly: LinearDifferentialOperator property

readonly forcing: Expression

The forcing in L[y] = forcing.

Raw WebAssembly: LinearDifferentialOperator property

readonly order: number

The order of this differential operator.

Raw WebAssembly: LinearDifferentialOperator property

readonly restrictions: Expression[]

Denominators required to remain nonzero on the operator 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.

Raw WebAssembly: OrdinaryDifferentialEquationSeriesRecurrence property

readonly forcingCoefficients: Expression[]

Shifted forcing coefficients.

Raw WebAssembly: OrdinaryDifferentialEquationSeriesRecurrence property

readonly indexStart: number

The first nonnegative recurrence index.

Raw WebAssembly: OrdinaryDifferentialEquationSeriesRecurrence property

readonly operatorCoefficientSeries: Expression[]

Concatenated shifted coefficient series in derivative-order sequence.

Raw WebAssembly: OrdinaryDifferentialEquationSeriesRecurrence property

readonly operatorCoefficientSeriesLengths: Uint32Array

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

Raw WebAssembly: OrdinaryDifferentialEquationSeriesRecurrence property

readonly order: number

The order of the operator defining this recurrence.

OrdinaryDifferentialEquationSeries#

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

Raw WebAssembly: OrdinaryDifferentialEquationSeries property

readonly expansionPoint: Expression

The expansion point.

Raw WebAssembly: OrdinaryDifferentialEquationSeries property

readonly initialCoefficients: Expression[]

Normalized Taylor coefficients from the supplied initial derivative jet.

Raw WebAssembly: OrdinaryDifferentialEquationSeries property

readonly operator: LinearDifferentialOperator

The normalized operator defining this local problem.

Raw WebAssembly: OrdinaryDifferentialEquationSeries property

readonly proofStatus: string

The exact proof status of this series.

Raw WebAssembly: OrdinaryDifferentialEquationSeries property

readonly recurrence: OrdinaryDifferentialEquationSeriesRecurrence

The all-index recurrence proved by formal coefficient comparison.

verify_ordinary_differential_equation_system_solution#

Raw WebAssembly: Default context

verifyOrdinaryDifferentialEquationSystemSolution(
    equations: Expression[],
    dependent_function_calls: Expression[],
    independent_variable: string,
    components: Expression[],
    generated_constants: Expression[],
    condition_residuals?: Expression[] | null,
): OrdinaryDifferentialEquationSystemVerificationReport
Calling forms

Raw WebAssembly: Explicit context: Context.verifyOrdinaryDifferentialEquationSystemSolution

verifyOrdinaryDifferentialEquationSystemSolution(
    equations: Expression[],
    dependent_function_calls: Expression[],
    independent_variable: string,
    components: Expression[],
    generated_constants: Expression[],
    condition_residuals?: Expression[] | null,
): OrdinaryDifferentialEquationSystemVerificationReport

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.

Raw WebAssembly: OrdinaryDifferentialEquationSolveResult property

readonly decline: string | undefined

The typed reason no certified candidate was produced.

Raw WebAssembly: OrdinaryDifferentialEquationSolveResult property

readonly form: string | undefined

Whether the solution is the value of the unknown or a relation read as zero.

Raw WebAssembly: OrdinaryDifferentialEquationSolveResult property

readonly frequencyDomainEquation: Expression | undefined

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

Raw WebAssembly: OrdinaryDifferentialEquationSolveResult property

readonly generality: string | undefined

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

Raw WebAssembly: OrdinaryDifferentialEquationSolveResult property

readonly generatedConstants: Expression[]

Exactly the constants the solution treats as free.

Raw WebAssembly: OrdinaryDifferentialEquationSolveResult property

readonly image: Expression | undefined

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

Raw WebAssembly: OrdinaryDifferentialEquationSolveResult property

readonly method: string

The method the request actually ran.

Raw WebAssembly: OrdinaryDifferentialEquationSolveResult property

readonly solution: Expression | undefined

The certified solution, which no declined request carries.

Raw WebAssembly: OrdinaryDifferentialEquationSolveResult property

readonly verdict: string

Whether the request was solved or declined.

Raw WebAssembly: OrdinaryDifferentialEquationSolveResult property

readonly verification: string | undefined

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.

Raw WebAssembly: OrdinaryDifferentialEquationSystemSolveResult property

readonly components: Expression[]

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

Raw WebAssembly: OrdinaryDifferentialEquationSystemSolveResult property

readonly decline: string | undefined

The typed reason no certified assignment was produced.

Raw WebAssembly: OrdinaryDifferentialEquationSystemSolveResult property

readonly generality: string | undefined

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

Raw WebAssembly: OrdinaryDifferentialEquationSystemSolveResult property

readonly generatedConstants: Expression[]

Exactly the constants the assignment treats as free.

Raw WebAssembly: OrdinaryDifferentialEquationSystemSolveResult property

readonly method: string

The method the system request actually ran.

Raw WebAssembly: OrdinaryDifferentialEquationSystemSolveResult property

readonly route: string | undefined

The route the certified assignment came from.

Raw WebAssembly: OrdinaryDifferentialEquationSystemSolveResult property

readonly verdict: string

Whether the system was solved or declined.

Raw WebAssembly: OrdinaryDifferentialEquationSystemSolveResult property

readonly verification: string | undefined

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

OrdinaryDifferentialEquationSystemVerificationReport#

Not exposed by the WASM / JavaScript bindings. Available as api::OrdinaryDifferentialEquationPointSymmetrySearchDecline in Rust.

verdict, generality, and required_rank.

FirstOrderNonlinearSolutionAnalysis#

Not exposed by the WASM / JavaScript bindings. Available as FirstOrderNonlinearSolutionAnalysis in Python, api::FirstOrderNonlinearSolutionAnalysis in Rust.

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

FirstOrderNonlinearSolutionBranch#

Not exposed by the WASM / JavaScript bindings. Available as FirstOrderNonlinearSolutionBranch in Python, api::FirstOrderNonlinearSolutionBranch in Rust.

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

FirstOrderNonlinearParametricSolution#

Not exposed by the WASM / JavaScript bindings. Available as FirstOrderNonlinearParametricSolution in Python, api::FirstOrderNonlinearParametricSolution in Rust.

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

OrdinaryDifferentialEquationPointSymmetry#

Not exposed by the WASM / JavaScript bindings. Available as OrdinaryDifferentialEquationPointSymmetry in Python, api::OrdinaryDifferentialEquationPointSymmetry in Rust.

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

OrdinaryDifferentialEquationPointSymmetrySearch#

Not exposed by the WASM / JavaScript bindings. Available as OrdinaryDifferentialEquationPointSymmetrySearch in Python, api::OrdinaryDifferentialEquationPointSymmetrySearch in Rust.

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

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#

Not exposed by the WASM / JavaScript bindings. Available as api::OrdinaryDifferentialEquationMethod in Rust.

The route a scalar ordinary differential equation request must take.

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

OrdinaryDifferentialEquationSystemMethod#

Not exposed by the WASM / JavaScript bindings. Available as api::OrdinaryDifferentialEquationSystemMethod in Rust.

The route a system of ordinary differential equations must take.

Cases: Automatic, FundamentalMatrix, Sequential.

OrdinaryDifferentialEquationRegularity#

Not exposed by the WASM / JavaScript bindings. Available as api::OrdinaryDifferentialEquationRegularity in Rust.

The differentiability a scalar ordinary differential equation answer must have.

Cases: Classical, PiecewiseClassical, Weak.

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#

Not exposed by the WASM / JavaScript bindings. Available as api::OrdinaryDifferentialEquationSolveVerdict in Rust.

Whether a scalar ordinary differential equation request was solved.

Cases: Declined, Solved.

OrdinaryDifferentialEquationSystemRoute#

Not exposed by the WASM / JavaScript bindings. Available as api::OrdinaryDifferentialEquationSystemRoute in Rust.

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

Cases: DependencyBlocks, FundamentalMatrix, Sequential.

OrdinaryDifferentialEquationSolutionForm#

Not exposed by the WASM / JavaScript bindings. Available as api::OrdinaryDifferentialEquationSolutionForm in Rust.

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

Cases: Explicit, Implicit.

OrdinaryDifferentialEquationVerificationVerdict#

Not exposed by the WASM / JavaScript bindings. Available as api::OrdinaryDifferentialEquationVerificationVerdict in Rust.

The exact decision an independent ordinary differential equation verifier reached.

Cases: Inconclusive, Rejected, Verified.

OrdinaryDifferentialEquationGeneralityVerdict#

Not exposed by the WASM / JavaScript bindings. Available as api::OrdinaryDifferentialEquationGeneralityVerdict in Rust.

The exact rank decision behind a complete-family claim.

Cases: Deficient, FullRank, Inconclusive.

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#

Not exposed by the WASM / JavaScript bindings. Available as api::OrdinaryDifferentialEquationSolveDecline in Rust.

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.

OrdinaryDifferentialEquationSystemSolveDecline#

Not exposed by the WASM / JavaScript bindings. Available as api::OrdinaryDifferentialEquationSystemSolveDecline in Rust.

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

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

OrdinaryDifferentialEquationPointSymmetrySearchDecline#

Not exposed by the WASM / JavaScript bindings. Available as api::OrdinaryDifferentialEquationPointSymmetrySearchDecline in Rust.

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

Cases: NoSymmetryProved, DeterminingSystemUndecidable.

Additional API#

FirstOrderNonlinearParametricSolution#

FirstOrderNonlinearParametricSolution.coordinate#

Raw WebAssembly: FirstOrderNonlinearParametricSolution property

readonly coordinate: Expression

The independent coordinate as a function of the parameter.

FirstOrderNonlinearParametricSolution.generatedConstants#

Raw WebAssembly: FirstOrderNonlinearParametricSolution property

readonly generatedConstants: Expression[]

The integration constants of this parameterized branch.

FirstOrderNonlinearParametricSolution.parameter#

Raw WebAssembly: FirstOrderNonlinearParametricSolution property

readonly parameter: Expression

The exact parameter symbol for this parameterized branch.

FirstOrderNonlinearParametricSolution.value#

Raw WebAssembly: FirstOrderNonlinearParametricSolution property

readonly value: Expression

The dependent value as a function of the parameter.

FirstOrderNonlinearSolutionAnalysis#

FirstOrderNonlinearSolutionAnalysis.parametricSolutions#

Raw WebAssembly: FirstOrderNonlinearSolutionAnalysis property

readonly parametricSolutions: FirstOrderNonlinearParametricSolution[]

Every certified parameterized branch.

FirstOrderNonlinearSolutionAnalysis.regularFamily#

Raw WebAssembly: FirstOrderNonlinearSolutionAnalysis property

readonly regularFamily: FirstOrderNonlinearSolutionBranch | undefined

The certified regular one-parameter family, when one was proved.

FirstOrderNonlinearSolutionAnalysis.singularSolutions#

Raw WebAssembly: FirstOrderNonlinearSolutionAnalysis property

readonly singularSolutions: FirstOrderNonlinearSolutionBranch[]

Every certified singular or equilibrium branch outside the regular family.

FirstOrderNonlinearSolutionBranch#

FirstOrderNonlinearSolutionBranch.expression#

Raw WebAssembly: FirstOrderNonlinearSolutionBranch property

readonly expression: Expression

The branch value or its implicit residual relation.

FirstOrderNonlinearSolutionBranch.form#

Raw WebAssembly: FirstOrderNonlinearSolutionBranch property

readonly form: string

Whether this branch gives a value or an implicit relation read as zero.

FirstOrderNonlinearSolutionBranch.generatedConstants#

Raw WebAssembly: FirstOrderNonlinearSolutionBranch property

readonly generatedConstants: Expression[]

The free constants generated for this branch.

OrdinaryDifferentialEquationPointSymmetry#

OrdinaryDifferentialEquationPointSymmetry.horizontalComponent#

Raw WebAssembly: OrdinaryDifferentialEquationPointSymmetry property

readonly horizontalComponent: Expression

The horizontal component of the verified infinitesimal generator.

OrdinaryDifferentialEquationPointSymmetry.verticalComponent#

Raw WebAssembly: OrdinaryDifferentialEquationPointSymmetry property

readonly verticalComponent: Expression

The vertical component of the verified infinitesimal generator.

OrdinaryDifferentialEquationPointSymmetrySearch#

OrdinaryDifferentialEquationPointSymmetrySearch.decline#

Raw WebAssembly: OrdinaryDifferentialEquationPointSymmetrySearch property

readonly decline: string | undefined

The typed reason no symmetry was proved, when the bounded search declined.

OrdinaryDifferentialEquationPointSymmetrySearch.symmetries#

Raw WebAssembly: OrdinaryDifferentialEquationPointSymmetrySearch property

readonly symmetries: OrdinaryDifferentialEquationPointSymmetry[]

Every independently verified generator found within the fixed search budget.

OrdinaryDifferentialEquationSystemVerificationReport#

OrdinaryDifferentialEquationSystemVerificationReport.generality#

Raw WebAssembly: OrdinaryDifferentialEquationSystemVerificationReport property

readonly generality: string

The rank decision on the map from the supplied constants to the initial jet.

OrdinaryDifferentialEquationSystemVerificationReport.requiredRank#

Raw WebAssembly: OrdinaryDifferentialEquationSystemVerificationReport property

readonly requiredRank: number

The dimension a complete family of the system must span.

OrdinaryDifferentialEquationSystemVerificationReport.verdict#

Raw WebAssembly: OrdinaryDifferentialEquationSystemVerificationReport property

readonly verdict: string

The decision on every equation residual and every datum of the supplied assignment.

Symi documentation · WASM / JavaScript