Related Articles
Find the root of given non decreasing function between A and B
• Last Updated : 15 Sep, 2020

Given three numbers a, b, and c that forms a monotonically increasing function of the form a*x2 + b*x + c and two number A and B, the task is to find the root of the function i.e., find the value of x such that where A ≤ x ≤ B.

Examples:

Input: a = 2, b = -3, c = -2, A = 0, B = 3
Output: 2.0000
Explanation:
f(x) = 2x^2 – 3x – 2 putting the value of x = 2.000
We get f(2.000) = 2(2.000)^2 – 3(2.000) – 2 = 0

Input: a = 2, b = -3, c = -2, A = -2, B = 1
Output: No solution

Approach: Below is the graphical representation of any function : From the above graph, we have,

1. Whenever f(A)*f(B) ≤ 0, it means that the graph of the function will cut the x-axis somewhere within that range and signifies that somewhere there is a point which makes the value of the function as 0 and then the graph proceeds to be negative y-axis.
2. If f(A)*f(B) > 0, it means that in this range [A, B] the y values of f(A) and f(B) both remain positive throughout, so they never cut x-axis.

Therefore, from the above observation, the idea is to use Binary Search to solve this problem. Using the given range of [A, B] as lower and upper bound for the root of the equation, x can be found out by applying binary search on this range. Below are the steps:

1. Find the middle(say mid) of the range [A, B].
2. If f(mid)*f(A) ≤ 0 is true then search space is reduced to [A, mid], because the cut at x-axis has been occurred in this segment.
3. Else search space is reduced to [mid, B]
4. The minimum possible value for root is when the high value becomes just smaller than EPS(smallest value ~10-6) + lower bound value i.e., fabs(high – low) > EPS.
5. Print the value of the root.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach ``#include  ``using` `namespace` `std; ``#define eps 1e-6 `` ` `// Given function ``double` `func(``double` `a, ``double` `b, ``            ``double` `c, ``double` `x) ``{ ``    ``return` `a * x * x + b * x + c; ``} `` ` `// Function to find the root of the ``// given non-decreasing Function ``double` `findRoot(``double` `a, ``double` `b, ``                ``double` `c, ``double` `low, ``                ``double` `high) ``{ ``    ``double` `x; `` ` `    ``// To get the minimum possible ``    ``// answer for the root ``    ``while` `(``fabs``(high - low) > eps) { `` ` `        ``// Find mid ``        ``x = (low + high) / 2; `` ` `        ``// Search in [low, x] ``        ``if` `(func(a, b, c, low) ``                ``* func(a, b, c, x) ``            ``<= 0) { ``            ``high = x; ``        ``} `` ` `        ``// Search in [x, high] ``        ``else` `{ ``            ``low = x; ``        ``} ``    ``} `` ` `    ``// Return the required answer ``    ``return` `x; ``} `` ` `// Function to find the roots of the ``// given equation within range [a, b] ``void` `solve(``double` `a, ``double` `b, ``double` `c, ``        ``double` `A, ``double` `B) ``{ `` ` `    ``// If root doesn't exists ``    ``if` `(func(a, b, c, A) ``            ``* func(a, b, c, B) ``        ``> 0) { ``        ``cout << ``"No solution"``; ``    ``} `` ` `    ``// Else find the root upto 4 ``    ``// decimal places ``    ``else` `{ ``        ``cout << fixed ``            ``<< setprecision(4) ``            ``<< findRoot(a, b, c, ``                        ``A, B); ``    ``} ``} `` ` `// Driver Code ``int` `main() ``{ ``    ``// Given range ``    ``double` `a = 2, b = -3, c = -2, ``        ``A = 0, B = 3; `` ` `    ``// Function Call ``    ``solve(a, b, c, A, B); ``    ``return` `0; ``} `

## Java

 `// Java program for the above approach``import` `java.util.*;``import` `java.lang.*;`` ` `class` `GFG{``     ` `static` `final` `double` `eps = 1e-``6``;`` ` `// Given function``static` `double` `func(``double` `a, ``double` `b,``                   ``double` `c, ``double` `x)``{``    ``return` `a * x * x + b * x + c;``}`` ` `// Function to find the root of the``// given non-decreasing Function``static` `double` `findRoot(``double` `a, ``double` `b,``                       ``double` `c, ``double` `low,``                       ``double` `high)``{``    ``double` `x = -``1``;``     ` `    ``// To get the minimum possible``    ``// answer for the root``    ``while` `(Math.abs(high - low) > eps)``    ``{``         ` `        ``// Find mid``        ``x = (low + high) / ``2``;``         ` `        ``// Search in [low, x]``        ``if` `(func(a, b, c, low) * ``            ``func(a, b, c, x) <= ``0``)``        ``{``            ``high = x;``        ``}``         ` `        ``// Search in [x, high]``        ``else``        ``{``            ``low = x;``        ``}``    ``}``     ` `    ``// Return the required answer``    ``return` `x;``}`` ` `// Function to find the roots of the``// given equation within range [a, b]``static` `void` `solve(``double` `a, ``double` `b, ``double` `c,``                  ``double` `A, ``double` `B)``{``     ` `    ``// If root doesn't exists``    ``if` `(func(a, b, c, A) * func(a, b, c, B) > ``0``)``    ``{``        ``System.out.println(``"No solution"``);``    ``}``     ` `    ``// Else find the root upto 4``    ``// decimal places``    ``else` `    ``{``        ``System.out.format(``"%.4f"``, findRoot(``            ``a, b, c, A, B));``    ``}``}`` ` `// Driver Code``public` `static` `void` `main (String[] args)``{``     ` `    ``// Given range``    ``double` `a = ``2``, b = -``3``, c = -``2``,``           ``A = ``0``, B = ``3``;``            ` `    ``// Function call``    ``solve(a, b, c, A, B);``}``}`` ` `// This code is contributed by offbeat`

