Bisection method to find root of sin(x) in c recursively - c

Question

I want to find the root of sin(x) function by approximating an interval [a,b] recursively, but my output is:
-0.350783
But I want to get
3.1415
This is my code so far
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
double dicho(double a,double b)
{
double m=(a+b)/2;
double eps=0.000001;
if((b-a)>=eps)
{
if(abs(sin(0)-sin(m))<=eps){
return m;
}
if(sin(m)<0){
a=m;
}
if(sin(m)>0){
b=m;
}
dicho(a,b);
}
}
void main()
{
int a,b;
a=3;
b=4;
double res=sin(dicho(a,b));
printf("%lf\n",res);
}

Answer 1

Everything klutt said. But there's also a glitch in your algorithm. Namely in the [3, 4] interval the sine function is strictly decreasing and this breaks down your logic a little bit.
Reworking your dicho function something like this seems to work:
double dicho(double a,double b)
{
double m=(a+b)/2;
double eps=0.000001;
if((b-a)>=eps)
{
printf("a: %lf b: %lf, m: %lf diff: %lf\n",
a, b, m, sin(0) - sin(m));
if(fabs(sin(0)-sin(m)) <= eps){
return m;
}
if(sin(m) < 0){
b = m; // look in [a, (a+b)/2]
}
if(sin(m)>0){
a = m; // look in [[a+b]/2, b]
}
return dicho(a,b);
}
return m;
}
When running with this function you can see the solution actually converges towards pi:
a: 3.000000 b: 4.000000, m: 3.500000 diff: 0.350783
a: 3.000000 b: 3.500000, m: 3.250000 diff: 0.108195
a: 3.000000 b: 3.250000, m: 3.125000 diff: -0.016592
a: 3.125000 b: 3.250000, m: 3.187500 diff: 0.045891
a: 3.125000 b: 3.187500, m: 3.156250 diff: 0.014657
a: 3.125000 b: 3.156250, m: 3.140625 diff: -0.000968
a: 3.140625 b: 3.156250, m: 3.148438 diff: 0.006845
a: 3.140625 b: 3.148438, m: 3.144531 diff: 0.002939
a: 3.140625 b: 3.144531, m: 3.142578 diff: 0.000985
a: 3.140625 b: 3.142578, m: 3.141602 diff: 0.000009
a: 3.140625 b: 3.141602, m: 3.141113 diff: -0.000479
a: 3.141113 b: 3.141602, m: 3.141357 diff: -0.000235
a: 3.141357 b: 3.141602, m: 3.141479 diff: -0.000113
a: 3.141479 b: 3.141602, m: 3.141541 diff: -0.000052
a: 3.141541 b: 3.141602, m: 3.141571 diff: -0.000022
a: 3.141571 b: 3.141602, m: 3.141586 diff: -0.000006
a: 3.141586 b: 3.141602, m: 3.141594 diff: 0.000001
a: 3.141586 b: 3.141594, m: 3.141590 diff: -0.000003
a: 3.141590 b: 3.141594, m: 3.141592 diff: -0.000001
3.141592
But with your original recursion logic (use fabs instead of abs though):
a: 3.000000 b: 4.000000, m: 3.500000 diff: 0.350783
a: 3.500000 b: 4.000000, m: 3.750000 diff: 0.571561
a: 3.750000 b: 4.000000, m: 3.875000 diff: 0.669405
a: 3.875000 b: 4.000000, m: 3.937500 diff: 0.714499
a: 3.937500 b: 4.000000, m: 3.968750 diff: 0.736010
a: 3.968750 b: 4.000000, m: 3.984375 diff: 0.746497
a: 3.984375 b: 4.000000, m: 3.992188 diff: 0.751673
a: 3.992188 b: 4.000000, m: 3.996094 diff: 0.754243
a: 3.996094 b: 4.000000, m: 3.998047 diff: 0.755524
a: 3.998047 b: 4.000000, m: 3.999023 diff: 0.756164
a: 3.999023 b: 4.000000, m: 3.999512 diff: 0.756483
a: 3.999512 b: 4.000000, m: 3.999756 diff: 0.756643
a: 3.999756 b: 4.000000, m: 3.999878 diff: 0.756723
a: 3.999878 b: 4.000000, m: 3.999939 diff: 0.756763
a: 3.999939 b: 4.000000, m: 3.999969 diff: 0.756783
a: 3.999969 b: 4.000000, m: 3.999985 diff: 0.756793
a: 3.999985 b: 4.000000, m: 3.999992 diff: 0.756798
a: 3.999992 b: 4.000000, m: 3.999996 diff: 0.756800
a: 3.999996 b: 4.000000, m: 3.999998 diff: 0.756801
a: 3.999998 b: 4.000000, m: 3.999999 diff: 0.756802
4.000000

