Wolfram Language & System Documentation Center

FindRoot

FindRoot[f,{x,x₀}]

searches for a numerical root of f, starting from the point x=x₀.

FindRoot[lhs==rhs,{x,x₀}]

searches for a numerical solution to the equation lhs==rhs.

FindRoot[{f₁,f₂,…},{{x,x₀},{y,y₀},…}]

searches for a simultaneous numerical root of all the f_i.

FindRoot[{eqn₁,eqn₂,…},{{x,x₀},{y,y₀},…}]

searches for a numerical solution to the simultaneous equations eqn_i.

FindRoot

FindRoot[f,{x,x₀}]

searches for a numerical root of f, starting from the point x=x₀.

FindRoot[lhs==rhs,{x,x₀}]

searches for a numerical solution to the equation lhs==rhs.

FindRoot[{f₁,f₂,…},{{x,x₀},{y,y₀},…}]

searches for a simultaneous numerical root of all the f_i.

FindRoot[{eqn₁,eqn₂,…},{{x,x₀},{y,y₀},…}]

searches for a numerical solution to the simultaneous equations eqn_i.

Details and Options

If the starting point for a variable is given as a list, the values of the variable are taken to be lists with the same dimensions.
FindRoot returns a list of replacements for x, y, … , in the same form as obtained from Solve.
FindRoot first localizes the values of all variables, then evaluates f with the variables being symbolic, and then repeatedly evaluates the result numerically.
FindRoot has attribute HoldAll, and effectively uses Block to localize variables.
FindRoot[lhs==rhs,{x,x₀,x₁}] searches for a solution using x₀ and x₁ as the first two values of x, avoiding the use of derivatives.
FindRoot[lhs==rhs,{x,x_start,x_min,x_max}] searches for a solution, stopping the search if x ever gets outside the range x_min to x_max.
If you specify only one starting value of x, FindRoot searches for a solution using Newton methods. If you specify two starting values, FindRoot uses a variant of the secant method.
If all equations and starting values are real, then FindRoot will search only for real roots. If any are complex, it will also search for complex roots.
You can always tell FindRoot to search for complex roots by adding 0.I to the starting value.
The following options can be given:

AccuracyGoal	Automatic	the accuracy sought
EvaluationMonitor	None	expression to evaluate whenever equations are evaluated
Jacobian	Automatic	the Jacobian of the system
MaxIterations	100	maximum number of iterations to use
	Automatic	method to be used
PrecisionGoal	Automatic	the precision sought
StepMonitor	None	expression to evaluate whenever a step is taken
WorkingPrecision	MachinePrecision	the precision to use in internal computations

The default settings for AccuracyGoal and PrecisionGoal are WorkingPrecision/2.
The setting for AccuracyGoal specifies the number of digits of accuracy to seek in both the value of the position of the root, and the value of the function at the root.
The setting for PrecisionGoal specifies the number of digits of precision to seek in the value of the position of the root.
FindRoot continues until either of the goals specified by AccuracyGoal or PrecisionGoal is achieved.
If FindRoot does not succeed in finding a solution to the accuracy you specify within MaxIterations steps, it returns the most recent approximation to a solution that it found. You can then apply FindRoot again, with this approximation as a starting point.

Examples

open all close all

Basic Examples (3)

Find a root of near :

Wolfram Language code: FindRoot[Sin[x] + Exp[x], {x, 0}]

Find a solution to near :

Wolfram Language code: FindRoot[Cos[x] == x, {x, 0}]

Solve a nonlinear system of equations:

Wolfram Language code: FindRoot[{Exp[x - 2] == y, y ^ 2 == x}, {{x, 1}, {y, 1}}]

Scope (4)

Find the solution of a system of two nonlinear equations:

Wolfram Language code: FindRoot[{y == Exp[x], x + y == 2}, {{x, 1}, {y, 1}}]

Find a root for a three-component function of three variables:

Wolfram Language code: FindRoot[{Sin[x + y], Cos[x - y], x ^ 2 + y ^ 2 - z}, {{x, 1}, {y, 0}, {z, 0}}]

You can cause the search to use complex values by giving a complex starting value:

Wolfram Language code: FindRoot[Zeta[z], {z, 1 / 2 + 14 I}]

When the function is complex for real input, a real starting value may give a complex result:

Wolfram Language code: FindRoot[(Cos[z + I] - 2)(z + 2), {z, 1}]

Wolfram Language code: FindRoot[(Cos[z + I] - 2)(z + 2), {z, -1}]

Generalizations & Extensions (1)

A variable may be considered as vector valued if specified in the starting value:

Wolfram Language code: A = {{1, 2, 3}, {4, 5, 6}, {6, 7, 8}};

Wolfram Language code: FindRoot[{A.x == λ x, x.x == 1}, {{x, RandomReal[1, 3]}, {λ, 1}}]

Options (10)

AccuracyGoal (1)

Change tolerances for error estimates:

Wolfram Language code: 10 - x /. FindRoot[Sin[x - 10] - x + 10, {x, 0}]

Relax error tolerances for stopping:

Wolfram Language code: 10 - x /. FindRoot[Sin[x - 10] - x + 10, {x, 0}, AccuracyGoal -> 4, PrecisionGoal -> 4]

Make estimated relative distance to the root the main criterion for stopping:

Wolfram Language code: 10 - x /. FindRoot[Sin[x - 10] - x + 10, {x, 0}, AccuracyGoal -> Infinity, PrecisionGoal -> 8]

DampingFactor (1)

DampingFactor can be used to help speed convergence to higher-order roots:

Wolfram Language code: Block[{s = 0}, {FindRoot[Sin[x] - 1, {x, 1.5}, StepMonitor :> s++], s}]

Wolfram Language code: Block[{s = 0}, {FindRoot[Sin[x] - 1, {x, 1.5}, DampingFactor -> 2, StepMonitor :> s++], s}]

EvaluationMonitor (1)

EvaluationMonitor can be used to keep track of function evaluations used:

Wolfram Language code: {res, {evx}} = Reap[FindRoot[x ^ 2 == Exp[x], {x, 0}, EvaluationMonitor :> Sow[x]]]

Wolfram Language code: Show[Plot[{x ^ 2, Exp[x]}, {x, -1, 0}], ListPlot[{Transpose[{evx, evx ^ 2}], Transpose[{evx, Exp[evx]}]}]]

Jacobian (1)

Specify the Jacobian for a "black-box" function:

Wolfram Language code:

n = 1000;
A = SparseArray[{{i_, i_} -> -2., {i_, j_} /; Abs[i - j] == 1 -> 1.}, {n, n}, 0.];
blackbox[x_ ? VectorQ] := n ^ 2 A.x + x - x ^ 3 - 1;

Wolfram Language code: J[x_ ? VectorQ] := Module[{d = 1 - 3 x ^ 2}, n ^ 2 A + SparseArray[{i_, i_} :> d[[i]], {n, n}]]

Wolfram Language code:

sc = ConstantArray[0., n];
Block[{e = 0}, Timing[FindRoot[blackbox[x], {x, sc}, Jacobian -> J[x], EvaluationMonitor :> e++];e]]

Without a specified Jacobian, extra evaluations are used to compute finite differences:

Wolfram Language code: Block[{e = 0}, Timing[FindRoot[blackbox[x], {x, sc}, EvaluationMonitor :> e++];e]]

If you just know the sparse form, specifying the sparse pattern template saves evaluations:

Wolfram Language code: sp = SparseArray[{{i_, j_} /; Abs[i - j] ≤ 1 -> _}, {n, n}]

Wolfram Language code:

Block[{e = 0}, Timing[FindRoot[blackbox[x], {x, sc}, Jacobian -> {"FiniteDifference", Sparse -> sp}, EvaluationMonitor :> e++];e]]

Inspect the number of Jacobian evaluations needed by different methods:

Wolfram Language code: Block[{j = 0}, FindRoot[blackbox[x], {x, sc}, Jacobian -> {J[x], EvaluationMonitor :> j++}];"Jacobian Evaluations" -> j]

Wolfram Language code:

Block[{j = 0}, FindRoot[blackbox[x], {x, sc}, 
	Method -> "AffineCovariantNewton", Jacobian -> {J[x], EvaluationMonitor :> j++}];"Jacobian Evaluations" -> j]

MaxIterations (1)

Limit or increase the number of steps taken:

Wolfram Language code: FindRoot[Exp[1 / (x ^ 2 - 1)] - 10 ^ -8, {x, .1}, MaxIterations -> 10]

The default number of iterations is 100:

Wolfram Language code: FindRoot[Exp[1 / (x ^ 2 - 1)], {x, .1}]

Eventually the algorithm stalls out since this mollifier function has all derivatives 0 at :

Wolfram Language code: FindRoot[Exp[1 / (x ^ 2 - 1)], {x, .1}, MaxIterations -> 1000]

Method (2)

Method options are also explained in Unconstrained Optimization.

Find a root for using different methods:

Wolfram Language code:

f[x_] = ArcTan[1000 Cos[x]];
Plot[f[x], {x, 0, 12}, Exclusions -> None]

Define a function that monitors the steps and evaluations used by FindRoot:

Wolfram Language code:

monitoredFindRoot[args__] := Module[{s = 0, e = 0, j = 0}, 
	{FindRoot[args, StepMonitor :> s++, EvaluationMonitor :> e++, Jacobian -> {Automatic, EvaluationMonitor :> j++}], "Steps" -> s, "Evaluations" -> e, "Jacobian Evaluations" -> j}]

