Wolfram Language & System Documentation Center

FindArgMin

FindArgMin[f,x]

gives the position x_min of a local minimum of f.

FindArgMin[f,{x,x₀}]

gives the position x_min of a local minimum of f, found by a search starting from the point x=x₀.

FindArgMin[f,{{x,x₀},{y,y₀},…}]

gives the position {x_min,y_min,…} of a local minimum of a function of several variables.

FindArgMin[{f,cons},{{x,x₀},{y,y₀},…}]

gives the position of a local minimum subject to the constraints cons.

FindArgMin[{f,cons},{x,y,…}]

starts from a point within the region defined by the constraints.

FindArgMin

FindArgMin[f,x]

gives the position x_min of a local minimum of f.

FindArgMin[f,{x,x₀}]

gives the position x_min of a local minimum of f, found by a search starting from the point x=x₀.

FindArgMin[f,{{x,x₀},{y,y₀},…}]

gives the position {x_min,y_min,…} of a local minimum of a function of several variables.

FindArgMin[{f,cons},{{x,x₀},{y,y₀},…}]

gives the position of a local minimum subject to the constraints cons.

FindArgMin[{f,cons},{x,y,…}]

starts from a point within the region defined by the constraints.

Details and Options

FindArgMin[…,{x,y,…}] is effectively equivalent to {x,y,…}/.Last[FindMinimum[…,{x,y,…},…]].
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.
cons can contain equations, inequalities or logical combinations of these.
The constraints cons can be any logical combination of:
lhs==rhs equations

lhs>rhs or lhs>=rhs inequalities

{x,y,…}∈reg region specification
FindArgMin first localizes the values of all variables, then evaluates f with the variables being symbolic, and then repeatedly evaluates the result numerically.
FindArgMin has attribute HoldAll, and effectively uses Block to localize variables.
FindArgMin[f,{x,x₀,x₁}] searches for a local minimum in f using x₀ and x₁ as the first two values of x, avoiding the use of derivatives.
FindArgMin[f,{x,x₀,x_min,x_max}] searches for a local minimum, stopping the search if x ever gets outside the range x_min to x_max.
Except when f and cons are both linear, the results found by FindArgMin may correspond only to local, but not global, minima.
By default, all variables are assumed to be real.
For linear f and cons, x∈Integers can be used to specify that a variable can take on only integer values.
FindArgMin takes the same options as FindMinimum.

List of all options

AccuracyGoal	Automatic	the accuracy sought
EvaluationMonitor	None	expression to evaluate whenever f is evaluated
Gradient	Automatic	the list of gradient components for f
MaxIterations	Automatic	maximum number of iterations to use
Method	Automatic	method to use
PrecisionGoal	Automatic	the precision sought
StepMonitor	None	expression to evaluate whenever a step is taken
WorkingPrecision	MachinePrecision	the precision used in internal computations

Examples

open all close all

Basic Examples (4)

Find a point {x} at which the univariate function 2x^2+3x-5 has a minimum:

Wolfram Language code: FindArgMin[2x ^ 2 + 3x - 5, x]

Find a point {x,y} at which the function Sin[x]Sin[2y] has a minimum:

Wolfram Language code: FindArgMin[Sin[x]Sin[2y], {x, y}]

Find a point at which a function is a minimum subject to constraints:

Wolfram Language code: FindArgMin[{-x + 2y, x ^ 2 + y ^ 2 ≤ 1}, {x, y}]

Find a minimizer point in a geometric region:

Wolfram Language code: NArgMin[{x + y, {x, y}∈Disk[]}, {x, y}]

Plot it:

Wolfram Language code: Show[ContourPlot[x + y, {x, y}∈Disk[]], Graphics[{Red, PointSize[Large], Point[%]}]]

Scope (12)

With different starting points, get the locations of different local minima:

Wolfram Language code: FindArgMin[x Cos[x], {x, 5}]

Wolfram Language code: FindArgMin[x Cos[x], {x, 10}]

Location of a local minimum of a two-variable function starting from x=2, y=2:

Wolfram Language code: FindArgMin[Sin[x]Sin[2y], {{x, 2}, {y, 2}}]

Location of a local minimum constrained within a disk:

Wolfram Language code: FindArgMin[{Sin[x]Sin[2y], x ^ 2 + y ^ 2 < 3}, {{x, 2}, {y, 2}}]

Starting point does not have to be provided:

Wolfram Language code: FindArgMin[{Sin[x]Sin[2y], x ^ 2 + y ^ 2 < 3}, {x, y}]

For linear objective and constraints, integer constraints can be imposed:

Wolfram Language code: FindArgMin[{x + y, 3x + 2y ≥ 7 && x ≥ 0 && y ≥ 0}, {x, y}]

Wolfram Language code: FindArgMin[{x + y, 3x + 2y ≥ 7 && x ≥ 0 && y ≥ 0 && x∈Integers}, {x, y}]

Or constraints can be specified:

Wolfram Language code: FindArgMin[{-x - y, x ^ 2 + y ^ 2 ≤ 1 || (x + 2) ^ 2 + (y + 2) ^ 2 ≤ 1}, {x, y}]

Find a minimum in a region:

Wolfram Language code:

t = RotationTransform[{{0, 0, 1}, {1, 1, 1}}];
ℛ = TransformedRegion[Ellipsoid[{0, 0, 0}, {1, 2, 3}], t];

Wolfram Language code: FindArgMin[{z, {x, y, z}∈ℛ}, {x, y, z}]

Plot it:

Wolfram Language code:

Graphics3D[{{Opacity[0.5], Green, GeometricTransformation[Ellipsoid[{0, 0, 0}, {1, 2, 3}], t]}, {Red, PointSize[Large], Point[%]}}]

Find the minimum distance between two regions:

Wolfram Language code:

Subscript[ℛ, 1] = Disk[];
Subscript[ℛ, 2] = InfiniteLine[{{-2, 0}, {0, 2}}];

Wolfram Language code: FindArgMin[{(x - u)^2 + (y - v)^2, {{x, y}∈Subscript[ℛ, 1], {u, v}∈Subscript[ℛ, 2]}}, {x, y, u, v}]

Plot it:

Wolfram Language code: Graphics[{{LightBlue, Subscript[ℛ, 1]}, {Green, Subscript[ℛ, 2]}, {Red, Point[Partition[%, 2]]}}]

Find the minimum such that the triangle and ellipse still intersect:

Wolfram Language code:

Subscript[ℛ, 1] = Triangle[{{0, 0}, {1, 0}, {0, 1}}];
Subscript[ℛ, 2] = Disk[{1, 1}, {2r, r}];

Wolfram Language code: FindArgMin[{r, {x, y}∈Subscript[ℛ, 1] && {x, y}∈Subscript[ℛ, 2]}, {r, x, y}]

Plot it:

Wolfram Language code: Graphics[{{LightBlue, Subscript[ℛ, 1], Subscript[ℛ, 2]}, {Red, Point[{x, y}]}} /. Thread[{r, x, y} -> %]]

Find the disk of minimum radius that contains the given three points:

Wolfram Language code: Subscript[ℛ, 3] = Disk[{a, b}, r];

Wolfram Language code: FindArgMin[{r, ({0, 0} | {1, 0} | {0, 1})∈Subscript[ℛ, 3]}, {a, b, r}]

Plot it:

Wolfram Language code: Graphics[{{LightBlue, Subscript[ℛ, 3]} /. Thread[{a, b, r} -> %], {Red, Point[{{0, 0}, {1, 0}, {0, 1}}]}}]

Using Circumsphere gives the same result directly:

Wolfram Language code: Circumsphere[{{0, 0}, {1, 0}, {0, 1}}]//N

Use to specify that is a vector in :

Wolfram Language code: ℛ = Sphere[];

Wolfram Language code: FindArgMin[{x.{1, 2, 3}, x∈ℛ}, x]

Find the minimum distance between two regions:

Wolfram Language code:

Subscript[ℛ, 1] = Triangle[{{0, 0}, {1, 0}, {0, 1}}];
Subscript[ℛ, 2] = Disk[{2, 2}, 1];

Wolfram Language code: FindArgMin[{EuclideanDistance[x, y], {x∈Subscript[ℛ, 1], y∈Subscript[ℛ, 2]}}, {x, y}]

Plot it:

Wolfram Language code: Graphics[{{LightBlue, Subscript[ℛ, 1], Subscript[ℛ, 2]}, {Red, Point[%]}}]

Options (7)

AccuracyGoal & PrecisionGoal (2)

This enforces convergence criteria $TemplateBox[{{{x, _, k}, -, {x, ^, *}}}, Norm]<=max(10^(-9),10^(-8)TemplateBox[{{x, _, k}}, Norm])$ and $TemplateBox[{{del , {f, (, {x, _, k}, )}}}, Norm]<=10^(-9)$ :

Wolfram Language code: FindArgMin[Sin[x / 2], {x, 1}, AccuracyGoal -> 9, PrecisionGoal -> 8]

This enforces convergence criteria $TemplateBox[{{{x, _, k}, -, {x, ^, *}}}, Norm]<=max(10^(-20),10^(-18)TemplateBox[{{x, _, k}}, Norm])$ and $TemplateBox[{{del , {f, (, {x, _, k}, )}}}, Norm]<=10^(-20)$ :

Wolfram Language code: FindArgMin[Sin[x / 2], {x, 1}, AccuracyGoal -> 20, PrecisionGoal -> 18]

Setting a high WorkingPrecision makes the process convergent:

Wolfram Language code: FindArgMin[Sin[x / 2], {x, 1}, AccuracyGoal -> 20, PrecisionGoal -> 18, WorkingPrecision -> 40]

EvaluationMonitor (1)

Plot convergence to the local minimum:

Wolfram Language code: ListPlot[Last[Reap[FindArgMin[x Cos[x], {x, 5}, EvaluationMonitor :> Sow[x]]]]]

Gradient (1)

Use a given gradient; the Hessian is computed automatically:

