How can I use assumptions with FindRoot?

Question

I have something like

FindRoot[f[x], {x, a}]

Now I want FindRoot to constrain the solutions to 0 < x < 1. How can I obtain this?

Answer 1

I would call these constraints, not assumptions.

From the docs,

FindRoot[lhs==rhs,{$x$, $x_{\text{start}}$, $x_{\text{min}}$, $x_{\text{max}}$}] searches for a solution, stopping the search if x ever gets outside the range $x_{\text{min}}$ to $x_{\text{max}}$

Keep in mind that FindRoot uses iterative numerical methods such as Newton's method or Brent's method which will converge to a single solution, but will not find all solutions. What this syntax does is simply stop the iteration as soon as $x$ gets outside of the specified range. If this happens, it does not mean that there are no solutions inside that range.

Here's a concrete example where there are several roots, but the search stops as soon as the method reached the edge of the search region:

In[2]:= FindRoot[Sin[x], {x, 1, .1, 10}]

During evaluation of In[2]:= FindRoot::reged: The point {0.1} is at the edge of the
   search region {0.1,10.} in coordinate 1 and the computed search direction points 
   outside the region. >>

Out[2]= {x -> 0.1}

---

If you need to find all roots inside an interval, I'd recommend using Reduce which will often work (if using Mathematica 7 or later). Note that while Reduce may not be able to find solution for the general case, it will very often work if you restrict the search domain to a real interval. Even for hard problems with transcendental functions.

Answer 2

Something like that works, more advanced answers should come from others.

f[x_] := Sin[x*10]

Sort@DeleteDuplicates[Select[FindRoot[f[x], {x, Range[0, 1, 0.1]}][[1,2]], (0 <= # < 1)&],
Abs[#2 - #1] < 10^-8 &]

Gives:

{0., 0.314159, 0.628319, 0.942478}

Answer 3

This is one of the simpler ways to do it:

Solve[f[x] == 0 && 0 < x && x < 1, x]

Specifying conditions within Solve or any other function you are using is more efficient than playing Select on the results. This way, Mathematica knows where to look for solutions and only finds those within your constraints.