WOLFRAM

Wolfram Language & System Documentation Center

DFixedPoints[eqn,x[t],t]

gives the fixed points for a differential equation.

DFixedPoints[{eqn1,eqn2,…},{x1[t],x2[t],…},t]

gives the fixed points for a system of differential equations.

Details and Options
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Linear Equations  
Nonlinear Equations  
Linear Systems  
Nonlinear Systems  
Options  
Assumptions  
Applications  
Physics  
Biology  
Chemistry  
Control Systems  
Properties & Relations  
See Also
Related Guides
History
Cite this Page

DFixedPoints

DFixedPoints[eqn,x[t],t]

gives the fixed points for a differential equation.

DFixedPoints[{eqn1,eqn2,…},{x1[t],x2[t],…},t]

gives the fixed points for a system of differential equations.

Details and Options

  • Fixed points are also known as stationary points or equilibrium points of the differential equation.
  • DFixedPoints is typically used to locate all fixed points for nonlinear continuous-time systems that frequently occur in ecological, economical or technical modeling. The local behavior at these fixed points can be analyzed using DStabilityConditions.
  • For a system of differential equations , a point is a fixed point iff . In effect, the initial value remains stationary; if you initialize at , you stay at .
  • DFixedPoints returns a list of the form {{,,…},…}, where {,,…} is a fixed point of the system.
  • Systems of higher-order ODEs are treated as systems of first-order ODEs with additional variables corresponding to the higher-order derivatives. In this case, the fixed points are given as nested lists {{x,x',…},{y,y',…},…}.
  • DFixedPoints works for linear and nonlinear ordinary differential equations.
  • The following options can be given:
  • Assumptions $Assumptionsassumptions on parameters

Examples

open all close all

Basic Examples  (4)

Find the fixed point for the equation :

