Implementing bisection method in java
I am implementing bisection method for solving equations in java. I originally coded a solution for the predefined polynomial equation x ^ 3 + 4x ^ 2 - 10. Now I generalize the solution to whatever polynomial the user enters.
I read the coefficients of the corresponding degrees. Now I only need to set up the f () method so that I can evaluate f (a), f (b) and f (c).
// BISECTION METHOD IMPLEMENTATION IN JAVA
// This program uses bisection method to solve for x^3 + 4x^2 -10 = 0
package nisarg;
import java.util.Scanner;
public class BetterBisection {
public static void main(String[] args) {
double a, b, c; // a, b and c have the usual meaning
double f_of_a, f_of_b; // f_of_a, f_of_b store values of f(a) and f(b)
// respectively
int highest_degree;
System.out.println("What is the highest degree of your polynomial? ");
Scanner input = new Scanner(System.in);
highest_degree = input.nextInt();
for (int i = highest_degree; i >= 0; i--) {
int coeff_deg_i;
coeff_deg_i = poly_input(i);
// System.out.println(coeff_deg_i);
}
// The following do-while loop keeps asking the user for a and b until
// f(a)f(b) does not become negative
do {
a = input();
b = input();
if (f(a) * f(b) >= 0) {
System.out
.println("Sorry the two numbers are not bracketing the root. Please try again ");
}
} while (f(a) * f(b) >= 0);
f_of_a = f(a);
f_of_b = f(b);
double root = bisectionMethod(f_of_a, f_of_b, a, b);
System.out.println("Root is : " + root);
}
public static double input() { // Reads in the bracketing number i.e a and b
Scanner input = new Scanner(System.in);
System.out.println("Enter a bracketing number");
return (input.nextDouble());
}
public static double f(double num) { // Calculates f(x) given x and returns
// f(x)
final int COEFF_DEG_3 = 1; // Coefficient of x^3
final int COEFF_DEG_2 = 4; // Coefficient of x^2
final int COEFF_DEG_0 = -10; // Coefficient of x^0
return (COEFF_DEG_3 * Math.pow(num, 3) + COEFF_DEG_2 * Math.pow(num, 2) + COEFF_DEG_0
* Math.pow(num, 0));
}
public static double bisectionMethod(double f_of_a, double f_of_b, double a,
double b) { // Does the actual work of evaluating
double c; // the root using the method of bisection.
double f_of_c;
final double TOLERANCE = 0.0001;
while (Math.abs(a - b) > TOLERANCE) {
c = (a + b) / 2;
f_of_c = f(c);
if (f_of_c * f(a) == 0 || f_of_c * f(b) == 0) {
return c;
} else if (f_of_c * f(a) > 0) {
a = c;
} else {
b = c;
}
}
return (a + b) / 2;
}
public static int poly_input(int degree) {
System.out.println("Please enter coefficient for degree " + degree);
Scanner input = new Scanner(System.in);
int coefficient;
coefficient = input.nextInt();
return coefficient;
}
}
+3
source to share
2 answers
You cannot use loops to define variables. Or they have 12 explicit variables:
public class global {
public static int coeff_deg_1;
public static int coeff_deg_2;
public static int coeff_deg_3;
// and so on...
}
Or define one array with 12 elements:
public class global {
public static final int coeff_degs = new int[12];
}
+1
source to share
here's a recursive one:
public static double f(double x) {
return (x*x*x)-4*x-10;
}
public static double RecursiveBisection(Function fct, final double left, final double right, final double tolerance) {
double x = 0;
double dx = 0;
if ( Math.abs(right - left) < tolerance ) // base case
return (left + right) / 2;
else { // recursive case
x = (left + right)/2;
System.out.println("Root obtained: " + x);
dx = right - left;
System.out.println("Estimated error: " + dx);
if ( fct.f(left) * fct.f(x) > 0 ) // on same side
return RecursiveBisection (fct, x, right, tolerance);
else // opposite side
return RecursiveBisection(fct, left, x, tolerance);
}
}
0
source to share