Wolfram Language & System Documentation Center

ArgMax

ArgMax[f,x]

gives a position x_max at which f is maximized.

ArgMax[f,{x,y,…}]

gives a position {x_max,y_max,…} at which f is maximized.

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

gives a position at which f is maximized subject to the constraints cons.

ArgMax[…,x∈rdom]

constrains x to be in the region or domain rdom.

ArgMax[…,…,dom]

constrains variables to the domain dom, typically Reals or Integers.

ArgMax

ArgMax[f,x]

gives a position x_max at which f is maximized.

ArgMax[f,{x,y,…}]

gives a position {x_max,y_max,…} at which f is maximized.

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

gives a position at which f is maximized subject to the constraints cons.

ArgMax[…,x∈rdom]

constrains x to be in the region or domain rdom.

ArgMax[…,…,dom]

constrains variables to the domain dom, typically Reals or Integers.

Details and Options

ArgMax finds the global maximum of f subject to the constraints given.
ArgMax is typically used to find the largest possible values given constraints. In different areas, this may be called the best strategy, best fit, best configuration and so on.

If f and cons are linear or polynomial, ArgMax will always find a global maximum.
The constraints cons can be any logical combination of:

	lhs==rhs	equations
	lhs>rhs, lhs≥rhs, lhs<rhs, lhs≤rhs	inequalities (LessEqual,…)
	lhsrhs, lhsrhs, lhsrhs, lhsrhs	vector inequalities (VectorLessEqual,…)
	Exists[…], ForAll[…]	quantified conditions
	{x,y,…}∈rdom	region or domain specification

ArgMax[{f,cons},x∈rdom] is effectively equivalent to ArgMax[{f,cons∧x∈rdom},x].
For x∈rdom, the different coordinates can be referred to using Indexed[x,i].
Possible domains rdom include:

	Reals	real scalar variable
	Integers	integer scalar variable
	Vectors[n,dom]	vector variable in
	Matrices[{m,n},dom]	matrix variable in
	ℛ	vector variable restricted to the geometric region

By default, all variables are assumed to be real.
ArgMax will return exact results if given exact input. With approximate input, it automatically calls NArgMax.
If the maximum is achieved only infinitesimally outside the region defined by the constraints, or only asymptotically, ArgMax will return the closest specifiable point.
Even if the same maximum is achieved at several points, only one is returned.
If the constraints cannot be satisfied, ArgMax returns {Indeterminate,Indeterminate,…}.
N[ArgMax[…]] calls NArgMax for optimization problems that cannot be solved symbolically.

Examples

open all close all

Basic Examples (5)

Find a maximizer point for a univariate function:

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

Find a maximizer point for a multivariate function:

Wolfram Language code: ArgMax[1 - (x y - 3) ^ 2, {x, y}]

Find a maximizer point for a function subject to constraints:

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

Find a maximizer point as a function of parameters:

Wolfram Language code: ArgMax[a x ^ 2 + b x + c, x]

Find a maximizer point for a function over a geometric region:

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

Plot it:

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

Scope (36)

Basic Uses (7)

Maximize over the unconstrained reals:

Wolfram Language code: ArgMax[Sin[x] + Cos[x], {x}]

If the single variable is not given in a list, the result is a value at which the maximum is attained:

Wolfram Language code: ArgMax[Sin[x] + Cos[x], x]

Maximize subject to constraints :

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

Constraints may involve arbitrary logical combinations:

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

An unbounded problem:

Wolfram Language code: ArgMax[{x + y, x ≤ y ^ 2}, {x, y}]

An infeasible problem:

Wolfram Language code: ArgMax[{x + y, x ^ 2 + y ^ 2 < 0}, {x, y}]

The supremum value may not be attained:

Wolfram Language code: ArgMax[-Exp[x], x]

Use a vector variable and a vector inequality:

Wolfram Language code: ArgMax[{{-1, -1}.v, {{1, 2}, {1, 0}}.v{3, -1}}, v]

Univariate Problems (7)

Unconstrained univariate polynomial maximization:

