The error is self-explainatory.

Why are you adding a number to an array? Recheck your logic/alogorithm
- you need to be operating on array *element*, not the array *object*
on that line.

-cheers,
Manish

Why are you adding to an array reference? Java has no pointer
arithmetic, and even if it did, a non-null array reference points to the
array object, not necessarily the first cell of the array.

This looks like an attempt to run C code in Java.

To do what you want, you need to pass around enough information to
identify a consecutive slice of the array, such as start index and
length, or start and end index, as well as the array reference.

Patricia

I like your original program, even though it doesn't run. It is good
thinking. I just changed it so that it runs. Following is the file
Tool.java. It runs correctly.

public class Tool {
    public static double max(double[] aArray, int iTotal, int iStart)
    {
        if (iTotal == 1)
        {
            return aArray[iStart];
        }
        else
        {
            int iEnd = iStart + iTotal - 1;
            int iFirstHalfCount = iTotal/2;
            int iLastHalfCount  = iTotal - iFirstHalfCount;

            double dMaxFirstHalf = max(aArray, iFirstHalfCount, iStart);
            double dMaxLastHalf = max(aArray, iLastHalfCount,
iStart+iFirstHalfCount);

            if (dMaxFirstHalf >= dMaxLastHalf) {
                return dMaxFirstHalf;
            }
            else {
                return dMaxLastHalf;
            }
        }

    }

    public static void main(String[] args)
        {
                double[] myArray = {3.3, 15.8, 9.7, 4.3, 16.6, 1.4,
3.6, 8.0, 5.2};
                double max = max(myArray, 6, 0);

                System.out.println("max = " + max);
        }

}

   Incidentally, I don't think "what you're trying to do" (assuming I
correctly guessed what you're trying to do) will work. Imagine the array is
of length 4. log2(4) = 2, so you could make at most 2 recursive calls, but
you actually make 4 recursive calls.

   Here's the simplest solution I can think of (in pseudocode) which
satisfy the (arbitrary?) requirement that the method must be recursive:

<pseudocode>
public double max(double[] a, int n) {
 double max = MINIMAL_DOUBLE_VALUE;
 if (length of a == 1) {
   return a[0];
 }
 if (n == SOME_MAGIC_VALUE) {
   return AN_IRRELEVANT_VALUE;
 }
 max(a[], SOME_MAGIC_VALUE); /*obligatory recursive call*/
 for (double d : a) {
   if (d > max) {
     max = d;
   }
 }
 return max;
}
</pseudocode>

   There's two cases of interest: Either the the length of the array is 1,
or it is greater than 1.

   If the array is length 1, then we may only make lg2(1) == 0 recursive
calls. Luckily, the algorithm above makes 0 recursive calls if the array
length is 1.

   If the array length is > 1, then we may make l2(array length) >= 1
recurisve calls. Luckiyl, the algorithm above makes 1 recursive call if the
array length is > 1.

   Assumptions made are that an empty array won't be passed in (in which
case the max is undefined), and that SOME_MAGIC_VALUE will not be a value
passed in for n. For example, if we assume the user will never provide a
negative n, SOME_MAGIC_VALUE can be -1.

   - Oliver