The default (Newton's) method:

Wolfram Language code: monitoredFindRoot[ArcTan[1000Cos[x]], {x, 1}]

Brent's root-bracketing method requiring two initial conditions bracketing the root:

Wolfram Language code: monitoredFindRoot[ArcTan[1000Cos[x]], {x, 1, 2}, Method -> "Brent"]

Secant method, starting with two initial conditions:

Wolfram Language code: monitoredFindRoot[ArcTan[1000Cos[x]], {x, 1, 2}, Method -> "Secant"]

Select the affine covariant Newton method:

Wolfram Language code: monitoredFindRoot[ArcTan[1000Cos[x]], {x, 1}, Method -> "AffineCovariantNewton"]

PrecisionGoal (1)

Change tolerances for error estimates:

Wolfram Language code: 10 - x /. FindRoot[Sin[x - 10] - x + 10, {x, 0}]

Relax error tolerances for stopping:

Wolfram Language code: 10 - x /. FindRoot[Sin[x - 10] - x + 10, {x, 0}, AccuracyGoal -> 4, PrecisionGoal -> 4]

Make estimated relative distance to the root the main criterion for stopping:

Wolfram Language code: 10 - x /. FindRoot[Sin[x - 10] - x + 10, {x, 0}, AccuracyGoal -> Infinity, PrecisionGoal -> 8]

StepMonitor (1)

Monitor when iterative steps have been taken:

Wolfram Language code: f[x_, y_] = {x - 1, 10(y - Cos[2x] + 1)};

Wolfram Language code: {res, {stxy}} = Reap[FindRoot[f[x, y], {{x, -1}, {y, -1}}, StepMonitor :> Sow[{x, y}]]]

Show the steps on a contour plot of :

Wolfram Language code: ContourPlot[f[x, y].f[x, y], {x, -1, 1}, {y, -2, 1}, Epilog -> {Red, Map[Point, stxy]}]

Show steps (red) and evaluations (green). A step may require several evaluations:

Wolfram Language code: {res, {exy}} = Reap[FindRoot[f[x, y], {{x, -1}, {y, -1}}, EvaluationMonitor :> Sow[{x, y}]]];

Wolfram Language code:

ContourPlot[f[x, y].f[x, y], {x, -1, 1}, {y, -2, 1}, Epilog -> {{PointSize[0.04], Red, Map[Point, stxy]}, {Green, Map[Point, exy]}}]

WorkingPrecision (1)

Find a root using 100-digit precision arithmetic:

Wolfram Language code: FindRoot[Cos[x ^ 2] - x, {x, 1}, WorkingPrecision -> 100]

Find the root starting with machine precision and adaptively working up to precision 100:

Wolfram Language code:

Block[{prec = MachinePrecision}, FindRoot[Cos[x ^ 2] - x, {x, 1.0}, WorkingPrecision -> 100, StepMonitor :> If[Precision[x] ≠ prec, prec = Precision[x];Print["Increased precision to ", prec, " at x = ", x];]]]

Applications (3)

Computing Inverse Functions (1)

For an isomorphism , the inverse is the root of :

Wolfram Language code: inv[f_, s_] := Function[{t}, s /. FindRoot[f - t, {s, 1}]]

An approximate inverse for the exponential function:

Wolfram Language code: einv = inv[Exp[x], x]

It is very close to the built-in Log function:

Wolfram Language code: Plot[einv[x] - Log[x], {x, 0, 1}, PlotRange -> All]

A "black-box" function giving the period of an oscillation:

Wolfram Language code:

f[a_ ? NumberQ] := Module[{p = 0}, NDSolve[{x''[t] + x[t] + x[t] ^ 3 == 0, x[0] == a, x'[0] == 0}, x, {t, ∞}, Method -> {"EventLocator", "Event" -> x[t], "EventAction" :> Throw[p = t, "StopIntegration"]}];
	4p];

Wolfram Language code: Plot[f[a], {a, 0, 4}]

Plot its inverse:

Wolfram Language code: finv = inv[f[a], a]

Wolfram Language code: Plot[finv[s], {s, 3, 6}]

Solving Boundary Value Problems (2)

Solve a boundary value problem , using a shooting method:

Wolfram Language code: x1[s_ ? NumberQ] := First[x[1] /. NDSolve[{x''[t] + x'[t] + x[t] ^ 3 == Sin[4 t], x[0] == 0, x'[0] == s}, x, {t, 0, 1}]]

Wolfram Language code: Plot[x1[s], {s, -10, 10}]

Use points on either side of the root to give bracketing starting values:

Wolfram Language code: FindRoot[x1[s], {s, -1, 0}]

Plot the solution:

Wolfram Language code: sol = NDSolve[{x''[t] + x'[t] + x[t] ^ 3 == Sin[4t], x[0] == 0, x'[0] == s} /. %, x, {t, 0, 1}]

Wolfram Language code: Plot[x[t] /. sol, {t, 0, 1}]

Solve the boundary-value problem , with n collocation points:

Wolfram Language code: n = 100;

Consider as a first-order system :

Wolfram Language code: f[{u_, v_}] := {v, (1 - u - u ^ 3) / ϵ};

Equations for collocation using the trapezoidal rule:

Wolfram Language code:

eqns = Flatten[Join[{Subscript[u, 0] == 0, Subscript[u, n] == 0}, Table[Thread[{Subscript[u, i], Subscript[v, i]} == {Subscript[u, i - 1], Subscript[v, i - 1]} + (1/2 n)(f[{Subscript[u, i - 1], Subscript[v, i - 1]}] + f[{Subscript[u, i], Subscript[v, i]}])], {i, 1, n}]]];

Use 0 as a starting value:

Wolfram Language code: sv = Flatten[Table[{{Subscript[u, i], 0}, {Subscript[v, i], 0}}, {i, 0, n}], 1];

Find a solution for a particular value of ϵ:

Wolfram Language code:

froot = FindRoot[eqns /. ϵ -> 0.01, sv];
sol = Table[Subscript[u, i], {i, 0, n}] /. froot;
ListLinePlot[sol]

Properties & Relations (2)

For a polynomial system of equations, NSolve finds all solutions and FindRoot finds one:

Wolfram Language code: polysys = Table[Total[RandomInteger[{-9, 9}, 5]RandomChoice[{x, y, z}, 5] ^ RandomInteger[{0, 3}, 5]] == 0, {3}]

FindRoot will find a single solution using an iterative method:

Wolfram Language code: FindRoot[polysys, Transpose[{{x, y, z}, RandomComplex[1 + I, 3]}]]

NSolve will find all solutions using a direct method:

Wolfram Language code: NSolve[polysys, {x, y, z}]

For equations involving parameters or exact solutions use Solve, Reduce, or FindInstance:

Wolfram Language code: eq = x Exp[2x + a] + 3 == 0;

Solve will return some solutions:

Wolfram Language code: Solve[eq, x]

Reduce will enumerate all solutions:

Wolfram Language code: Reduce[eq, x]

FindInstance will find particular instances:

Wolfram Language code: FindInstance[eq, {x, a}, 2]

Possible Issues (3)

If a function is complex, variables are allowed to have complex values:

Wolfram Language code: FindRoot[Zeta[1 / 2 + I t], {t, 1}]

If the function is kept real, variables are also taken to be real:

Wolfram Language code: FindRoot[Abs[Zeta[1 / 2 + I t]], {t, 1}]

It can be time-consuming to compute functions symbolically:

Wolfram Language code: f[x_] := Nest[Sin[# + Sin[2#]]&, x, 20]

Wolfram Language code: FindRoot[f[x], {x, 0}]//Timing

Restricting the function definition avoids symbolic evaluation:

Wolfram Language code: g[x_ ? NumericQ] := Nest[Sin[# + Sin[2#]]&, x, 20]

Wolfram Language code: FindRoot[g[x], {x, 0}]//Timing

Restricting the search domain too much can be problematic. Find the solution of a system of two nonlinear equations starting from 1/2 in the region from [0,1]:

Wolfram Language code: FindRoot[{y == Exp[x], x + y == 2}, {{x, 1 / 2, 0, 1}, {y, 1 / 2, 0, 1}}]

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

FindRoot

Details and Options

Examples

Basic Examples (3)

Scope (4)

Generalizations & Extensions (1)

Options (10)

AccuracyGoal (1)

DampingFactor (1)

EvaluationMonitor (1)

Jacobian (1)

MaxIterations (1)

Method (2)

PrecisionGoal (1)

StepMonitor (1)

WorkingPrecision (1)

Applications (3)

Computing Inverse Functions (1)

Solving Boundary Value Problems (2)

Properties & Relations (2)

Possible Issues (3)

Text

CMS

APA

BibTeX

BibLaTeX

FindRoot

Details and Options

Examples

Basic Examples (3)

Scope (4)

Generalizations & Extensions (1)

Options (10)

AccuracyGoal (1)

DampingFactor (1)

EvaluationMonitor (1)

Jacobian (1)

MaxIterations (1)

Method (2)

PrecisionGoal (1)

StepMonitor (1)

WorkingPrecision (1)

Applications (3)

Computing Inverse Functions (1)

Solving Boundary Value Problems (2)

Properties & Relations (2)

Possible Issues (3)

See Also

Tech Notes

Related Guides

Related Links

History

Text

CMS

APA

BibTeX

BibLaTeX