Wolfram Language code: ArgMax[-x ^ 4 + 2x ^ 3 + 5x - 7, x]

Constrained univariate polynomial maximization:

Wolfram Language code: ArgMax[{-3x ^ 2 - x + 9, 2x ^ 3 + 5x - 7 ≥ 0}, x]

Exp-log functions:

Wolfram Language code: ArgMax[-E ^ (2E ^ x) + Log[x ^ 2 + 1] + 20x, x]

Analytic functions over bounded constraints:

Wolfram Language code: ArgMax[{AiryAi[x + Sin[x]] + Cos[x ^ 2], -5 ≤ x ≤ 5}, x]

Wolfram Language code:

Plot[AiryAi[x + Sin[x]] + Cos[x ^ 2], {x, -5, 5}, Epilog -> {Red, Point[{%, AiryAi[x + Sin[x]] + Cos[x ^ 2] /. x -> %}]}]

Wolfram Language code: ArgMax[{BesselJ[2, x] / Gamma[x + 1] + (x + 1) ^ Sin[x], 0 ≤ x ≤ 10}, x]

Wolfram Language code:

Plot[BesselJ[2, x] / Gamma[x + 1] + (x + 1) ^ Sin[x], {x, 0, 10}, Epilog -> {Red, Point[{%, BesselJ[2, x] / Gamma[x + 1] + (x + 1) ^ Sin[x] /. x -> %}]}]

Periodic functions:

Wolfram Language code: ArgMax[{Sin[x], -1 / 2 ≤ Cos[x] ≤ 1 / 2}, x]

Combination of trigonometric functions with commensurable periods:

Wolfram Language code: ArgMax[Sin[E ^ (x / 3) - 3 x] + 2 Cos[2 E ^ (x / 3) - 6 x + 1] ^ 2, x]

Piecewise functions:

Wolfram Language code: ArgMax[{Floor[x + UnitStep[x - 1]] - x, Ceiling[Abs[x]] < 5}, x]

Unconstrained problems solvable using function property information:

Wolfram Language code: ArgMax[SinhIntegral[DawsonF[x]], x]

Wolfram Language code: ArgMax[BesselJ[7 / 4, x ^ 2 + x + 1], x]

Multivariate Problems (9)

Multivariate linear constrained maximization:

Wolfram Language code: ArgMax[{2x + 3y - z, 1 ≤ x + y + z ≤ 2 && 1 ≤ x - y + z ≤ 2 && x - y - z == 3}, {x, y, z}]

Linear-fractional constrained maximization:

Wolfram Language code: ArgMax[{(2x + y - z) / (5x - 7y + 3), 0 ≤ x + y + z ≤ 1 && 1 ≤ x - y + z ≤ 2 && x - y - z == 3}, {x, y, z}]

Unconstrained polynomial maximization:

Wolfram Language code: ArgMax[x ^ 2 - 2y - 1 - (x ^ 2 - 2y) ^ 2, {x, y}]

Constrained polynomial optimization can always be solved:

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

The maximum value may not be attained:

Wolfram Language code: ArgMax[{1 - x ^ 2, x y ≥ 1}, {x, y}]

The objective function may be unbounded:

Wolfram Language code: ArgMax[{x, x y ≤ 1}, {x, y}]

There may be no points satisfying the constraints:

Wolfram Language code: ArgMax[{x, x ^ 2 + y ^ 2 < 0}, {x, y}]

Quantified polynomial constraints:

Wolfram Language code:

ArgMax[{-(x + 7)^2 - (y - 8)^2, Subscript[∀, z]Subscript[∃, w]3 z^2 w + (x + y) z^4 - 1 == (x^3 - x y + y^2 - 1) w^2}, {x, y}]

Algebraic maximization:

Wolfram Language code: ArgMax[{-x - Sqrt[x + y] , x Sqrt[y] ≥ 1}, {x, y}]

Bounded transcendental maximization:

Wolfram Language code: ArgMax[{E ^ x + Log[y], x Log[y] == 2 && -10 ≤ x ≤ 10 && 1 / 10 ≤ y ≤ 10}, {x, y}]

