The Newton-Raphson method is notoriously problematic for this task, as it can explode when approaching a root. A bisection search is by far the most robust and efficient technique for solving this problem. If it's taking too long, then your implementation is the problem. Are you using some glacial script? Python is slower than a herd of snails stampeding up the side of a salt dome in a hailstorm. I have posted on my website a C code that will find roots for 4096-point Gauss Quadrature in mere seconds. Intel processors can execute a billion instructions per second. It's not the processor or the method so focus on the implementation. If you don't have to compile and then link it (e.g., C or FORTRAN), then don't waste your time with it.

The book "Numerical Recipies" contains an algorithm the authors call RFSAFE (I believe) that combines the speed of Newton Raphson with the safety of binary search. As long as you isolate the zero your looking for between two numbers (i.e. bounds) just as required by binary search, you will compute that zero using RFSAFE. Note that there needs to be just one zero that lies between the bounds.

However, in agreement with Mr. Benton's answer, you should check your implementation of binary search first. I recommend trying RFSAFE only if your implementation of binary search is correct and it's still too slow due to the number of instances of its use.

Sure sir I will try it and confirm

I checked and its actually called RTSAFE. Some people don't trust the Numerical Recipes (NR) algorithms (in general), but I've tried the specific algorithm RTSAFE in the past and it works perfectly well. I have no comment to make considering other NR algorithms. Since you can get RTSAFE for free at s3.amazonaws.com/nrbook.com/book_F210.html i've attached a copy (a FORTRAN implementation).