Исследование методов решения линейных уравнений

 

СОДЕРЖАНИЕ

Метод ветвей и границ

Метод первого порядка

Метод второго порядка

Оптимальный поиск

Пассивный поиск

метод дихотомии

Метод золотого сечения

Динамическое программирование

Линейное программирование. Метод Жордана-Гаусса.

Список литературы

Метод ветвей и границ

В качестве примера метода ветвей и границ рассмотрим задачу коммивояжера.

Постановка задачи.

Имеется N пунктов, расстояние между которыми известны. Необходимо, начав движения из п.1. последовательно обойти все остальные по самому короткому пути и вернуться в п.1. Условие a заключается в следующем: в каждый пункт надо войти только один раз и один раз из него выйти. На рис.1. приведен пример задачи для N = 5. На ребрах, соединяющих вершины графа (пункты), указаны расстояния.

Рис. 1.

Условие a делает невозможным выбор на некотором шаге вычислений оптимального из путей, приводящих в некоторую точку. Решение задачи методом прямого перебора всех возможных (N-1)! возможно лишь для малых N, Необходим метод, который позволяет уменьшать число рассматриваемых вариантов. Таким методом является метод ветвей и границ (МВТ).

Основное содержание метода заключается в том, что строятся нижние оценки функции цели (ФЦ), позволяющие отбраковать множество вариантов, для которых значение ФЦ заведомо хуже. По мере рассмотрения новых вариантов граница перемещается вниз (в задаче минимизации) до тех пор, пока число различных вариантов не уменьшается настолько, что выбор лучшего из них будет сделан непосредственным сравнением.

Решение задачи.

Запишем исходные данные в виде таблицы C0 = (Cij). В ней i и j - номера пунктов, движение на каждом шаге совершается из i в j, длина этого шага пути Cij, крестиками отмечены запрещенные переходы. Пусть Сi = min Cij. Найдем Сi для каждого i (в таблице эти значения подчеркнуты), после чего совершим приведение матрицы С0 к C01 по строкам, где Cij1 вычисляются по формулам Cij1 = Cij - Ci. Обозначим d01 = åCi. и Cj1 = min Cij. Найдем Cj для всех j и выполним приведение C01 по столбцам. В приведенном примере все Сj = 0, поэтому C02 = C01, константа приведения по столбцам d02 = 0, d0 = d01 + d02 = 23.

Можно утверждать, что задачам с матрицами C0 и C01 соответствует один и тот же оптимальный маршрут. Длина любого пути LS(C0) и LS(C02) связаны формулой LS(C0) = LS(C02) + d0. что следует из условия a. Тогда любой путь по матрице представляет движение по клеткам таблицы, причем в каждой строке и каждом столбце можно побывать только один раз.

Величину d0 можно использовать в качестве нижней границы при оценке всех возможных путей.

Рассмотрим путь, который включает переход из i в j. Для него LS ³ gij = d0 + Cij. Такой переход всегда есть, так как в приведенной матрице хотя бы один элемент в строке - нулевой. Выбирая один из них, мы выбираем оптимизацию одного шага пути (самый короткий первый шаг). При этом, конечно, мы не знаем, как это отразится на длине последующего пути. Обозначим (ij) множество путей, не содержащих непосредственный переход из i в j. Поскольку из i надо куда-то выйти, а в j откуда-то прийти, то этому множеству соответствует оценка:

LS ³ g(ij) = d0 + qij, где qij =

Тогда нижней оценкой для множества путей будет g2 = d0 + qij. Мы заинтересованы в выборе такого перехода ij, для которого эта оценка является самой высокой. Этот выбор можно сделать, отыскав среди нулевых элементов i строки такой, которому соответствует q2 = max qij. Выбором пары (ij) все множество возможных путей разбивается на два подмножества. Одно из них содержит переход (ij) (ему соответствует оценка g1 = d0 + q1), другое (ij) (ему соответствует оценка g2 = d0 + q2).

В нашем примере первым шагом пути должен быть переход из п.1. Сij= 0 для i,j = 1,2. Множество всех возможных путей W разбиваем на два: содержащих переход (12) и не содержащих переход (12). Строим для них нижние оценки. g1 = d0 = 23. Для перехода, не содержащего (12), соответствует путь, содержащий переходы (14) и (32). На этом первая итерация вычислительного процесса заканчивается. При дальнейшем движении за поиском оптимального пути будем наблюдать с помощью дерева вариантов (рис.2).

Рис. 2.

Рассмотрим теперь первое подмножество. В нем уже реализован переход (12), поэтому в таблице С02 строку 1 и столбец 2 удаляем (вычеркиваем) из дальнейшего рассмотрения. С02 преобразуется в С1, а после приведения - в С12. В верхнем левом углу таблицы С1 ставим крестик, так как переход (21) в рассматриваемом подмножестве (12) становиться невозможным.

Теперь над новой таблицей проделываем те же действия, что и над С2. Для С12 константа приведения a1 = 2. Далее в качестве возможных рассмотрим подмножества, содержащие пути (23) и (), и произведем их оценку:

(23) g23 = g1 = (d0 + d1) + с23 = 23 + 2 + 0 = 25.

() = g2 = (d0 + d1) + W23 = 25 + 5 = 30,

где W23 = = C24 + C 43 = 3+2 = 5.

После вычеркивания из таблицы C12 строки i = 2 и столбца j = 3 получается матрица С2 размером 3х3. Очередное разбиение возможных вариантов перемещения на подмножестве (34) и () дает оценки g34 = 26 и =27.

После очередного сокращения матрицы таблица принимает размер 2х2 и однозначно определяет путь: начальная точка 4, конечная - 1, путь (451). Он имеет длину 6. По дереву вариантов мы прошли путь до вершины. Длинный путь (123451) имеет длину 32. Аналогично множество () содержит единственный путь (3541) длиной 2. Путь (123541) имеет длину 27, его длина меньше, чем у пути, содержащего переход (34). В качестве нижней границы теперь следует выбирать 27. Любое множество, имеющее оценку больше 27, следует отбросить. Если же оценка меньше 27, то такой путь подлежит исследованию. Если, пройдя по новому пути, получим значение длины меньше 27, то это новое значение следует взять в качестве новой оценки. Итак, мы прошли по дереву вариантов до вершины и длину одного их путей используем для последующей оценки вариантов.

Возвращаемся теперь по дереву вверх до ближайшего узла (12). Не рассмотренная ветвь дерева () имеет нижнюю оценку 30, что хуже достигнутого результата. Значит, эту ветвь можно далее не исследовать. Переходим к ветви (). Оценка для этой ветви ниже 27, поэтому данное множество следует рассмотреть.

В результате исследования придем к результату, что оптимальный путь (123541).

Сравним теперь данный метод с динамическим программированием. В ДП на очередном шаге выбирается самый короткий путь, ведущий в данную точку; все остальные пути исключаются из дальнейшего рассмотрения. В МВГ при разбиении также рассматривается самый короткий путь, содержащий переход (ij) и множество остальных путей (). Но, в отличии от ДП, мы не может множество (ij) исключить из дальнейшего рассмотрения. В процессе последовательного разбиения, двигаясь от корня к одной из вершин, необходимо запомнить в каждом из узлов информацию для последующего анализа множества возможных путей при возврате от вершины к корню дерева. Следует отметить, что МВГ весьма экономичен с точки зрения требуемой памяти. Если решение задачи метод ветвей и границ прервать (например, по истечении отведенного времени), то хотя оптимальное решение не будет достигнуто, в памяти будет храниться одно из возможных решений. В динамическом программировании решение получается только на последнем шаге вычислительного процесса (оно же и оптимальное).

Из изложенного следует сделать вывод, что МВГ - весьма эффективный метод, с помощью которого можно решать разнообразные задачи с аддитивной целевой функцией.

Листинг программы

var

Way:TVector;

LengthOfWay:real;:boolean;Addiction(var Matrix:Tarray;SizeOfMatrix:integer):real;,MinInCol:real;,j:integer;,d2,d:real;MinElInRow(NumRow:integer):real;:integer;:real;:integer;:=0;min:=1e38;i:=1 to SizeOfMatrix do(Matrix[NumRow,i]<min) then begin:=Matrix[NumRow,i];index:=i;index=0 then raise Error;:=min;MinElInCol(NumCol:integer):real;:integer;:real;:integer;:=0;min:=1e38;i:=1 to SizeOfMatrix do(Matrix[i,NumCol]<min) then begin:=Matrix[i,NumCol];index:=i;index=0 then raise Error;:=min;:=0;i:=1 to SizeOfMatrix do:=MinElInRow(i);:=d1+MinInRow;j:=1 to SizeOfMatrix do[i,j]:=Matrix[i,j]-MinInRow;;:=0;i:=1 to SizeOfMatrix do:=MinElInCol(i);:=d2+MinInCol;j:=1 to SizeOfMatrix do[j,i]:=Matrix[j,i]-MinInCol;;:=d1+d2;:=d;FindBestWay(var matrix:TArray;SizeOfMatrix:integer;basis:integer;LowLimit:real);:Tarray;,LowLimit2:real;:integer;:real;:integer;:real;,Column:integer;,min2,min:extended;Print;,j:integer;:integer;:string;i:=1 to SizeOfMatrix doj:=1 to SizeOfMatrix doMatrix[i,j]>Maxint then s:=' X 'Str(Round(Matrix[i,j]):3,s);:=Text+s+' ';:=Text+#13+#10;:=Text+#13+#10;FindNextPoint(var BestPointAfterBasis:integer;var SpareDistance:real);,min2:real;:integer;,BestColumn:integer;i:=1 to SizeOfMatrix doRound(Matrix[i,0])=basis then:=i;;i:=1 to SizeOfMatrix doMatrix[RowOfBasis,i]=0 then:=i;:=Round(Matrix[0,i]);;:=1e38;i:=1 to SizeOfMatrix do(i<>BestColumn) and (Matrix[RowOfBasis,i]<min1) then

min1:=Matrix[RowOfBasis,i];:=1e38;

for i:=1 to SizeOfMatrix do(i<>RowOfBasis) and (Matrix[i,BestColumn]<min2) then:=Matrix[i,BestColumn];:=min1+min2;;FormLessMatrix(From,T0:integer);,j:integer;,jj:integer;,ColumnOfTo,Row:integer;i:=1 to SizeOfMatrix doRound(Matrix[i,0])=From then:=i;;i:=1 to SizeOfMatrix doRound(Matrix[0,i])=T0 then:=i;;i:=0 to SizeOfMatrix-1 doj:=0 to SizeOfMatrix-1 doi>=RowOfFrom then ii:=i+1ii:=i;j>=ColumnOfTo then jj:=j+1jj:=j;[i,j]:=Matrix[ii,jj];i:=1 to SizeOfMatrix-1 doRound(LessMatrix[i,0])=T0 then:=i;;Row<=SizeOfMatrix-1 then LessMatrix[Row,1]:=1e38;;SizeOfMatrix=2 then:=Matrix[1,2]+Matrix[2,1];:=Matrix[1,1]+Matrix[2,2];min1<min2 then min:=min1min:=min2;:=LowLimit+min;LengthOfBestway>LengthOfWay then(Way.CountOfPoints);.Points[Way.CountOfPoints]:=Round(Matrix[0,2]);:=LengthOfWay;:=Way;(Way.CountOfPoints);;not(HightLimitWasSeted) then:=true;:=LengthOfWay;if SizeOfMatrix>2 then(Way.CountOfPoints);(NextPoint,SpareDistance);.Points[Way.CountOfPoints]:=NextPoint;(Basis,NextPoint);:=Addiction(LessMatrix,SizeOfMatrix-1);:=d+LowLimit;:=LowLimit+SpareDistance;(LessMatrix,SizeOfMatrix-1,NextPoint,LowLimit1);LengthOfBestWay>=LowLimit2 theni:=1 to SizeOfMatrix doRound(Matrix[i,0])=Basis then:=i;;i:=1 to SizeOfMatrix doRound(Matrix[0,i])=NextPoint then:=i;;[Row,Column]:=1e38;(Matrix,SizeOfMatrix);:=LowLimit2LengthOfBestWay<=LowLimit2;(Way.CountOfPoints);raise Error;:=1e38;.CountOfPoints:=1;.Points[1]:=1;:='';:=Addiction(MatrixOfLinking,n);:=false;(MatrixOfLinking,n,1,d0)

end;.

Метод первого порядка

В этом методе Xk+1=Xk-hkf¢(Xk). Очередная точка выбирается в направлении скорейшего убывания функции. Шаг hk должен выбираться достаточно малым, чтоб выполнялось f¢(Xk+1)< f¢(Xk)(рис 3).

Рис.3 Рис.4

Величина шага должна уменьшаться по мере приближения к X0. тогда у нас происходит дробление шага. Шаг hk выбирают так, чтоб выполнялось неравенство

f¢(Xk+1) - f¢(Xk) ? - ? hk// f¢(Xk)//2

где 0 < ? < 1 - произвольно выбранная константа.

На очередном шаге процесса проверяется неравенство. Если оно выполнено - шаг сохраняется, если нет - шаг уменьшается так, чтобы выполнилось неравенство. Геометрическая интерпретация представлена на рис.4. траектория движения аппроксимирует ломаной линией градиентную кривую, проходящую через точки X0 и X0. Если выбрана постоянная величина шага, то количество итераций, которое необходимо выполнить, может оказаться очень большим.

Разновидностью является метод покоординатного спуска (рис.5). Движение к X0 осуществляется по отрезкам прямых, параллельным координатным осям.

Градиентные методы очень просты в реализации и поэтому часто используются на практике. Но при сложной структуре f(Xk) они могут плохо сходится. Поэтому используют вторые производные f(Xk).

Рис.5

Метод второго порядка

Рис.6

Методы второго порядка являются обобщенным методом Ньютона. На рис.6 приведена геометрическая интерпретация отыскания корня уравнения j(X)=0 методом касательных. Разложение j(X) в окрестности Xk дает

j(X) = j(Xk) + j¢(Xk)(X - Xk) + 0(| X - Xk |)

Отбрасывая малые высшего порядка и пологая, что j(X)=0,получим

X = Xk+1 = Xk - j(Xk) / j¢(Xk).

Пусть теперь j(X)- функция n-мерного аргумента. Разложим ее в ряд Тейлора, отбросив малые высшего порядка

j(Xk) + j¢(Xk)(X - Xk)., откуда Xk+1 = Xk - j(Xk) / j¢(Xk).

Теперь считаем j(X)градиентом f(X), т.е. j = f¢. Приравнивая f¢=0, находим стационарные точки f(X). Формула для вычисления координат этих точек преобразуется к виду:

