Hi This is a question somewhere between maths and numerical methods...

I am using the algorithm for Nelder Mead found here:

in java. It works nicely with the two example functions - rosen and parab.
I am trying to adjust it to my function:

Code:
	static double myFunction(double p[]) {
double v0;
double sum = 0;
double curve;
double errorVector;
int index = 0;
v0 = (1 + (p[0] / 2) * timings.get(0) * timings.get(0))
/ timings.get(0);

for (Double f : timings) {
index++;
curve = (v0 * f - (p[0] / 2)) * f * f;
errorVector = index - rotorCurve;
sum += errorVector * errorVector;
}
System.out.println("p:" + p[0]);
return sum;
}
so that I can minimize for the sum and find p[0].
My test data is

The problem I think is occuring with my understanding of the 2D array simplex[]. As far as I understand the first two columns are the paramter initial values and the third is storing the value of the function, but Im not sure why there are three rows. I assume its three different values for the paramters or something, but it doesnt seem to make sense to me.

I have attached my version of the algorithm for my function, in the hope that someone can help me get it to solve the problem.
Thanks

EDIT:!!
Sorry I made a mistake in my attachment. I had done a couple of undo's that need to be put back.

The array simplex should be:
Code:
        double simplex[][] = // [row][col] = [whichvx][coord,FUNC]
{{ 0.004, 0.0}};

#### Attachments

6.7 KB · Views: 461

Is this in the wrong place? Could an admin move it please? Perhaps general engineering would be better?

Office_Shredder
Staff Emeritus
Gold Member
2021 Award
The first two columns of simplex are storing initial points to evaluate your function if your function is over R2, and the third column is storing function values. If it's over R then it looks like the first column is initial points to evaluate at, the second column is storing the value of the function, and the third column is totally superfluous. The point is that you are supposed to evaluate the function on a simplex - in two dimensions that is a triangle with three vertices to keep track of, in 2 dimensions it's a line segment with two vertices to keep track of. So it seems like NPoints should be changed to 2 along with NDims to 1, and you should resize your simplex matrix to be 2x2 (this last part I suppose is not strictly necessary, but there are elements in that matrix that will never be referenced/changed).

Thanks Office_Shredder, so now it compiles and converges, however it converges to the wrong value. I have a paper that gets the result as 0.0068 and My matlab program also gets that value, however this seems to converge to -0.32
I now have simplex setup as:

{{ 0.006, 0.0}, {0.0, 0.0}};

i.e 2x2. Should the other values all start at 0? Or should they be something else?
Thanks
A

Office_Shredder
Staff Emeritus
Gold Member
2021 Award
It doesn't matter what they start at, the first thing the program does is evaluate your function and fill in (in your case) f(.006) and f(0) into the second column.
That's what
for (int i=0; i<NPTS; i++)
simplex[FUNC] = func(simplex);

is doing.

As to why it's converging to the wrong value, my understanding is that if your starting simplex is too small that you can get stuck in a local search. If the concavity around .0068 is very large, it might be that on the interval [0, .006] the function is sloped so that following the gradient means moving towards negative numbers, in which case the search would do that. You should try starting with a larger interval, like have your first column have a 0 and a 1 in it.

Integral
Staff Emeritus