Answer 2

When compiling with -Wall -Wextra this code gives me three warnings.
$ gcc b.c -lm -Wall -Wextra
b.c: In function ‘dicho’:
b.c:12:12: warning: using integer absolute value function ‘abs’ when argument is of floating point type ‘double’ [-Wabsolute-value]
12 | if(abs(sin(0)-sin(m))<=eps){
| ^~~
b.c: At top level:
b.c:28:6: warning: return type of ‘main’ is not ‘int’ [-Wmain]
28 | void main()
| ^~~~
b.c: In function ‘dicho’:
b.c:26:1: warning: control reaches end of non-void function [-Wreturn-type]
26 | }
| ^
You need to:
Change the signature of main to int main()
Change abs to fabs
Make sure that the recursive function actually does return. For instance, the recursive call dicho(a,b); within the dicho function should be return dicho(a,b); Also, what happens if (b-a)<eps? You should return something there too.
What happens if sin(m) evaluates to 0? Then you would be stuck in an endless loop. Well, not really because fabs(sin(0)-sin(m))<=eps will catch that case, but were you really aware of that? ;)
This does not solve the issue with wrong output, but it is the minimum on your way to solving it.

Answer 3

You have some serious programming errors like using integer abs where you should use floating point fabs and missing return statements.
But the worst part is the algorithm is wrong. When the algorithm is wrong, it won't help to fix the programming errors. The program will still fail.
The main problem with your algorithm is that you assume that sin(a) is less than zero and that sin(b) is greater than zero. You can't just assume that!
You need to handle all cases - for instance:
if (sin(a) > 0 && sin(b) > 0)
{
// both greater than zero
// What to do now ??? Maybe there isn't a solution in this interval
}
if (sin(a) < 0 && sin(b) < 0)
{
// both less than zero
// What to do now ??? Maybe there isn't a solution in this interval
}
if (sin(a) > 0)
{
// sin(a) larger than sin(b)
// Do recursive call
return dicho(?, ?);
}
else
{
// sin(a) less than sin(b)
// Do recursive call
return dicho(?, ?);
}
But what to put into the recursive call ?
Your approach is to do
return dicho(a, (a+b)/2));
in one case and
return dicho((a+b)/2), b);
in the other.
But that will not work!
Assume the following:
sin(a) is less than zero
sin(b) is greater than zero
sin((a+b)/2) is greater than zero
In this case we can do:
option 1:
return dicho((a+b)/2), b); // very bad as both are now greater than zero
option 2:
return dicho(a, (a+b)/2)); // good! one negative and one positive
So from this you see that just cutting the interval in half isn't a good idea. You need to add code that checks whether sin at the middle point is less or greater than zero and then do the call for the correct sub-interval (depending on the value of sin(a) and sin(b))
Something like:
if (sin(a) > 0)
{
// sin(a) larger than sin(b)
if (sin((a+b)/2) > 0)
{
return dicho((a+b)/2, b);
}
return dicho(a, (a+b)/2);
}
else
{
// sin(a) less than sin(b)
.... similar to the aboove code
}
Putting all cases into a truth table is often very helpful. Like:
----------------------------------------------------------------------------------
fabs(sin(a)) < eps | | | return a;
----------------------------------------------------------------------------------
fabs(sin(b)) < eps | | | return b;
----------------------------------------------------------------------------------
sin(a) > 0 | sin(b) > 0 | | oh dear - bad
----------------------------------------------------------------------------------
sin(a) < 0 | sin(b) < 0 | | oh dear - bad
----------------------------------------------------------------------------------
sin(a) > 0 | sin(b) < 0 | sin((a+b)/2) > 0 | return dicho((a+b)/2), b);
----------------------------------------------------------------------------------
sin(a) > 0 | sin(b) < 0 | sin((a+b)/2) < 0 | return dicho(a, (a+b)/2));
----------------------------------------------------------------------------------
sin(a) < 0 | sin(b) > 0 | sin((a+b)/2) > 0 | return dicho(a, (a+b)/2));
----------------------------------------------------------------------------------
sin(a) < 0 | sin(b) > 0 | sin((a+b)/2) < 0 | return dicho((a+b)/2), b);
----------------------------------------------------------------------------------

Answer 4

clang is even more helpful, suggesting that you use fabs
so6.c:12:12: warning: using integer absolute value function 'abs' when argument is of floating point type [-Wabsolute-value]
if(abs(sin(0)-sin(m))<=eps){
^
so6.c:12:12: note: use function 'fabs' instead
if(abs(sin(0)-sin(m))<=eps){
^~~
fabs
so6.c:25:1: warning: control may reach end of non-void function [-Wreturn-type]
}
^