Wolfram Language & System Documentation Center

SystemModelSimulateSensitivity

SystemModelSimulateSensitivity[model,{p₁,p₂,…}]

simulates model and sensitivities to parameters p_i following experiment settings.

SystemModelSimulateSensitivity[model,t_max,{p₁,p₂,…}]

simulates from 0 to t_max.

SystemModelSimulateSensitivity[model,{t_min,t_max},{p₁,p₂,…}]

simulates from t_min to t_max.

SystemModelSimulateSensitivity[model,vars,{t_min,t_max},{p₁,p₂,…}]

stores only simulation data for the variables vars.

SystemModelSimulateSensitivity

SystemModelSimulateSensitivity[model,{p₁,p₂,…}]

simulates model and sensitivities to parameters p_i following experiment settings.

SystemModelSimulateSensitivity[model,t_max,{p₁,p₂,…}]

simulates from 0 to t_max.

SystemModelSimulateSensitivity[model,{t_min,t_max},{p₁,p₂,…}]

simulates from t_min to t_max.

SystemModelSimulateSensitivity[model,vars,{t_min,t_max},{p₁,p₂,…}]

stores only simulation data for the variables vars.

Details and Options

SystemModelSimulateSensitivity is used to estimate the variations in simulation results when changing parameter values in system models.
The model can have the following forms:

	SystemModel[…]	general system model
	StateSpaceModel[…]	state-space model
	TransferFunctionModel[…]	transfer function model
	AffineStateSpaceModel[…]	affine state-space model
	NonlinearStateSpaceModel[…]	nonlinear state-space model
	DiscreteInputOutputModel[…]	discrete input-output model

SystemModelSimulateSensitivity returns a SystemModelSimulationData object.
SystemModelSimulateSensitivity generates solutions for all real-valued variables , as well as derivatives , , …, for .
Sensitivities can be listed in a SystemModelSimulationData object sd with sd["SensitivityNames"].
The stored simulation variables vars can have the following values:
Automatic automatically choose what to store

{v₁,v₂,…} store only variables v_i

All store all variables
SystemModelSimulateSensitivity[…,spec] uses Association spec for initial values, parameters and inputs:

"ParameterValues"	{p₁val₁,…}	parameter p_i has value val_i
"InitialValues"	{v₁val₁,…}	variable v_i has initial value val_i
"Inputs"	{in₁fun₁,…}	input in_i has value fun_i[t] at time t

Setting "ParameterValues" or "InitialValues" to {p_i{c₁,c₂,…},…} runs simulations in parallel, with p_i taking values c_j.
"InitialValues" corresponds to the start property in the Modelica model.
The following options can be given:

InterpolationOrder	Automatic	continuity degree of output between events
Method	Automatic	what simulation method to use
ProgressReporting	$ProgressReporting	control display of progress

The option setting Automatic normally means that the setting is taken from model or its experiment setting.
With Method{"Sensitivity""WSM"} sensitivities are computed for state variables using the CVODES solver for a SystemModel model.
Other Method simulation suboptions are as indicated in SystemModelSimulate.

Examples

open all close all

Basic Examples (3)

Study sensitivity of a parameter over the time interval in model experiment settings:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], {"a"}]

Extract sensitivity names and plot them:

Wolfram Language code: sim["SensitivityNames"]

Wolfram Language code: SystemModelPlot[sim, {{"y", "a"}, {"z", "a"}}]

Show the sensitivity of a signal to relative changes in a parameter:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], {"y", "z"}, 5, {"a"}]

Plot bounds for y and z when varying a by 10%:

Wolfram Language code: SystemModelPlot[sim, {{"y", "a", 0.1}, {"z", "a", 0.1}}]

Use the diagram representation of a model as input:

Wolfram Language code: SystemModel["IntroductoryExamples.ComponentBased.ElectricCircuit"]

Copy and paste the output above:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], {"capacitor1.v"}, 5, {"sineVoltage1.f"}]

Scope (17)

Models (3)

Compute variables and sensitivities when simulating a NonlinearStateSpaceModel:

Wolfram Language code:

