how can i fix subscript indices must be either real positive integers or logicals

I am new to matlab and i am tring to do multi objective optimization using gamultiobj , i have multi functions but when i try to run each function it says "Not enough input argument " plus when i try to run the main fun it says subscript indices must be either real positive integer or logicals" i have attached all of my functions!

[KSSV]

You cannot staright away run the function, you need to input the varibles it wants and then call it. So the error "Not enough input argument " is legit.

[KSSV]

Specify the line number where you are getting the error: subscript indices must be either real positive integer or logicals

[Walter Roberson]

disp('Total Function Count:'+gaoutput1.funccount);

When you use that code, it takes the number in funccount and it adds it (numerically) to the character codes for every element of the vector 'Total Function Count:' --- which is, recall, the vector ['T' 'o' 't' 'a' 'l' and so on]

If you instead were to use

disp("Total Function Count:"+gaoutput1.funccount);

then the outputcome would be completely different. The + operator for string() objects (such as those created with double-quotes) is the "append" operator, and a number as the other operand will be automatically converted to character representation before the appending.

[metasebia dabi]

When I try to use

disp("Total Function Count:"+gaoutput1.funccount); It will make " red and tell me it is invalid characteristics

[Walter Roberson]

@metasebia dabi

Then you are using R2015b or earlier, and should have mentioned that. You should switch to using fprintf()

fprintf('Total Function Count: %d\n', gaoutput1.funccount);

When someone says that they are new to MATLAB, we do not expect them to be using a version that is 5 years old.

Answer 1

[Walter Roberson]

At a location approximately half way through the third line, you have

(x(60^3*(x(1) - x(2)))/6

You might possibly have intended something like (x(6)^3*(x(1)-x(2)))/6 . But watch out for just replacing the 0 with a ) -- you would have had to add an extra ) to get the ) to balance and there is no telling where you added it.

You appear to have used some kind of code generation to generate your code from a symbolic expression. I can tell that you did not use matlabFunction() just by itself -- but it is possible that you used matlabFunction() and then hand-editted pieces together.

I recommend that you go back to the code generation and tell it to optimize. Not so much that you want the optimization (though that would not hurt), but rather that you want the expressions to be split into multiple lines for readability.

And when you create the symbolic expressions that you are going to do code generation for, you should wrap every numeric constant with a sym() call, except that you can leave powers alone. Seeing numbers such as

(19515681011313314790985107421875*x(5))/73786976294838206464 in your code makes it clear that you just let it convert floating point constants to whatever was most convenient... that divisor is 2^66 exactly.

So for example,

syms t
c = 2.99792458e8
arfreq = 0.000000488;
obj = arfreq/c*t

you would instead do something like

syms t
Q = @(v) sym(v);
c = Q(299792458);
arfreq = Q(488)/sym(10)^9;    %avoid floating point
obj = arfreq/c*t

In this case the pure numeric constants would lead to generating 2304514843640387*t/4722366482869645213696 but the more careful constants would lead to 61*t/37474057250000000 . Which is still a bit "funny money", magic constants with no obvious meaning to look at them, but they would be a lot more comprehendable, without the problems like 0.000000488 being converted to 2304514843640387/4722366482869645213696

[metasebia dabi]

THANK u it was very help full it was the line 3 obj.m function

[metasebia dabi]

THE other thing is can u help me with how can i simiplify the numeric form ? IT is a long equation!

[Walter Roberson]

Go back to the expressions and wrap all of the numeric constants with sym()

Better yet, when you have floating point numbers such as 0.5831 express them as sym() of an integer divided by 10 to a power, such as sym(5831)/10000 .

And when you use matlabFunction() to generate the code, tell it to write to a file, and tell it to turn on optimization.

Unless, that is, you are using R2019b or R2020a... matlabFunction optimize option is broken for those releases.

[metasebia dabi]

Ok.thank u so much!!

[metasebia dabi]

