Laborator 1 Cucu Eugeniu

8/16/2019 Laborator 1 Cucu Eugeniu

1/5

Ministerul Educației al Republicii Moldova

Universitatea Tehnică a Moldovei

Catedra Automatica si Tehnologii Informationale

RAPORTLucrarea de laborator nr.1

la Cercetari Opera ț ionale

Tema: Optimizarea necondiționată

Varianta 9

A efectuat:

st. gr. SI-141 E. Cucu

A verificat:

lector superior V.Bagrin

Chișinău 2016


2/5

Scopul lucrării

Studiul metodelor de optimizare neliniară fără restricții. Definirea și utilizarea unor proceduri pentru minimizarea funcțiilor cu ajutorul

metodei gradientului și a metodelor de direcții conjugate cu o eroare mai mică

= 10−5 . Analiza rezultatelor obținute, inclusiv stabilirea tipului minimului local sau global. Să se compare rezultatele, luând în considerare numărul de iterații, evaluările pentru

funcție si gradient.

Mersul lucrării

Să se determine minimul global al funcției , = + 2 + 2 3 Varianta 9 : a = 2, b = 4.

Aproximația inițiala

, =1,1

Argumentarea solutiei:

4 + 2 2 = 0 = > = 0 . 32 + 8 3 = 0 = > = 0 . 2 4 22 8 det(1) = det(4) = 4 > 0 ; det(2) = 20 > 0 deci (0.3,0,2) este punct minim.

1. Determinam gradientul funcției ∇, = (4 + 2 22 + 8 3) = ∇1,1 = 47

2. Determinam (alfa) din formula(2(1-4 )^2+2*(1-4 )(1-7 )+4(1-7 )^2-2(1-4 )-3(1-7 ))' = 0

3. Cu ajutorul metodei iterative cu condiția de stopare ||∇, | | < 1 0−5,determinam , minimul global al funcției , cu dupa forula , = − , − ∇− , −.

Listingul programului

import javacalculus.core.CALC;

import javacalculus.core.CalcParser;import javacalculus.evaluator.CalcSUB;import javacalculus.struct.CalcDouble;import javacalculus.struct.CalcObject;import javacalculus.struct.CalcSymbol;//2*x^2+2*x*y+4*y^2-2*x-3*y

import java.util.Scanner;

