Оптимизация в САПР

break;

       

p=(-inverseGJ(hesse(x0))*df(x0)); // выбираем ньютоновское направление поиска

 

      FindAlpha(x,p,e,i1Min);     // находим коэффициент удлинения вектора

x1=x0+p*alpha;        // спускаемся в новую точку

 

// проверка на окончание  поиска

      if(norma(x1-x0)/norma(x0)<e && norma(x0)<e && norma(x1)<e)

break;

 

// дополнительный КОП

if (norma(df(x1))>norma(df(x0)))

{

*max_step=k;

return x0;

}

 

x0=x1;      // сохрарняем предыдущую точку

MASSIV.insertCol(x0); // добавляем новое значение х в массив

   }

 

*max_step=k;   // возвращаем количество итераций

return x1;    // возвращаем найденный минимум

}

 

 

// Метод Зангвила

 

CMatrix CMETODI::Sangvil(

CMatrix x,   // начальная точка

double e,   // погрешность поиска

int* max_step)  // максимальное количество итераций

{

int k=0;    // задаём счётчик числа итераций

// переопределяем массив  значений х

// при пошаговом поиске  и задаём

// значение начальной  точки

MASSIV.setSize(x.getSizeRow(),x.getSizeCol());

MASSIV.setCol(1,x); 

 

if(norma(df(x))<e) // дополнительный КОП:

{       // если х0 - точка

*max_step=0;  // минимума, то завершить

return x;   // поиск

}

 

CMatrix x0(x),   // предыдущая точка

x1,     // текущая точка

i;      // единичная матрица

 

i.setSingle(x0.getSizeRow()); // переопределение размера

  

double lambda=1000; // необходимый коэффициент

 

   for(k=0; k<*max_step; k++)  // выполняем поиск в

   {          // соответствии с методом

      if(norma(df(x0))<e)   // проверка на окончание поиска

break;

 

      for(;;)    // бесконечный цикл

      {

x1=x0-inverseGJ(hesse(x0)+lambda*i)*df(x0); // новая точка

 

if(f(x1)<f(x0)) // рассматриваем

{      // 2 ситуации

lambda*=0.5;

break;

}

else

lambda*=2; 

}

x0=x1;      // сохрарняем предыдущую точку

MASSIV.insertCol(x0); // добавляем новое значение х в массив

   }

 

*max_step=k;   // возвращаем количество итераций

   return x1;    // возвращаем найденный минимум

}

 

// Метод Флетчера-Ривса

 

CMatrix CMETODI::FletcherReeves(

CMatrix x,   // начальная точка

double e,   // погрешность поиска

int* max_step,  // максимальное количество итераций

int i1Min)   // метод одномерного поиска

{

int k=0;    // задаём счётчик числа итераций

 

// переопределяем массив  значений х

// при пошаговом поиске  и задаём

// значение начальной точки

MASSIV.setSize(x.getSizeRow(),x.getSizeCol());

MASSIV.setCol(1,x);

 

CMatrix p(x),  // направление поиска

g(x);    // градиент функции

double beta;  // число, меняющее длину р

 

// сокращаем ТИЛ в  соответствии с методом

while(norma(df(x))>e && k<*max_step)

{

k++;        // увеличиваем счётчик итераций

 

if(k%(x.getSizeRow())==1) // проверяем номер итерации

p = -df(x);     // устанавливаем антиградиентное напрвление

else

{         // вычисляем в соответствии с формулой

beta = (pow(norma(df(x)),2))/(pow(norma(g),2));

p = -df(x) + p*beta;  // новое направление поиска

}

g=df(x);       // сохраняем текущий градиент

FindAlpha(x,p,e,i1Min);  // находим коэффициент удлинения вектора

x = x + p*alpha;    // спускаемся в новую точку

 

MASSIV.insertCol(x);   // добавляем новое значение х в массив

}

 

*max_step=k;  // возвращаем количество итераций

   return x;   // возвращаем найденный минимум

}

 

// Метод Пауэлла - 1

 