Again after fixing (x(60^3*(x(1) - x(2)))/6 it again says the subscript indices must be either real positive integer or logicals!

[Walter Roberson]

S = fileread('objval.m');
unique(regexp(S, 'x\(.*?\)', 'match'))

Now look for an output that is not x(NUMBER)

[metasebia dabi]

thank you and sir i have another issue no i have result in the pareto front but the result is a single point where could be my mistek?

[Walter Roberson]

Sometimes there is only a single global minima. Sometimes the local minima are just hard to find.

[metasebia dabi]

so.... is there any way to fix this?

[metasebia dabi]

so should i diduct the variable ..... what is the solution to get real pareto front solution

[Walter Roberson]

What is your current code?

[rakeb yonas]

greetings Walter

i am Metasebia

this is my current code

pls help me with this!

[metasebia dabi]

Greetings Sir i have attached the code by another account!

please help me with this problem!

[Walter Roberson]

You have 250 lines of nonlinear constraints, and you have a linear equality constraint (and a linear inequality constraint too.)

It looks like it is struggling a lot just to find any points that satisfy the constraints.

[metasebia dabi]

so should i decrease the constraints ???

[Walter Roberson]

In over 60000 function calls, it is able to get objective #2 to 0, but the lowest it can get for objective #1 is about 2.84E+14 . It is not able to satisfy the constraints even once.

Checking in more detail, it is not possible to satisfy the nonlinear constraints. You define

fc=50000000;

fc is a large positive constant

B1=0.85-((0.05).*(fc-28)./7);

small positive constant multiplied by roughly 1% of a large positive constant, gives a large negative value

and you have the constraint

0.65-B1

small positive constant minus large negative constant gives large positive constant. But inequality constraints must be negative to be satisfied.

This constraint is independent of the inputs, and therefore should not be used.

I am also having trouble with the constraint

1-Mn./Mr;

but that is going to take more investigation to determine whether there is any chance of satisfying the constraint. So far it has never been satisfied over a million random locations.

[Metasebia Gelan]

i only perform the optimization for some constrantes and fix the things that you said but still there is an error saying

Error using matlab.graphics.chart.primitive.Line/set

Complex values are not supported.

Error in gaplotpareto>plotFirstFront (line 84)

set(plotHandle,'Xdata',xy(:,1), 'Ydata',xy(:,2));

Error in gaplotpareto (line 28)

plotFirstFront(state.Score(range,:),state.Rank(range),markers{1 +

mod(i,5)},objectivesToPlot(:)',flag,tag);

Error in gadsplot>callOnePlotFcn (line 222)

optimvalues = plotfcn(varargin{1:end});

Error in gadsplot (line 169)

[state,optimvalues] =

callOnePlotFcn(fname,plotNames{i},state,options.OutputPlotFcnOptions,optimvalues,flag,args{i}{:});

Error in gamultiobjsolve (line 115)

gadsplot(options,state,currentState,'Genetic Algorithm');

Error in gamultiobj (line 303)

[x,fval,exitFlag,output,population,scores] = gamultiobjsolve(FitnessFcn,nvars, ...

[Metasebia Gelan]

greetings walter

i have attached my current code to!!

best regards

metasebia

[Walter Roberson]

You did not fix the B1 problem. Your constraints cannot be met.

I have attached a cleaned up version of nonlcon.m . You should save your current version and rename this one to nonlcon.m . It would be easier on me if you could develop using this modified version instead of what you have been using.

This version is vectorized -- it can take an N x 8 array of sample points and calculate all the nonlinear constraints for them simultaneously. This makes it much easier to explore to see if there are any points that can satisfy the constraints. With the previous code, I sampled over 1 million points in the bounds.

This version also builds up the final constraint array in pieces, such as

cin1 = abs(sqrt(M./(0.27.*W.*fc)))-x(:,1);
cin2 = ftop-fa;
cin3 = C-x(:,2);
[...]
Cineq=[cin1, cin2, cin3, cin4, cin5, cin6, cin7, cin8, cin9, cin10, cin11, cin12, cin13, cin14, cin15, cin16, cin17, cin18, cin19];

This makes it easier to debug problems with mismatched variable sizes, and make it easier to explore why particular constraints are not satisfied.

You will notice this version has

%{
cin8 = zeros(size(M)); cin8(1) = 0.65-B1;
%}
cin8 = zeros(size(M,1),0);   %should be present, but always positive

This leaves logical space for the 0.65-B1 constraint but leaves it empty, because as I demonstrated earlier A) the constraint is independent of inputs and so should not be present at this level; and B) as I showed, B1 is a quite negative number so 0.65-B1 is always positive so the constraint cannot ever be satisfied.

I also put in

%{
cin14 = abs((Vu-Vp).*dv)-Mu;
cin15 = Vs-VS;
cin16 = Vu./q-Vn;
cin17 = 0.5.*q.*(Vc+Vp)-Vu;
cin18 = Vu./q-Vn;
cin19 = fpe-0.8.*fpy;
%}
cin14 = zeros(size(M,1),0);   %removed
cin15 = zeros(size(M,1),0);   %removed
cin16 = zeros(size(M,1),0);   %removed
cin17 = zeros(size(M,1),0);   %removed
cin18 = zeros(size(M,1),0);   %removed
cin19 = zeros(size(M,1),0);   %removed

to make it easier if you want to restore those constraints (that you used to have) later.

You absolutely cannot get anywhere until you either fix your B1 constraint or you decide to leave it disabled (like I do here.)

If you put in new code, please be sure to use .* and ./ and .^ to vectorize the constraints.

[Walter Roberson]

Example of reason to vectorize constraints:

%sample many points across the entire defined range
N = rand(1e6, 8);
rval = lb + (ub-lb).*N;

%calculate constraints at each point, all at once
val = nonlcon(rval);

%see if it is even hypothetically possible to satisfy the constraints
min(val)

if the min() is positive in any entry, then that is a constraint that was not satisfied on any of the 1 million points, and you need to chase through the code to figure out why that constraint was never negative (never satisfied). You might, for example, discover that to get negative for that constraint would require that one of the inputs is outside the range you set in lb and ub. Or you might find a logic error in calculating the constraint.

Once you get to a state where min(val) is 0 or positive for all entries, then that does not mean that there is definitely a point that can satisfied all constraints. There is the possibility that some constraints are mutually exclusive, that the range of values that can satisfy one of them can never satisfy another, and vice versa. But at least once min(val) is <= 0 then you have a fighting chance; if any min(val) > 0 then you have no chance.

[metasebia dabi]

Thank you for u support Walter Theother question that I have is how can I vectorize the objective and constraint function without manual metoude b/c the function is to long , like Mn in my function Best regards

[Walter Roberson]

I already posted the vectorized nonlinear constraint, above.

Because you already are using x(:,INDEX), vectorizing is mostly a matter of doing some search and replace

* -> .*
/ -> ./
^ -> .^

then search for

..

to find any cases where you might have ended up changing an operationg that was already .* into ..* .

Mr=min(Mcr,1.33.*Mu);

That is already vectorized.

F=[f1,f2];

and that is already fine for the case where your rows correspond to different input samples and your columns correspond to the input variables.

Your previous nonlcon function required additional changes to handle S and SMax in vectorized form. It also needed a small adjustment to the way that min() is calculated for dva .

Vectorized objective attached.

[metasebia dabi]

gteatings walter

thank you in advance for ur support .

i have some changes in my objective fuction and it became longer , when i try to vectors it manualy it is hard and out of the wendow , i coun't be able ro simplify as well as fectorize it , i have already attached it in hear can you pls help me with it.

best regards

[metasebia dabi]

and i fix the B1 case it was rhe errror in the inpute thst is why i want to change the objective function fc in line 8 of the nonlinear.m is 50 not 50000000. so should i write the constraint of B1 like others?

[Walter Roberson]

Your x(3) is not used in either your objective function or your constraints function. It is, however, used in your Aeq, B, and ub / lb, and your Aineq, bineq.

Effectively, it will be adjusted to whatever value is needed to work out the constraints, and is useless on its own. Ideally it should be replaced algebraically to reduce the number of variables being searched over, as the system will continually be wasting time just adjusting the useless variable.

Your x(7) is not used in either your objective function or your constraints function or your inequalities. Your code makes it look like it is used, but instead its input value is ignored and a calculated value is written into it. It should be removed as an input, and the variables renamed in the code to a meaningful name.

Your x(8) is used in your objective function, but is not used in your constraints functions or your inequalities. Your constraints function makes it look like it is used, but instead its input value is ignored and a calculated value is written into it. This is confusing, and the variable should be renamed in the constraints function to a more meaningful name.

I have attached current working version of the code.

If you execute it you will notice that it does not run an optimization, and instead complains about unsolved constraints.

The unsolved constraint it is refering to is the 1-Mn/Mr constraint -- cin13 in the code. Your Mn is always negative and your Mr is always positive, so the ratio of the two is always negative, and subtracting a negative from 1 gives a value that is always positive; therefore the constraint cannot be met.

Your change for fc to fc=50 allows the B1 constraint to pass. However, it is still a constraint that is independent of the inputs, so you should not have it in the code: either check the ratio before you start any optimization, or else put it in as an assert() statement to abort processing if it cannot be met. A constraint that is either always true or always false regardless of inputs is a poor constraint.

[metasebia dabi]

greeting walter u have helped me so much in this but i came up with additional chalege can eyou please see it and help me with it

i have solved the issue with the unsolved constraint which is 1-Mn/Mr but mister wolter the resultes in the pareto chart are not good i want the result of safty or my seconde function f2 to be positive no. and must be greater than one but see the figer , the parito front what should i do??

i atached the new code and the results from pareto front please see it and help me with this?

best regards

Metasebia Dabi

[metasebia dabi]

the results in the left side of the chart are negative as well as are almost zero why did this happen.

i have attached my design code in here i used every thing in the nonlcon from my design code

[Walter Roberson]

Mcr=(((31.*2.^(1./2))./10 - ((x1 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).*((12354898479057801913548821935370803857421875.*x2)./309485009821345068724781056 + (352997099401651483244252055296308681640625.*x5)./309485009821345068724781056 - (352997099401651483244252055296308681640625.*x6)./309485009821345068724781056 + (14119883976066059329770082211852347265625.*x6.*(x1 - x2))./618970019642690137449562112 - (14119883976066059329770082211852347265625.*x4.*(2.*x5 + x6 - 3500))./1237940039285380274899124224 + 454739836963295317117559435156108837041015625./77371252455336267181195264))./((500000.*x5)./3 - (500000.*x6)./3 + 10000.*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + 3500.*x2.*(x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 + 2.*(50.*x5 - 50.*x6).*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + (875.*x2.^3)./3 + (x6.^3.*(x1 - x2))./6 - (x4.^3.*(2.*x5 + x6 - 3500))./12 + 2.*x6.*(x1 - x2).*(x1./2 + x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 - x4.*(x4./2 - x1 + (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2.*(2.*x5 + x6 - 3500) + 8947848533333333./536870912) + ((1836769977535370803857421875.*x2)./73786976294838206464 + (52479142215296308681640625.*x5)./73786976294838206464 - (52479142215296308681640625.*x6)./73786976294838206464 + (2099165688611852347265625.*x6.*(x1 - x2))./147573952589676412928 - (2099165688611852347265625.*x4.*(2.*x5 + x6 - 3500))./295147905179352825856 - (5.*2.^(1./2).*((500000.*x5)./3 - (500000.*x6)./3 + 10000.*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + 3500.*x2.*(x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 + 2.*(50.*x5 - 50.*x6).*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + (875.*x2.^3)./3 + (x6.^3.*(x1 - x2))./6 - (x4.^3.*(2.*x5 + x6 - 3500))./12 + 2.*x6.*(x1 - x2).*(x1./2 + x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 - x4.*(x4./2 - x1 + (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2.*(2.*x5 + x6 - 3500) + 8947848533333333./536870912))./(2.*(x1 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000))) + 182273709256141679345841015625./18446744073709551616)./(((19.*x1)./20 + ((500000.*x5)./3 - (500000.*x6)./3 + 10000.*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + 3500.*x2.*(x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 + 2.*(50.*x5 - 50.*x6).*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + (875.*x2.^3)./3 + (x6.^3.*(x1 - x2))./6 - (x4.^3.*(2.*x5 + x6 - 3500))./12 + 2.*x6.*(x1 - x2).*(x1./2 + x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 - x4.*(x4./2 - x1 + (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2.*(2.*x5 + x6 - 3500) + 8947848533333333./536870912)./((x1 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).*(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000))).*(exp(- (19.*x1)./1000000 - 39./250) + ((-4448731201136791./(262144.*(1674.*exp(- (19.*x1)./1000000 - 39./250) - 1674))).^(1./2).*(3348.*exp(- (19.*x1)./1000000 - 39./250) - 3348))./83700000 - (5615878112699533.*((19.*x1)./20 + ((500000.*x5)./3 - (500000.*x6)./3 + 10000.*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + 3500.*x2.*(x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 + 2.*(50.*x5 - 50.*x6).*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + (875.*x2.^3)./3 + (x6.^3.*(x1 - x2))./6 - (x4.^3.*(2.*x5 + x6 - 3500))./12 + 2.*x6.*(x1 - x2).*(x1./2 + x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 - x4.*(x4./2 - x1 + (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2.*(2.*x5 + x6 - 3500) + 8947848533333333./536870912)./((x1 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).*(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000))).*((433207581343744000.*((1836769977535370803857421875.*x2)./73786976294838206464 + (52479142215296308681640625.*x5)./73786976294838206464 - (52479142215296308681640625.*x6)./73786976294838206464 + (2099165688611852347265625.*x6.*(x1 - x2))./147573952589676412928 - (2099165688611852347265625.*x4.*(2.*x5 + x6 - 3500))./295147905179352825856 - (5.*2.^(1./2).*((500000.*x5)./3 - (500000.*x6)./3 + 10000.*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + 3500.*x2.*(x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 + 2.*(50.*x5 - 50.*x6).*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + (875.*x2.^3)./3 + (x6.^3.*(x1 - x2))./6 - (x4.^3.*(2.*x5 + x6 - 3500))./12 + 2.*x6.*(x1 - x2).*(x1./2 + x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 - x4.*(x4./2 - x1 + (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2.*(2.*x5 + x6 - 3500) + 8947848533333333./536870912))./(2.*(x1 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000))) + 182273709256141679345841015625./18446744073709551616))./(4700489980329509121.*((19.*x1)./20 + ((500000.*x5)./3 - (500000.*x6)./3 + 10000.*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + 3500.*x2.*(x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 + 2.*(50.*x5 - 50.*x6).*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + (875.*x2.^3)./3 + (x6.^3.*(x1 - x2))./6 - (x4.^3.*(2.*x5 + x6 - 3500))./12 + 2.*x6.*(x1 - x2).*(x1./2 + x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 - x4.*(x4./2 - x1 + (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2.*(2.*x5 + x6 - 3500) + 8947848533333333./536870912)./((x1 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).*(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)))) - 197000).*((19.*x1.*((1836769977535370803857421875.*x2)./73786976294838206464 + (52479142215296308681640625.*x5)./73786976294838206464 - (52479142215296308681640625.*x6)./73786976294838206464 + (2099165688611852347265625.*x6.*(x1 - x2))./147573952589676412928 - (2099165688611852347265625.*x4.*(2.*x5 + x6 - 3500))./295147905179352825856 + 97188102216156370467983526729./18446744073709551616))./(20.*((500000.*x5)./3 - (500000.*x6)./3 + 10000.*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + 3500.*x2.*(x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 + 2.*(50.*x5 - 50.*x6).*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + (875.*x2.^3)./3 + (x6.^3.*(x1 - x2))./6 - (x4.^3.*(2.*x5 + x6 - 3500))./12 + 2.*x6.*(x1 - x2).*(x1./2 + x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 - x4.*(x4./2 - x1 + (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2.*(2.*x5 + x6 - 3500) + 8947848533333333./536870912)) + ((1836769977535370803857421875.*x2)./73786976294838206464 + (52479142215296308681640625.*x5)./73786976294838206464 - (52479142215296308681640625.*x6)./73786976294838206464 + (2099165688611852347265625.*x6.*(x1 - x2))./147573952589676412928 - (2099165688611852347265625.*x4.*(2.*x5 + x6 - 3500))./295147905179352825856 - (5.*2.^(1./2).*((500000.*x5)./3 - (500000.*x6)./3 + 10000.*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + 3500.*x2.*(x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 + 2.*(50.*x5 - 50.*x6).*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + (875.*x2.^3)./3 + (x6.^3.*(x1 - x2))./6 - (x4.^3.*(2.*x5 + x6 - 3500))./12 + 2.*x6.*(x1 - x2).*(x1./2 + x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 - x4.*(x4./2 - x1 + (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2.*(2.*x5 + x6 - 3500) + 8947848533333333./536870912))./(2.*(x1 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000))) + 182273709256141679345841015625./18446744073709551616)./(((19.*x1)./20 + ((500000.*x5)./3 - (500000.*x6)./3 + 10000.*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + 3500.*x2.*(x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 + 2.*(50.*x5 - 50.*x6).*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + (875.*x2.^3)./3 + (x6.^3.*(x1 - x2))./6 - (x4.^3.*(2.*x5 + x6 - 3500))./12 + 2.*x6.*(x1 - x2).*(x1./2 + x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 - x4.*(x4./2 - x1 + (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2.*(2.*x5 + x6 - 3500) + 8947848533333333./536870912)./((x1 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).*(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000))).*(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)) + (361.*x1.^2.*((1836769977535370803857421875.*x2)./73786976294838206464 + (52479142215296308681640625.*x5)./73786976294838206464 - (52479142215296308681640625.*x6)./73786976294838206464 + (2099165688611852347265625.*x6.*(x1 - x2))./147573952589676412928 - (2099165688611852347265625.*x4.*(2.*x5 + x6 - 3500))./295147905179352825856 - (5.*2.^(1./2).*((500000.*x5)./3 - (500000.*x6)./3 + 10000.*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + 3500.*x2.*(x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 + 2.*(50.*x5 - 50.*x6).*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + (875.*x2.^3)./3 + (x6.^3.*(x1 - x2))./6 - (x4.^3.*(2.*x5 + x6 - 3500))./12 + 2.*x6.*(x1 - x2).*(x1./2 + x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 - x4.*(x4./2 - x1 + (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2.*(2.*x5 + x6 - 3500) + 8947848533333333./536870912))./(2.*(x1 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000))) + 182273709256141679345841015625./18446744073709551616))./(400.*((19.*x1)./20 + ((500000.*x5)./3 - (500000.*x6)./3 + 10000.*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + 3500.*x2.*(x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 + 2.*(50.*x5 - 50.*x6).*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + (875.*x2.^3)./3 + (x6.^3.*(x1 - x2))./6 - (x4.^3.*(2.*x5 + x6 - 3500))./12 + 2.*x6.*(x1 - x2).*(x1./2 + x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 - x4.*(x4./2 - x1 + (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2.*(2.*x5 + x6 - 3500) + 8947848533333333./536870912)./((x1 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).*(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000))).*((500000.*x5)./3 - (500000.*x6)./3 + 10000.*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + 3500.*x2.*(x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 + 2.*(50.*x5 - 50.*x6).*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + (875.*x2.^3)./3 + (x6.^3.*(x1 - x2))./6 - (x4.^3.*(2.*x5 + x6 - 3500))./12 + 2.*x6.*(x1 - x2).*(x1./2 + x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 - x4.*(x4./2 - x1 + (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2.*(2.*x5 + x6 - 3500) + 8947848533333333./536870912))))./(298549297149645568.*((1836769977535370803857421875.*x2)./73786976294838206464 + (52479142215296308681640625.*x5)./73786976294838206464 - (52479142215296308681640625.*x6)./73786976294838206464 + (2099165688611852347265625.*x6.*(x1 - x2))./147573952589676412928 - (2099165688611852347265625.*x4.*(2.*x5 + x6 - 3500))./295147905179352825856 - (5.*2.^(1./2).*((500000.*x5)./3 - (500000.*x6)./3 + 10000.*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + 3500.*x2.*(x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 + 2.*(50.*x5 - 50.*x6).*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + (875.*x2.^3)./3 + (x6.^3.*(x1 - x2))./6 - (x4.^3.*(2.*x5 + x6 - 3500))./12 + 2.*x6.*(x1 - x2).*(x1./2 + x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 - x4.*(x4./2 - x1 + (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2.*(2.*x5 + x6 - 3500) + 8947848533333333./536870912))./(2.*(x1 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000))) + 182273709256141679345841015625./18446744073709551616)) - 145./1674).*(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)) + (19.*x1.*(x1 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).*((1836769977535370803857421875.*x2)./73786976294838206464 + (52479142215296308681640625.*x5)./73786976294838206464 - (52479142215296308681640625.*x6)./73786976294838206464 + (2099165688611852347265625.*x6.*(x1 - x2))./147573952589676412928 - (2099165688611852347265625.*x4.*(2.*x5 + x6 - 3500))./295147905179352825856 - (5.*2.^(1./2).*((500000.*x5)./3 - (500000.*x6)./3 + 10000.*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + 3500.*x2.*(x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 + 2.*(50.*x5 - 50.*x6).*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + (875.*x2.^3)./3 + (x6.^3.*(x1 - x2))./6 - (x4.^3.*(2.*x5 + x6 - 3500))./12 + 2.*x6.*(x1 - x2).*(x1./2 + x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 - x4.*(x4./2 - x1 + (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2.*(2.*x5 + x6 - 3500) + 8947848533333333./536870912))./(2.*(x1 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000))) + 182273709256141679345841015625./18446744073709551616))./(20.*((19.*x1)./20 + ((500000.*x5)./3 - (500000.*x6)./3 + 10000.*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + 3500.*x2.*(x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 + 2.*(50.*x5 - 50.*x6).*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + (875.*x2.^3)./3 + (x6.^3.*(x1 - x2))./6 - (x4.^3.*(2.*x5 + x6 - 3500))./12 + 2.*x6.*(x1 - x2).*(x1./2 + x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 - x4.*(x4./2 - x1 + (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2.*(2.*x5 + x6 - 3500) + 8947848533333333./536870912)./((x1 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).*(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000))).*((500000.*x5)./3 - (500000.*x6)./3 + 10000.*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + 3500.*x2.*(x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 + 2.*(50.*x5 - 50.*x6).*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + (875.*x2.^3)./3 + (x6.^3.*(x1 - x2))./6 - (x4.^3.*(2.*x5 + x6 - 3500))./12 + 2.*x6.*(x1 - x2).*(x1./2 + x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 - x4.*(x4./2 - x1 + (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2.*(2.*x5 + x6 - 3500) + 8947848533333333./536870912))).*(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000).*((500000.*x5)./3 - (500000.*x6)./3 + 10000.*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + 3500.*x2.*(x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 + 2.*(50.*x5 - 50.*x6).*(x2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000) + 100./3).^2 + (875.*x2.^3)./3 + (x6.^3.*(x1 - x2))./6 - (x4.^3.*(2.*x5 + x6 - 3500))./12 + 2.*x6.*(x1 - x2).*(x1./2 + x2./2 - (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2 - x4.*(x4./2 - x1 + (10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3)./(3500.*x2 + 100.*x5 - 100.*x6 + 2.*x6.*(x1 - x2) - x4.*(2.*x5 + x6 - 3500) + 10000)).^2.*(2.*x5 + x6 - 3500) + 8947848533333333./536870912))./(10000.*x2 + (100.*x5 - 100.*x6).*(x2 + 100./3) + 1750.*x2.^2 - x4.*(x1 - x4./2).*(2.*x5 + x6 - 3500) + 2.*x6.*(x1./2 + x2./2).*(x1 - x2) + 1000000./3);

Your Mcr come out as large negative numbers, around -1e19

Mr=min(Mcr,1.33.*Mu);

Your mu is a moderately large positive number, about 1E10. The min() of a negative and a positive is going to be the negative, so the min() is effectively just passing through the Mcr values.

f2=Mn./Mr;

Your Mn are moderately large positive numbers, about 1e11. As discussed above, your Mr are about -1e19. 1e11/-1e19 is on the order of -1e-9 -- a number that cannot be greater than 1 -- it cannot even be greater than 0.

[metasebia dabi]

Greetings Walter how can I handle maximizing one objective and minimizing the other, where do have to make change in my objective finction. One of my objective is to maximize the safety(f2) and the other is to minimize the cost(f1) , what kind of change is expected from me to change in the objective function

[Walter Roberson]

Have your objective function return the negative of the value to be maximized. Minimizing -1*x is the same as maximimzing x.

[metasebia dabi]

So should I make every value of x negative of should I multiplay the whole function by negative

[Walter Roberson]

Change

F=[f1,f2];

to

F=[f1,-f2];

[metasebia dabi]

Thank u so much

[metasebia dabi]

What kind of chartshould I expect is it like one of the row start from large to small??

[Walter Roberson]

The plot will probably look like a gentle parabolic descending from maximum safety and minimum cost to the left, to less safety and higher cost towards the right.

The safety will still be about 6*e-10, no-where near the 1 you were hoping for. This is because the algorithm for computing f2 has not changed, and I showed above that f2 is only about 1e-10

[metasebia dabi]

But I went a safety greater than 1 ! What is the problem and am still getting a chart which is concave up not descending , is the problem with my code?

[metasebia dabi]

How do I change the algorithm for computing f2 should I multiplay all x by -ve

[Walter Roberson]

I would not know, as I have not seen the equations.

Remember, though, the previous discussion:

Your Mn are moderately large positive numbers, about 1e11. As discussed above, your Mr are about -1e19. 1e11/-1e19 is on the order of -1e-9 -- a number that cannot be greater than 1 -- it cannot even be greater than 0.

We (already) take the negative of it in order to maximize it, but in order to be able to get the value greater than 1, then either Mn has to increase by 9 orders of magnitude, or else Mr has to decrease by 9 orders of magnitude (or some combination of the two)

[metasebia dabi]

i fix those problems with Mn and Mr and in my current code Mn/Mr is positive grater than 1 , now i change my mind and i wont to maximize my second function f2 but rather that minimizing -f2 to compute the maximization it makes all results negative why ?

i have attached the code in here!

[Walter Roberson]

Adjusted

[metasebia dabi]

thank you so much

[metasebia dabi]

i have another essue mr. walter

to check my results i work out the one of the solution in pareto solution, in my design code but there is defrence in results of the objective function why is this happening?? i have attached the design cod

[metasebia dabi]

Greetings Walter Can you help me!

[Walter Roberson]

elseif S/6>tf> S/18,tf = tf;

MATLAB interprets that as meaning

    elseif ((S/6>tf)> S/18)
        tf = tf;

S/6>tf is calculated, returning 0 (false) or 1 (true). That 0 or 1 is then compared to S/18.

In this particular case it does not matter, since the branch effectively does nothing even if it works, but the code is misleading.

And you really should deal with the question of what to do if S/6 == tf exactly, or if tf < S/18 . If those cases are meaningful, then deal with them; if they are not meaningful then just have the if without any else.

You have a number of similar cases.

I suggest that you learn how to use min() and max(). Instead of writing something like

 if C > 0.65
    C = 0.65;
 elseif C < 0.65
     C = C;
 end

just write

 C = min(C, 0.65);

It is a bit counter-intuitive, but use min() when you want to set a value to be the maximum level something should have, and use max() when you want to set a value to be the minimum level something should have.

But other than those... unfortunately I do not know what I am looking at. Your design code calculates some things, but I have no idea how those things link to your previous code.

[metasebia dabi]

I insert one of the final result of optimized solutions from my previous code , which are x1,x2,x3,x4,x5,x6,x7 and insert this results in the design code , the previous code is formulated using this design code so after inserting this results I run the code and calculate the result of safety factor Mn/Mr but in the optimization this result is fgal2 and the result is 11 but the out put of the original code using the optimized cross sections is 3,my question is why does it have this difference in results , is it b/c I use -f2 to maximize?