sim = SystemModelSimulateSensitivity[NonlinearStateSpaceModel[{{Cos[x] + 4*a*Sin[x/2]}, 
  {x + Sin[x]}}, {x}, {}, {Automatic}, Automatic, 
 SamplingPeriod -> None], 10, {a}, <|"ParameterValues" -> {a -> 1}|>]

Extract sensitivity names and plot them:

Wolfram Language code: sim["SensitivityNames"]

Wolfram Language code: SystemModelPlot[sim, {{x, a}, {Subscript[, 1], a}}, PlotRange -> All]

Plot bounds for a state when varying a by 40%:

Wolfram Language code: SystemModelPlot[sim, {{x, a, 0.4}}, PlotRange -> All]

Compute sensitivities in a parameter sweep for an AffineStateSpaceModel:

Wolfram Language code:

sims = SystemModelSimulateSensitivity[AffineStateSpaceModel[{{Cos[x2], (-1 - a)*x2 + 
    Cos[x1^2]}, {{0}, {1}}, {x2}, {{0}}}, 
 {x1, x2}, Automatic, {Automatic}, Automatic, SamplingPeriod -> None], 5, {a}, <|"ParameterValues" -> {a -> {1, 10}}|>]

Plot bounds for a state when varying a by 50%:

Wolfram Language code: SystemModelPlot[sims, {{x2, a, 0.5}}]

Compute sensitivities for a DiscreteInputOutputModel:

Wolfram Language code: diom = DiscreteInputOutputModel[{u[0] + y[-1] + a y[-2], u[1] + u[0] + u[-1]}, {{u, {-2, -1, 1}}}, {{y, {-1, -1, -1}}}]

Wolfram Language code: sim = SystemModelSimulateSensitivity[diom, {a}, <|"Inputs" -> {1 -> Range[-20, 20]}, "ParameterValues" -> {a -> 1}|>]

Plot bounds for the output when varying a by 5%:

Wolfram Language code: SystemModelPlot[sim, {{y, a, 0.05}}]

Simulation Time (3)

Simulate with settings from the model:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], {"a"}]

Wolfram Language code: sim["SimulationInterval"]

Simulate from time 0 to 5:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], 5, {"a"}]

Wolfram Language code: sim["SimulationInterval"]

Simulate for an explicit time interval:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], {2, 10}, {"a"}]

Wolfram Language code: sim["SimulationInterval"]

Sensitivity Results (6)

Study the sensitivity of one parameter:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], 50, {"a"}]

Wolfram Language code: sim["SensitivityNames"]

Wolfram Language code: SystemModelPlot[sim, {{"y", "a"}}]

Simulate with sensitivity to parameter a:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], 5, {"a"}];

Get the sensitivity names:

Wolfram Language code: sim["SensitivityNames"]

Get the sensitivity y has to changes in a:

Wolfram Language code: {ySensA} = sim[{{"y", "a"}}]

Study the sensitivities from one parameter:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], 5, {"sineVoltage1.f"}];

Wolfram Language code: sim["SensitivityNames"]//Short

Plot one of the sensitivities:

Wolfram Language code: SystemModelPlot[sim, {{"capacitor1.v", "sineVoltage1.f"}}]

Show the sensitivity of a signal to a parameter a:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], 50, {"a"}]

Get the sensitivity names:

Wolfram Language code: sim["SensitivityNames"]

Get the sensitivity y has to changes in a, as well as the nominal trajectory for y:

Wolfram Language code: {ySensA, y} = sim[{{"y", "a"}, "y"}, t]

Plot y with original parameter a, and with parameter a increased by 0.05:

Wolfram Language code: Plot[{Tooltip[y, "Nominal"], Tooltip[y + 0.05 ySensA, "Perturbed"]}, {t, 0, 50}]

Show the sensitivity of a signal to relative changes in a parameter:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], 5, {"a"}];

Get the sensitivity names:

Wolfram Language code: sim["SensitivityNames"]

Get the sensitivity y and z have to changes in a, as well as nominal trajectories and value:

Wolfram Language code: {ySensA, zSensA, y, z, a0} = sim[{{"y", "a"}, {"z", "a"}, "y", "z", "a"}, t];

Plot bounds for y and z when varying a by 10% of the sensitivity:

Wolfram Language code: {dY, dZ} = {a0 0.1ySensA, a0 0.1zSensA};

Wolfram Language code: Plot[{Tooltip[y, "y"], y + dY, y - dY, Tooltip[z, "z"], z + dZ, z - dZ}, {t, 0, 5}, Filling -> {2 -> {3}, 5 -> {6}}]

Show the sensitivity of a signal to absolute changes in a parameter a:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], 50, {"a"}]

Get the sensitivity y has to changes in a, as well as the trajectory for y:

Wolfram Language code: {ySensA, y} = sim[{{"y", "a"}, "y"}, t];

Compute the change in y when parameter a changes with absolute value 0.1:

Wolfram Language code: dY = 0.1 ySensA;

Plot the variation of y when parameter a varies by ±0.1:

Wolfram Language code: Plot[{Tooltip[y, "y"], y + dY, y - dY}, {t, 0, 50}, Filling -> {2 -> {3}}]

Variables, Parameters and Inputs (3)

Change the initial values of a simulation:

Wolfram Language code: Subscript[sim, 1] = SystemModelSimulateSensitivity[[image], 50, {"a"}];

Wolfram Language code: Subscript[sim, 2] = SystemModelSimulateSensitivity[[image], 50, {"a"}, <|"InitialValues" -> {"y" -> 2.85}|>];

Compare the changes in a plot:

Wolfram Language code: SystemModelPlot[{Subscript[sim, 1], Subscript[sim, 2]}, {{"y", "a"}}]

Change the parameter values of a simulation:

Wolfram Language code: Subscript[sim, 1] = SystemModelSimulateSensitivity[[image], 50, {"a"}];

Wolfram Language code: Subscript[sim, 2] = SystemModelSimulateSensitivity[[image], 50, {"a"}, <|"ParameterValues" -> {"a" -> 2.95}|>];

Compare the two in a plot:

Wolfram Language code: SystemModelPlot[{Subscript[sim, 1], Subscript[sim, 2]}, {{"y", "a"}}]

Give an input function for a variable and study the sensitivity of the output to a gain parameter:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], 10, {"gain.k"}, <|"Inputs" -> {"u" -> Sin}|>]

Plot the sensitivity of the output to the gain parameter:

Wolfram Language code: SystemModelPlot[sim, {{"integrator.y", "gain.k", 0.1}}]

Result Storage (2)

Store only selected variables:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], {"y", "a"}, {"a"}]

Only the given variables and parameters are saved:

Wolfram Language code: {sim["VariableNames"], sim["ParameterNames"]}

Store only selected variables and simulate with a given simulation interval:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], {"TR", "lambda"}, {0, 50}, {"lambda"}]

Plot bounds for TR when varying lambda by 20%:

Wolfram Language code: SystemModelPlot[sim, {{"TR", "lambda", 0.2}}]

Generalizations & Extensions (1)

Debug messages are collected in the message group "WSMDebug":

Wolfram Language code: Hold["WSMDebug"] /. $MessageGroups

Turn on debug messages for initialization:

Wolfram Language code: On[SystemModelSimulateSensitivity::dinit]

Wolfram Language code:

SystemModelSimulateSensitivity["DocumentationExamples.Basic.OneParameter", {0, 1}, {"a"}, Method -> {"Sensitivity" -> "WSM"}]

Turn off all debug messages for "WSMDebug":

Wolfram Language code: Off["WSMDebug"]

Options (4)

InterpolationOrder (1)

Simulate with interpolation orders 1 and 3, and 3 interpolation points:

Wolfram Language code:

{Subscript[sim, 1], Subscript[sim, 2]} = Table[SystemModelSimulateSensitivity[[image], 7, {"a"}, Method -> {Automatic, "InterpolationPoints" -> 3}, InterpolationOrder -> intOrder], {intOrder, {1, 3}}];

Show the sensitivity variable:

Wolfram Language code: SystemModelPlot[{Subscript[sim, 1], Subscript[sim, 2]}, {{"y", "a"}}]

Method (2)

With Method{"Sensitivity""WSM"}, sensitivities are computed for state variables using the CVODES solver for a SystemModel:

Wolfram Language code: simWSM = SystemModelSimulateSensitivity[[image], 5, {"a"}, Method -> {"Sensitivity" -> "WSM"}]

Wolfram Language code: simWSM["SensitivityNames"]

Compute sensitivities for all real-valued variables with the default method:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], 5, {"a"}]

Wolfram Language code: sim["SensitivityNames"]

Simulate a SystemModel and compute sensitivities with the number of interpolation points set by the model:

Wolfram Language code:

sim = SystemModelSimulateSensitivity[[image], 5, {"a"}];
SystemModelPlot[sim, {{"y", "a"}, {"z", "a"}, {Derivative[1]["z"], "a"}}]

Simulate and compute sensitivities with a custom number of interpolation points:

Wolfram Language code:

sim = SystemModelSimulateSensitivity[[image], 5, {"a"}, Method -> {"InterpolationPoints" -> 5}];
SystemModelPlot[sim, {{"y", "a"}, {"z", "a"}, {Derivative[1]["z"], "a"}}]

Simulate and compute sensitivities for state variables with a custom number of interpolation points:

Wolfram Language code:

simWSM = SystemModelSimulateSensitivity[[image], 5, {"a"}, Method -> {"Sensitivity" -> "WSM", "InterpolationPoints" -> 5}];
SystemModelPlot[simWSM, {{"y", "a"}, {"z", "a"}}]

ProgressReporting (1)

Control progress reporting with ProgressReporting:

Wolfram Language code: SystemModelSimulateSensitivity[[image], {"a"}, ProgressReporting -> False]

Applications (5)

Study the sensitivity of a model:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], {"y"}, 40, {"a"}];

Wolfram Language code: {y, ysensa} = sim[{"y", {"y", "a"}}, t];

Get the value of the parameter:

Wolfram Language code: a0 = First[sim[{"a"}]]

Find the peak deviation when varying the parameter:

Wolfram Language code: {peakVal, {peakTime}} = NMaximize[{0.05 a0 ysensa, 0 < t < 40}, {t}]

Show a 5% sensitivity bound and the peak deviation time:

Wolfram Language code:

Plot[Evaluate[{y, y + 0.05 a0 ysensa, y - 0.05 a0 ysensa}], {t, 0, 40}, Filling -> {2 -> {3}}, GridLines -> {{peakTime[[2]]}, None}]

Find out which variable is most sensitive to a frequency parameter:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], {"integrator1.y", "integrator2.y", "integrator3.y"}, 1, {"sine.f"}];

A 10% sensitivity bound shows that "integrator3.y" is most sensitive to the parameter:

Wolfram Language code: SystemModelPlot[sim, Table[{v, "sine.f", 0.1}, {v, {"integrator1.y", "integrator2.y", "integrator3.y"}}]]

Simulate a rolling wheel:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], {"wheel1.x", "wheel1.y"}, 10, {"wheel1.radius", "wheel1.m"}]

Select the position of the wheel and its sensitivities to different parameters:

Wolfram Language code:

{x, y, xsensrad, ysensrad, xsensmass, ysensmass} = sim[{"wheel1.x", "wheel1.y", {"wheel1.x", "wheel1.radius"}, {"wheel1.y", "wheel1.radius"}, {"wheel1.x", "wheel1.m"}, {"wheel1.y", "wheel1.m"}}, t];

Wolfram Language code: {r0, m0} = sim[{"wheel1.radius", "wheel1.m"}]

Show the path of the wheel with 4% variation of the wheel radius and mass, respectively:

Wolfram Language code:

d = 0.04;
ParametricPlot[{{x, y}, {x + v d #[[1]], y + v d #[[2]]}}, {v, -1, 1}, {t, 0, 10}, PlotPoints -> 40, Mesh -> None, Axes -> None, PlotLabel -> #[[3]], FrameTicks -> {{Automatic, None}, {None, None}}]& /@ {{xsensrad r0, ysensrad r0, "Wheel radius"}, {xsensmass m0, ysensmass m0, "Wheel mass"}}

Calibrate parameters in a model by comparing to measurement data:

Wolfram Language code: model = \!$\*GraphicsBox[«8»]$;

Wolfram Language code: data = Import["ExampleData/inertiaTestData.dat"];

Wolfram Language code: {p1, p2, var} = {"Resistor1.R", "SpringDamper1.d", "Inertia2.w"};

Set up caching for simulation and use SystemModelSimulateSensitivity to get gradients:

Wolfram Language code:

g[p_ ? NumericQ, q_ ? NumericQ] := g[p, q] = Quiet[AssociationThread[{var, {var, p1}, {var, p2}}, SystemModelSimulateSensitivity[model, {var}, 40, {p1, p2}, <|"ParameterValues" -> {p1 -> p, p2 -> q}|>, ProgressReporting -> False][{var, {var, p1}, {var, p2}}]], {SystemModelSimulateSensitivity::gen}]

Plot the result of the simulation for specific parameter values:

Wolfram Language code: Plot[g[0.1, 0.25][var][t], {t, 0, 40}]

Fit parameters to the measurement data without using gradients:

Wolfram Language code: AbsoluteTiming[FindFit[data, g[p, q][var][t], {{p, 0.1}, {q, 0.25}}, t, Gradient -> "FiniteDifference"]]

Fit using sensitivity information:

Wolfram Language code:

AbsoluteTiming[pars = FindFit[data, g[p, q][var][t], {{p, 0.1}, {q, 0.25}}, t, Gradient :> Comap[Lookup[g[p, q], {{var, p1}, {var, p2}}], t]]]

Simulate with the fitted parameters:

Wolfram Language code: sim = SystemModelSimulate[model, {0, 40}, <|"ParameterValues" -> ({p1 -> p, p2 -> q} /. pars)|>];

Show the test data and the calibrated model together:

Wolfram Language code: Show[SystemModelPlot[sim, {var}, PlotStyle -> Orange], ListPlot[data]]

Plot a solution with its sensitivity bounds:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], 30, {"a"}]

Wolfram Language code: sim["SensitivityNames"]

Wolfram Language code: {y, ysensa} = sim[{"y", {"y", "a"} }, t];

Get the nominal value of the parameter:

Wolfram Language code: a0 = First[sim[{"a"}]]

Show a 5% sensitivity bound:

Wolfram Language code: dY = 0.05 * a0 ysensa;

Wolfram Language code: Plot[Evaluate[{y, y + dY, y - dY}], {t, 0, 30}, Filling -> {2 -> {3}}]

Simulate with a maximal variation of 5%:

Wolfram Language code: simv = SystemModelSimulate[[image], 30, <|"ParameterValues" -> {"a" -> a0 Range[0.95, 1.05, 0.02]}|>];

Get the trajectories:

Wolfram Language code: yV = Table[sd[{"y"}, t][[1]], {sd, simv}];

Show that the trajectories are mostly contained in the approximated sensitivity bounds:

Wolfram Language code: Plot[Evaluate[{y, y + dY, y - dY, yV}], {t, 0, 30}, Filling -> {2 -> {3}}]

Properties & Relations (4)

Compare a sensitivity simulation with the sensitivity of the corresponding differential equation:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], 50, {"a"}];

Wolfram Language code: SystemModelPlot[sim, {"y", {"y", "a"}}]

Wolfram Language code: y = DSolve[{f'[t] + Sin[a]f[t] == 0, f[0] == b}, f[t], t][[1, 1, 2]];

Wolfram Language code: ySensA = D[y, a]

Wolfram Language code: Plot[Evaluate[{y, ySensA} /. {a -> 3, b -> 1}], {t, 0, 50}, PlotRange -> All]

Plot bounds for a relative parameter change:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], 5, {"a"}];

Get the sensitivity y has to changes in a, as well as y and the value for a:

Wolfram Language code: {ySensA, y, a0} = sim[{{"y", "a"}, "y", "a"}, t];

Plot bounds for y when varying a by 10% of the sensitivity:

Wolfram Language code: dY = a0 0.1ySensA;

Wolfram Language code: Plot[{Tooltip[y, "y"], y + dY, y - dY}, {t, 0, 5}, Filling -> {2 -> {3}}, AxesLabel -> {"t", None}]

Use SystemModelPlot instead:

Wolfram Language code: SystemModelPlot[sim, {{"y", "a", 0.1}}]

Sensitivities are valid for small changes in the parameter:

Wolfram Language code: {par, var} = {"sineVoltage1.f", "capacitor1.v"};

Get sensitivities to a parameter:

Wolfram Language code: sim = SystemModelSimulateSensitivity[[image], {var}, 5, {par}];

Simulate with variation of the parameter:

Wolfram Language code: {p0} = sim[{par}];

Wolfram Language code: sim2 = SystemModelSimulate[[image], {var}, 5, <|"ParameterValues" -> {par -> {0.9p0, 1.1p0}}|>];

Comparing in a plot, a 10% variation gives trajectories outside computed bounds:

Wolfram Language code: Show[SystemModelPlot[sim, {{var, par, 0.1}}, {2.5, 3.5}], SystemModelPlot[sim2, {var}]]

Use SystemModelParametricSimulate for a function that can be evaluated for different values:

Wolfram Language code: sols = SystemModelParametricSimulate[[image], "capacitor1.v", {"sineVoltage1.f"}]

Compute solutions for different values of the frequency parameter:

Wolfram Language code: fns = Table[sols[hz], {hz, 1, 5}]

Plot the solutions over time:

Wolfram Language code: Table[Plot[fn[t], {t, 0, 10}], {fn, fns}]

Neat Examples (1)

Show sensitivity bounds for the and axes in the Rabinovich–Fabrikant equations:

Wolfram Language code:

sim = SystemModelSimulateSensitivity[[image], {"x", "y", "z"}, 100, {"a", "g"}, <|"ParameterValues" -> {"a" -> 0.01, "g" -> 0.05}|>];

Wolfram Language code: {x, y, z, dx, dy, dz} = sim[{"x", "y", "z", {"x", "a"}, {"y", "a"}, {"z", "a"}}, t];

Wolfram Language code:

d = 0.04;
ParametricPlot[{x + v d dx, y  + v  d dy}, {v, 0, 1}, {t, 0, 19}, PlotPoints -> 40, Axes -> None, ColorFunction -> ColorData["HypsometricTints"], Mesh -> False]

Show the sensitivity bounds in 3D:

Wolfram Language code: Graphics3D[Tube@@Transpose@Table[{{x, y, z}, 0.0005Norm[{dx, dy, dz}]}, {t, 10, 55, 0.05}], Axes -> True]

Top

More Learning

Tech Support

Wolfram Solutions

Wolfram Solutions For Education

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

SystemModelSimulateSensitivity

Details and Options

Examples

Basic Examples (3)

Scope (17)

Models (3)

Simulation Time (3)

Sensitivity Results (6)

Variables, Parameters and Inputs (3)

Result Storage (2)

Generalizations & Extensions (1)

Options (4)

InterpolationOrder (1)

Method (2)

ProgressReporting (1)

Applications (5)

Properties & Relations (4)

Neat Examples (1)

Text

CMS

APA

BibTeX

BibLaTeX

	Automatic	automatically choose what to store
	{v₁,v₂,…}	store only variables v_i
	All	store all variables

SystemModelSimulateSensitivity

Details and Options

Examples

Basic Examples (3)

Scope (17)

Models (3)

Simulation Time (3)

Sensitivity Results (6)

Variables, Parameters and Inputs (3)

Result Storage (2)

Generalizations & Extensions (1)

Options (4)

InterpolationOrder (1)

Method (2)

ProgressReporting (1)

Applications (5)

Properties & Relations (4)

Neat Examples (1)

See Also

Related Guides

Related Links

History

Text

CMS

APA

BibTeX

BibLaTeX