Xk+1 = Xk - f¢(Xk) / f¢¢(Xk).

Недостатки метода Ньютона заключаются в том, что на каждом шаге необходимо вычислять f¢¢, и она должна быть положительно определена, иначе процесс может расходится.

Метод весьма эффективен, но его лучше применять, когда к X0 подошли достаточно близко, причем в районе X0 функция сильно выпукла.

Листинг программы по методам 1го и 2го порядков

f(x:real):real;

// result:=sin(x);:=(x-3)*(x-3)*(x-3)*(x-3);;df(x:real):real;

// result:=cos(x);:=4*(x-3)*(x-3)*(x-3);;ddf(x:real):real;

//result:=-sin(x);:=12*(x-3)*(x-3);;TForm1.Button1Click(Sender: TObject);e,h,xk,xk1,d:real;:integer;:=StrToFloat(Edit3.Text);:=StrToFloat(Edit1.Text);:=StrToFloat(Edit4.Text);.Clear;

Memo1.Text:='Поиск с использованием f''(x)'#13#10#13#10;

i:=0;:=xk1;:=xk-h*df(xk);df(xk)*df(xk1)>0 then h:=h*2;f(xk)<f(xk1) then h:=h/3;(df(xk)*df(xk1)<=0) and (abs(f(xk))>=abs(f(xk1)));.Lines.Add(Format('X( %d )= %4.4f f( %1:4.4f ) = %2:4.4f f''(%1:4.4f )=%3:4.4f h=%4:4.4f',[i,xk,f(xk),df(xk),h] ));(i);(abs(xk1-xk)<e) or (df(xk)=0);.Lines.Add(Format(#13#10'Найдено значение f(%4.4f)=%4.4f с погрешностью e=%4.4f',[xk,f(xk),e]));;TForm1.Button2Click(Sender: TObject);e,h,xk,xk1,d:real;:integer;:=StrToFloat(Edit3.Text);:=StrToFloat(Edit1.Text);:=StrToFloat(Edit4.Text);.Clear;

Memo1.Text:='Поиск с использованием f''(x)'#13#10#13#10;

i:=0;:=xk1;:=xk-h*df(xk)/ddf(xk);df(xk)*df(xk1)>0 then h:=h*2;f(xk)<f(xk1) then h:=h/2;(df(xk)*df(xk1)<=0) and (f(xk)>=f(xk1));.Lines.Add(Format('X( %d )= %4.4f f( %1:4.4f ) = %2:4.4f f''(%1:4.4f )=%3:4.4f h=%4:4.4f',[i,xk,f(xk),df(xk),h] ));(i);(abs(xk1-xk)<e) or (ddf(xk)=0);.Lines.Add(Format(#13#10'Найдено значение f(%4.4f)=%4.4f с погрешностью e=%4.4f',[xk,f(xk),e]));;.

Оптимальный поиск

функция программирование задача

Рассмотрим класс функций одного аргумента, которые называются унимодальными. Определим унимодальную функцию y = f(X) следующим образом:

1.f(X) задана на отрезке [a,b]. 2. пусть X1 и X2 ? [a,b], причем X1 < X2 пусть X0 - точка, в которой f(X) достигает минимума (максимума); тогда из X1 > X0 следует f(X2) > f(X1), а из X2 < X0 следует f(X1) > f(X2).

Примеры унимодальных функций приведены на рис.7. Заметим, что определение унимодальности исключает возможность участков f(X) с постоянным значением

рис. 7

минимум f(X) может находится во внутренней точке [a,b] или на границе. Первоначально о положении X0 ничего не известно, кроме того, что, X0 ? [a,b]. [a,b] можно назвать отрезком неопределенности.

Выбор Xi и вычисление F(Xi) называется экспериментом. Во всех случаях после выполнения заданных экспериментов отрезок неопределенности становится уже. Последовательное повторение экспериментов позволит достигнуть величины отрезка неопределенности меньшей, чем любое наперед заданное ? > 0. правило выбора Xi называется стратегией. Оптимальной называется стратегия, которая приводит к X0 (с точностью до ?) за минимальное число шагов (экспериментов).

Обозначим длину отрезка неопределенности Ln(X1, X2, . . ., Xn), где n - число экспериментов;

f(Xk) = min f(Xi), 1? i ? n,

где K - номер эксперимента, которому соответствует минимальное значение f(Xi). Тогда получим:

X2 - X1, k=1;

Ln(X1, X2, . . ., Xn, к) = Xk+1 - Xk-1, 1? k ? n;

Xn - Xn-1, k=n.

Т.о., Ln зависит как от выбора способа разбиения [a,b], так и от поведения f(X).

Пассивный поиск

В пассивном поиске все эксперименты проводятся одновременно. Без ограничения общности положим X1 = a = 0; Xn = b = 1;

Рассмотрим n = 4; 0 < X2 < X3 < 1

Тогда Ln = max { X2 - 0, X3 - 0, 1 - X2, 1 - X3}= max { X3, 1 - X2}

1? k ? 4= min max { X3, 1 - X2}

0 < X2 < X3 < 1 k= 2,3

Так как X2 < X3, то оптимальной стратегией будет X2 = ½ - ? /2, X3 = ½ + ? /2, а соответствующее Ln = ½ + ? /2 (рис.8,а ).

Под ? > 0 понимают минимальное число, которое делает 2 эксперимента X2 и X3 различными.

При рассмотрении n = 5 получаем (рис 8,б), что Ln улучшилось на ? /2, что заставляет отказаться от нечетного числа экспериментов.

При произвольном четном n наилучшая стратегия составляется парами ? - экспериментов (Xi разнесены на расстояние ?).

В общем случае Ln ? 2/n + ? /2.

рис.8

метод дихотомии

Существует довольно очевидная теорема: "Если непрерывная функция на концах некоторого интервала имеет значения разных знаков, то внутри этого интервала у нее есть корень (как минимум, один, но м.б. и несколько)". Вот на базе этой теоремы и построено численное нахождение приближенного значения корня функции. Обобщенно этот метод называется "дихотомией", т.е. "делением отрезка на две части". Обобщенный алгоритм выглядит так:

задать начальный интервал [a;b];

убедиться, что на концах функция имеет разный знак

< 0.;

Начальное приближение

= .

повторять

выбрать внутри интервала точку X;

сравнить знак функции в точке X со знаком функции в одном из концов;

если совпадает, то переместить этот конец интервала в точку X,

иначе переместить в точку X другой конец интервала;

После каждой итерации отрезок, содержащий корень уменьшается вдвое;

пока не будет достигнута нужная точность.

"Нужная точность" определяется условиями задачи. Иногда требуется, чтобы значение функции было меньше некой наперед заданной величины, но это редко - чаще всего требуется определить значение корня с отклонением от истинного в заданных пределах. Лучше всего, если можно с уверенностью гарантировать интервал, в котором находится корень.

Метод выбора точки деления - ключевой для скорости работы метода. Хорошо, если функция, чей корень находится, проста и быстро вычисляется; но внутри функции могут быть и матричные операции, и численное интегрирование, и все что угодно; так что главным критерием оптимизации является минимизация числа делений (естественно, без ухудшения точности метода).

Метод деления пополам позволяет исключать в точности половину интервала на каждой итерации. При использовании метода считается, что функция непрерывна и имеет на концах интервала разный знак. После вычисления значения функции в середине интервала одна часть интервала отбрасывается так, чтобы функция имела разный знак на концах оставшейся части. Инерционный процесс продолжается до тех пор, пока длина полученного отрезка не станет меньше заданной величины . За приближенное решение принимается средняя точка последнего промежутка.

Метод золотого сечения

Метод золотого сечения позволяет исключать интервалы, вычисляя только одно значение функции на каждой итерации. В результате двух рассмотренных значений функции определяется интервал, который должен использоваться в дальнейшем. Этот интервал будет содержать одну из предыдущих точек и следующую точку, помещаемую симметрично ей. Точка делит интервал на две части так, что отношение целого к большей части равно отношению большей части к меньшей, т. е. равно так называемому «золотому сечению».

Воспользуемся соотношением

Lj-1 = Lj + Lj+1.

Будем поддерживать постоянными отношения длин интервалов

Lj-1 / Lj = Lj / Lj+1 = ?.

Это уравнение имеет единственный положительный корень ? = (1+5^1/2) / 2= 1.618 (рис.9). первые 2 эксперимента

Рис.9

находятся на расстоянии 0.618 от концов отрезка. По результатам экспериментов сохраняется 1 из интервалов, и все повторяется. После n экспериментов

Ln = 1/ ?n-1.

Поиск с помощью метода золотого сечения является асимптотически наиболее эффективным способом реализации минимаксной стратегии поиска, так как требует наименьшего числа оценки значения функции для достижения заданной точности по сравнению с другими методами исключения интервалов.

Листинг программы по методу пассивного поиска, методу дихотомии, методу золотого сечения, оптимальный поиску

function TMyForm.F(x:real):real;:=(2*x-2)*(2*x-2)+2;TMyForm.PasPoisk(XMax,XMin,Eps,D:Real):string;: word;: word;: word;: real;: array[word] of real;:=trunc((2*(XMax-XMin))/Epsilon);(frac((2*(XMax-XMin))/Epsilon)<>0) then inc(N);odd(N) then inc(N);

x[1]:=XMin;[N]:=XMax;

temp:=XMin;i:=1 to (N div 2 - 1) do:=temp+(XMax-XMin)/(N/2);[2*i]:=temp-D;[2*i+1]:=temp+D;:=1;i:=2 to N do(f(x[Index])>f(x[i])) then Index:=i;i:=1 to N do chGraph.Series[0].AddXY(x[i],f(x[i]),'',clBlue);.Series[1].AddXY(x[Index],f(x[Index]),'',clRed);:=FloatToStr(x[Index])+'; Количество итераций = '+IntToStr(N)+'.';TMyForm.Dihotomy(XMax,XMin,Eps,D:Real):string;: word;: array [1..4] of real;[1]:=XMin;[4]:=XMax;:=2;.Series[0].AddXY(x[1],f(x[1]),'',clAqua);.Series[0].AddXY(x[4],f(x[4]),'',clAqua);((abs(x[4]-x[1])/2)>Eps) do[2]:=((x[4]-x[1])/2)-D;[3]:=((x[4]-x[1])/2)+D;(N,2);.Series[0].AddXY(x[2],f(x[2]),'',clAqua);.Series[0].AddXY(x[2],f(x[3]),'',clAqua);(f(x[3])>f(x[2])) then x[4]:=x[3]x[1]:=x[2];.Series[1].AddXY((x[1]+x[4])/2,f((x[1]+x[4])/2),'',clRed);:=FloatToStr((x[1]+x[4])/2)+'; Количество итераций = '+IntToStr(N);TMyForm.GoldSection(XMax,XMin,Eps,D:Real):string;Tau=0.618;: byte;: word;: array[1..4] of Real;: array[1..4] of Real;[1]:=XMin;[4]:=XMax;[2]:=XMax-Tau*(XMax-XMin);

x[3]:=XMin+Tau*(XMax-XMin);

for i:=1 to 4 do y[i]:=f(x[i]);i:=1 to 4 do chGraph.Series[0].AddXY(x[i],f(x[i]),'',clRed);:=4;(abs(x[4]-x[1])/2)>Eps doy[3]>y[2] then[4]:=x[3]; y[4]:=y[3];[3]:=x[2]; y[3]:=y[2];[2]:=x[4]-Tau*(x[4]-x[1]);[2]:=f(x[2]);.Series[0].AddXY(x[2],y[2],'',clRed);(N)[1]:=x[2]; y[1]:=y[2];[2]:=x[3]; y[2]:=y[3];[3]:=x[1]-Tau*(x[4]-x[1]);[3]:=f(x[3]);.Series[0].AddXY(x[3],y[3],'',clRed);(N);.Series[1].AddXY((x[1]+x[4])/2,f((x[1]+x[4])/2),'',clBlue);:=FloatToStr((x[4]+x[1])/2)+'; Количество итераций = '+IntToStr(N);TMyForm.OptPoisk(XMax,XMin,Eps,D:Real):string;fb: array[byte] of word;: array[1..4] of real;: array[byte] of real;: byte;: word;[1]:=XMin;

fb[0]:=1;[4]:=XMax;[1]:=1;:=1;

while (fb[N]<((XMax-XMin)/Eps)) do(N);[N]:=fb[N-1]+fb[N-2];[N]:=((XMax-XMin)-fb[N-2]*D)/fb[N];i:=1 to N-1 do[i]:=fb[N-i+1]*L[N]-fb[N-i-1]*D;i:=1 to N do[2]:=x[4]-L[i];[3]:=x[1]+L[i];.Series[0].AddXY(x[2],f(x[2]),'',clBlue);.Series[0].AddXY(x[3],f(x[3]),'',clBlue);f(x[3])>f(x[2]) then[4]:=x[3];[3]:=x[2][1]:=x[2];[2]:=x[3];;.Series[1].AddXY((x[1]+x[4])/2,f((x[1]+x[4])/2),'',clRed);:=FloatToStr((x[4]+x[1])/2)+'; Количество итераций = '+IntToStr(N);TMyForm.ExitClick(Sender: TObject);;TMyForm.btExecClick(Sender: TObject);:=StrToFloat(edMin.Text);:=StrToFloat(edMax.Text);:=StrToFloat(edEps.Text);:=0.25*Epsilon('Данные некорректны');;.Enabled:=False;.Enabled:=False;.Enabled:=False;.Enabled:=False;.Enabled:=False;.Enabled:=False;.Enabled:=False;.Enabled:=False;.Width:=500;.Height:=310;.Show;.Show;rbM1.Checked=true then lbX.Caption:=lbX.Caption+(PasPoisk(XMax,XMin,Epsilon,Delta));rbM2.Checked=true then lbX.Caption:=lbX.Caption+(Dihotomy(XMax,XMin,Epsilon,Delta));rbM3.Checked=true then lbX.Caption:=lbX.Caption+(GoldSection(XMax,XMin,Epsilon,Delta));rbM4.Checked=true then lbX.Caption:=lbX.Caption+(OptPoisk(XMax,XMin,Epsilon,Delta));;.

Динамическое программирование

Метод динамического программирования - широко известный и мощный математический метод современной теории управления.

Рассмотрим управляемую систему, состояние которой в каждый момент времени характеризуется n-мерным вектором x с компонентами x1 , …, xn . Предполагаем, что время t изменяется дискретно и принимает целочисленные значения 0, 1, …. Так, для процессов в экономике и экологии дискретным значениям времени могут отвечать дни, месяцы или годы, а для процессов в электронных устройствах интервалы между соседними дискретными моментами времени равны времени срабатывания устройства. Предполагаем, что на каждом шаге на систему оказывается управляющее воздействие при помощи m-мерного вектора управления u с компонентами u1 , …, um . Таким образом, в каждый момент времени t состояние системы характеризуется вектором x(t), а управляющее воздействие - вектором u(t). На выбор управления обычно бывают наложены ограничения, которые в достаточно общей форме можно представить в виде

u(t) k U, t = 0, 1, …

Здесь U - заданное множество в n-мерном пространстве.

Под влиянием выбранного в момент t управления (принятого решения) система переходит в следующий момент времени в новое состояние. Этот переход можно описать соотношением

x(t + 1) = f (x(t), u(t)), t = 0, 1, …

Здесь f (x, u) - n-мерная функция от n-мерного вектора x и m-мерного вектора u, характеризующая динамику рассматриваемой системы. Эта функция предполагается известной (заданной) и отвечает принятой математической модели рассматриваемого управляемого процесса.

Зададим еще начальное состояние системы

(0) = x0,

где x0 - заданный n-мерный вектор. Таким образом, многошаговый процесс управления описывается соотношениями (1)-(3). Процедура расчета конкретного процесса сводится к следующему. Пусть в некоторый момент t состояние системы x(t) известно. Тогда для определения состояния x(t + 1) необходимо выполнить две операции:

1)выбрать допустимое управление u(t), удовлетворяющее условию (1);

2)определить состояние x(t + 1) в следующий момент времени согласно (2). Так как начальное состояние системы задано, то описанную процедуру можно последовательно выполнить для всех t = 0, 1, … Последовательность состояний x(0), x(1), … часто называется траекторией системы.

Заметим, что выбор управления на каждом шаге содержит значительный произвол. Этот произвол исчезает, если задать цель управления в виде требования минимизации (или максимизации) некоторого критерия оптимальности. Таким образом мы приходим к постановке задачи оптимального управления.

Задача оптимального управления

Пусть задан некоторый критерий качества процесса управления (критерий оптимальности) вида

Здесь R(x, u) и F (x) - заданные скалярные функции своих аргументов, N - момент окончания процесса, N > 0. При этом функция R может отражать расход средств или энергии на каждом шаге процесса, а функция F - характеризовать оценку конечного состояния системы или точность приведения в заданное состояние.

Задача оптимального управления формулируется как задача определения допустимых управлений u(0), u(1), …, u(N - 1), удовлетворяющих ограничениям (1), и соответствующей траектории, то есть последовательности x(0), x(1), …, x(N ), которые в совокупности доставляют минимальное значение критерию (4) для процесса (2), (3).

Минимизация критерия (4) обычно отвечает выбору управления, обеспечивающего наименьшие затраты средств, ресурсов, энергии, наименьшее отклонение от заданной цели или заданной траектории процесса. Наряду с этим часто ставится также задача о максимизации критерия вида (4), например о максимизации дохода или объема производства. Однако нетрудно видеть, что максимизация критерия J эквивалентна минимизации критерия (- J ). Поэтому простая замена знака у функций R и F в (4) приводит задачу о максимизации критерия к задаче о его минимизации. Далее всюду для определенности рассматриваем задачу о минимизации критерия (4).

Листинг программы

type= string[3];= array of ElType;FORBIDDEN:ElType = 'x';: TForm1;

D: Array of TVector; // Матрица весов переходов

P: Array of TVector; // Матрица узлов

{$R *.dfm}TForm1.Button2Click(Sender: TObject);, j: integer;

_Width, _Height: Integer;, Weight2: integer;, Y: Integer;: string;

_Width := 5;

_Height := 4;(D, _Width);i := Low(D) to High(D) do(D[i], 2 * _Height - 1);[0,0] := '4'; D[1,0] := '5'; D[2,0] := '3';[0,1] := '5'; D[1,1] := '4'; D[2,1] := '6';[0,2] := '4'; D[1,2] := '5'; D[2,2] := '5';[0,3] := '4'; D[1,3] := '5'; D[2,3] := '6';[0,4] := '6'; D[1,4] := '5'; D[2,4] := '5';[0,5] := '7'; D[1,5] := '5'; D[2,5] := '7';[0,6] := '6'; D[1,6] := '8'; D[2,6] := '7';[3,0] := '5'; D[4,0] := FORBIDDEN;[3,1] := '6'; D[4,1] := '7';[3,2] := '5'; D[4,2] := FORBIDDEN;[3,3] := '6'; D[4,3] := '8';[3,4] := '7'; D[4,4] := FORBIDDEN;[3,5] := '8'; D[4,5] := '9';[3,6] := '7'; D[4,6] := FORBIDDEN;(P, _Width);i := Low(P) to High(P) do(P[i], _Height);i := Low(P) to High(P) doj := Low(P[i]) to High(P[i]) do begin(i=0) and (j=0) then begin[i,j] := '0';;;(i=0) then begin[i,j] := IntToStr(StrToInt(P[i,j-1]) + StrToInt(D[i,2*j-1]));;;(j=0) then begin[i,j] := IntToStr(StrToInt(P[i-1,j]) + StrToInt(D[i-1,2*j]));;;:= StrToInt(P[i,j-1]) + StrToInt(D[i,2*j-1]);:= StrToInt(P[i-1,j]) + StrToInt(D[i-1,2*j]);Weight1<Weight2 then begin[i,j] := IntToStr(Weight1);[i-1,2*j] := FORBIDDEN;[i,j] := IntToStr(Weight2);[i,2*j-1] := FORBIDDEN;;;i := Low(P) to High(P) do begin:= '';j := Low(P[i]) to High(P[i]) do:= S + P[i,j] + #9;.Lines.Add(S);;:= _Width;:= _Height;:= '(' + IntToStr(X) + ';' + IntToStr(Y) + ')';(X<>1) and (Y<>1) do beginD[X-1-1,2*Y-1-1]<>FORBIDDEN then X := X - 1Y := Y - 1;:= '(' + IntToStr(X) + ';' + IntToStr(Y) + ') -> ' + S;;:= '(1;1) -> ' + S;(S);;.

Линейное программирование. Метод Джордана-Гаусса

Методы линейного программирования - численные методы решения оптимизационных задач, cводящихся к формальным моделям линейного программирования <#"265" src="doc_zip29.jpg" />

Divide(var V: Vector; D: real): boolean;: Integer;:= true;I := Low(V) to High(V) do(V[I]=0) and (D=0) then V[I] := 0 elseD<>0 then[I] := V[I] / DResult := false;;Multiply(var V: Vector; K: real);: Integer;I := Low(V) to High(V) do[I] := V[I] * K;;Subtract(var V1, V2: Vector);: Integer;I := Low(V1) to High(V1) do[I] := V1[I] - V2[I];;TForm1.Button2Click(Sender: TObject);: Matrix;, j: integer;: real;: TStringList;(M,StringGrid1.RowCount-1);I := Low(M) to High(M) do(M[I],StringGrid1.ColCount-1);I := Low(M) to High(M) doJ := Low(M[I]) to High(M[I]) do[I,J] := StrToInt(StringGrid1.Cells[J+1,I+1]);:= TStringList.Create;.Add('<style> .matrix {text-align: right; padding-right: 0.5em; padding-left: 1em; margin: -4;} </style>');.Add('<ol><p>Данная СЛАУ:');

MatrixToHTML(Report, M);I := Low(M) to High(M) do begin.Add('<li><p>Избавляемся от коэффициентов перед <i>x_{' + IntToStr(I+1) + '}</i>:');M[i,i]<>1 thennot Divide(M[I], M[I,I]) then begin // Приведение текущей строки(Handle, 'Деление на ноль: ...', 'Внимание', MB_OK + MB_ICONWARNING);.Free;;;j := Low(M) to High(M) do beginI=j then Continue;:= 1;M[I,I]<>M[J,I] then begin:= M[J,I];not Divide(M[J], k) then begin(Handle, 'Деление на ноль: ...', 'Внимание', MB_OK + MB_ICONWARNING);.Free;;;;(M[j],M[I]);(k<>1) and (I>j) then Multiply(M[j], k);;(Report, M);;.SaveToFile(ExtractFilePath(Application.ExeName) + 'result.html');.Free;(Handle, PChar('Создан файл отчета: ' + ExtractFilePath(Application.ExeName) + 'result.html'),

'Решение получено', MB_OK + MB_ICONINFORMATION);.Navigate(ExtractFilePath(Application.ExeName) + 'result.html');;TForm1.Button1Click(Sender: TObject);: Integer;:= StrToInt(LabeledEdit1.Text);.RowCount := N+1;.ColCount := N + 2;;

end.

Заключение

В результате выполнения данной курсовой работы были изучены и программно реализованы алгоритмы методов оптимизации и по результатам выполнения программ проанализированы изученные в этом семестре методы решения задач на динамическое, линейное и нелинейное программирование.

В результате выполнения работы были реализованы следующие алгоритмы:

Метод ветвей и границ на примере задачи о коммивояжоре;

Поиски 1-ого и 2-ого порядка;

Линейное программирование на примере симплексного метода.

Список литературы

1.Галкин А.А. методы оптимизации в примерах и задачах: Учеб. Пособие. - Владимир: ВПИ, 1989. - 96 с.

2.Жирков В.Ф. моделирование производственных процессов с дискретным характером управления: Учеб. Пособие. - Владимир: НПИ, 1984. - 84 с.

.Черноусько Ф.Л., Баничук Н.В. Вариационные задачи механики и управления: Численные методы. М.: Наука, 1973. 238 с.

4.Internet.

СОДЕРЖАНИЕ Метод ветвей и границ Метод первого порядка Метод второго порядка Оптимальный поиск Пассивный поиск метод дихотомии Метод зо

Больше работ по теме: