i want to add cplex and yalmip on my mac how ?

103 views (last 30 days)
Esraa Aziz
Esraa Aziz on 6 Dec 2025 at 12:19
Edited: Torsten on 8 Dec 2025 at 14:40
i want to add cplex and yalmip on my mac how ? i was use cplex on my windows matlab and i trasfered it to my mac and trying to set it up but it didn't < why ?? and what is the problem please ?
  3 Comments
Show 1 older comment
Dyuman Joshi
Dyuman Joshi on 6 Dec 2025 at 13:26
Edited: Dyuman Joshi on 6 Dec 2025 at 13:27
@dpb, No they are not TMW products.
YALMIP is a free MATLAB toolbox for solving (complex) optimization problems.
CPLEX is a similar toolbox (currently developed by IBM), however that is not specific to MATLAB.
@Esraa Aziz, you should contact their respective authors or refer to their websites, forums, How-tos, FAQs etc etc for resolving the problems related to installation.
If you have a problem related to programming utilizing these toolboxes in MATLAB, then we might be able to help.
"what is the problem please ?"
We don't know. How would we know?
Walter Roberson
Walter Roberson on 6 Dec 2025 at 22:59
@Esraa Aziz comments to @Dyuman Joshi
They are package solvers we can add them to matlab and solve some equations

Sign in to comment.

Sign in to answer this question.

Accepted Answer

John D'Errico
John D'Errico on 6 Dec 2025 at 14:43
Edited: John D'Errico on 6 Dec 2025 at 14:58
YALMIP is an external toolbox, written in MATLAB, so it could in theory be used by any MATLAB installation. However, it is probably a bad idea to just copy that code from a Windoze installation to a Mac one. Instead, you will want to download a fresh copy from the source.
https://yalmip.github.io/download/
This way, at least you get the most recent release. And YALMIP is free.
As for CPLEX, this is an IBM product.
https://www.ibm.com/products/ilog-cplex-optimization-studio/pricing
From my reading, you can get a Mac version, but you probably connot just move the one you have on your Windoze machine directly over. You will need to download a Mac specific version, as from what I can see, it uses compiled code specific to the machine you will be running on. As such, trying to just use the code from a Windoze machine will not work directly.
I'll let you worry about the CPLEX pricing, as I did not read very far, nor did you tell us what size problems you are trying to solve. It looks like the free version is limited in ability, mainly in terms of the size of problems it can solve.
  17 Comments
Show 15 older comments
Torsten
Torsten on 7 Dec 2025 at 18:51
@Walter Roberson
Thank you for your efforts to format the OP's comment and sorry for deleting it before you finished.
Walter Roberson
Walter Roberson on 7 Dec 2025 at 19:23
@Esraa Aziz commented to me
research programe has 3 wind prosumers and retaler they trade as peer to peer trading and i want to add electric vehicles als, until now without a lot of variables and the variables nomber is 17000 ,

Sign in to comment.

More Answers (1)

