CODEWITHSUNDEEP
javaarraysrecursion
DarkLeafyGreen
DarkLeafyGreen

Reputation: 70406

Return set of numbers in recursion

following code searches for one zero point of a polynomial function. It uses recursion technique:

    private static double funktion(int[] koef, double x){
        return koef[0] * Math.pow(x,4) + koef[1] * Math.pow(x,3) + 
               koef[2] * Math.pow(x,2) + koef[3]*x + koef[4]; 
    }

    private static double nullstelle(double a, double b, int[] koef){
        double middle = (a + b)/2;
        double result = middle; 
        if(Math.abs(a-b) > 0.00001){
            double sin = funktion(koef, middle);
            if(sin == 0){
                result = middle;
            }else if(Math.signum(funktion(koef, a)) == 
                             Math.signum(funktion(koef, middle))){
                result = nullstelle(middle, b, koef);
            }else{
                result = nullstelle(a, middle, koef);
            }
        }
        return result;
    }

I am wondering how to return all zero points. My ideas is to use an array but I am not sure how to do that. Any ideas?

I am not allowed to use anything else than arrays (e.g. hash tables or sets are not allowed)

Upvotes: 2

Views: 262

Answers (5)

Peter Lawrey
Peter Lawrey

Reputation: 533492

Math.pow is a very expensive function. You can avoid it entirely using nested expressions. (And its shorter)

private static double funktion(int[] koef, double x){
     return (((koef[0] * x + koef[1]) * x + 
           koef[2]) * x + koef[3]) * x + koef[4]; 
}

Upvotes: 1

JeremyP
JeremyP

Reputation: 86651

First of all your solution as it stands suffers from one of the same problems as your previous question in that you can't guarantee that you'll get the zero calculation exactly correct. Unfortunately, this time you can't use the simple solution of checking that a and b have opposite signs because, for an arbitrary polynomial, a zero need not imply the function crosses the y = 0 line e.g. y = x^4.

Anyway, to answer your question:

  1. create an array of size 4 of type Double. Use null to denote that an array slot is empty. As your function is a quartic, there is a maximum of four zeroes.
  2. pass the array as a parameter in your function.
  3. when you have detected a zero, fill in the first free slot left in the array with the value of the zero.

No actual Java provided because this is homework.

Upvotes: 1

Woot4Moo
Woot4Moo

Reputation: 24316

Here is some explanation as this is homework:

1) We need to create an array of the data type you will be using to store zero points. My guess is double.
2) The array will need some type of starting size, lets say 10 for the sake of discussion
3) In the nullstelle method we will add an element to the array created in step 1
4) If the array has size LIMIT -1 we copy the array to a new array with size equal to LIMIT * 2
5) We now return this array.

If it needs to be sorted we can walk over the list utilizing whatever sort technique is to be decided on.

Upvotes: 2

pablosaraiva
pablosaraiva

Reputation: 2343

 public double[] returnOnlyZeros(int[] whatever1, double whatever2) {
  double[] result = new double[/*put the size here*/];

  // your math here

  // put the values into the result array

  return result;
 }

Upvotes: 0

andrewmu
andrewmu

Reputation: 14534

I would pass in a Collection such as a HashSet to your functions and put all the numbers you discover into it.

As you say you can only use arrays, then you know the maximum number of zero-points that can be found, presumably, so create an array of that size, assigned NaN to every element, then pass in that array and the maximum current index of it to every function call. You will need to return the new size of the array as the result so that you always know how many numbers have been found.

Upvotes: 2

Related Questions