CMatrix CMETODI::Pauell_1(

CMatrix x,   // начальная точка

double e,   // погрешность поиска

int* max_step,  // максимальное количество итераций

int i1Min)   // метод одномерного поиска

{

int k=0;    // задаём счётчик числа итераций

 

// переопределяем массив  значений х

// при пошаговом поиске и задаём

// значение начальной  точки

MASSIV.setSize(x.getSizeRow(),x.getSizeCol());

MASSIV.setCol(1,x);

 

CMatrix x1(x),  // начальная точка

p(x),    // направление поиска

d(x),    // ускоряющее направление

PI;    // система сопряжённых направлений

 

// устанавливаем начальное  значение системы

PI.setSize(x.getSizeRow(),x.getSizeRow()+1); 

 

p.setNull();  // делаем направление поиска нулевым

 

// строим начальную  поисковую систему,

// которая состоит  из координатных ортов

for(int i=1; i<=x.getSizeRow(); i++)

{

p[i] = 1;

PI.setCol(i,p);

p[i] = 0;

}

 

// сокращаем ТИЛ в  соответствии с методом

while(norma(df(x))>e && k<*max_step)

{

x1=x;    // сохраняем начальную точку

 

// выполняем поиск  вдоль системы направлений

for(i=1; i<=x.getSizeRow(); i++)

{

p=PI.getCol(i);   // получаем направление

FindAlpha(x,p,e,i1Min); // находим коэффициент удлинения вектора

x = x + alpha*p;   // спускаемся в новую точку

}

 

d=x-x1;       // получаем новое направление

FindAlpha(x,d,e,i1Min);  // находим коэффициент удлинения вектора

x = x + alpha*d;    // спускаемся в новую точку

 

PI.setCol(x.getSizeRow()+1,d);  // устанавливаем последним

// новое направление

if(x.getSizeRow()!=1)

for(i=1; i<=x.getSizeCol()+1; i++) // создаём новую систему

PI.setCol(i,PI.getCol(i+1));  // в соответствии с методом

 

k++;       // увеличиваем счётчик итераций

 

MASSIV.insertCol(x);  // добавляем новое значение х в массив

}

 

*max_step=k;  // возвращаем количество итераций

return x;   // возвращаем найденный минимум

}

 

 

// Метод Пауэлла - 2

 

CMatrix CMETODI::Pauell_2(

CMatrix x,   // начальная точка

double e,   // погрешность поиска

int* max_step,  // максимальное количество итераций

int i1Min)   // метод одномерного поиска

{

int k=0;    // задаём счётчик числа итераций

 

// переопределяем массив  значений х

// при пошаговом поиске  и задаём

// значение начальной  точки

MASSIV.setSize(x.getSizeRow(),x.getSizeCol());

MASSIV.setCol(1,x);

 

CMatrix x1(x),  // начальная точка

p(x),    // направление поиска

d(x),    // ускоряющее направление

PI;    // система сопряжённых направлений

 

// устанавливаем начальное  значение системы

PI.setSize(x.getSizeRow(),x.getSizeRow()+1);

 

p.setNull();  // делаем направление поиска нулевым

 

// строим начальную  поисковую систему,

// которая состоит  из координатных ортов

for(int i=1; i<=x.getSizeRow(); i++)

{

p[i] = 1;

PI.setCol(i,p);

p[i] = 0;

}

 

// сокращаем ТИЛ в  соответствии с методом

while(norma(df(x))>e && f(x1)>=f(x) && k<*max_step)

{

x1=x;    // сохраняем начальную точку

 

// выполняем поиск  вдоль системы направлений

for(i=1; i<=x.getSizeRow(); i++)

{

p=PI.getCol(i);   // получаем направление

FindAlpha(x,p,e,i1Min); // находим коэффициент удлинения вектора

x = x + alpha*p;   // спускаемся в новую точку

}

 

d=x-x1;       // получаем новое направление

FindAlpha(x,d,e,i1Min);  // находим коэффициент удлинения вектора

x = x + alpha*d;    // спускаемся в новую точку

 

PI.setCol(1,d);

PI.setCol(x.getSizeRow()+1,d);  // устанавливаем последним

// новое направление

if(x.getSizeRow()!=1)

for(i=2; i<x.getSizeCol()+1; i++) // создаём новую систему

PI.setCol(i,PI.getCol(i+1));  // в соответствии с методом

 

k++;       // увеличиваем счётчик итераций

 

MASSIV.insertCol(x);  // добавляем новое значение х в массив

}

 

*max_step=k;  // возвращаем количество итераций

return x;   // возвращаем найденный минимум

}

 

 

 

 

 