Torsten
Torsten about 14 hours ago
Edited: Torsten about 9 hours ago
Ran in:
This is the problem-based MATLAB code to set up your problem. I might have done some mistakes translating your constraints, but the main commands you have to use (optimproblem,optimvar,Constraints,Objective,solve) should now be obvious for you.
Interestingly, defining C15 and C16 together in one constraint vector does not work. Further, using C15 without C16 gives an infeasible or unbounded solution whereas C15 and C16 takes too long for MATLAB answers.
You will have to work on it (and include realistic arrays for P_gen).
As I just found, you can most probably keep your original YALMIP code and invoke INTLINPROG instead of CPLEX using "sdpsettings".
%% A cooperative Stackelberg game based energy management considering price discrimination and risk assessment
clc
clear
close all
prob = optimproblem('ObjectiveSense','maximize');
% Define decision variables
zeta=optimvar('zeta',1,3);%,sdpvar(1,3); % Vector for optimization
eta_1=optimvar('eta_1',10,1);%sdpvar(10,1); % Penalty for the first player
eta_2=optimvar('eta_2',10,1);%sdpvar(10,1); % Penalty for the second player
eta_3=optimvar('eta_3',10,1);%sdpvar(10,1); % Penalty for the third player
P_Ps_1=optimvar('P_Ps_1',10,24);%sdpvar(10,24); % Power sold by the first player
P_Ps_2=optimvar('P_Ps_2',10,24);%sdpvar(10,24); % Power sold by the second player
P_Ps_3=optimvar('P_Ps_3',10,24);%sdpvar(10,24); % Power sold by the third player
P_Pb_1=optimvar('P_Pb_1',10,24);%sdpvar(10,24); % Power bought by the first player
P_Pb_2=optimvar('P_Pb_2',10,24);%sdpvar(10,24); % Power bought by the second player
P_Pb_3=optimvar('P_Pb_3',10,24);%sdpvar(10,24); % Power bought by the third player
u_Ps=optimvar('u_Ps',3,24);%sdpvar(3,24); % Power sold vector
u_Pb=optimvar('u_Pb',3,24);%sdpvar(3,24); % Power bought vector
% Power trading variables for three entities (P_trading)
P_trading_1 = optimvar('P_trading_1',10,24);%sdpvar(10, 24);
P_trading_2 = optimvar('P_trading_2',10,24);%sdpvar(10, 24);
P_trading_3 = optimvar('P_trading_3',10,24);%sdpvar(10, 24);
% State of Charge variables for three entities (SOC)
SOC_1 = optimvar('SOC_1',10,24);%sdpvar(10, 24);
SOC_2 = optimvar('SOC_2',10,24);%sdpvar(10, 24);
SOC_3 = optimvar('SOC_3',10,24);%sdpvar(10, 24);
% Power for energy consumed (P_Ec) by three entities
P_Ec_1 = optimvar('P_Ec_1',10,24);%sdpvar(10, 24);
P_Ec_2 = optimvar('P_Ec_2',10,24);%sdpvar(10, 24);
P_Ec_3 = optimvar('P_Ec_3',10,24);%sdpvar(10, 24);
% Power for energy discharged (P_Ed) by three entities
P_Ed_1 = optimvar('P_Ed_1',10,24);%sdpvar(10, 24);
P_Ed_2 = optimvar('P_Ed_2',10,24);%sdpvar(10, 24);
P_Ed_3 = optimvar('P_Ed_3',10,24);%sdpvar(10, 24);
% Binary variables indicating the absolute value of power (Uabs) for three entities
Uabs_1 = optimvar('Uabs_1',10,24,'Type','integer','LowerBound',0,'UpperBound',1);%binvar(10, 24);
Uabs_2 = optimvar('Uabs_2',10,24,'Type','integer','LowerBound',0,'UpperBound',1);%binvar(10, 24);
Uabs_3 = optimvar('Uabs_3',10,24,'Type','integer','LowerBound',0,'UpperBound',1);%binvar(10, 24);
% Binary variables indicating the re-elasticity of power (Urelea) for three entities
Urelea_1 = optimvar('Urelea_1',10,24,'Type','integer','LowerBound',0,'UpperBound',1);%binvar(10, 24);
Urelea_2 = optimvar('Urelea_2',10,24,'Type','integer','LowerBound',0,'UpperBound',1);%binvar(10, 24);
Urelea_3 = optimvar('Urelea_3',10,24,'Type','integer','LowerBound',0,'UpperBound',1);%binvar(10, 24);
% Lagrange multiplier variables for production cost (lamda_pro) for three entities
lamda_pro_1 = optimvar('lamda_pro_1',10,24);%sdpvar(10, 24);
lamda_pro_2 = optimvar('lamda_pro_2',10,24);%sdpvar(10, 24);
lamda_pro_3 = optimvar('lamda_pro_3',10,24);%sdpvar(10, 24);
% Lagrange multiplier variable for power trading (lamda_trading)
lamda_trading = optimvar('lamda_trading',10,24);%sdpvar(10, 24);
% Lagrange multiplier variables for power balance (lamda_Pb) for three entities
lamda_Pb_1 = optimvar('lamda_Pb_1',10,24);%sdpvar(10, 24);
lamda_Pb_2 = optimvar('lamda_Pb_2',10,24);%sdpvar(10, 24);
lamda_Pb_3 = optimvar('lamda_Pb_3',10,24);%sdpvar(10, 24);
% Lagrange multiplier variables for power surplus (lamda_Ps) for three entities
lamda_Ps_1 = optimvar('lamda_Ps_1',10,24);%sdpvar(10, 24);
lamda_Ps_2 = optimvar('lamda_Ps_2',10,24);%sdpvar(10, 24);
lamda_Ps_3 = optimvar('lamda_Ps_3',10,24);%sdpvar(10, 24);
% Lagrange multiplier variables for energy consumed (lamda_Ec) by three entities
lamda_Ec_1 = optimvar('lamda_Ec_1',10,24);%sdpvar(10, 24);
lamda_Ec_2 = optimvar('lamda_Ec_2',10,24);%sdpvar(10, 24);
lamda_Ec_3 = optimvar('lamda_Ec_3',10,24);%sdpvar(10, 24);
% Lagrange multiplier variables for energy discharged (lamda_Ed) by three entities
lamda_Ed_1 = optimvar('lamda_Ed_1',10,24);%sdpvar(10, 24);
lamda_Ed_2 = optimvar('lamda_Ed_2',10,24);%sdpvar(10, 24);
lamda_Ed_3 = optimvar('lamda_Ed_3',10,24);%sdpvar(10, 24);
% Lagrange multiplier variables for minimum SOC constraint (lamda_SOCmin) for three entities
lamda_SOCmin_1 = optimvar('lamda_SOCmin_1',10,24);%sdpvar(10, 24);
lamda_SOCmin_2 = optimvar('lamda_SOCmin_2',10,24);%sdpvar(10, 24);
lamda_SOCmin_3 = optimvar('lamda_SOCmin_3',10,24);%sdpvar(10, 24);
% Lagrange multiplier variables for maximum SOC constraint (lamda_SOCmax) for three entities
lamda_SOCmax_1 = optimvar('lamda_SOCmax_1',10,24);%sdpvar(10, 24);
lamda_SOCmax_2 = optimvar('lamda_SOCmax_2',10,24);%sdpvar(10, 24);
lamda_SOCmax_3 = optimvar('lamda_SOCmax_3',10,24);%sdpvar(10, 24);
% Lagrange multiplier variables for SOC equality constraint (lamda_SOC1) for three entities
lamda_SOC1_1 = optimvar('lamda_SOC1_1',10,24);%sdpvar(10, 24);
lamda_SOC1_2 = optimvar('lamda_SOC1_2',10,24);%sdpvar(10, 24);
lamda_SOC1_3 = optimvar('lamda_SOC1_3',10,24);%sdpvar(10, 24);
% Lagrange multiplier variables for SOC equality constraint (lamda_SOC2) for three entities
lamda_SOC2_1 = optimvar('lamda_SOC2_1',10,24);%sdpvar(10, 1);
lamda_SOC2_2 = optimvar('lamda_SOC2_2',10,24);%sdpvar(10, 1);
lamda_SOC2_3 = optimvar('lamda_SOC2_3',10,24);%sdpvar(10, 1);
% Define constants and parameters
u_Db=1e3*[0.4,0.4,0.4,0.4,0.4,0.4,0.79,0.79,0.79,1.2,1.2,1.2,1.2,1.2,0.79,0.79,0.79,1.2,1.2,1.2,0.79,0.79,0.4,0.4];% Demand bids
u_Ds=1e3*[0.35,0.35,0.35,0.35,0.35,0.35,0.68,0.68,0.68,1.12,1.12,1.12,1.12,1.12,0.68,0.68,0.68,1.12,1.12,1.12,0.79,0.79,0.35,0.35];% Demand supply
% Calculate upper bound for power balance (u_Pbmax)
u_Pbmax=1e3*[0.7,0.7,0.7,0.7,0.7,0.7,1.1,1.1,1.1,1.5,1.5,1.5,1.5,1.5,1,1,1,1.5,1.5,1.5,1.1,1.1,0.7,0.7]; % Maximum buying price
% Calculate lower bound for power balance (u_Pbmin)
u_Pbmin = u_Pbmax - 0.5 * 1e3 * ones(1, 24);
% Set the upper bound for power surplus (u_Psmax) equal to the energy discharged (u_Ds) for each hour
u_Psmax = u_Ds;
% Calculate lower bound for power surplus (u_Psmin) as the upper bound (u_Psmax) minus 0.35*1e3 for each hour
u_Psmin = u_Psmax - 0.35 * 1e3 * ones(1, 24);
% Power consumption profiles for every Load in each hour
P_load_1=[6.62295082,5.770491803,5.442622951,5.31147541,5.37704918,5.573770492,6.295081967,6.491803279,7.213114754,7.803278689,8.131147541,8.131147541,7.93442623,7.278688525,7.016393443,7.016393443,7.147540984,8.262295082,9.442622951,9.37704918,9.37704918,7.93442623,6.819672131,5.901639344];
P_load_2=[3.344262295,3.016393443,2.754098361,2.754098361,2.754098361,2.885245902,3.147540984,3.344262295,3.639344262,3.93442623,4,4.131147541,4,3.737704918,3.475409836,3.606557377,3.606557377,4.131147541,4.721311475,4.655737705,4.721311475,4,3.409836066,3.016393443];
P_load_3=[11.60655738,10.16393443,9.442622951,9.245901639,9.114754098,9.639344262,10.75409836,11.3442623,12.45901639,13.50819672,14.10772834,14.16393443,13.63934426,12.72131148,12.19672131,12.32786885,12.59016393,14.29508197,16.59016393,16.45901639,16.26229508,13.7704918,12.13114754,10.55737705];
Sw=10;
%load P_Gen.mat
P_Gen_1 = zeros(10,24);
P_Gen_2 = zeros(10,24);
P_Gen_3 = zeros(10,24);
% Probability of occurrence for Load 1 events
pai_1 = 0.1 * ones(1, 10);
% Probability of occurrence for Load 2 events
pai_2 = 0.1 * ones(1, 10);
% Probability of occurrence for Load 3 events
pai_3 = 0.1 * ones(1, 10);
% Constants and parameters
C_E = 80; % Energy cost coefficient
P_Pbmax = 15; % Maximum power for the battery
P_Psmax = 15; % Maximum power for the supercapacitor
Cap = 10; % Capacity of the storage system
P_Ecmax = 3; % Maximum charging power for electric vehicles
P_Edmax = 3; % Maximum discharging power for electric vehicles
SOCmin = 0.2; % Minimum state of charge for the storage system
SOCmax = 0.85; % Maximum state of charge for the storage system
SOCini = 0.33; % Initial state of charge for the storage system
SOCexp = 0.85; % Expected state of charge for the storage system
beta = 0.1; % Weighting factor for the objective function
M = 1E8; % Large constant for big-M method
% Average power values
u_Ps_ave=0.85*1e3;
u_Pb_ave=1.20*1e3;
% Add constraints to the matrix
C1=[
u_Pbmin<=u_Pb(1,:),
u_Pb(1,:)<=u_Pbmax,
u_Pbmin<=u_Pb(2,:),
u_Pb(2,:)<=u_Pbmax,
u_Pbmin<=u_Pb(3,:),
u_Pb(3,:)<=u_Pbmax,
u_Psmin<=u_Ps(1,:),
u_Ps(1,:)<=u_Psmax ,
u_Psmin<=u_Ps(2,:),
u_Ps(2,:)<=u_Psmax,
u_Psmin<=u_Ps(3,:),
u_Ps(3,:)<=u_Psmax];
C2 = [
sum(u_Pb(1,:))/24<=u_Pb_ave,
sum(u_Pb(2,:))/24<=u_Pb_ave,
sum(u_Pb(3,:))/24<=u_Pb_ave,
sum(u_Ps(1,:))/24<=u_Ps_ave,
sum(u_Ps(2,:))/24<=u_Ps_ave,
sum(u_Ps(3,:))/24<=u_Ps_ave,
];
prob.Constraints.C1 = C1;
prob.Constraints.C2 = C2;
% Initialize bilinear equations
biliner_eq1=0;biliner_eq2=0;biliner_eq3=0;
% Loop through scenarios
for w=1:Sw
biliner_eq1=biliner_eq1+sum(lamda_pro_1(w,:).*(P_load_1(1,:)-P_Gen_1(w,:)))+sum(lamda_Pb_1(w,:)*P_Pbmax)+sum(lamda_Ps_1(w,:)*P_Psmax)+...
sum(lamda_Ec_1(w,:)*P_Ecmax)+sum(lamda_Ed_1(w,:)*P_Edmax)+sum(lamda_SOCmax_1(w,:)*SOCmax)+sum(lamda_SOCmin_1(w,:)*SOCmin);
biliner_eq2=biliner_eq2+sum(lamda_pro_2(w,:).*(P_load_2(1,:)-P_Gen_2(w,:)))+sum(lamda_Pb_2(w,:)*P_Pbmax)+sum(lamda_Ps_2(w,:)*P_Psmax)+...
sum(lamda_Ec_2(w,:)*P_Ecmax)+sum(lamda_Ed_2(w,:)*P_Edmax)+sum(lamda_SOCmax_2(w,:)*SOCmax)+sum(lamda_SOCmin_2(w,:)*SOCmin);
biliner_eq3=biliner_eq3+sum(lamda_pro_3(w,:).*(P_load_3(1,:)-P_Gen_3(w,:)))+sum(lamda_Pb_3(w,:)*P_Pbmax)+sum(lamda_Ps_3(w,:)*P_Psmax)+...
sum(lamda_Ec_3(w,:)*P_Ecmax)+sum(lamda_Ed_3(w,:)*P_Edmax)+sum(lamda_SOCmax_3(w,:)*SOCmax)+sum(lamda_SOCmin_3(w,:)*SOCmin);
end
% Constraints for each scenario w in the loop
C3 = [];
for w = 1:Sw
% Update constraint matrix with inequality constraints
C3 = [C3,
zeta(1) - (u_Ds * P_Ps_1(w,:)' - u_Db * P_Pb_1(w,:)' + biliner_eq1) <= eta_1(w),
zeta(2) - (u_Ds * P_Ps_2(w,:)' - u_Db * P_Pb_2(w,:)' + biliner_eq2) <= eta_2(w),
zeta(3) - (u_Ds * P_Ps_3(w,:)' - u_Db * P_Pb_3(w,:)' + biliner_eq3) <= eta_3(w),
0 <= eta_1(w),
0 <= eta_2(w),
0 <= eta_3(w)
];
end
prob.Constraints.C3 = C3;
% Constraints for each scenario w in the loop
C4 = [];
for w = 1:Sw
% Update constraint matrix with equality constraints
C4 = [C4,
P_Pb_1(w,:) + P_Gen_1(w,:) + P_Ed_1(w,:) + P_trading_1(w,:) == P_Ps_1(w,:) + P_load_1(1,:) + P_Ec_1(w,:),
P_Pb_2(w,:) + P_Gen_2(w,:) + P_Ed_2(w,:) + P_trading_2(w,:) == P_Ps_2(w,:) + P_load_2(1,:) + P_Ec_2(w,:),
P_Pb_3(w,:) + P_Gen_3(w,:) + P_Ed_3(w,:) + P_trading_3(w,:) == P_Ps_3(w,:) + P_load_3(1,:) + P_Ec_3(w,:)
];
end
prob.Constraints.C4 = C4;
% Maximum trading constraint
P_trading_max = 5.5;
C5 = [];
C6 = [];
for w = 1:Sw
for t=1:24
C5=[C5,
-P_trading_max<=P_trading_1(w,t),
P_trading_1(w,t)<=P_trading_max, %0503060907070303000307
-P_trading_max<=P_trading_2(w,t),
P_trading_2(w,t)<=P_trading_max,
-P_trading_max<=P_trading_3(w,t),
P_trading_3(w,t)<=P_trading_max,
];
C6=[C6,
P_trading_1(w,t)+P_trading_2(w,t)+P_trading_3(w,t)==0, %060206090807000505030609070003020102090900
];
end
end
prob.Constraints.C5 = C5;
prob.Constraints.C6 = C6;
% Constraints for power variables
C7 = [0 <= P_Pb_1(1:Sw,:),
P_Pb_1(1:Sw,:)<= P_Pbmax,
0 <= P_Pb_2(1:Sw,:),
P_Pb_2(1:Sw,:)<= P_Pbmax,
0 <= P_Pb_3(1:Sw,:),
P_Pb_3(1:Sw,:)<= P_Pbmax,
0 <= P_Ps_1(1:Sw,:),
P_Ps_1(1:Sw,:)<= P_Psmax,
0 <= P_Ps_2(1:Sw,:),
P_Ps_2(1:Sw,:)<= P_Psmax,
0 <= P_Ps_3(1:Sw,:),
P_Ps_3(1:Sw,:)<= P_Psmax,
0 <= P_Ec_1(1:Sw,:),
P_Ec_1(1:Sw,:)<= P_Ecmax,
0 <= P_Ec_2(1:Sw,:),
P_Ec_2(1:Sw,:)<= P_Ecmax,
0 <= P_Ec_3(1:Sw,:),
P_Ec_3(1:Sw,:)<= P_Ecmax,
0 <= P_Ed_1(1:Sw,:),
P_Ed_1(1:Sw,:)<= P_Edmax,
0 <= P_Ed_2(1:Sw,:),
P_Ed_2(1:Sw,:)<= P_Edmax,
0 <= P_Ed_3(1:Sw,:),
P_Ed_3(1:Sw,:)<= P_Edmax,
SOCmin <= SOC_1(1:Sw,:),
SOC_1(1:Sw,:)<= SOCmax,
SOCmin <= SOC_2(1:Sw,:),
SOC_2(1:Sw,:)<= SOCmax,
SOCmin <= SOC_2(1:Sw,:),
SOC_2(1:Sw,:)<= SOCmax];
prob.Constraints.C7 = C7;
C8 = [SOC_1(:,1)*Cap == (SOCini*Cap + (0.95*P_Ec_1(:,1) - 1/1.05*P_Ed_1(:,1))),
SOC_2(:,1)*Cap == (SOCini*Cap + (0.95*P_Ec_2(:,1) - 1/1.05*P_Ed_2(:,1))),
SOC_3(:,1)*Cap == (SOCini*Cap + (0.95*P_Ec_3(:,1) - 1/1.05*P_Ed_3(:,1))),
SOC_1(:,24) == SOCexp,
SOC_2(:,24) == SOCexp,
SOC_3(:,24) == SOCexp
];
prob.Constraints.C8 = C8;
% Loop for updating SOC for each time step from 2 to 24
C9 = [];
for t = 2:24
C9 = [C9,
SOC_1(:,t)*Cap == (SOC_1(:,t-1)*Cap + (0.95*P_Ec_1(:,t) - 1/1.05*P_Ed_1(:,t))),
SOC_2(:,t)*Cap == (SOC_2(:,t-1)*Cap + (0.95*P_Ec_2(:,t) - 1/1.05*P_Ed_2(:,t))),
SOC_3(:,t)*Cap == (SOC_3(:,t-1)*Cap + (0.95*P_Ec_3(:,t) - 1/1.05*P_Ed_3(:,t)))
];
end
prob.Constraints.C9 = C9;
% Constraints for charging and discharging variables
C10 = [];
for t = 1:24
C10 = [C10,
0 <= P_Ec_1(:,t),
P_Ec_1(:,t)<= P_Ecmax,
0 <= P_Ec_1(:,t),
P_Ec_1(:,t)<= Uabs_1(:,t)*M,
0 <= P_Ed_1(:,t),
P_Ed_1(:,t)<= P_Edmax,
0 <= P_Ed_1(:,t),
P_Ed_1(:,t)<= Urelea_1(:,t)*M,
Uabs_1(:,t) + Urelea_1(:,t) <= 1,
0 <= P_Ec_2(:,t),
P_Ec_2(:,t)<= P_Ecmax,
0 <= P_Ec_2(:,t),
P_Ec_2(:,t)<= Uabs_2(:,t)*M,
0 <= P_Ed_2(:,t),
P_Ed_2(:,t)<= P_Edmax,
0 <= P_Ed_2(:,t),
P_Ed_2(:,t)<= Urelea_2(:,t)*M,
Uabs_2(:,t) + Urelea_2(:,t) <= 1,
0 <= P_Ec_3(:,t),
P_Ec_3(:,t)<= P_Ecmax,
0 <= P_Ec_3(:,t),
P_Ec_3(:,t)<= Uabs_3(:,t)*M,
0 <= P_Ed_3(:,t),
P_Ed_3(:,t)<= P_Edmax,
0 <= P_Ed_3(:,t),
P_Ed_3(:,t)<= Urelea_3(:,t)*M,
Uabs_3(:,t) + Urelea_3(:,t) <= 1
];
end
prob.Constraints.C10 = C10;
% Constraints for Lagrange multipliers for power balance and state-of-charge
C11 = [];
C12 = [];
C13 = [];
for w = 1:Sw
C11=[C11,
lamda_pro_1(w,:)+lamda_Pb_1(w,:)<=u_Pb(1,:), %0100080527
lamda_pro_2(w,:)+lamda_Pb_2(w,:)<=u_Pb(2,:),
lamda_pro_3(w,:)+lamda_Pb_3(w,:)<=u_Pb(3,:),
-lamda_pro_1(w,:)+lamda_Ps_1(w,:)<=-u_Ps(1,:), %0100080528
-lamda_pro_2(w,:)+lamda_Ps_2(w,:)<=-u_Ps(2,:),
-lamda_pro_3(w,:)+lamda_Ps_3(w,:)<=-u_Ps(3,:),
-lamda_pro_1(w,:)+lamda_Ec_1(w,:)-0.95*lamda_SOC1_1(w,:)<=C_E*ones(1,24), %0100080530
-lamda_pro_2(w,:)+lamda_Ec_2(w,:)-0.95*lamda_SOC1_2(w,:)<=C_E*ones(1,24),
-lamda_pro_3(w,:)+lamda_Ec_3(w,:)-0.95*lamda_SOC1_3(w,:)<=C_E*ones(1,24),
lamda_pro_1(w,:)+lamda_Ed_1(w,:)+1/1.05*lamda_SOC1_1(w,:)<=C_E*ones(1,24), %0100080531
lamda_pro_2(w,:)+lamda_Ed_2(w,:)+1/1.05*lamda_SOC1_2(w,:)<=C_E*ones(1,24),
lamda_pro_3(w,:)+lamda_Ed_3(w,:)+1/1.05*lamda_SOC1_3(w,:)<=C_E*ones(1,24),
];
C12 = [C12,
lamda_pro_1(w,:)+lamda_trading(w,:)==0, %0100080529
lamda_pro_2(w,:)+lamda_trading(w,:)==0,
lamda_pro_3(w,:)+lamda_trading(w,:)==0,
];
C13 = [C13,
lamda_SOCmax_1(w,24)+lamda_SOCmin_1(w,24)+Cap*lamda_SOC1_1(w,24)+lamda_SOC2_1(w)==0, %0100080533
lamda_SOCmax_2(w,24)+lamda_SOCmin_2(w,24)+Cap*lamda_SOC1_2(w,24)+lamda_SOC2_2(w)==0, %0100080533
lamda_SOCmax_3(w,24)+lamda_SOCmin_3(w,24)+Cap*lamda_SOC1_3(w,24)+lamda_SOC2_3(w)==0, %0100080533
];
end
prob.Constraints.C11 = C11;
prob.Constraints.C12 = C12;
prob.Constraints.C13 = C13;
% Loop for updating SOC constraints from time step 1 to 23
C14=[];
for w = 1:Sw
for t = 1:23
C14 = [C14,
lamda_SOCmax_1(w,t) + lamda_SOCmin_1(w,t) + Cap*lamda_SOC1_1(w,t) - Cap*lamda_SOC1_1(w,t+1) == 0,
lamda_SOCmax_2(w,t) + lamda_SOCmin_2(w,t) + Cap*lamda_SOC1_2(w,t) - Cap*lamda_SOC1_2(w,t+1) == 0,
lamda_SOCmax_3(w,t) + lamda_SOCmin_3(w,t) + Cap*lamda_SOC1_3(w,t) - Cap*lamda_SOC1_3(w,t+1) == 0,
];
end
end
prob.Constraints.C14 = C14;
% Binary variables representing decisions for each time step and scenario
v34_1=optimvar('v34_1',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v34_2=optimvar('v34_2',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v34_3=optimvar('v34_3',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v35_1=optimvar('v35_1',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v35_2=optimvar('v35_2',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v35_3=optimvar('v35_3',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v36_1=optimvar('v36_1',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v36_2=optimvar('v36_2',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v36_3=optimvar('v36_3',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v37_1=optimvar('v37_1',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v37_2=optimvar('v37_2',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v37_3=optimvar('v37_3',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v38_1=optimvar('v38_1',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v38_2=optimvar('v38_2',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v38_3=optimvar('v38_3',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v39_1=optimvar('v39_1',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v39_2=optimvar('v39_2',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v39_3=optimvar('v39_3',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v40_1=optimvar('v40_1',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v40_2=optimvar('v40_2',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v40_3=optimvar('v40_3',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v41_1=optimvar('v41_1',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v41_2=optimvar('v41_2',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v41_3=optimvar('v41_3',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v42_1=optimvar('v42_1',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v42_2=optimvar('v42_2',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v42_3=optimvar('v42_3',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v43_1=optimvar('v43_1',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v43_2=optimvar('v43_2',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
v43_3=optimvar('v43_3',Sw,24,'Type','integer','LowerBound',0,'UpperBound',1);
%v34_1=binvar(Sw,24);v34_2=binvar(Sw,24);v34_3=binvar(Sw,24);
%v35_1=binvar(Sw,24);v35_2=binvar(Sw,24);v35_3=binvar(Sw,24);
%v36_1=binvar(Sw,24);v36_2=binvar(Sw,24);v36_3=binvar(Sw,24);
%v37_1=binvar(Sw,24);v37_2=binvar(Sw,24);v37_3=binvar(Sw,24);
%v38_1=binvar(Sw,24);v38_2=binvar(Sw,24);v38_3=binvar(Sw,24);
%v39_1=binvar(Sw,24);v39_2=binvar(Sw,24);v39_3=binvar(Sw,24);
%v40_1=binvar(Sw,24);v40_2=binvar(Sw,24);v40_3=binvar(Sw,24);
%v41_1=binvar(Sw,24);v41_2=binvar(Sw,24);v41_3=binvar(Sw,24);
%v42_1=binvar(Sw,24);v42_2=binvar(Sw,24);v42_3=binvar(Sw,24);
%v43_1=binvar(Sw,24);v43_2=binvar(Sw,24);v43_3=binvar(Sw,24);
% Binary variables indicating on/off status of various components
C15=[];
C16=[];
for w=1:Sw
for t=1:24
C15=[C15,
0>=lamda_Pb_1(w,t),
lamda_Pb_1(w,t)>=-M*v34_1(w,t),
0>=P_Pb_1(w,t)-P_Pbmax,
P_Pb_1(w,t)-P_Pbmax>=-M*(1-v34_1(w,t)),
0>=lamda_Pb_2(w,t),
lamda_Pb_2(w,t)>=-M*v34_2(w,t),
0>=P_Pb_2(w,t)-P_Pbmax,
P_Pb_2(w,t)-P_Pbmax>=-M*(1-v34_2(w,t)),
0>=lamda_Pb_3(w,t),
lamda_Pb_3(w,t)>=-M*v34_3(w,t),
0>=P_Pb_3(w,t)-P_Pbmax,
P_Pb_3(w,t)-P_Pbmax>=-M*(1-v34_3(w,t)),
0>=lamda_Ps_1(w,t),
lamda_Ps_1(w,t)>=-M*v35_1(w,t),
0>=P_Ps_1(w,t)-P_Psmax,
P_Ps_1(w,t)-P_Psmax>=-M*(1-v35_1(w,t)),
0>=lamda_Ps_2(w,t),
lamda_Ps_2(w,t)>=-M*v35_2(w,t),
0>=P_Ps_2(w,t)-P_Psmax,
P_Ps_2(w,t)-P_Psmax>=-M*(1-v35_2(w,t)),
0>=lamda_Ps_3(w,t),
lamda_Ps_3(w,t)>=-M*v35_3(w,t),
0>=P_Ps_3(w,t)-P_Psmax,
P_Ps_3(w,t)-P_Psmax>=-M*(1-v35_3(w,t)),
0>=lamda_Ec_1(w,t),
lamda_Ec_1(w,t)>=-M*v36_1(w,t),
0>=P_Ec_1(w,t)-P_Ecmax,
P_Ec_1(w,t)-P_Ecmax>=-M*(1-v36_1(w,t)),
0>=lamda_Ec_2(w,t),
lamda_Ec_2(w,t)>=-M*v36_2(w,t),
0>=P_Ec_2(w,t)-P_Ecmax,
P_Ec_2(w,t)-P_Ecmax>=-M*(1-v36_2(w,t)),
0>=lamda_Ec_3(w,t),
lamda_Ec_3(w,t)>=-M*v36_3(w,t),
0>=P_Ec_3(w,t)-P_Ecmax,
P_Ec_3(w,t)-P_Ecmax>=-M*(1-v36_3(w,t)),
0>=lamda_Ed_1(w,t),
lamda_Ed_1(w,t)>=-M*v37_1(w,t),
0>=P_Ed_1(w,t)-P_Edmax,
P_Ed_1(w,t)-P_Edmax>=-M*(1-v37_1(w,t)),
0>=lamda_Ed_2(w,t),
lamda_Ed_2(w,t)>=-M*v37_2(w,t),
0>=P_Ed_2(w,t)-P_Edmax,
P_Ed_2(w,t)-P_Edmax>=-M*(1-v37_2(w,t)),
0>=lamda_Ed_3(w,t),
lamda_Ed_3(w,t)>=-M*v37_3(w,t),
0>=P_Ed_3(w,t)-P_Edmax,
P_Ed_3(w,t)-P_Edmax>=-M*(1-v37_3(w,t)),
0>=lamda_SOCmax_1(w,t),
lamda_SOCmax_1(w,t)>=-M*v38_1(w,t),
0>=SOC_1(w,t)-SOCmax,
SOC_1(w,t)-SOCmax>=-M*(1-v38_1(w,t)),
0>=lamda_SOCmax_2(w,t),
lamda_SOCmax_2(w,t)>=-M*v38_2(w,t),
0>=SOC_2(w,t)-SOCmax,
SOC_2(w,t)-SOCmax>=-M*(1-v38_2(w,t)),
0>=lamda_SOCmax_3(w,t),
lamda_SOCmax_3(w,t)>=-M*v38_3(w,t),
0>=SOC_3(w,t)-SOCmax,
SOC_3(w,t)-SOCmax>=-M*(1-v38_3(w,t)),
];
C16=[C16,
0<=lamda_SOCmin_1(w,t),
lamda_SOCmin_1(w,t)<=M*v39_1(w,t),
0<=SOC_1(w,t)-SOCmin,
SOC_1(w,t)-SOCmin<=M*(1-v39_1(w,t)),
0<=lamda_SOCmin_2(w,t),
lamda_SOCmin_2(w,t)<=M*v39_2(w,t),
0<=SOC_2(w,t)-SOCmin,
SOC_2(w,t)-SOCmin<=M*(1-v39_2(w,t)),
0<=lamda_SOCmin_3(w,t),
lamda_SOCmin_3(w,t)<=M*v39_3(w,t),
0<=SOC_3(w,t)-SOCmin,
SOC_3(w,t)-SOCmin<=M*(1-v39_3(w,t)),
0<=P_Pb_1(w,t),
P_Pb_1(w,t)<=M*v40_1(w,t),
0<=u_Pb(1,t)-lamda_pro_1(w,t)-lamda_Pb_1(w,t),
u_Pb(1,t)-lamda_pro_1(w,t)-lamda_Pb_1(w,t)<=M*(1-v40_1(w,t)),
0<=P_Pb_2(w,t),
P_Pb_2(w,t)<=M*v40_2(w,t),
0<=u_Pb(2,t)-lamda_pro_2(w,t)-lamda_Pb_2(w,t),
u_Pb(2,t)-lamda_pro_2(w,t)-lamda_Pb_2(w,t)<=M*(1-v40_2(w,t)),
0<=P_Pb_3(w,t),
P_Pb_3(w,t)<=M*v40_3(w,t),
0<=u_Pb(3,t)-lamda_pro_3(w,t)-lamda_Pb_3(w,t),
u_Pb(3,t)-lamda_pro_3(w,t)-lamda_Pb_3(w,t)<=M*(1-v40_3(w,t)),
0<=P_Ps_1(w,t),
P_Ps_1(w,t)<=M*v41_1(w,t),
0<=-u_Ps(1,t)+lamda_pro_1(w,t)-lamda_Ps_1(w,t),
-u_Ps(1,t)+lamda_pro_1(w,t)-lamda_Ps_1(w,t)<=M*(1-v41_1(w,t)),
0<=P_Ps_2(w,t),
P_Ps_2(w,t)<=M*v41_2(w,t),
0<=-u_Ps(2,t)+lamda_pro_2(w,t)-lamda_Ps_2(w,t),
-u_Ps(2,t)+lamda_pro_2(w,t)-lamda_Ps_2(w,t)<=M*(1-v41_2(w,t)),
0<=P_Ps_3(w,t),
P_Ps_3(w,t)<=M*v41_3(w,t),
0<=-u_Ps(3,t)+lamda_pro_3(w,t)-lamda_Ps_3(w,t),
-u_Ps(3,t)+lamda_pro_3(w,t)-lamda_Ps_3(w,t)<=M*(1-v41_3(w,t)),
0<=P_Ec_1(w,t),
P_Ec_1(w,t)<=M*v42_1(w,t),
0<=C_E+lamda_pro_1(w,t)-lamda_Ec_1(w,t)+0.95*lamda_SOC1_1(w,t),
C_E+lamda_pro_1(w,t)-lamda_Ec_1(w,t)+0.95*lamda_SOC1_1(w,t)<=M*(1-v42_1(w,t)),
0<=P_Ec_2(w,t),
P_Ec_2(w,t)<=M*v42_2(w,t),
0<=C_E+lamda_pro_2(w,t)-lamda_Ec_2(w,t)+0.95*lamda_SOC1_2(w,t),
C_E+lamda_pro_2(w,t)-lamda_Ec_2(w,t)+0.95*lamda_SOC1_2(w,t)<=M*(1-v42_2(w,t)),
0<=P_Ec_3(w,t),
P_Ec_3(w,t)<=M*v42_3(w,t),
0<=C_E+lamda_pro_3(w,t)-lamda_Ec_3(w,t)+0.95*lamda_SOC1_3(w,t),
C_E+lamda_pro_3(w,t)-lamda_Ec_3(w,t)+0.95*lamda_SOC1_3(w,t)<=M*(1-v42_3(w,t)),
0<=P_Ed_1(w,t),
P_Ed_1(w,t)<=M*v43_1(w,t),
0<=C_E-lamda_pro_1(w,t)-lamda_Ed_1(w,t)-1/1.05*lamda_SOC1_1(w,t),
C_E-lamda_pro_1(w,t)-lamda_Ed_1(w,t)-1/1.05*lamda_SOC1_1(w,t)<=M*(1-v43_1(w,t)),
0<=P_Ed_2(w,t),
P_Ed_2(w,t)<=M*v43_2(w,t),
0<=C_E-lamda_pro_2(w,t)-lamda_Ed_2(w,t)-1/1.05*lamda_SOC1_2(w,t),
C_E-lamda_pro_2(w,t)-lamda_Ed_2(w,t)-1/1.05*lamda_SOC1_2(w,t)<=M*(1-v43_2(w,t)),
0<=P_Ed_3(w,t),
P_Ed_3(w,t)<=M*v43_3(w,t),
0<=C_E-lamda_pro_3(w,t)-lamda_Ed_3(w,t)-1/1.05*lamda_SOC1_3(w,t),
C_E-lamda_pro_3(w,t)-lamda_Ed_3(w,t)-1/1.05*lamda_SOC1_3(w,t)<=M*(1-v43_3(w,t)),
];
end
end
prob.Constraints.C15 = C15;
%prob.Constraints.C16 = C16;
% Initialize the single-objective function value
obj_single = 0;
for w = 1:Sw
obj_single=obj_single+...
pai_1(w)*(u_Ds*P_Ps_1(w,:)'-u_Db*P_Pb_1(w,:)'-C_E*sum(P_Ec_1(w,:)+P_Ed_1(w,:))+sum(lamda_pro_1(w,:).*(P_load_1(1,:)-P_Gen_1(w,:)))+...
sum(lamda_Pb_1(w,:)*P_Pbmax)+sum(lamda_Ps_1(w,:)*P_Psmax)+sum(lamda_Ec_1(w,:)*P_Ecmax)+sum(lamda_Ed_1(w,:)*P_Edmax)+...
sum(lamda_SOCmax_1(w,:)*SOCmax)+sum(lamda_SOCmin_1(w,:)*SOCmin))+...
pai_2(w)*(u_Ds*P_Ps_2(w,:)'-u_Db*P_Pb_2(w,:)'-C_E*sum(P_Ec_2(w,:)+P_Ed_2(w,:))+sum(lamda_pro_2(w,:).*(P_load_2(1,:)-P_Gen_2(w,:)))+...
sum(lamda_Pb_2(w,:)*P_Pbmax)+sum(lamda_Ps_2(w,:)*P_Psmax)+sum(lamda_Ec_2(w,:)*P_Ecmax)+sum(lamda_Ed_2(w,:)*P_Edmax)+...
sum(lamda_SOCmax_2(w,:)*SOCmax)+sum(lamda_SOCmin_2(w,:)*SOCmin))+...
pai_3(w)*(u_Ds*P_Ps_3(w,:)'-u_Db*P_Pb_3(w,:)'-C_E*sum(P_Ec_3(w,:)+P_Ed_3(w,:))+sum(lamda_pro_3(w,:).*(P_load_3(1,:)-P_Gen_3(w,:)))+...
sum(lamda_Pb_3(w,:)*P_Pbmax)+sum(lamda_Ps_3(w,:)*P_Psmax)+sum(lamda_Ec_3(w,:)*P_Ecmax)+sum(lamda_Ed_3(w,:)*P_Edmax)+...
sum(lamda_SOCmax_3(w,:)*SOCmax)+sum(lamda_SOCmin_3(w,:)*SOCmin));
end
% Add the risk dispatching cost to the objective function
obj_single=obj_single+beta*(zeta(1)-pai_1*eta_1/(1-0.95))+beta*(zeta(2)-pai_2*eta_2/(1-0.95))+beta*(zeta(3)-pai_3*eta_3/(1-0.95));%
% Define optimization settings
%ops=sdpsettings('solver','cplex','verbose',2,'usex0',0);
%ops.cplex.mip.tolerances.mipgap=0.1;
% Optimize the objective function with the defined constraints
prob.Objective = obj_single;
result = solve(prob)
Solving problem using intlinprog. Running HiGHS 1.7.1: Copyright (c) 2024 HiGHS under MIT licence terms Coefficient ranges: Matrix [4e-02, 1e+08] Cost [2e-02, 1e+02] Bound [1e+00, 1e+00] RHS [2e-01, 1e+08] Presolving model Presolve: Primal infeasible or unbounded Solving report Status Primal infeasible or unbounded Primal bound -inf Dual bound inf Gap 0% (tolerance: 0.01%) Solution status - Timing 0.03 (total) 0.02 (presolve) 0.00 (postsolve) Nodes 0 LP iterations 0 (total) 0 (strong br.) 0 (separation) 0 (heuristics) Root LP problem is unbounded. Intlinprog stopped because the root LP problem is unbounded.
result = struct with fields:
P_Ec_1: [] P_Ec_2: [] P_Ec_3: [] P_Ed_1: [] P_Ed_2: [] P_Ed_3: [] P_Pb_1: [] P_Pb_2: [] P_Pb_3: [] P_Ps_1: [] P_Ps_2: [] P_Ps_3: [] P_trading_1: [] P_trading_2: [] P_trading_3: [] SOC_1: [] SOC_2: [] SOC_3: [] Uabs_1: [] Uabs_2: [] Uabs_3: [] Urelea_1: [] Urelea_2: [] Urelea_3: [] eta_1: [] eta_2: [] eta_3: [] lamda_Ec_1: [] lamda_Ec_2: [] lamda_Ec_3: [] lamda_Ed_1: [] lamda_Ed_2: [] lamda_Ed_3: [] lamda_Pb_1: [] lamda_Pb_2: [] lamda_Pb_3: [] lamda_Ps_1: [] lamda_Ps_2: [] lamda_Ps_3: [] lamda_SOC1_1: [] lamda_SOC1_2: [] lamda_SOC1_3: [] lamda_SOC2_1: [] lamda_SOC2_2: [] lamda_SOC2_3: [] lamda_SOCmax_1: [] lamda_SOCmax_2: [] lamda_SOCmax_3: [] lamda_SOCmin_1: [] lamda_SOCmin_2: [] lamda_SOCmin_3: [] lamda_pro_1: [] lamda_pro_2: [] lamda_pro_3: [] lamda_trading: [] u_Pb: [] u_Ps: [] v34_1: [] v34_2: [] v34_3: [] v35_1: [] v35_2: [] v35_3: [] v36_1: [] v36_2: [] v36_3: [] v37_1: [] v37_2: [] v37_3: [] v38_1: [] v38_2: [] v38_3: [] zeta: []
%result=optimize(C,-obj_single,ops);
  3 Comments
Show 1 older comment
Walter Roberson
Walter Roberson about 12 hours ago
@Esraa Aziz
When you use optimvar() and so on, you construct optimization expressions. solve() then analyzes the optimization expressions and determines that it should use intlinprog internally.
Torsten
Torsten about 4 hours ago
Edited: Torsten 26 minutes ago
@Esraa Aziz
As said, you could first try your code (with YALMIP) and invoke INTLINPROG instead of CPLEX using the "sdpsettings".
If you use the code from above, instead of many explicitly written constraints, you should use bound constraints on the variables for better readability. E.g.
u_Ps=optimvar('u_Ps',3,24);%sdpvar(3,24); % Power sold vector
u_Pb=optimvar('u_Pb',3,24);%sdpvar(3,24); % Power bought vector
C1=[
u_Pbmin<=u_Pb(1,:),
u_Pb(1,:)<=u_Pbmax,
u_Pbmin<=u_Pb(2,:),
u_Pb(2,:)<=u_Pbmax,
u_Pbmin<=u_Pb(3,:),
u_Pb(3,:)<=u_Pbmax,
u_Psmin<=u_Ps(1,:),
u_Ps(1,:)<=u_Psmax ,
u_Psmin<=u_Ps(2,:),
u_Ps(2,:)<=u_Psmax,
u_Psmin<=u_Ps(3,:),
u_Ps(3,:)<=u_Psmax];
should be replaced by
u_Ps=optimvar('u_Ps',3,24,'LowerBound',[u_Psmin;u_Psmin;u_Psmin],'UpperBound',[u_Psmax;u_Psmax;u_Psmax]);%sdpvar(3,24); % Power sold vector
u_Pb=optimvar('u_Pb',3,24,'LowerBound',[u_Pbmin;u_Pbmin;u_Pbmin],'UpperBound',[u_Pbmax;u_Pbmax;u_Pbmax]);%sdpvar(3,24); % Power bought vector
Further
SOCmin <= SOC_1(1:Sw,:) <= SOCmax,
SOCmin <= SOC_2(1:Sw,:) <= SOCmax,
SOCmin <= SOC_2(1:Sw,:) <= SOCmax
in your code should read
SOCmin <= SOC_1(1:Sw,:) <= SOCmax,
SOCmin <= SOC_2(1:Sw,:) <= SOCmax,
SOCmin <= SOC_3(1:Sw,:) <= SOCmax
I guess.
You will have to correct this in the code I gave you, too.

Sign in to comment.

Categories

Find more on Quadratic Programming and Cone Programming in Help Center and File Exchange

Tags

Community Treasure Hunt

Find the treasures in MATLAB Central and discover how the community can help you!

Start Hunting!