Piecewise maximization:

Wolfram Language code: ArgMax[{-Max[x - y, Abs[y]], Min[x - 2, x - y ^ 2] ≥ Abs[x y - 1]}, {x, y}]

Convex maximization:

Wolfram Language code: ArgMax[v.{1, -1}, {VectorGreaterEqual[{{{1, 0}, {0, 1}, {-1, -2}}.v, {0, 0, -2}}, "ExponentialCone"]}, v]

Maximize concave objective function such that is positive semidefinite and :

Wolfram Language code:

res = ArgMax[{Log[x + y], (⁠|       |       |
| ----- | ----- |
| x + y | 1     |
| 1     | x - y |⁠)Underscript[, {"SemidefiniteCone", 2}]0 && 1 ≤ x ≤ 10 && -1 ≤ y ≤ 1}, {x, y}]

Plot the region and the minimizing point:

Wolfram Language code:

Show[Plot3D[Log[x + y], {x, 1, 10}, {y, -1, 1}, ...], Graphics3D[{Red, PointSize[0.05], Point[Append[res, Log[x + y] /. Thread[{x, y} -> res]]]}]]

Parametric Problems (4)

Parametric linear optimization:

Wolfram Language code:

ArgMax[{8x + 7y, -6 x - 4 y ≤ 8 - 5 a - 7 b && 7 x + 5 y ≤ a + 4 b && -x + y ≤ 6 + 4a - 5 b && -4 x + 7 y ≤ -1 - 2 a - 7 b && 5 y ≤ 6 - 9 b}, {x, y}]

Coordinates of the minimizer point are continuous functions of parameters:

Wolfram Language code: GraphicsRow[Plot3D[#, {a, -3, 3}, {b, 0, 3}, Axes -> False]& /@ %, ImageSize -> Medium]

Parametric quadratic optimization:

Wolfram Language code: ArgMax[{-(x - 1) ^ 2 - (2y - 1) ^ 2, x + 2y ≤ a + b && 2x - y ≤ a - b + 1 && x - 2y ≤ 2a - b + 1}, {x, y}]

Coordinates of the minimizer point are continuous functions of parameters:

Wolfram Language code: GraphicsRow[Plot3D[#, {a, -3, 3}, {b, 0, 3}, Axes -> False]& /@ %, ImageSize -> Medium]

Unconstrained parametric polynomial maximization:

Wolfram Language code: ArgMax[-x ^ 4 + a x ^ 2 + b, x]

Constrained parametric polynomial maximization:

Wolfram Language code: ArgMax[{-x ^ 2 - y ^ 2, x ^ 3 + y ^ 2 == a}, {x, y}]

Optimization over Integers (3)

Univariate problems:

Wolfram Language code: ArgMax[{x ^ 3 Log[x] - E ^ x, x > 0}, x, Integers]

Integer linear programming:

Wolfram Language code: ArgMax[{2x + 3y - z, 1 ≤ x + y + z ≤ 2 && 1 ≤ x - y + z ≤ 2 && x - y - z == 3}, {x, y, z}, Integers]

Polynomial maximization over the integers:

Wolfram Language code: ArgMax[{-x ^ 2 - x y + 1, x y ≥ 1}, {x, y}, Integers]

Optimization over Regions (6)

Maximize over a region:

Wolfram Language code: ℛ = Cylinder[{{1, 2, 3}, {3, 2, 1}}, 1];

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

Plot it:

Wolfram Language code: Graphics3D[{{Opacity[0.5], Green, ℛ}, {Red, PointSize[Large], Point[%]}}]

Find points in two regions realizing the maximum distance:

Wolfram Language code:

Subscript[ℛ, 1] = Disk[];
Subscript[ℛ, 2] = Line[{{-(1/2), -(1/2)}, {-(1/2), (1/2)}, {(1/2), (1/2)}, {(1/2), -(1/2)}, {-(1/2), -(1/2)}}];

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

Plot it:

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

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

Wolfram Language code:

Subscript[ℛ, 1] = Triangle[{{0, 0}, {1, 0}, {0, 1}}];
Subscript[ℛ, 2] = Circle[{(1/3), (1/3)}, {2 r, r}];

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

Plot it:

Wolfram Language code:

Graphics[{{StandardBlue, Subscript[ℛ, 1]}, {Green, Subscript[ℛ, 2]}, {Red, Point[{x, y}]}} /. Thread[{r, x, y} -> %]]

Find the maximum for which contains the given three points:

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

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

Plot it:

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

Use to specify that is a vector in :

Wolfram Language code: ℛ = Sphere[];

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

Find points in two regions realizing the maximum distance:

Wolfram Language code:

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

Wolfram Language code: ArgMax[(x - y).(x - y), {x∈Subscript[ℛ, 1], y∈Subscript[ℛ, 2]}]//RootReduce

Plot it:

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

Options (2)

Method (1)

Specify that ArgMax should use cylindrical algebraic decomposition:

Wolfram Language code: maxcad = ArgMax[{x ^ 2 - y ^ 3 + 2x y, x ^ 2 + y ^ 2 == 1}, {x, y}, Method -> "CAD"]

Use Lagrange multipliers:

Wolfram Language code: maxlm = ArgMax[{x ^ 2 - y ^ 3 + 2x y, x ^ 2 + y ^ 2 == 1}, {x, y}, Method -> "LagrangeMultipliers"]

Use the default method:

Wolfram Language code: maxdef = ArgMax[{x ^ 2 - y ^ 3 + 2x y, x ^ 2 + y ^ 2 == 1}, {x, y}]

All results are equivalent:

Wolfram Language code: RootReduce[maxcad] === RootReduce[maxlm] === RootReduce[maxdef]

WorkingPrecision (1)

Finding an exact maximum point can take a long time:

Wolfram Language code: TimeConstrained[ArgMax[{x ^ 2 + y ^ 2 + z ^ 2, x ^ 2 - 3 x y z + 9 z ^ 2 + y ^ 2 == E && x y z ≤ Pi}, {x, y, z}], 60]

With WorkingPrecision->200, you get an approximate maximum point:

Wolfram Language code:

ArgMax[{x ^ 2 + y ^ 2 + z ^ 2, x ^ 2 - 3 x y z + 9 z ^ 2 + y ^ 2 == E && x y z ≤ Pi}, {x, y, z}, WorkingPrecision -> 200]//Timing

Applications (15)

Basic Applications (3)

Find the lengths of sides of a unit perimeter rectangle with the maximal area:

Wolfram Language code: ArgMax[{x y, 2x + 2y == 1 && x > 0 && y > 0}, {x, y}]

Find the lengths of sides of a unit perimeter triangle with the maximal area:

Wolfram Language code:

triangle = a > 0 && b > 0 && c > 0 && a + b > c && a + c > b && b + c > a;
s = 1 / 2(a + b + c);

Wolfram Language code: ArgMax[{Sqrt[s(s - a)(s - b)(s - c)], triangle && a + b + c == 1}, {a, b, c}]

Find the time at which a projectile reaches the maximum height:

Wolfram Language code: ArgMax[ {v Sin[α] t - 5 t ^ 2, t ≥ 0 && 0 < Sin[α] ≤ 1 && v > 0}, t]

Wolfram Language code: Refine[%, 0 < Sin[α] ≤ 1 && v > 0]

Geometric Distances (9)

The point q in a region ℛ that is farthest from a given point p is given by ArgMax[{Norm[p-q],q∈ℛ},q]. Find the farthest point in Disk[] from {1,1}:

Wolfram Language code:

p = {1, 1};
ℛ = Disk[];

Wolfram Language code: q = Simplify@ArgMax[Norm[p - {q1, q2}], {q1, q2}∈ℛ]

Plot it:

Wolfram Language code: Graphics[{{StandardBlue, EdgeForm[Gray], ℛ}, {Red, Point[{p, q}]}, {Dashed, Line[{p, q}]}}]

Find the farthest point from {1,2} in the standard unit simplex Simplex[2]:

Wolfram Language code:

p = {1, 2};
ℛ = Simplex[{{0, 0}, {1, 0}, {0, 1}}];

Wolfram Language code: q = Simplify@ArgMax[Norm[p - {q1, q2}], {q1, q2}∈ℛ]

Plot it:

Wolfram Language code: Graphics[{{StandardBlue, EdgeForm[Gray], ℛ}, {Red, Point[{p, q}]}, {Dashed, Line[{p, q}]}}]

Find the farthest point from {1,1,1} in the standard unit sphere Sphere[]:

Wolfram Language code:

p = {1, 1, 1};
ℛ = Sphere[];

Wolfram Language code: q = Simplify@ArgMax[Norm[p - {q1, q2, q3}], {q1, q2, q3}∈ℛ]

Plot it:

Wolfram Language code: Graphics3D[{{Opacity[0.5], ℛ}, {Red, Point[{p, q}]}, {Dashed, Line[{p, q}]}}]

Find the farthest point from {-1,1,1} in the standard unit simplex Simplex[3]:

Wolfram Language code:

p = {-1, 1, 1};
ℛ = Simplex[{{0, 0, 0}, {1, 0, 0}, {0, 1, 0}, {0, 0, 1}}];

Wolfram Language code: q = Simplify@ArgMax[Norm[p - {q1, q2, q3}], {q1, q2, q3}∈ℛ]

Plot it:

Wolfram Language code: Graphics3D[{{Opacity[0.5], ℛ}, {Red, Point[{p, q}]}, {Dashed, Line[{p, q}]}}]

The diameter of a region ℛ is given by the distance between the farthest points in ℛ, which can be computed through ArgMax[Norm[p-q],{q∈ℛ,p∈ℛ}]. Find the diameter of Circle[]:

Wolfram Language code: ℛ = Circle[];

Wolfram Language code: {pt, qt} = ArgMax[Norm[p - q], {q∈ℛ, p∈ℛ}]

The diameter:

Wolfram Language code: Norm[pt - qt]//Simplify

Plot it:

Wolfram Language code: Graphics[{{ℛ}, {Red, Point[{pt, qt}]}, {Dashed, Line[{pt, qt}]}}]

Find the diameter of the standard unit simplex Simplex[2]:

Wolfram Language code: ℛ = Simplex[{{0, 0}, {1, 0}, {0, 1}}];

Wolfram Language code: {pt, qt} = ArgMax[Norm[p - q], {q∈ℛ, p∈ℛ}]

The diameter:

Wolfram Language code: Norm[pt - qt]

Plot it:

Wolfram Language code: Graphics[{{StandardBlue, EdgeForm[Gray], ℛ}, {Red, Point[{pt, qt}]}, {Dashed, Line[{pt, qt}]}}]

Find the diameter of the standard unit cube Cuboid[]:

Wolfram Language code: ℛ = Cuboid[];

Wolfram Language code: {pt, qt} = ArgMax[Norm[p - q], {q∈ℛ, p∈ℛ}]

The diameter:

Wolfram Language code: Norm[pt - qt]//Simplify

Plot it:

Wolfram Language code: Graphics3D[{{Opacity[0.5], ℛ}, {Red, Point[{pt, qt}]}, {Dashed, Line[{pt, qt}]}}]

The farthest points p∈ and q∈ can be found through ArgMax[Norm[p-q],{p∈,q∈}]. Find the farthest points in Disk[{0,0}] and Rectangle[{3,3}]:

Wolfram Language code: 𝒫 = Disk[{0, 0}]; 𝒬 = Rectangle[{3, 3}];

Wolfram Language code: {pt, qt} = Simplify@ArgMax[Norm[p - q], {p∈𝒫, q∈𝒬}]

The farthest distance:

Wolfram Language code: Norm[pt - qt]//Simplify

Plot it:

Wolfram Language code: Graphics[{{StandardBlue, EdgeForm[Gray], 𝒫, 𝒬}, {Red, Point[{pt, qt}]}, {Dashed, Line[{pt, qt}]}}]

Find the farthest points in Line[{{0,0,0},{1,1,1}}] and Ball[{5,5,0},1]:

Wolfram Language code: 𝒫 = Line[{{0, 0, 0}, {1, 1, 1}}]; 𝒬 = Ball[{5, 5, 0}, 1];

Wolfram Language code: {pt, qt} = Simplify@ArgMax[Norm[p - q], {p∈𝒫, q∈𝒬}]

The farthest distance:

Wolfram Language code: Norm[pt - qt]//Simplify

Plot it:

Wolfram Language code: Graphics3D[{{𝒫, {Opacity[0.5], 𝒬}}, {Red, Point[{pt, qt}]}, {Dashed, Line[{pt, qt}]}}]

Geometric Centers (3)

If ℛ⊆ⁿ is a region that is full dimensional, then the Chebyshev center is the point p∈ℛ that maximizes -SignedRegionDistance[ℛ,p], i.e. the distance to the complement region. Find the Chebyshev center for Disk[]:

Wolfram Language code: ℛ = Disk[];

Wolfram Language code: p = ArgMax[-SignedRegionDistance[ℛ, {p1, p2}], {p1, p2}∈ℛ]

Wolfram Language code: Graphics[{{StandardBlue, EdgeForm[Gray], ℛ}, {Red, Point[p]}}]

Find the Chebyshev center for Rectangle[]:

Wolfram Language code: ℛ = Rectangle[];

Wolfram Language code: p = ArgMax[-SignedRegionDistance[ℛ, {p1, p2}], {p1, p2}∈ℛ]

Wolfram Language code: Graphics[{{StandardBlue, EdgeForm[Gray], ℛ}, {Red, Point[p]}}]

The analytic center of a region defined by inequalities ℛ=ImplicitRegion[f₁[x]≥0∧⋯∧f_m[x]≥0,x] is given by ArgMax[{Log[f₁[x]⋯ f_m[x]],x∈ℛ},x]. Find the analytic center for Triangle[{{0,0},{1,0},{0,1}}]:

Wolfram Language code: RegionMember[Triangle[{{0, 0}, {1, 0}, {0, 1}}], {x, y}]

From the conditions above you have an inequality representation:

Wolfram Language code: {f1, f2, f3} = {x, y, 1 - x - y};

The analytic center:

Wolfram Language code: c = ArgMax[Log[f1 f2 f3], {x, y}∈Triangle[{{0, 0}, {1, 0}, {0, 1}}]]

Plot it:

Wolfram Language code: Graphics[{{StandardBlue, EdgeForm[Gray], Triangle[{{0, 0}, {1, 0}, {0, 1}}]}, {Red, Point[c]}}]

Find the analytic center for Cylinder[]:

Wolfram Language code: RegionMember[Cylinder[], {x, y, z}]

Hence you get the inequality representation:

Wolfram Language code: {f1, f2, f3} = {(1 + z) / 2, 1 - (1 + z) / 2, 1 - (x^2 + y^2)};

And the analytic center:

Wolfram Language code: c = ArgMax[Log[f1 f2 f3], {x, y, z}∈Cylinder[]]

Plot it:

Wolfram Language code: Graphics3D[{{Opacity[0.3], Cylinder[]}, {Red, Point[c]}}]

Properties & Relations (4)

Maximize gives both the value of the maximum and the maximizer point:

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

ArgMax gives an exact global maximizer point:

Wolfram Language code: f = Expand[-Product[(x - i)(x - 100 - i), {i, 5}]];

Wolfram Language code: ArgMax[f, x]

Wolfram Language code: Plot[f, {x, 0, 100}, Epilog -> {PointSize[Medium], Green, Point[{%, f /. x -> %}]}]

NArgMax attempts to find a global maximizer numerically, but may find a local maximizer:

Wolfram Language code: NArgMax[f, x]

Wolfram Language code: Plot[f, {x, 0.5, 5.5}, Epilog -> {PointSize[Medium], Red, Point[{%, f /. x -> %}]}]

FindArgMax finds a local maximizer point depending on the starting point:

Wolfram Language code: FindArgMax[f, {x, #}]& /@ {1, 50}

Wolfram Language code:

Plot[f, {x, 0, 100}, Epilog -> {PointSize[Medium], {Red, Point[{%[[1, 1]], f /. x -> %[[1, 1]]}]}, {Green, Point[{%[[2, 1]], f /. x -> %[[2, 1]]}]}}]

The maximum point satisfies the constraints, unless messages say otherwise:

Wolfram Language code: m = ArgMin[{(x - 2) ^ 2 + (y - 3 / 2) ^ 2, x ^ 2 + y ^ 2 ≤ 1}, {x, y}]

Wolfram Language code: x ^ 2 + y ^ 2 ≤ 1 /. Thread[{x, y} -> m]

The given point maximizes the distance from the point {2,}:

Wolfram Language code:

RegionPlot[x ^ 2 + y ^ 2 ≤ 1, {x, -1.2, 2.2}, {y, -1.2, 2.2}, Epilog -> {PointSize[Medium], {Red, Point[m]}, {Green, Point[{2, 3 / 2}]}}]

When the maximum is not attained, ArgMax may give a point on the boundary:

Wolfram Language code: ArgMax[{(x - 2) ^ 2 + (y - 3 / 2) ^ 2, x ^ 2 + y ^ 2 < 1}, {x, y}]

Here the objective function tends to the maximum value when y tends to infinity:

Wolfram Language code: ArgMax[{1 - x, x y == 1 && x > 0}, {x, y}]

ArgMax can solve linear optimization problems:

Wolfram Language code: res = ArgMax[{2x + 3y - z, 1 ≤ x + y + z ≤ 2 && 1 ≤ x - y + z ≤ 2 && x - y - z == 3}, {x, y, z}]

LinearOptimization can be used to solve the same problem by negating the objective:

Wolfram Language code:

LinearOptimization[-(2x + 3y - z), {1 ≤ x + y + z ≤ 2 && 1 ≤ x - y + z ≤ 2
	 && x - y - z == 3}, {x, y, z}]

Possible Issues (2)

The maximum value may not be attained:

Wolfram Language code: ArgMax[{1 - x ^ 2, x y ≥ 1}, {x, y}]

The objective function may be unbounded:

Wolfram Language code: ArgMax[{x, x y ≤ 1}, {x, y}]

There may be no points satisfying the constraints:

Wolfram Language code: ArgMax[{x, x ^ 2 + y ^ 2 < 0}, {x, y}]

ArgMax requires that all functions present in the input be real valued:

Wolfram Language code: ArgMax[{-x - y, Sqrt[x] - Sqrt[y] == 0}, {x, y}]

Values for which the equation is satisfied but the square roots are not real are disallowed:

Wolfram Language code: {Sqrt[x] - Sqrt[y] == 0, Sqrt[x], Sqrt[y]} /. {x -> -1, y -> -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

ArgMax

Details and Options

Examples

Basic Examples (5)

Scope (36)

Basic Uses (7)

Univariate Problems (7)

Multivariate Problems (9)

Parametric Problems (4)

Optimization over Integers (3)

Optimization over Regions (6)

Options (2)

Method (1)

WorkingPrecision (1)

Applications (15)

Basic Applications (3)

Geometric Distances (9)

Geometric Centers (3)

Properties & Relations (4)

Possible Issues (2)

Text

CMS

APA

BibTeX

BibLaTeX

ArgMax

Details and Options

Examples

Basic Examples (5)

Scope (36)

Basic Uses (7)

Univariate Problems (7)

Multivariate Problems (9)

Parametric Problems (4)

Optimization over Integers (3)

Optimization over Regions (6)

Options (2)

Method (1)

WorkingPrecision (1)

Applications (15)

Basic Applications (3)

Geometric Distances (9)

Geometric Centers (3)

Properties & Relations (4)

Possible Issues (2)

See Also

Tech Notes

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX