Root Finding

[john mater]

I have been set an assignment to develop functions newton and bisection which use these methods to find the roots of functions. I have a function class a testfunction class and a root class, im having trouble bringing everything together.. if someone could take a look over what ive got i'd be grateful.

import java.lang.Math;
public class Roots
{
public static final double H=0.0000001;
public static double EndValue,x1,x2;
//returns the derivative of the function in x
public static double Derivative(double x)
{
return ((Function(x+H)-Function(x-H))/2*H)
;
}
public static double Function(double x)
{
return(x*x - 2);
}
//Supposed to itererate until the difference x2-x1 gets small enough
public static double Iterate(double x1)
{
x2 = x1 - ((Function(x1))/(Derivative(x1)));
if( (Math.abs(x2-x1)<H) ){EndValue = x2;return x2;}
else {Iterate(x2);}
return x2;
}
// Bisection method
}

public class Function
{
//** Choice var stores which function we are using
private int choice;
/***********************************************/
/** Constructor for objects of type Function **/
/***********************************************/
public Function()
{
/** initialise choice variable to default 1 **/
choice = 1;
}
/***********************************************/
/** Constructor for Function that sets choice **/
/***********************************************/
public Function(int x)
{
/** Initialise instance variables **/
choice = x;
}
/***********************/
/*** Change function ***/
/***********************/
public void set(int ch)
{
/** Only change if valid choice **/
if ((ch>0) && (ch<4))
{
choice = ch;
}
}
/**************************************/
/*** Apply function to a real value ***/
/**************************************/
public double apply(double x)
{
/** Make choice according to which function is set **/
if (choice == 1)
{
return (Math.pow(x, 3) - (4 * x) + 2);
}
else if (choice == 2)
{
return (Math.pow(x,3) - (3*Math.sin(x)));
}
else
{
return (Math.pow(x,3) - (3*Math.pow(x,2)) + x - 5);
}
}
/****************************************/
/*** Apply derivative to a real value ***/
/****************************************/
public double deriv(double x)
{
/** Make choice according to which function is set **/
if (choice == 1)
{
return (3 * Math.pow(x, 2) - 4);
}
else if (choice == 2)
{
return (3 * Math.pow(x, 2) - (3*Math.cos(x)));
}
else
{
return ((3 * Math.pow(x, 2)) - (6 * x) + 1);
}
}
}

Function class was given to us and I dont really understand how to use it.

[Campbell Ritchie]

Go through the code in the (badly-named) Function class and see what the different options in the apply() method do. They appear to work out formulae of the x^3 + 3x^2 - 5x - 3 variety. And don't use Math.pow(x, 3) for cube. Use x * x * x.

[john mater]

Thanks, noted and changed.. how do I go about creating a test class with some arbitrary starting values and a function from Function which tests my root finding methods?

[john mater]

Someone please help as this code is driving me crazy.. I have two Classes Function and Roots:

 import java.lang.Math;
public class Roots
{
// Bisection method
public static void newton()
{
double err = 1e-5,xx = 0 ;
double dx =0, x=0;
int k = 0;
while (Math.abs(xx-x) > err && k<100 && f(x)!=0) {
dx = f(x)/d(x);
xx=x;
x =x - dx;
k++;
System.out.println("Iteration number: " + k);
System.out.println("Root obtained: " + x);
System.out.println("Estimated error: " + Math.abs(xx-x));
}
}
// Method to provide function f(x)
public static double f(Function x) {
return f(x)=apply;
}
// Method to provide the derivative f'(x).
public static double d(Function x) {
return deriv;
}
}

public class Function
{
//** Choice var stores which function we are using
private int choice;
/***********************************************/
/** Constructor for objects of type Function **/
/***********************************************/
public Function()
{
/** initialise choice variable to default 1 **/
choice = 1;
}
/***********************************************/
/** Constructor for Function that sets choice **/
/***********************************************/
public Function(int x)
{
/** Initialise instance variables **/
choice = x;
}
/***********************/
/*** Change function ***/
/***********************/
public void set(int ch)
{
/** Only change if valid choice **/
if ((ch>0) && (ch<4))
{
choice = ch;
}
}
/**************************************/
/*** Apply function to a real value ***/
/**************************************/
public double apply(double x)
{
/** Make choice according to which function is set **/
if (choice == 1)
{
return (Math.pow(x, 3) - (4 * x) + 2);
}
else if (choice == 2)
{
return (Math.pow(x,3) - (3*Math.sin(x)));
}
else
{
return (Math.pow(x,3) - (3*Math.pow(x,2)) + x - 5);
}
}
/****************************************/
/*** Apply derivative to a real value ***/
/****************************************/
public double deriv(double x)
{
/** Make choice according to which function is set **/
if (choice == 1)
{
return (3 * Math.pow(x, 2) - 4);
}
else if (choice == 2)
{
return (3 * Math.pow(x, 2) - (3*Math.cos(x)));
}
else
{
return ((3 * Math.pow(x, 2)) - (6 * x) + 1);
}
}
} 

My question is how do I modify Roots to call/use the functions created by my Function class? Thanks

[Campbell Ritchie]

Does that class compile? Please tell us the details of what actually happens.