Wolfram Language code: FindArgMin[Sin[x]Sin[2 y], {x, y}, Gradient -> {Cos[x] Sin[2 y], 2 Cos[2 y] Sin[x]}, Method -> "Newton"]

Supply both gradient and Hessian:

Wolfram Language code:

FindArgMin[Sin[x]Sin[2y], {x, y}, Gradient -> {Cos[x] Sin[2 y], 2 Cos[2 y] Sin[x]}, Method -> {"Newton", Hessian -> {{-Sin[x] Sin[2 y], 2 Cos[x] Cos[2 y]}, {2 Cos[x] Cos[2 y], -4 Sin[x] Sin[2 y]}}}]

Method (1)

In this case, the default derivative-based methods have difficulties:

Wolfram Language code: FindArgMin[RealAbs[x + 1] + RealAbs[x + 1.01] + RealAbs[y + 1], {x, y}]

Wolfram Language code: FindArgMin[RealAbs[x + 1] + RealAbs[x + 1.01] + RealAbs[y + 1], {x, y}, Method -> "ConjugateGradient"]

Direct search methods that do not require derivatives can be helpful in these cases:

Wolfram Language code: FindArgMin[RealAbs[x + 1] + RealAbs[x + 1.01] + RealAbs[y + 1], {x, y}, Method -> "PrincipalAxis"]

NMinimize also uses a range of direct search methods:

Wolfram Language code: NMinimize[{RealAbs[x + 1] + RealAbs[x + 1.01] + RealAbs[y + 1]}, {x, y}]

StepMonitor (1)

Steps taken by FindArgMin in finding the minimum of a function:

Wolfram Language code:

pts = Reap[FindArgMin[(1 - x) ^ 2 + 100(-x ^ 2 - y) ^ 2 + 1, {{x, -1.2}, {y, 1}}, StepMonitor :> Sow[{x, y}]]][[2, 1]];
pts  = Join[{{-1.2, 1}}, pts];

Wolfram Language code:

ContourPlot[(1 - x) ^ 2 + 100(-x ^ 2 - y) ^ 2 + 1//Log, {x, -1.3, 1.5}, {y, -1.5, 1.4}, Epilog -> {Red, Line[pts], Point[pts]}]

WorkingPrecision (1)

Set the working precision to ; by default AccuracyGoal and PrecisionGoal are set to :

Wolfram Language code: FindArgMin[Cos[x ^ 2 - 3 y] + Sin[x ^ 2 + y ^ 2], {x, y}, Method -> "Newton", WorkingPrecision -> 20]

Properties & Relations (1)

FindMinimum gives both the value of the minimum and the minimizer point:

Wolfram Language code: FindMinimum[{x - 2y, x ^ 2 + y ^ 2 ≤ 1}, {x, y}]

FindArgMin gives the location of the minimum:

Wolfram Language code: FindArgMin[{x - 2y, x ^ 2 + y ^ 2 ≤ 1}, {x, y}]

FindMinValue gives the value at the minimum:

Wolfram Language code: FindMinValue[{x - 2y, x ^ 2 + y ^ 2 ≤ 1}, {x, y}]

Possible Issues (4)

If the constraint region is empty, the algorithm will not converge:

Wolfram Language code: FindArgMin[{x + y, x ^ 2 + y ^ 2 ≥ 2 && x ^ 2 + y ^ 2 ≤ 1}, {x, y}]

If the minimum value is not finite, the algorithm will not converge:

Wolfram Language code: FindArgMin[Tan[x], {x, 2}]

Wolfram Language code: FindArgMin[{-x ^ 2 - y ^ 2, x ^ 2 + y ^ 2 > 10}, {x, y}]

Integer linear programming algorithm is only available for machine-number problems:

Wolfram Language code: FindArgMin[{x + y, x + 2y ≥ 3 && x > 1 && y > 1 && x∈Integers}, {x, y}, WorkingPrecision -> 20]

Sometimes providing a suitable starting point can help the algorithm to converge:

Wolfram Language code: FindArgMin[x * Sin[1 / x] ^ 2, {x}]

Wolfram Language code: FindArgMin[x * Sin[1 / x] ^ 2, {x, .3}]

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

FindArgMin

Details and Options

List of all options

Examples

Basic Examples (4)

Scope (12)

Options (7)

AccuracyGoal & PrecisionGoal (2)

EvaluationMonitor (1)

Gradient (1)

Method (1)

StepMonitor (1)

WorkingPrecision (1)

Properties & Relations (1)

Possible Issues (4)

Text

CMS

APA

BibTeX

BibLaTeX

	lhs==rhs	equations
	lhs>rhs or lhs>=rhs	inequalities
	{x,y,…}∈reg	region specification

FindArgMin

Details and Options

List of all options

Examples

Basic Examples (4)

Scope (12)

Options (7)

AccuracyGoal & PrecisionGoal (2)

EvaluationMonitor (1)

Gradient (1)

Method (1)

StepMonitor (1)

WorkingPrecision (1)

Properties & Relations (1)

Possible Issues (4)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX