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.