## Python3

 `# Python3 program for the above approach``import` `math ``eps ``=` `1e``-``6`` ` `# Given function``def` `func(a ,b , c , x):`` ` `    ``return` `a ``*` `x ``*` `x ``+` `b ``*` `x ``+` `c`` ` `# Function to find the root of the``# given non-decreasing Function``def` `findRoot( a, b, c, low, high):`` ` `    ``x ``=` `-``1``     ` `    ``# To get the minimum possible``    ``# answer for the root``    ``while` `abs``(high ``-` `low) > eps:``     ` `        ``# Find mid``        ``x ``=` `(low ``+` `high) ``/` `2``         ` `        ``# Search in [low, x]``        ``if` `(func(a, b, c, low) ``*` `            ``func(a, b, c, x) <``=` `0``):``            ``high ``=` `x``     ` `        ``# Search in [x, high]``        ``else``:``            ``low ``=` `x``             ` `    ``# Return the required answer``    ``return` `x`` ` `# Function to find the roots of the``# given equation within range [a, b]``def` `solve(a, b, c, A, B):`` ` `    ``# If root doesn't exists``    ``if` `(func(a, b, c, A) ``*` `        ``func(a, b, c, B) > ``0``):``        ``print``(``"No solution"``)``     ` `    ``# Else find the root upto 4``    ``# decimal places``    ``else``:``        ``print``(``"{:.4f}"``.``format``(findRoot(``              ``a, b, c, A, B)))``     ` `# Driver code``if` `__name__ ``=``=` `'__main__'``: `` ` `    ``# Given range``    ``a ``=` `2``    ``b ``=` `-``3``    ``c ``=` `-``2``    ``A ``=` `0``    ``B ``=` `3``             ` `    ``# Function call``    ``solve(a, b, c, A, B)`` ` `# This code is contributed by jana_sayantan`

## C#

 `// C# program for the above approach``using` `System;`` ` `class` `GFG{``     ` `static` `readonly` `double` `eps = 1e-6;`` ` `// Given function``static` `double` `func(``double` `a, ``double` `b,``                   ``double` `c, ``double` `x)``{``    ``return` `a * x * x + b * x + c;``}`` ` `// Function to find the root of the``// given non-decreasing Function``static` `double` `findRoot(``double` `a, ``double` `b,``                       ``double` `c, ``double` `low,``                       ``double` `high)``{``    ``double` `x = -1;``     ` `    ``// To get the minimum possible``    ``// answer for the root``    ``while` `(Math.Abs(high - low) > eps)``    ``{``         ` `        ``// Find mid``        ``x = (low + high) / 2;``         ` `        ``// Search in [low, x]``        ``if` `(func(a, b, c, low) * ``            ``func(a, b, c, x) <= 0)``        ``{``            ``high = x;``        ``}``         ` `        ``// Search in [x, high]``        ``else``        ``{``            ``low = x;``        ``}``    ``}``     ` `    ``// Return the required answer``    ``return` `x;``}`` ` `// Function to find the roots of the``// given equation within range [a, b]``static` `void` `solve(``double` `a, ``double` `b, ``double` `c,``                  ``double` `A, ``double` `B)``{``     ` `    ``// If root doesn't exists``    ``if` `(func(a, b, c, A) * func(a, b, c, B) > 0)``    ``{``        ``Console.WriteLine(``"No solution"``);``    ``}``     ` `    ``// Else find the root upto 4``    ``// decimal places``    ``else``    ``{``        ``Console.Write(``"{0:F4}"``, findRoot(``            ``a, b, c, A, B));``    ``}``}`` ` `// Driver Code``public` `static` `void` `Main(String[] args)``{``     ` `    ``// Given range``    ``double` `a = 2, b = -3, c = -2,``           ``A = 0, B = 3;``             ` `    ``// Function call``    ``solve(a, b, c, A, B);``}``}`` ` `// This code is contributed by 29AjayKumar `
Output:
```2.0000
```

Time Complexity: O(log(B – A))
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up