Pointers changing eachother despite being unrelated

I am trying to use the Simplex Downhill method for finding the minimum of a function. I take three points as arrays of two values and assign each a pointer so that I can order them high-to-low according to their output of some function (Rosenbrock's parabolic valley in this case). After ordering these pointers I attempt to update the arrays with the respective values, however both the high and medium point take the same value unless the points were already in the correct order.

I set the three arrays and their respective pointers,

double plarray[] = {0., 0.};
double pmarray[] = {2., 0.};
double pharray[] = {0., 2.};
double *pl, *pm, *ph;
pl = &plarray[0], pm = &pmarray[0], ph = &pharray[0];

and sort the pointers as above. This bit works well, however when I try to replace the arrays with the proper values using this function,

void update(double x[], double *y){
x[0] = *y;
x[1] = *(y+1);
}

both pmarray and pharray take on the same values. I've tried swapping them around but it doesn't seem to change anything. Interestingly, plarray seems to work perfectly fine regardless of update order.

Brop (array of pointers sorted from lowest to highest in terms of their Brock output) is sorted as such where brockop points to Brock. sortSize sorts the pointers given by the given function,

brop = sortSize(pl, pm, ph,  brockop);
double ** sortSize(double * p1p, double * p2p, double * p3p, double (func)(double *)){
static double * order[3];
double bp1 = func(p1p);
double bp2 = func(p2p);
double bp3 = func(p3p);
double brocks[] = {bp1, bp2, bp3};
order[2] = ((bp1 > bp2 && bp1 > bp3)? p1p: (bp2 > bp3)? p2p:p3p);
order[0] = ((bp1 < bp2 && bp1 < bp3)? p1p: (bp2 < bp3)? p2p:p3p);
order[1] = ((bp1 != func(order[0]) && bp1 != func(order[2]))? p1p: (bp2 != func(order[0]) && bp2 != func(order[2]))? p2p: p3p);
return order;
}

I then assign the pointers to the sorted values in brop,

pl = *brop;
pm = *(brop + 1);
ph = *(brop + 2);

Please note that brop is an array of the pointers to the points of the function I wanted to sort, not a point itself.

I have some output after adding a bunch of printf for debugging,

y of Brop[0], (0.000000, 0.000000) = 1.000000
y of Brop[1], (-1.000000, 1.500000) = 29.000000
y of Brop[2], (0.000000, 2.000000) = 401.000000
--------Before assigning to Brop values--------
P_h pointer: -1.000000, 1.500000, yh = 29.000000
P_m pointer: 0.000000, 2.000000, ym = 401.000000
P_l pointer: 0.000000, 0.000000, yl = 1.000000
--------Array values before assigning to brop ------
P_h array: -1.000000, 1.500000, yh = 29.000000
P_m array: 0.000000, 2.000000, ym = 401.000000
P_l array: 0.000000, 0.000000, yl = 1.000000
-------Pointers asigned to brop values-----
P_h pointer: 0.000000, 2.000000, yh = 401.000000
P_m pointer: -1.000000, 1.500000, ym = 29.000000
P_l pointer: 0.000000, 0.000000, yl = 1.000000
--------Array values after assigning to brop-------
P_h array: -1.000000, 1.500000, yh = 29.000000
P_m array: 0.000000, 2.000000, ym = 401.000000
P_l array: 0.000000, 0.000000, yl = 1.000000
------------P_m updated--------
P_h pointer: -1.000000, 1.500000, yh = 29.000000
P_m pointer: -1.000000, 1.500000, ym = 29.000000
P_l pointer: 0.000000, 0.000000, yl = 1.000000
------------P_h updated--------
P_h pointer: -1.000000, 1.500000, yh = 29.000000
P_m pointer: -1.000000, 1.500000, ym = 29.000000
P_l pointer: 0.000000, 0.000000, yl = 1.000000
----------Arrays updated-----------
P_h: -1.000000, 1.500000, yh = 29.000000
P_m: -1.000000, 1.500000, ym = 29.000000
P_l: 0.000000, 0.000000, yl = 1.000000

Code used to produce debug output:

printf("--------Before assigning to Brop values--------\n");
printf("P_h pointer: %lf, %lf, yh = %lf\n", *ph, *(ph+1), Brock(ph));
printf("P_m pointer: %lf, %lf, ym = %lf\n", *pm, *(pm+1), Brock(pm));
printf("P_l pointer: %lf, %lf, yl = %lf\n", *pl, *(pl+1), Brock(pl));
printf("--------Array values before assigning to brop ------\n");
printf("P_h array: %lf, %lf, yh = %lf\n", pharray[0], pharray[1], BrockNP(pharray));
printf("P_m array: %lf, %lf, ym = %lf\n", pmarray[0], pmarray[1], BrockNP(pmarray));
printf("P_l array: %lf, %lf, yl = %lf\n", plarray[0], plarray[1], BrockNP(plarray));
pl = *brop;
pm = *(brop + 1);
ph = *(brop + 2);
printf("-------Pointers asigned to brop values-----\n");
printf("P_h pointer: %lf, %lf, yh = %lf\n", *ph, *(ph+1), Brock(ph));
printf("P_m pointer: %lf, %lf, ym = %lf\n", *pm, *(pm+1), Brock(pm));
printf("P_l pointer: %lf, %lf, yl = %lf\n", *pl, *(pl+1), Brock(pl));
printf("--------Array values after assigning to brop-------\n");
printf("P_h array: %lf, %lf, yh = %lf\n", pharray[0], pharray[1], BrockNP(pharray));
printf("P_m array: %lf, %lf, ym = %lf\n", pmarray[0], pmarray[1], BrockNP(pmarray));
printf("P_l array: %lf, %lf, yl = %lf\n", plarray[0], plarray[1], BrockNP(plarray));
update(pmarray, *(brop + 1));
printf("------------P_m updated--------\n");
printf("P_h pointer: %lf, %lf, yh = %lf\n", *ph, *(ph+1), Brock(ph));
printf("P_m pointer: %lf, %lf, ym = %lf\n", *pm, *(pm+1), Brock(pm));
printf("P_l pointer: %lf, %lf, yl = %lf\n", *pl, *(pl+1), Brock(pl));
update(pharray, *(brop+2));
printf("------------P_h updated--------\n");
printf("P_h pointer: %lf, %lf, yh = %lf\n", *ph, *(ph+1), Brock(ph));
printf("P_m pointer: %lf, %lf, ym = %lf\n", *pm, *(pm+1), Brock(pm));
printf("P_l pointer: %lf, %lf, yl = %lf\n", *pl, *(pl+1), Brock(pl));
update(plarray, *brop);
printf("----------Arrays updated-----------\n");
printf("P_h: %lf, %lf, yh = %lf\n", *ph, *(ph+1), Brock(ph));
printf("P_m: %lf, %lf, ym = %lf\n", *pm, *(pm+1), Brock(pm));
printf("P_l: %lf, %lf, yl = %lf\n", *pl, *(pl+1), Brock(pl));
printf("after sorting\n");

Function used for y-values:

double Brock(double * vec){
return 100*pow(*(vec+1) - ((*vec)*(*vec)), 2) + pow(1 - *vec, 2);
}

Minimal Reproducible Example:

#include <stdio.h>
#include <math.h>
double BrockNP(double x[]){
return 100*pow(x[1] - (x[0]*x[0]), 2) + pow(1 - x[0], 2);
}	
double Brock(double * vec){
return 100*pow(*(vec+1) - ((*vec)*(*vec)), 2) + pow(1 - *vec, 2);
}
double ** sortSize(double * p1p, double * p2p, double * p3p, double (func)(double *));
void update(double x[], double *y);
int main(){
double *pl, *pm, *ph;
double **brop;
double (*brockop)(double *);
double plarray[] = {0., 0.};
double pmarray[] = {2., 0.};
double pharray[] = {0., 2.};
pl = &plarray[0], pm = &pmarray[0], ph = &pharray[0];
brockop = &Brock;
brop = sortSize(pl, pm, ph,  brockop);
printf("--------Before assigning to Brop values--------\n");
printf("P_h pointer: %lf, %lf, yh = %lf\n", *ph, *(ph+1), Brock(ph));
printf("P_m pointer: %lf, %lf, ym = %lf\n", *pm, *(pm+1), Brock(pm));
printf("P_l pointer: %lf, %lf, yl = %lf\n", *pl, *(pl+1), Brock(pl));
printf("--------Array values before assigning to brop ------\n");
printf("P_h array: %lf, %lf, yh = %lf\n", pharray[0], pharray[1], BrockNP(pharray));
printf("P_m array: %lf, %lf, ym = %lf\n", pmarray[0], pmarray[1], BrockNP(pmarray));
printf("P_l array: %lf, %lf, yl = %lf\n", plarray[0], plarray[1], BrockNP(plarray));
pl = *brop;
pm = *(brop + 1);
ph = *(brop + 2);
printf("-------Pointers asigned to brop values-----\n");
printf("P_h pointer: %lf, %lf, yh = %lf\n", *ph, *(ph+1), Brock(ph));
printf("P_m pointer: %lf, %lf, ym = %lf\n", *pm, *(pm+1), Brock(pm));
printf("P_l pointer: %lf, %lf, yl = %lf\n", *pl, *(pl+1), Brock(pl));
printf("--------Array values after assigning to brop-------\n");
printf("P_h array: %lf, %lf, yh = %lf\n", pharray[0], pharray[1], BrockNP(pharray));
printf("P_m array: %lf, %lf, ym = %lf\n", pmarray[0], pmarray[1], BrockNP(pmarray));
printf("P_l array: %lf, %lf, yl = %lf\n", plarray[0], plarray[1], BrockNP(plarray));
update(pmarray, *(brop + 1));      //This seems to set pharray and pmarray to the same array
printf("------------P_m updated--------\n");
printf("P_h pointer: %lf, %lf, yh = %lf\n", *ph, *(ph+1), Brock(ph));
printf("P_m pointer: %lf, %lf, ym = %lf\n", *pm, *(pm+1), Brock(pm));
printf("P_l pointer: %lf, %lf, yl = %lf\n", *pl, *(pl+1), Brock(pl));
update(pharray, *(brop+2));
printf("------------P_h updated--------\n");
printf("P_h pointer: %lf, %lf, yh = %lf\n", *ph, *(ph+1), Brock(ph));
printf("P_m pointer: %lf, %lf, ym = %lf\n", *pm, *(pm+1), Brock(pm));
printf("P_l pointer: %lf, %lf, yl = %lf\n", *pl, *(pl+1), Brock(pl));
update(plarray, *brop);
printf("----------Arrays updated-----------\n");
printf("P_h: %lf, %lf, yh = %lf\n", *ph, *(ph+1), Brock(ph));
printf("P_m: %lf, %lf, ym = %lf\n", *pm, *(pm+1), Brock(pm));
printf("P_l: %lf, %lf, yl = %lf\n", *pl, *(pl+1), Brock(pl));
printf("after sorting\n");    
return 0;
}
double ** sortSize(double * p1p, double * p2p, double * p3p, double (func)(double *)){
static double * order[3];
double bp1 = func(p1p);
double bp2 = func(p2p);
double bp3 = func(p3p);
double brocks[] = {bp1, bp2, bp3};
order[2] = ((bp1 > bp2 && bp1 > bp3)? p1p: (bp2 > bp3)? p2p:p3p);
order[0] = ((bp1 < bp2 && bp1 < bp3)? p1p: (bp2 < bp3)? p2p:p3p);
order[1] = ((bp1 != func(order[0]) && bp1 != func(order[2]))? p1p: (bp2 != func(order[0]) && bp2 != func(order[2]))? p2p: p3p);
return order;
}
void update(double x[], double *y){
x[0] = *y;
x[1] = *(y+1);
}

Any help would be much appreciated.

Edit: brop is just the array of pointers in size order as above.

If we simplify your code down to the absolute minimum (using just two doubles instead of three arrays), you'll see that you do the equivalent of this:

double x = 42, y = 43;
double *px = &y, *py = &x; // !! notice that these are swapped !!
x = *px; // A
y = *py; // B

Line A here overwrites the value of x. So even though py points to x, the original value of x is already lost, so y will be set to 43 because that's what's stored in x when the code reaches line B.

There are multiple ways to solve this:

• create a copy of your three arrays, apply the permutation, and then copy back,
• sort your points in-place by swapping values between the three arrays in your sort function, or
• always use the pointers pl, pm, ph instead of the original arrays. So you won't need to copy things around at all.

The first is probably the simplest fix to the existing code:

double plarray[] = {0., 0.};
double pmarray[] = {2., 0.};
double pharray[] = {0., 2.};
// ... sort ...
pl = brop[0];
pm = brop[1];
ph = brop[2];
double tmp_plarray[2];
double tmp_pmarray[2];
double tmp_pharray[2];
// apply permutation into temporary arrays
update(tmp_plarray, pl);
update(tmp_pmarray, pm);
update(tmp_pharray, ph);
// copy back into original arrays
update(plarray, tmp_plarray);
update(pmarray, tmp_pmarray);
update(pharray, tmp_pharray);

Though I'd recommend going with the 3rd as it will simplify a lot of your code greatly while simultaneously being faster.