Wolfram Language code: DFixedPoints[x'[t] == -2x[t], x[t], t]

Find the fixed point for the equation :

Wolfram Language code: DFixedPoints[x'[t] == 2x[t] + 1, x[t], t]

Find the fixed points and conditions for stability for the equation :

Wolfram Language code: DFixedPoints[y'[t] == a y[t], y, t]
Wolfram Language code: DStabilityConditions[y'[t] == a y[t], y, t]

Plot several solutions for different values of a:

Wolfram Language code: sol = DSolveValue[{y'[t] == a y[t], y[0] == -1}, y[t], t]
Wolfram Language code: Table[Plot[sol, {t, 0, 4}, Rule[...]], {a, {-1.1, 1.1}}]

Fixed points and stability analysis of a two-dimensional system:

Wolfram Language code: DFixedPoints[{x'[t] == b x[t] + y[t], y'[t] == -2 x[t] + a y[t]}, {x, y}, t]
Wolfram Language code: DStabilityConditions[{x'[t] == b x[t] + y[t], y'[t] == -2 x[t] + a y[t]}, {x, y}, t]

Plot the parameter region for which the system is stable:

Wolfram Language code: RegionPlot[%[[1, 2]], {a, -5, 5}, {b, -5, 5}]

Scope  (23)

Linear Equations  (5)

Find the fixed point for the equation :

Wolfram Language code: DFixedPoints[x'[t] == -3 x[t], x, t]

A first-order linear inhomogeneous equation:

Wolfram Language code: DFixedPoints[y'[t] == a y[t] + 5, y, t]
Wolfram Language code: DStabilityConditions[y'[t] == a y[t] + 5, y, t]

Plot the unstable solution for :

Wolfram Language code: sol = DSolveValue[{y'[t] == a y[t] + 5, y[0] == 1}, y[t], t]; Plot[sol /. a -> 0.5, {t, 0, 10}]

Plot the stable solution for :

Wolfram Language code: sol = DSolveValue[{y'[t] == a y[t] + 5, y[0] == 1}, y[t], t]; Plot[sol /. a -> -0.5, {t, 0, 10}]

Second-order linear equation:

Wolfram Language code: DFixedPoints[y''[t] + a y'[t] + b y[t] == 0, y, t]

Third-order linear equation:

Wolfram Language code: DFixedPoints[y'''[t] + a y''[t] + b y'[t] + c y[t] == 0, y, t]

Higher-order inhomogeneous ODE:

Wolfram Language code: DFixedPoints[y'''[x] + 5y''[x] + 3y'[x] + 6y[x] == 3, y, x]

Solve the ODE using coordinates of the fixed point as initial values:

Wolfram Language code: DSolve[{y'''[x] + 5y''[x] + 3y'[x] + 6y[x] == 3, y[0] == 1 / 2, y'[0] == 0, y''[0] == 0}, y[x], x]

Nonlinear Equations  (3)

Stability analysis of a nonlinear differential equation:

Wolfram Language code: DFixedPoints[x'[t] == x[t]^2 + 3x[t], x, t]
Wolfram Language code: DStabilityConditions[x'[t] == x[t]^2 + 3x[t], x, t]

Use StreamPlot to demonstrate the stability:

Wolfram Language code: StreamPlot[{1, x^2 + 3x}, {t, 0, 10}, {x, -4, 1}]

The stability of a first-order nonlinear equation:

Wolfram Language code: DFixedPoints[x'[t] == x[t]^2 - 5x[t] + 6, x, t]
Wolfram Language code: DStabilityConditions[x'[t] == x[t]^2 - 5x[t] + 6, x, t]

Plot the solution for the initial value :

Wolfram Language code: sol = DSolveValue[{x'[t] == x[t]^2 - 5x[t] + 6, x[0] == 5 / 2}, x[t], t]
Wolfram Language code: Plot[sol, {t, 0, 10}, PlotRange -> All]

Use StreamPlot to demonstrate the stability at point :

Wolfram Language code: StreamPlot[{1, x^2 - 5x + 6}, {t, 0, 10}, {x, 0, 4}]

Consider a second-order nonlinear ODE:

Wolfram Language code: eqn = y[x]^2 + 3 y'[x] + y''[x] == 2;

DSolve is unable to solve this equation:

Wolfram Language code: DSolve[eqn, y, x]

Find the fixed points for the equation using DFixedPoints:

Wolfram Language code: DFixedPoints[eqn, y, x]

Transform the equation into a system of first-order ODEs:

Wolfram Language code: sys = {y'[x] == y1[x], y[x]^2 + 3 y1[x] + y1'[x] == 2};

Plot the trajectories of the system in the plane:

Wolfram Language code: StreamPlot[{y1, 2 - y^2 - 3y1}, {y, -3, 3}, {y1, -3, 3}, ...]

Linear Systems  (11)

A stable linear system of uncoupled equations:

Wolfram Language code: DFixedPoints[{x'[t] == -x[t], y'[t] == -y[t]}, {x, y}, t]

Trajectories of the system:

Wolfram Language code: StreamPlot[{-x, -y}, {x, -3, 3}, {y, -3, 3}, ...]

An unstable linear system of uncoupled equations:

Wolfram Language code: DFixedPoints[{x'[t] == x[t], y'[t] == y[t]}, {x, y}, t]

Trajectories of the system:

Wolfram Language code: StreamPlot[{x, y}, {x, -3, 3}, {y, -3, 3}, ...]

The stability of a linear system with constant coefficients:

Wolfram Language code: DFixedPoints[{x'[t] == -x[t] - y[t], y'[t] == 2x[t] - y[t]}, {x, y}, t]
Wolfram Language code: DStabilityConditions[{x'[t] == -x[t] - y[t], y'[t] == 2x[t] - y[t]}, {x, y}, t]

Use StreamPlot to visualize the stability:

Wolfram Language code: StreamPlot[{-x - y, 2x - y}, {x, -3, 3}, {y, -3, 3}, StreamPoints -> Coarse, Epilog -> {Red, PointSize[Medium], Point[{0, 0}]}]

Unstable system with constant coefficients:

Wolfram Language code: DFixedPoints[{x'[t] == 3x[t] - 4y[t], y'[t] == x[t] - y[t]}, {x, y}, t]

Trajectories of the system:

Wolfram Language code: StreamPlot[{3x - 4y, x - y}, {x, -3, 3}, {y, -3, 3}, Rule[...]]

Stable system with constant coefficients:

Wolfram Language code: DFixedPoints[{x'[t] == -y[t], y'[t] == x[t]}, {x, y}, t]

Trajectories of the system:

Wolfram Language code: StreamPlot[{-y, x}, {x, -3, 3}, {y, -3, 3}, Rule[...]]

Inhomogeneous unstable system:

Wolfram Language code: DFixedPoints[{x'[t] == x[t] + y[t] - 2, y'[t] == x[t] - y[t]}, {x, y}, t]

Trajectories of the system:

Wolfram Language code: StreamPlot[{x + y - 2, x - y}, {x, -3, 3}, {y, -3, 3}, Rule[...]]

Inhomogeneous stable system:

Wolfram Language code: DFixedPoints[{x'[t] == -x[t] - y[t] - 1, y'[t] == 2x[t] - y[t] + 5}, {x, y}, t]
Wolfram Language code: StreamPlot[{-x - y - 1, 2x - y + 5}, {x, -3, 3}, {y, -3, 3}, Rule[...]]

Plot the solutions:

Wolfram Language code: sol = DSolveValue[{x'[t] == -x[t] - y[t] - 1, y'[t] == 2x[t] - y[t] + 5, x[0] == 2, y[0] == 0}, {x[t], y[t]}, t]
Wolfram Language code: Plot[sol, {t, 0, 10}]

For the system of two second-order ODEs, the fixed point is a nested list {{y,y'},{z,z'}}:

Wolfram Language code: DFixedPoints[{-z[t] - 3 y'[t] + y''[t] == 2, z''[t] == y[t] + z'[t] - z[t] - 3}, {y, z}, t]

Linear system with symbolic coefficients:

Wolfram Language code: DFixedPoints[{x'[t] == β y[t] + α, y'[t] == δ x[t] - γ}, {x, y}, t]

System of four linear ODEs:

Wolfram Language code: DFixedPoints[{Derivative[1][x][t] == 2 x[t] - 5 y[t], Derivative[1][y][t] == x[t] - 2 y[t], Derivative[1][u][t] == u[t] + 2 v[t], Derivative[1][v][t] == -5 u[t] - v[t]}, {x, y, u, v}, t]

Plot the solutions:

Wolfram Language code: sol = DSolveValue[{Derivative[1][x][t] == 2 x[t] - 5 y[t], Derivative[1][y][t] == x[t] - 2 y[t], Derivative[1][u][t] == u[t] + 2 v[t], Derivative[1][v][t] == -5 u[t] - v[t]}, {x[t], y[t], u[t], v[t]}, t]
Wolfram Language code: Plot[Evaluate[sol /. {C[1] -> 1, C[2] -> 2, C[3] -> 3, C[4] -> 4}], {t, 0, 10}]

10×10 linear system with random constant coefficients:

Wolfram Language code: SeedRandom[1234]; m = RandomInteger[10, {10, 10}]; g = RandomInteger[10, 10];
Wolfram Language code: dep = {x1[t], x2[t], x3[t], x4[t], x5[t], x6[t], x7[t], x8[t], x9[t], x10[t]};
Wolfram Language code: sys = Thread[D[dep, t] == m.dep + g];
Wolfram Language code: DFixedPoints[sys, dep, t]

Nonlinear Systems  (4)

A nonlinear first-order system:

Wolfram Language code: DFixedPoints[{x'[t] == −x[t] + 2x[t] y[t], y'[t] == y[t]−x[t]^2−y[t]^2}, {x, y}, t]

Analyze the stability of the points:

Wolfram Language code: DStabilityConditions[{x'[t] == −x[t] + 2x[t] y[t], y'[t] == y[t]−x[t]^2−y[t]^2}, {x, y}, t]

Use StreamPlot to visualize the stability:

Wolfram Language code: StreamPlot[{−x + 2x y, y−x^2−y^2}, {x, -2, 2}, {y, -1, 2}, Rule[...]]

A nonlinear system with periodic fixed points:

Wolfram Language code: DFixedPoints[{x'[t] == y[t], y'[t] == Sin[x[t]]}, {x, y}, t]

Analyze the stability of the points:

Wolfram Language code: DStabilityConditions[{x'[t] == y[t], y'[t] == Sin[x[t]]}, {x, y}, t]
Wolfram Language code: StreamPlot[{y, Sin[x]}, {x, -4Pi, 4Pi}, {y, -6, 6}, Rule[...]]

A nonlinear system with unstable fixed point at origin:

Wolfram Language code: DFixedPoints[{y[t] + x[t](1−x[t]^2−y[t]^2) == x'[t], −x[t] + y[t](1−x[t]^2−y[t]^2) == y'[t]}, {x, y}, t]
Wolfram Language code: StreamPlot[{y + x(1−x^2−y^2), −x + y(1−x^2−y^2)}, {x, -3, 3}, {y, -3, 3}, Epilog -> {Blue, PointSize[Medium], Point[{0, 0}]}]

Higher-order nonlinear system:

Wolfram Language code: DFixedPoints[{x''[t] == -2(x[t]^2 + y[t]^2)x'[t] - x[t] - 1, y''[t] == -2(x[t]^2 + y[t]^2)y'[t] - y[t]}, {x, y}, t]

Options  (1)

Assumptions  (1)

A system of two nonlinear equations has an infinite number of periodic fixed points:

Wolfram Language code: DFixedPoints[{x'[t] == y[t], y'[t] == Sin[x[t]]}, {x, y}, t]

Use Assumptions to specify the range of a dependent variable:

Wolfram Language code: DFixedPoints[{x'[t] == y[t], y'[t] == Sin[x[t]]}, {x, y}, t, Assumptions -> -4 < x[t] < 4]

Applications  (11)

Physics  (5)

Stability analysis for the spring-mass system with damping:

Wolfram Language code: DFixedPoints[m u''[t] + c u'[t] + k u[t] == 0, u, t]
Wolfram Language code: DStabilityConditions[m u''[t] + c u'[t] + k u[t] == 0, u, t]

Use assumptions to simplify the stability conditions:

Wolfram Language code: DStabilityConditions[m u''[t] + c u'[t] + k u[t] == 0, u, t, Assumptions -> m > 0 && c > 0 && k > 0]

Solve the spring-mass system equation:

Wolfram Language code: sol = DSolveValue[{m u''[t] + c u'[t] + k u[t] == 0, u[0] == 1, u'[0] == 0}, u[t], t]

Plot the solution for given values of parameters:

Wolfram Language code: Plot[sol /. {m -> 1, k -> 1, c -> 0.5}, {t, 0, 20}, PlotRange -> All]

Do stability analysis for the electric circuit equation:

Wolfram Language code: DFixedPoints[l i''[t] + r i'[t] + (1/c) i[t] == 0, i, t]
Wolfram Language code: DStabilityConditions[l i''[t] + r i'[t] + (1/c) i[t] == 0, i, t]

Solve the electric circuit equation:

Wolfram Language code: sol = DSolveValue[{l i''[t] + r i'[t] + (1/c) i[t] == 0, i[0] == 1, i'[0] == 0}, i[t], t]

Plot the solution for given values of parameters:

Wolfram Language code: Plot[sol /. {r -> 0.1, l -> 5 10^-2, c -> 0.1}, {t, 0, 10}, PlotRange -> All]

Stability analysis for the damped pendulum equation:

Wolfram Language code: DFixedPoints[θ''[t] + 1 / 5 θ'[t] + 9 Sin[θ[t]] == 0, θ, t]
Wolfram Language code: DStabilityConditions[θ''[t] + 1 / 5 θ'[t] + 9 Sin[θ[t]] == 0, θ, t]

Plot the phase portrait of the system:

Wolfram Language code: StreamPlot[{θ1, -1 / 5θ1 - 9Sin[θ]}, {θ, -3Pi, 3Pi}, {θ1, -10, 10}, ...]

Plot the solution for the initial conditions , :

Wolfram Language code: sol = NDSolve[{θ''[t] + 1 / 5 θ'[t] + 9 Sin[θ[t]] == 0, θ[0] == Pi / 2, θ'[0] == 0}, θ[t], {t, 0, 20}]; Plot[θ[t] /. sol, {t, 0, 20}, PlotRange -> All]

Stable system of Lorenz equations:

Wolfram Language code: σ = 10; b = 8 / 3; r = 15; eqns = {σ(−x[t] + y[t]) == x'[t], r x[t]−y[t]−x[t] z[t] == y'[t], −b z[t] + x[t] y[t] == z'[t]};
Wolfram Language code: DFixedPoints[eqns, {x, y, z}, t]
Wolfram Language code: DStabilityConditions[eqns, {x, y, z}, t]

Use StreamPlot3D to visualize the Lorenz attractors:

Wolfram Language code: StreamPlot3D[{σ(−x + y), r x−y−x z, −b z + x y}, {x, -10, 10}, {y, -10, 10}, {z, 0, 20}]

Unstable system of Lorenz equations:

Wolfram Language code: σ = 10; b = 8 / 3; r = 28; eqns = {σ(−x[t] + y[t]) == x'[t], r x[t]−y[t]−x[t] z[t] == y'[t], −b z[t] + x[t] y[t] == z'[t]};
Wolfram Language code: DFixedPoints[eqns, {x, y, z}, t]
Wolfram Language code: DStabilityConditions[eqns, {x, y, z}, t]

Solve the system and plot the solution:

Wolfram Language code: sol = NDSolve[{eqns, x[0] == 10, y[0] == 10, z[0] == 20}, {x[t], y[t], z[t]}, {t, 0, 200}];
Wolfram Language code: ParametricPlot3D[{x[t], y[t], z[t]} /. sol, {t, 0, 200}, PlotPoints -> 200, ColorFunction -> (Hue[#4]&)]

Biology  (3)

Stability analysis for the predator-prey model (Lotka–Volterra equations):

Wolfram Language code: DFixedPoints[{x'[t] == x[t](1 - 1 / 2y[t]), y'[t] == y[t](-3 / 4 + 1 / 4x[t])}, {x, y}, t]
Wolfram Language code: DStabilityConditions[{x'[t] == x[t](1 - 1 / 2y[t]), y'[t] == y[t](-3 / 4 + 1 / 4x[t])}, {x, y}, t]

Plot the phase portrait of the system:

Wolfram Language code: StreamPlot[{x(1 - 1 / 2y), y(-3 / 4 + 1 / 4x)}, {x, 0, 8}, {y, 0, 4}, Rule[...]]

Solve the system for the initial conditions , :

Wolfram Language code: sol = NDSolve[{x'[t] == x[t](1 - 1 / 2y[t]), y'[t] == y[t](-3 / 4 + 1 / 4x[t]), x[0] == 2, y[0] == 1}, {x[t], y[t]}, {t, 0, 30}]

Plot the solutions:

Wolfram Language code: Plot[Evaluate[{x[t], y[t]} /. sol], {t, 0, 30}, PlotLegends -> {"Prey", "Predator"}, PlotRange -> {0, 7}]

The Rosenzweig–MacArthur predator-prey model:

Wolfram Language code: eqns = {n'[t] == n[t](1 - n[t] / k) - an p[t]n[t] / (n[t] + h), p'[t] == p[t](ap n[t] / (n[t] + h) - m)};
Wolfram Language code: params = {an -> 1, ap -> 2, h -> 1, m -> 1, k -> 4};
Wolfram Language code: DFixedPoints[eqns /. params, {n, p}, t]
Wolfram Language code: StreamPlot[{n(1 - n / k) - an p n / (n + h), p(ap n / (n + h) - m)} /. params, {n, 0, 4}, {p, 0, 4}, Rule[...]]

The chemostat model represents biological systems in which microorganisms grow on abiotic resources:

Wolfram Language code: model = {x'[t] == (k x[t]y[t]/1 + y[t]) - x[t], y'[t] == -(x[t]y[t]/1 + y[t]) - y[t] + q};

Find the fixed points:

Wolfram Language code: DFixedPoints[model, {x, y}, t]//Simplify

Analyze the stability of the model for and :

Wolfram Language code: DStabilityConditions[model /. {k -> 2, q -> 2}, {x, y}, t]
Wolfram Language code: StreamPlot[{(k x y/1 + y) - x, -(x y/1 + y) - y + q} /. {k -> 2, q -> 2}, {x, 0, 4}, {y, 0, 3}, Rule[...]]

Chemistry  (1)

The Brusselator is a theoretical model for a type of autocatalytic reaction. The rate equations of the Brusselator model:

Wolfram Language code: sys = {x'[t] == x[t]^2y[t] - (b + 1)x[t] + a, y'[t] == -x[t]^2y[t] + b x[t]};

Find the fixed point of the system:

Wolfram Language code: DFixedPoints[sys, {x, y}, t]

The point is stable if b<1+a2:

Wolfram Language code: DStabilityConditions[sys /. {a -> 1, b -> 3 / 2}, {x, y}, t]
Wolfram Language code: StreamPlot[{x^2y - (b + 1)x + a, -x^2y + b x} /. {a -> 1, b -> 3 / 2}, {x, 0, 3}, {y, 0, 4}, Rule[...]]

The point is unstable if b>1+a2:

Wolfram Language code: DStabilityConditions[sys /. {a -> 1, b -> 5 / 2}, {x, y}, t]
Wolfram Language code: StreamPlot[{x^2y - (b + 1)x + a, -x^2y + b x} /. {a -> 1, b -> 5 / 2}, {x, 0, 3}, {y, 0, 4}, Rule[...]]

Control Systems  (2)

Analyze a satellite's attitude dynamics starting from Euler's equations of motion:

Euler’s equations with principal moments of inertia , , :

Wolfram Language code: eqns = Table[Subscript[j, i[[1]]] Subscript[ω, i[[1]]]'[t] - (Subscript[j, i[[2]]] - Subscript[j, i[[3]]])Subscript[ω, i[[2]]][t]Subscript[ω, i[[3]]][t] == Subscript[τ, i[[1]]][t], {i, {{x, y, z}, {y, z, x}, {z, x, y}}}] /. {Subscript[j, x] -> 300, Subscript[j, y] -> 320, Subscript[j, z] -> 270}

Find the fixed points of the equation for fixed values of , , :

Wolfram Language code: DFixedPoints[eqns /. {Subscript[τ, x][t] -> -27 / 400, Subscript[τ, y][t] -> 3 / 200, Subscript[τ, z][t] -> 1 / 50}, {Subscript[ω, x], Subscript[ω, y], Subscript[ω, z]}, t]

Choose the fixed point as an operating point:

Wolfram Language code: opPt = {Subscript[ω, x0] -> (1/30Sqrt[3]), Subscript[ω, y0] -> (3Sqrt[3]/100), Subscript[ω, z0] -> (3Sqrt[3]/200), Subscript[τ, x0] -> -(27/400), Subscript[τ, y0] -> (3/200), Subscript[τ, z0] -> (1/50)};

Construct a state-space model:

Wolfram Language code: ssm = StateSpaceModel[eqns, {{Subscript[ω, x][t], Subscript[ω, x0]}, {Subscript[ω, y][t], Subscript[ω, y0]}, {Subscript[ω, z][t], Subscript[ω, z0]}}, {{Subscript[τ, x][t], Subscript[τ, x0]}, {Subscript[τ, y][t], Subscript[τ, y0]}, {Subscript[τ, z][t], Subscript[τ, z0]}}, {Subscript[ω, x][t], Subscript[ω, y][t], Subscript[ω, z][t]}, t, SystemsModelLabels -> {{Subscript[τ, x], Subscript[τ, y], Subscript[τ, z]}, {Subscript[ω, x], Subscript[ω, y], Subscript[ω, z]}, {Subscript[ω, x], Subscript[ω, y], Subscript[ω, z]}}] /. opPt

The satellite’s attitude is unregulated if disturbed:

Wolfram Language code: OutputResponse[{ssm, {0.2, -0.1, 0.35}}, {0, 0, 0}, {t, 0, 3000}]; Plot[%, {t, 0, 3000}, PlotRange -> All, PlotLegends -> {Subscript[ω, x], Subscript[ω, y], Subscript[ω, z]}]

Verify the controllability of the model:

Wolfram Language code: ControllableModelQ[ssm]

Study an inverted pendulum using the Lagrangian:

The position of :

Wolfram Language code: Subscript[r, p] = Composition[TranslationTransform[{x[t], 0, 0}], RotationTransform[θ[t], {0, 0, 1}]][{0, 1, 0}]

Its velocity:

Wolfram Language code: Subscript[v, p] = D[Subscript[r, p], t]

The kinetic energy of the cart and pendulum:

Wolfram Language code: 𝒦 = (1/2)Subscript[m, 1] x'[t]^2 + (1/2)Subscript[m, 2]Subscript[v, p].Subscript[v, p]

The potential energy of the pendulum:

Wolfram Language code: 𝒰 = Subscript[m, 2]g Subscript[r, p][[2]]

The Lagrangian:

Wolfram Language code: ℒ = 𝒦 - 𝒰

The generalized forces:

Wolfram Language code: {Subscript[f, x], Subscript[f, θ]} = D[f[t] δx - Subscript[b, x]x'[t]δx - Subscript[b, θ]θ'[t]δθ, {{δx, δθ}}]

The equations of motion:

Wolfram Language code: eqns = Table[Subscript[∂, t]D[ℒ, q'[t]] - D[ℒ, q[t]] == Subscript[f, q], {q, {x, θ}}]//Simplify

A state-space model:

Wolfram Language code: ssm = StateSpaceModel[eqns, {x[t], x'[t], θ[t], θ'[t]}, f[t], {x[t], θ[t]}, t, SystemsModelLabels -> {f, {x, θ}, {x, Derivative[1][x], θ, Derivative[1][θ]}}]

The non-positive eigenvalues make it an unstable system:

Wolfram Language code: Eigenvalues[First[Normal[ssm /. {Subscript[m, 1] -> 1 / 2, Subscript[m, 2] -> 1 / 10, l -> 3 / 10, g -> 10, Subscript[b, x] -> 15 / 100, Subscript[b, θ] -> 1 / 100}]]]//N
Wolfram Language code: DFixedPoints[eqns /. {Subscript[m, 1] -> 1 / 2, Subscript[m, 2] -> 1 / 10, l -> 3 / 10, g -> 10, Subscript[b, x] -> 15 / 100, Subscript[b, θ] -> 1 / 100, f[t] -> 0}, {x, θ}, t]
Wolfram Language code: DStabilityConditions[eqns /. {Subscript[m, 1] -> 1 / 2, Subscript[m, 2] -> 1 / 10, l -> 3 / 10, g -> 10, Subscript[b, x] -> 15 / 100, Subscript[b, θ] -> 1 / 100, f[t] -> 0}, {x, θ}, t, {{1, 0, 2Pi, 0}, {1, 0, 3Pi, 0}}]

Properties & Relations  (8)

DFixedPoints returns fixed points for differential equations:

Wolfram Language code: DFixedPoints[y'[t] == a y[t], y, t]
Wolfram Language code: DFixedPoints[y'[t] == (1/2)y[t] + 1, y, t]

Use DFixedPoints to find all fixed points of a differential equation:

Wolfram Language code: DFixedPoints[y'[t] == 2 y[t](1 - y[t]), y[t], t]

Use DStabilityConditions to analyze the stability at specific fixed points:

Wolfram Language code: DStabilityConditions[y'[t] == 2 y[t](1 - y[t]), y[t], t, {{0}}]
Wolfram Language code: DStabilityConditions[y'[t] == 2 y[t](1 - y[t]), y[t], t, {{1}}]

Use DFixedPoints to find all fixed points of a nonlinear ODE:

Wolfram Language code: points = DFixedPoints[x'[t] == x[t]^2 + 3x[t], x, t]

Use Solve to find the fixed points:

Wolfram Language code: Solve[x^2 + 3x == 0, x]

The fixed points for the n^(th)-order differential equation are n-dimensional vectors:

Wolfram Language code: DFixedPoints[y''[t] + y'[t] + 3 y[t] == 5, y, t]

The fixed points for the system of n first-order differential equations are n-dimensional vectors:

Wolfram Language code: DFixedPoints[{y'[t] + z[t] == 3, y[t] + 2 z'[t] == 1}, {y[t], z[t]}, t]

Find the fixed points of a system of two ODEs:

Wolfram Language code: DFixedPoints[{x'[t] == -x[t] - y[t] - 1, y'[t] == 2x[t] - y[t] + 5}, {x, y}, t]

Use DSolveValue to solve the system using the fixed point as initial condition:

Wolfram Language code: sol = DSolveValue[{x'[t] == -x[t] - y[t] - 1, y'[t] == 2x[t] - y[t] + 5, x[0] == -2, y[0] == 1}, {x[t], y[t]}, t]//Simplify

Use DSolveValue to solve the system for given initial conditions:

Wolfram Language code: sol = DSolveValue[{x'[t] == -x[t] - y[t] - 1, y'[t] == 2x[t] - y[t] + 5, x[0] == 3, y[0] == -2}, {x[t], y[t]}, t]//Simplify

Plot the solution:

Wolfram Language code: Plot[Evaluate[sol], {t, 0, 20}]

Analyze the fixed points of a nonlinear ODE:

Wolfram Language code: DFixedPoints[x'[t] == (1/2)x[t](1 - x[t]), x, t]

Solve the ODE using NDSolve:

Wolfram Language code: sol = NDSolve[{x'[t] == (1/2)x[t](1 - x[t]), x[0] == 0.5}, x[t], {t, 0, 20}]

Plot the solution:

Wolfram Language code: Plot[x[t] /. sol, {t, 0, 20}, PlotRange -> All]

Find the fixed points for the system of two nonlinear ODEs:

Wolfram Language code: points = DFixedPoints[{x'[t] == x[t](2−x[t]−y[t]), y'[t] == −x[t] + 3y[t]−2x[t] y[t]}, {x, y}, t]

Calculate the Jacobian matrix of the system:

Wolfram Language code: (jacobian = D[{x(2−x−y), −x + 3y−2x y}, {{x, y}}])//MatrixForm

Calculate the eigenvalues of the Jacobian matrix for each fixed point:

Wolfram Language code: eig1 = Eigenvalues[jacobian /. Thread[{x, y} -> points[[1]]]]
Wolfram Language code: eig2 = Eigenvalues[jacobian /. Thread[{x, y} -> points[[2]]]]
Wolfram Language code: eig3 = Eigenvalues[jacobian /. Thread[{x, y} -> points[[3]]]]

The system is locally stable if all of the eigenvalues have negative real parts:

Wolfram Language code: Re[#] < 0& /@ eig1
Wolfram Language code: Re[#] < 0& /@ eig2
Wolfram Language code: Re[#] < 0& /@ eig3

Check the stability of the points using DStabilityConditions:

Wolfram Language code: DStabilityConditions[{x'[t] == x[t](2−x[t]−y[t]), y'[t] == −x[t] + 3y[t]−2x[t] y[t]}, {x, y}, t]
Wolfram Research (2024), DFixedPoints, Wolfram Language function, https://reference.wolfram.com/language/ref/DFixedPoints.html.

Text

Wolfram Research (2024), DFixedPoints, Wolfram Language function, https://reference.wolfram.com/language/ref/DFixedPoints.html.

CMS

Wolfram Language. 2024. "DFixedPoints." Wolfram Language & System Documentation Center. Wolfram Research. https://reference.wolfram.com/language/ref/DFixedPoints.html.

APA

Wolfram Language. (2024). DFixedPoints. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/DFixedPoints.html

BibTeX

@misc{reference.wolfram_2026_dfixedpoints, author="Wolfram Research", title="{DFixedPoints}", year="2024", howpublished="\url{https://reference.wolfram.com/language/ref/DFixedPoints.html}", note=[Accessed: 13-June-2026]}

BibLaTeX

@online{reference.wolfram_2026_dfixedpoints, organization={Wolfram Research}, title={DFixedPoints}, year={2024}, url={https://reference.wolfram.com/language/ref/DFixedPoints.html}, note=[Accessed: 13-June-2026]}