public class MinimumCalculate{

public static void main(String[] args) throws Exception{

Scanner in = new Scanner(System.in);System.out.println("Enter expression:");

String expressionFunction = in.nextLine();CalcParser parser = new CalcParser();CalcObject resultX = parser.parse("DIFF(" + expressionFunction + ", "


3/5

+ "x" + ")").evaluate();CalcObject resultY = parser.parse("DIFF(" + expressionFunction + ", "

+ "y" + ")").evaluate();CalcObject resultFunction =

parser.parse(expressionFunction).evaluate();System.out.println("Gradient Method");gradientMethod(expressionFunction, resultX, resultY, resultFunction);

System.out.println("Hestenes-Stiefel Method");hestenesStiefelMethod(4,2,8,1,1,resultX, resultY, resultFunction);

}

private static void hestenesStiefelMethod(double h11, double h12, doubleh22, double firstX, double firstY, CalcObject resultX, CalcObject resultY,CalcObject resultFunction) throws InterruptedException {

double x = 0,y = 0;double alpha;double[] d0 = new double[2];double[] d1 = new double[2];double gradient0X = getValue(firstX, firstY, resultX);double gradient0Y = getValue(firstX, firstY, resultY);if((int)gradient0X == 0 && (int)gradient0Y == 0)

System.out.println("x = " + firstX + "\ny = " + firstY + "\nf(x) = " +getValue(firstX,firstY,resultFunction));

else {d0[0] = gradient0X * (-1);d0[1] = gradient0Y * (-1);alpha = -

((gradient0X*d0[0]+gradient0Y*d0[1])/((2*d0[0]+1*d0[1])*d0[0])+((1*d0[0]+1*d0[1])*d0[1]));

x = firstX + (alpha*d0[0]);y = firstY + (alpha*d0[1]);if((int)getValue(x,y,resultX) == 0 && (int)getValue(x,y,resultY)

== 0) {System.out.println("x = " + x + "\ny = " + y + "\nf(x) = " +

getValue(x,y,resultFunction));}

else {double x1,y1;x1 = getValue(x,y,resultX);y1 = getValue(x,y,resultY);while((int)x1 != 0 && (int)y1 != 0) {

x1 = getValue(x, y, resultX);y1 = getValue(x, y, resultY);d1[0] = -x1 + ((((x1 * x1) + (y1 * y1)) / ((gradient0X *

gradient0X) + gradient0Y * gradient0Y)) * d0[0]);d1[1] = -y1 + ((((x1 * x1) + (y1 * y1)) / ((gradient0X *

gradient0X) + gradient0Y * gradient0Y)) * d0[1]);alpha = -((x1 * d1[0] + y1 * d1[1]) / (((h11 * d1[0] +

h12 * d1[1]) * d1[0]) + ((h12 * d1[0] + h22 * d1[1]) * d1[1])));gradient0X = x1;gradient0Y = y1;

x = x + (alpha * d1[0]);y = y + (alpha * d1[1]);

}System.out.println("x = " + x + "\ny = " + y + "\nf(x) = " +

getValue(x,y,resultFunction));}

}}

private static double getValue(double prevX, double prevY, CalcObjectresult) {

result = substituteVariable(result, "x", prevX);result = substituteVariable(result, "y", prevY);result = CALC.SYM_EVAL(result);

return Double.parseDouble(result.toString());}


4/5

private static String getAlpha(double prevX, double prevY, Stringexpression, CalcObject resultX, CalcObject resultY) {

resultX = substituteVariable(resultX, "x", prevX);resultX = substituteVariable(resultX, "y", prevY);resultY = substituteVariable(resultY, "x", prevX);resultY = substituteVariable(resultY, "y", prevY);resultX = CALC.SYM_EVAL(resultX);

resultY = CALC.SYM_EVAL(resultY);expression = expression.replace("x","(1-" +

(int)Double.parseDouble(resultX.toString()) + "*alpha)");expression = expression.replace("y","(1-" +

(int)Double.parseDouble(resultY.toString()) + "*alpha)");return expression;

}

static CalcObject substituteVariable(CalcObject input, String var, doublenumber) {

CalcSymbol symbol = new CalcSymbol(var);CalcDouble value = new CalcDouble(number);return CalcSUB.numericSubstitute(input, symbol, value);

}

private static void gradientMethod(String expression, CalcObject resultX,CalcObject resultY, CalcObject resultFunction) {

double prevX = 1,prevY = 1;double x = 0,y = 0;double alpha = 0.5;double gradientX;double gradientY;double error = 1000000;int iterator = 0;while(error > 0.001) {

iterator++;gradientX = getValue(prevX, prevY, resultX);gradientY = getValue(prevX, prevY, resultY);x = prevX - (alpha * gradientX);

y = prevY - (alpha * gradientY);if(getValue(x,y,resultFunction) -

getValue(prevX,prevY,resultFunction) > 0) {alpha /= 2;iterator--;

}else {

error = Math.sqrt(Math.pow(gradientX, 2) +Math.pow(gradientY, 2));

prevX = x;prevY = y;

}}System.out.println("x = " + x);if (expression.contains("y")) {

System.out.println("y = " + y);System.out.println("f(x,y) = " + getValue(x, y, resultFunction));

}else System.out.println("f(x) = " + getValue(x,y,resultFunction));System.out.println("iterator = " + iterator);

}}


5/5

Afisarea rezulatelor obținute

Concluzie

În urma efectuării lucrării de laborator, am obținut cunoștințe in determinareaminimului global al unei funcții.

În programul elaborat utilizatorul introduce expresia funcției si automat segenereaza funcția pentru determinarea lui alfa, la rezolvarea acestei ecuatii(derivareaapoi determinarea lui alfa din egalarea ecuatiei cu 0) automat de program am întilnitgreutăți deoarece nu am putut realiza determinarea necunoscutei, de pe alta parte

programul calculeaza automat gradientul lui x si y astfel generindu-se o functie pentru

determinarea lui alfa, usor determînd manual sau folosindu-ne de platformawolframalpha.com unde copiem functia obtinuta si obtinem rezultatul.

Dupa determinarea lui alfa îl introducem in program si automat se calculeazăminimul global al funcției și afișînd la ecran valoarea minima a lui x,y funcția in

punctul dat si numarul de iterații realizate.

Documents

Laborator 1 Cucu Eugeniu