Issue about "the same lower bound and upper bound" in 'fmincon'

Hey, everyone, I have a confusion about the lower bound and upper bound in 'fmincon'. My optimization problem can be described as below:

where and are two endogenous variables, and is the objective function.

I need to do the following two optimizations

1.Both and are endogenous, using 'fmincon' to solve out the optimized and

2.Given , using 'fmincon' to solve out the optimized

For the optimization problem 2, I tried the following two methods to do it:

(1) Setting the same lower and upper bound for x2 (which is 1 here), and using 'fmincon' to solve out the optimal x1 and x2;

(2) Substituting into the objective function and constraint conditions firslty, and use 'fmincon' to solve out the optimized .

However, the value of optimized under these two methods are different. Which method should I use here?

I check the link https://www.mathworks.com/help/optim/ug/iterations-can-violate-constraints.html which states that 'If you set a lower bound equal to an upper bound, iterations can violate these constraints.'. Does it mean that the method (1) is wrong?

Your comments are appreciated.

[Torsten]

However, the value of optimized under these two methods are different. Which method should I use here?

And how much do the two solutions differ ?

[Matt J]

Did you do this for all your constraints, including the linear ones A*x<=b, Aeq*x=beq ?

[sxj]

Thanks for your comments, Torsten and Matt.

The differences are shown as below where I choose the value of objective and endogenous variables in method (1) as reference point. Besides, there are actually four endogenous variables in my problem where I should solve out the optimal ones respectively.

Differences for the value of objective: -0.0023, 2.5349e-04,7.1896e-05,1.5973e-04

Percentage differences for the value of optimized x: -3.82%, 2.81%, -1.16%, 0.62%

Since I need to do sensitive test in which I test how the change of parameters affect the optimized values, it would be import to see which method should be used.

There is no linear constraints but non-linear constraints in my problem. I have already substitute the value of into the constraints when I use method 2.

Answer 1

[Matt J]

No, it is not wrong. It probably means you have multiple solutions or that the differences are merely floating point noise. You should check the objective function value at each solution to be sure.

Neither method 1 and 2 are generally the most efficient, however. The efficient way is to derive a simpler objective function in which x1 is the only input. For example, if your original objective function were,

f=@(x) (x(1)+2*x(2)+3).^2; 

the efficient approach when x2=1 would be to simplify this to,

x2=1;
c=2*x2+3;

f=@(x1) (x1+c).^2;

This way, you avoid doing extra arithmetic with x2 every time fmincon calls your objective.

[sxj]

Hey, Matt, your method seems to be the same as my method (2) where I choose as specific parameter and substitute into the objective and constraints.

[Matt J]

No, it is not the same. For example, if you simply passed x2=1 as follows,

fmincon(@(x1) fun([x1,1]),x0,[],[],[],[],[],[],@(x1)nonlcon([x1,1]))

then there is no computational savings along the lines of my last example, because fun() and nonlcon() are still executing the same code as when x2 was unknown.

[sxj]

Hey, Matt, I get your point and would adjust the code as your suggestions.

According to the differences between the two methods which I show above, does it seem to be floating point noise? The optimized value of objective function is almost the same, but the optimized value of endogeneous variables are somewhat different.

If there exists multiple solution, is it the issue of local minimum and global minimum and should I turn to the global search method in MATLAB?

[Matt J]

I can't really evaluate any of that without seeing the objective and running it myself. What was the objective value at the initial point? If it was 10000 then a difference of 0.0023 doesn't seem significant.

[sxj]

The objective value at the initial point is 9.1347e+03, and the objective value under the two methods are 9.222e+3 and 9.2012e+3 respectively. -0.0023 = (9.2012e+3-9.222e+3)/9.222e+3 measures the difference between the two method in which I choose one of them as the reference point.

The code contains several subfunction, I have to adjust a little for you to run it if it is neccessary.