CMatrix CMETODI::ComplexBox(CMatrix x,int num)

{

CMatrix complex[2*5+1];

int complexSize=2*x.getSizeRow();  // размер комплекса >(n+1), принимаем его = 2n

  int ii=0;

for(ii=1; ii<complexSize; ii++)

 complex[ii]=x.setSingle(5);

  complex[0]=x;

CMatrix Xi=x, Xc=x, Xh=x, Xr=x, X0=x;

double alpha=1.3, sigma=0, sum=0, sum2=0, Eps=0.0001;

CMatrix Ai;

CMatrix Bi;

int nmax_dot=0;

 

srand((unsigned)time(NULL));

int k=0, kk=0, kkk=0;

int i=0;

Xc=x;

for(i=1; i<complexSize; i++) 

{

  for(int j=0; j<=x.getSizeRow(); j++) 

   Xi[j]=Ai[j] + ((double)rand()/(double)(RAND_MAX)) * (Bi[j]-Ai[j]);

  kkk=0;

  while(!(isComplies_g(Xi, num)&&(isComplies_a_b(Xi, Ai, Bi, num))))  // 6

  {

   Xi=0.5*(Xi+Xc); 

      if(kkk++>1000)

   {    break;   }

  }

  complex[i]=Xi;  // 5

 

  Xc=(1/(double)i)*((i-1)*Xc+Xi); 

}

 

for(ii=0; ii<complexSize; ii++)

 

  sortComplexByFuncVal(complex, complexSize, num);

 

do   // вторая блок-схема

{

  for(ii=0; ii<complexSize; ii++)

  nmax_dot=complexSize-1;

  X0=centerOfGravity(&complex[0], complexSize, x, nmax_dot); 

 

  Xh=complex[nmax_dot];  // Xh=Xk  

 

  Xr=(alpha+1)*X0 - alpha*Xh; 

 

  kk=0;

  do

  {

   if(isComplies_g(Xr, num)&&(isComplies_a_b(Xr, Ai, Bi, num)))  // 16

   {

    if(f(Xr) > f(Xh)) 

    {

     Xr=0.5*(Xr+X0); 

     continue;

    }

    else

    {

     break; // ->21

    }

   }

   if(!isComplies_a_b(Xr, Ai, Bi, num))

   {

    for(ii=0; ii<Xr.getSizeCol(); ii++)   // 17

    {

     if(Xr[ii]<Ai[ii])

      Xr[ii] = Ai[ii] + 1e-6;

    }

    for(ii=0; ii<=Xr.getSizeRow(); ii++)

    {

     if(Xr[ii]>Bi[ii])

      Xr[ii] = Bi[ii] - 1e-6;

    }   }

   if(!isComplies_g(Xr, num))   //  18

   {

    Xr=0.5*(Xr+X0); 

   }

   if(kk++>1000) break;

  }  while(!((isComplies_g(Xr, num))&&(isComplies_a_b(x, Ai, Bi, num))));

  complex[nmax_dot]=Xr;  // 22

  sortComplexByFuncVal(complex, complexSize, num);

  sum=0; sum2=0; sigma=0;

  for(ii=0; ii<complexSize; ii++)

  {   sum+=f(complex[ii]);  }

  sum/=double(complexSize);

  for(ii=0; ii<complexSize; ii++)

   sigma += pow(f(complex[ii]) - sum, 2)/complexSize;

  if(k++>1000) break;

  if((sigma < Eps) && (findMaxDistance(&complex[0], complexSize-1)<Eps)) break; }

while(1);

x+=complex[0];

return x;

}