# How to minimise a function with parameter?

I am trying to find a minimum of a function depending on a parameter, but I cannot get it to work. For example, I try to find the minima of $\sin(ax)$ where $a$ is a parameter. For example, trying the following doesn't return anything:

Minimize[Sin[a*x], x]


Trying something like

Assuming[a > 0, Minimize[Sin[a*x], x]]


Also doesn't work. What's wrong with my code?

Thanks!

• You may try using Reduce like this: Reduce[D[Sin[a x], x] == 0 && D[Sin[a x], {x, 2}] > 0, x]. And the output reads: C \[Element] Integers && a \[Element] Reals && a != 0 && x == -((\[Pi] - 4 \[Pi] C)/(2 a)). The idea is to solve for first and second derivatives to find min or max. – Alx Jan 16 '17 at 2:47
• 1. Please have a look at FindMinimum[]. 2. You may use D[] to find your solution applying the rules of calculus. – Matthias Bode Jan 17 '17 at 15:39

f[a_, x_] = Sin[a*x];


To find all minimums

Assuming[Element[a, Reals],
Solve[{D[f[a, x], x] == 0, D[f[a, x], {x, 2}] > 0}, x] // Simplify]

(* {{x -> ConditionalExpression[(Pi*(-1 + 4*C - 4*C))/(2*a),
(Element[C | C, Integers] || Element[C | C - C | C,
Integers]) && C >= 0 && C >= 0]}} *)


One example,

% /. {C -> 2, C -> 1}

{{x -> (3*Pi)/(2*a)}}


To find the minimum in a single specified cycle

Assuming[a > 0,
Solve[{D[f[a, x], x] == 0, D[f[a, x], {x, 2}] > 0, a > 0, 0 <= x < 2 Pi/a},
x] // Simplify]

{{x -> (3*Pi)/(2*a)}}


I don't think Mathematica can analytically minimize a function with infinite amount of minima. How would you reasonable express the result? Anyways, Minimize works well for sufficiently simple functions:

Simplify[Minimize[(a*x)^2 + x, x], Assumptions -> a > 0]
(* {-(1/(4 a^2)), {x -> -(1/(2 a^2))}} *)


Note that you can give constraints on x but not on a within the body of Minimize. Therefore, Simplify is needed to obtain the desired result.

For most more sophisticated functions, numerical methods like NMinimize or (my favorite because of much better computational speed) FindRoot on the derivative. In the end, minimization is not trivial and requires some code that is somewhat optimized for your particular problem.