最小F (S_1、S_2): 1.25 S_1 ^ 2 + 0.4 S_2 ^ 2分钟ʄ(S_1、S_2、S_3): S_1 ^ 2 + 0.35 S_2 ^ 2 2 S_1 ^ 2 + 0.6 S_2 ^ 2≤5100000 5 S_1 ^ 2 + 3 S_2 ^ 2≤14250000

46个视图(30天)

显示旧的评论

奥斯曼督导员约7小时前

0
链接

这个问题直接联系

//www.tatmou.com/matlabcentral/answers/1966224-min-f-s_1-s_2-1-25-s_1-2-0-4s_2-2-min-s_1-s_2-s_3-s_1-2-0-35s_2-2-2s_1-2-0-6s_2

评论道: 奥斯曼督导员16分钟前

你能帮我解决一个双层规划问题,包含两个层次和两个约束?请问如何解决?我需要的代码,解决方案和算法。你能帮我吗?

minF (s1, s2) = 1.25 s1 ^ 2 + 0.4 s2 ^ 2

minf (s1, s2) = s1 ^ 2 + 035 s2 ^ 2

领域2 s1 ^ 2 + 0.6 s2 ^ 2 < = 5100000

5 s1 ^ 2 + 3 s_2 ^ 2 < = 14250000

s1, s2 > = 0

9日评论
显示8年长的评论隐藏8年长的评论

奥斯曼督导员 14分钟前

%定义上层目标函数

upperLevelObj = @ (s) 1.25 * s (1) ^ 2 + 0.4 * s (2) ^ 2;

%定义目标函数的较低水平

lowerLevelObj = @ (s)(1) ^ 2 + 0.35 *年代(2)^ 2;

%定义上层约束函数

upperLevelConstr = @ (s) (2 * s (1) ^ 2 + 0.6 * s (2) ^ 2 - 5100000;

5 * s (1) ^ 2 + 3 * s (2) ^ 2 - 14250000];

%建立上层的优化问题

upperLevelProblem。目标= upperLevelObj;

upperLevelProblem。x0 = (0,0);%初始猜测(s_1、s_2)

upperLevelProblem。Aineq = [];

upperLevelProblem。bineq = [];

upperLevelProblem。Aeq = [];

upperLevelProblem。说真的= [];

upperLevelProblem。磅= [];

upperLevelProblem。乌兰巴托= [];

upperLevelProblem。nonlcon = [];

upperLevelProblem。选择= optimoptions (“fmincon”,“显示”,“关闭”);

%解决上层的问题

[sUpperOptimal, upperOptimalCost] = fmincon (upperLevelProblem);

%建立低水平的优化问题

lowerLevelProblem。目标= lowerLevelObj;

lowerLevelProblem。x0 = sUpperOptimal;%使用上层最优解作为初始猜测

lowerLevelProblem。Aineq = [];

lowerLevelProblem。bineq = [];

lowerLevelProblem。Aeq = [];

lowerLevelProblem。说真的= [];

lowerLevelProblem。磅= [];

lowerLevelProblem。乌兰巴托= [];

lowerLevelProblem。nonlcon = upperLevelConstr;

lowerLevelProblem。选择= optimoptions (“fmincon”,“显示”,“关闭”);

%解决低层次的问题

[sLowerOptimal, lowerOptimalCost] = fmincon (lowerLevelProblem);

%显示最优值和成本

disp(“上层优化解决方案:”);

disp ([s_1 =, num2str (sUpperOptimal (1))));

disp ([s_2 =, num2str (sUpperOptimal (2))));

disp([上层优化成本:,num2str (upperOptimalCost)]);

disp(“低水平最优解决方案:”);

disp ([s_1 =, num2str (sLowerOptimal (1))));

disp ([s_2 =, num2str (sLowerOptimal (2))));

disp([低水平最优成本:,num2str (lowerOptimalCost)]);

是,正确.........................؟؟؟؟؟؟؟؟؟؟؟吗

登录置评。

在回答这个问题。

答案(1)

Torsten 约3小时前

0
链接

直接链接到这个答案

//www.tatmou.com/matlabcentral/answers/1966224-min-f-s_1-s_2-1-25-s_1-2-0-4s_2-2-min-s_1-s_2-s_3-s_1-2-0-35s_2-2-2s_1-2-0-6s_2 answer_1238009

编辑:Torsten 约3小时前

我猜你想最大化,最小化目标函数。最小化的结果显然是在这两种情况下s_1 = s_2 = 0。

                              %定义上层目标函数
                             
                              upperLevelObj = @ (s) 1.25 * s (1) ^ 2 + 0.4 * s (2) ^ 2;
                             
                              %定义目标函数的较低水平
                             
                              lowerLevelObj = @ (s)(1) ^ 2 + 0.35 *年代(2)^ 2;
                             
                              %定义上层约束函数
                             
                              upperLevelConstr = @ (s)协议([2 * s (1) ^ 2 + 0.6 * s (2) ^ 2 - 5100000;
                             
                              5 * s (1) ^ 2 + 3 * s (2) ^ 2 - 14250000], []);
                             
                              %建立上层的优化问题
                             
                              目标= upperLevelObj;
                             
                              x0 = [0;0);%初始猜测(s_1、s_2)
                             
                              Aineq = [];
                             
                              bineq = [];
                             
                              Aeq = [];
                             
                              说真的= [];
                             
                              磅= (0,0);
                             
                              乌兰巴托= (Inf;正);
                             
                              nonlcon = upperLevelConstr;
                             
                              选择= optimoptions (“fmincon”,“显示”,“关闭”,“TolX”1 e-16“TolFun”1 e-16);
                             
                              %解决上层的问题
                             
                              [sUpperOptimal, upperOptimalCost] = fmincon(目标,x0, Aineq、bineq Aeq,说真的,磅,乌兰巴托,nonlcon,选项);
                             
                              %建立低水平的优化问题
                             
                              目标= lowerLevelObj;
                             
                              x0 = sUpperOptimal;%使用上层最优解作为初始猜测
                             
                              Aineq = [];
                             
                              bineq = [];
                             
                              Aeq = [];
                             
                              说真的= [];
                             
                              磅= (0,0);
                             
                              乌兰巴托= (Inf;正);
                             
                              nonlcon = upperLevelConstr;
                             
                              选择= optimoptions (“fmincon”,“显示”,“关闭”,“TolX”1 e-16“TolFun”1 e-16);
                             
                              %解决低层次的问题
                             
                              [sLowerOptimal, lowerOptimalCost] = fmincon(目标,x0, Aineq、bineq Aeq,说真的,磅,乌兰巴托,nonlcon,选项);
                             
                              %显示最优值和成本
                             
                              disp (“上层优化解决方案:);
                             
                                上层优化解决方案:

                              disp ([“s_1 = 'num2str (sUpperOptimal (1))));
                             
                                s_1 = 7.037 e-08

                              disp ([“s_2 = 'num2str (sUpperOptimal (2))));
                             
                                s_2 = 1.2715 e-07

                              disp ([“上层优化成本:”num2str (upperOptimalCost)]);
                             
                                e-14上层优化成本:1.2657

                              disp (“低水平”最优解:);
                             
                                低水平的最优解:

                              disp ([“s_1 = 'num2str (sLowerOptimal (1))));
                             
                                s_1 = 8.6229 e-08

                              disp ([“s_2 = 'num2str (sLowerOptimal (2))));
                             
                                s_2 = 1.4824 e-07

                              disp ([的低水平最优成本:num2str (lowerOptimalCost)]);
                             
                                低水平最优成本:1.5127 e-14