РефератыИнформатикаРеРешение задач линейного программирования симплекс методом

Решение задач линейного программирования симплекс методом

Федеральное агентство по образованию РФ


Федеральное государственное образовательное учреждение


Среднего профессионального образования


Барнаульский строительный колледж


Курсовая работа.


По дисциплине: «Математические методы»


На тему: «Решение задач линейного программирования симплекс методом»


Выполнил: Нунгесер М.В.


Специальность: ПОВТ


Группа: 0881


Преподаватель: Клепикова Н.Н.


Барнаул 2010


Содержание:


Введение


Линейное программирование


Симплекс метод


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


Разработка алгоритма


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


Программная реализация на языке Delphi


Приложение


Заключение


Список используемой литературы


Введение

В последние годы в прикладной математике большое внимание уделяется новому классу задач оптимизации, заключающихся в нахождении в заданной области точек наибольшего или наименьшего значения некоторой функции, зависящей от большого числа переменных. Это так называемые задачи математического программирования, возникающие в самых разнообразных областях человеческой деятельности и прежде всего в экономических исследованиях, в практике планирования и организации производства. Изучение этого круга задач и методов их решения привело к созданию новой научной дисциплины, получившей позднее название линейного программирования. В конце 40-х годов американским математиком Дж. Данцигом был разработан эффективный метод решения данного класса задач – симплекс-метод. К задачам, решаемых этим методом в рамках математического программирования относятся такие типичные экономические задачи как «Определение наилучшего состава смеси», «Задача об оптимальном плане выпуска продукции», «Оптимизация межотраслевых потоков», « Задача о выборе производственной программы», «Транспортная задача», «Задача размещения», «Модель Неймана расширяющейся экономики» и другие. Решение таких задач дает большие выгоды как народному хозяйству в целом, так и отдельным его отраслям.


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


Линейное программирование

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


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


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


Математическая формулировка задачи линейного программирования


Нужно определить максимум линейной целевой функции (линейной формы)



при условиях



Иногда на xi
также накладывается некоторый набор ограничений в виде равенств, но от них можно избавиться, последовательно выражая одну переменную через другие и подставляя её во всех остальных равенствах и неравенствах (а также в функции f).


Такую задачу называют «основной» или «стандартной» в линейном программировании. Наиболее известным и широко применяемым на практике для решения общей задачи линейного программирования (ЛП) является симплекс метод.
Симплекс метод

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


Применение симплекс-метода для задачи линейного программирования предполагает предварительное приведение ее формальной постановки к канонической форме с n
неотрицательными переменными: (X1
, ..., Xn
)
, где требуется минимизация линейной целевой функции при m
линейных ограничениях типа равенств. Среди переменных задачи выбирается начальный базис из m
переменных, для определенности (X1
, ..., Xm
)
, которые должны иметь неотрицательные значения, когда остальные (n-m)
свободные переменные равны 0. Целевая функция и ограничения равенства преобразуются к диагональной форме относительно базисных переменных, переменных, где каждая базисная переменная входит только в одно уравнение с коэффициентом 1.


Данная формальная модель задачи линейного программирования обычно задается в форме, так называемой
симплекс-таблицы
, удобной для выполнения операций симплекс-метода:


Симплекс-таблица





























































1 X1
X2
... Xm
Xm+1
... Xn
X0
A0,0
0 0 ... 0 A0,m+1
... A0,n
X1
A1,0
1 0 ... 0 A1,m+1
... A1,n
X2
A2,0
0 1 ... 0 A2,m+1
... A2,n
... ... ... ... ... ... ... ... ...
Xm
Am,0
0 0 ... 1 Am,m+1
... Am,n

Верхняя строка симплекс-таблицы представляет целевую функцию задачи. Каждая строка симплекс-таблицы, кроме первой, соответствует определенному ограничению-равенству задачи. Свободные члены ограничений составляют крайний левый столбец таблицы. Слева от таблицы записаны текущие базисные переменные(X1
, ..., Xm
)
. Сверху от таблицы приведен набор всех переменных задачи, где Xm+1
, ..., Xn
- свободные переменные задачи.


На начальном шаге алгоритма симплекс-метода должно быть выбрано базисное допустимое решение(X1
, ..., Xm
) >= 0
при Xj
= 0 (j = m+1, ..., n)
, следовательно, все свободные члены ограничений Ai,0
>= 0 (i = 1, ..., m)
. Когда это условие выполнено, симплекс-таблица называется прямо-допустимой
, так как в этом случае базисные переменные, равные Ai,0
, определяют допустимое решение прямой задачи линейного программирования. Если все коэффициенты целевой функции A0,j
>= 0 (j = 1, ..., m)
, то симплекс-таблица называется двойственно-допустимой
, поскольку соответствующее решение является допустимым для двойственной задачи линейного программирования.


Если симплекс-таблица является одновременно прямо и двойственно допустимой, т.е. одновременно все Ai,0
>= 0
и A0,j
>= 0
, то решение оптимально.


Действительно, поскольку допустимыми являются лишь неотрицательные значения управляемых параметров, то изменение целевой функции за счет вариации свободных переменных, через которые она выражена, возможно только в сторону увеличения, т.e. будет ухудшаться. Если среди ее коэффициентов имеются A0,j
< 0
, то значение целевой функции еще можно уменьшить (т.e. улучшить), увеличивая значение любой свободной переменнойXj
с отрицательным коэффициентом A0,j
при побочном уменьшении базисных переменных, чтобы оставались справедливы ограничения задачи. Теоретически можно использовать любую свободную переменнуюXj
с A0,j
< 0
, но на практике обычно действуют в соответствии со стратегией наискорейшего спуска, выбирая минимальный элемент A0,p
< 0
из всех отрицательных A0,j
<&nbsp0
:


A0,p
= min
A0,j
< 0.j

Столбец p
симплекс-таблицы, соответствующий выбранному коэффициенту A0,p
< 0
, называется ведущим столбцом
. Свободная переменная ведущего столбца должна быть введена в базис вместо одной из текущих базисных переменных. Очевидно, из базиса следует исключить такую переменную Xq
, которая раньше других обращается в нуль при увеличении переменной Xp
ведущего столбца.


Её индекс легко определить, если среди положительных элементов ведущего столбца p
найти элемент, минимизирующий отношение (Ai,0
/ Ai,p
)
:


Aq,0
Ai,0
------ = min
------ , i = 1,...,m.Aq
,
p
iAi
,
p

Элемент Aq
,
p
называется ведущим элементом
, cтрока q
симплекс-таблицы, содержащая ведущий элемент, называется, соответственно, ведущей строкой
. Переменная ведущей строки Xq
заменяется в базисе переменной ведущего столбца Xp
и становится свободной переменной с значением 0, в то время как новая базисная переменнаяXp
достигнет максимально возможного значения, равного: max
Xp
= ( Aq
,0
/ Aq
,
p
).


После указанного взаимообразного обмена переменными Xp
и Xq
между наборами свободных и базисных переменных нужно модифицировать исходную каноническую модель задачи путем приведения ее к диагональной форме относительно нового множества базисных переменных. Для указанного преобразования можно формально использовать процедуру исключения Гаусса
, которая, как известно, состоит из двух элементарных операций, применяемых к системе алгебраических уравнений ( в данном случае ограничений - равенств):


· умножение уравнения E1
(X) = 0
на константу K1
и замена уравнения E1
(X) = 0
уравнением K1
*E1
(X) = 0;


· сложение уравнений E1
(X) = 0
и E2
(X) = 0
c последующей заменой уравнения E2
(X) = 0
уравнением E1
(X) + E2
(X) = 0
.


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


Ai,p
= 0, если i не равно q


и


Ai,p
= 1, если i = q.


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


Практика применения симплекс метода показала, что число итераций, требуемых для решения задачи линейного программирования обычно колеблется от 2m
до 3m
, хотя для некоторых специально построенных задач вычисления по правилам симплекс метода превращаются в прямой перебор базисных допустимых решений. Однако, трудные для симплекс метода задачи на практике встречаются крайне редко, что объясняет широкое распространение и большую популярность данного метода линейного программирования по сравнению с другими подходами.


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

На звероферме могут выращиваться норки, выдры и нутрии. Для обеспечения нормальных условий их выращивания используется 3 вида кормов. Количество корма каждого вида, которое должны получать зверьки в среднем приведено в таблице:

































Количество единиц корма, которое ежедневно должны получать
Вид корма
Норка
Выдра
Нутрия
Общее количество корма
I
4
2
5
190
II
5
3
4
320
III
7
9
5
454
Прибыль от реализации одной шкурки, руб.
150
320
350

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


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

1) Поставленная описательная задача переводится в математическую форму (целевая функция и ограничения).


2) Полученное математическое описание приводят к канонической форме.


3) Каноническую форму приводят к матричному виду.


4) Ищут первое допустимое решение. Для этого матрица должна быть правильной. Матрица в ЗЛП называется правильной, если она содержит минимум m правильных (базисных) столбцов, где m – число строк в матрице. Столбец в канонической ЗЛП называется правильным (базисным), если все его элементы равны нулю, кроме единственного равного единице.


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


6) Строят последовательность матриц. Нужно определить ведущий столбец, ведущую строку и ведущий элемент. Элемент, соответствующий ведущей строке, удаляется из базиса, а на его место ставят элемент, соответствующий ведущему столбцу. Составляют уравнение пересчета матрицы, выполняют пересчет, а затем проверяют его результаты на оптимальность. Если решение не оптимально, то заново ограничивают ведущий элемент, ведущую строку и ведущий столбец.


Признаком оптимальности решения является наличие в векторе решений только отрицательных или нулевых коэффициентов при всех ограничениях.


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


- Каждому отрицательному коэффициенту в векторе решения ставится в соответствие нулевой коэффициент для соответствующей переменной в ответе.


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


- Фиктивные переменные в ответе не учитываются.


Ведущим может быть назначен любой столбец, удовлетворяющий одному из условий:


1) Первый столбец, содержащий положительный элемент в векторе решений.


2) Столбец, содержащий наибольший положительный элемент в строке решения.


3) Если столбец удовлетворяет условию max(Cj
min bj
/aij
)
при решении на max, и m
in
(Cj
min bj
/aij
)
при решении задач на min.


Cj

– коэффициент целевой функции в столбце j, aij
– коэффициент в столбце j и строке i.


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

Определим максимальное значение целевой функции F(X) = 3500 x1
+3200 x2
+1500 x3
при следующих условиях ограничений.


4 x1
+ 2 x2
+ 5 x3
<=190


5 x1
+ 3 x2
+ 4 x3
<=320


7 x1
+ 9 x2
+ 5 x3
<=454


Для построения первого опорного плана систему неравенств приведем к системе уравнений путем введения дополнительных переменных.


4x1
+ 2x2
+ 5x3
+ 1x4
+ 0x5
+ 0x6
= 190


5x1
+ 3x2
+ 4x3
+ 0x4
+ 1x5
+ 0x6
= 320


7x1
+ 9x2
+ 5x3
+ 0x4
+ 0x5
+ 1x6
= 454


Матрица коэффициентов A = a(ij) этой системы уравнений имеет вид:


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


Решим систему уравнений относительно базисных переменных:


x4
, x5
, x6


Полагая, что свободные переменные равны 0, получим первый опорный план: X1 = (0,0,0,190,320,454)


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


Переходим к основному алгоритму симплекс-метода.










































X1
X2
X3
X4
X5
X6
св. чл.
4

2 5 1 0 0 190
5 3 4 0 1 0 320
7 9 5 0 0 1 454
-3500 -3200 -1500 0 0 0 0

Итерация №0


Текущий опорный план неоптимален, так как в индексной строке находятся отрицательные коэффициенты


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


Вычислим значения Di
по строкам как частное от деления


и из них выберем наименьшее:


Следовательно, 1-ая строка является ведущей


Разрешающий элемент равен 4 и находится на пересечении ведущего столбца и ведущей строки


Формируем следующую часть симплексной таблицы.


Вместо переменной x в план 1 войдет переменная x1


Строка, соответствующая переменной x1
в плане 1, получена в результате деления всех элементов строки x4
плана 0 на разрешающий элемент РЭ=4


На месте разрешающего элемента в плане 1 получаем 1.


В остальных клетках столбца x1
плана 1 записываем нули.


Таким образом, в новом плане 1 заполнены строка x1
и столбец x1
.


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


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


НЭ = СЭ - (А*В)/РЭ


СТЭ - элемент старого плана, РЭ - разрешающий элемент (4), А и В - элементы старого плана, образующие прямоугольник с элементами СТЭ и РЭ.


Представим расчет каждого элемента в виде таблицы:









































X1
X2
X3
X4
X5
X6
св. чл.
1 1/2 5/4 1/4 0 0 190/4
5 3 4 0 1 0 320
7 9 5 0 0 1 454
3500 3200 1500 0 0 0








































X1
X2
X3
X4
X5
X6
св. чл.
1 1/2 5/4 1/4 0 0 190/4
0 1/2 -9/4 -5/4 1 0 165/2
0 11/2

-15/4 -7/4 0 1 243/2
0 -1450 2875 875 0 0

Итерация №1


Текущий опорный план неоптимален, так как в индексной строке находятся отрицательные коэффициенты


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


Вычислим значения Di
по строкам как частное от деления и из них выберем наименьшее:


Следовательно, 3-ая строка является ведущей


Разрешающий элемент равен 5.5 и находится на пересечении ведущего столбца и ведущей строки


Формируем следующую часть симплексной таблицы.


Вместо переменной xв план 2 войдет переменная x2


Строка, соответствующая переменной x2
в плане 2, получена в результате деления всех элементов строки x6
плана 1 на разрешающий элемент РЭ=5.5


На месте разрешающего элемента в плане 2 получаем 1.


В остальных клетках столбца x2
плана 2 записываем нули.


Таким образом, в новом плане 2 заполнены строка x2
и столбец x2
.


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


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


НЭ = СЭ - (А*В)/РЭ


СТЭ - элемент старого плана, РЭ - разрешающий элемент (5.5), А и В - элементы старого плана, образующие прямоугольник с элементами СТЭ и РЭ.


Представим расчет каждого элемента в виде таблицы:


Конец итераций: найден оптимальный план


Окончательный вариант симплекс-таблицы:









































X1
X2
X3
X4
X5
X6
св. чл.
1 0 159/100 41/100 0 -9/100 729/20
0 0 -191/100 -109/100 1 -9/100 1429/20
0 1 -15/22 -7/22 0 9/50 243/11
0 0 1886.36 413.64 0 263.64

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


x1 = 729/20=36.45


x5 =1429/20= 71.45


x2 =243/11= 22.09


F(X) = 3500*36.45 + 3200*22.09 = 198281.82


Программная реализация

unit Unit1;


interface


uses


Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,


Dialogs, StdCtrls, ExtCtrls;


type


TForm1 = class(TForm)


Label1: TLabel;


Label2: TLabel;


Edit2: TEdit;


Exit: TButton;


Button_Next: TButton;


Edit1: TEdit;


Button_Prev: TButton;


ScrollBox1: TScrollBox;


Conditions: TGroupBox;


Label3: TLabel;


Extrem: TComboBox;


Memo1: TMemo;


procedure ExitClick(Sender: TObject);


proced

ure Button_NextClick(Sender: TObject);


procedure Button_PrevClick(Sender: TObject);


procedure FormCreate(Sender: TObject);


private


{ Private declarations }


public


{ Public declarations }


end;

const


mm = 100; nn = 100;


var


Form1: TForm1;


table_changed,done,solve,is_ok,kanon,need_basis,need_i_basis,is_basis,written: boolean;


m,n,y,i_basis,i0,j0,step,iter: integer;{m - элементов , n - ограничений}


pole: array [1..nn, 1..mm] of TEdit; {полядляввода}


podpis: array [0..nn, 0..mm] of TLabel; {подписиполей}


znak: array [1..nn] of TComboBox; {знакисравненияограничений}


matrix: array [1..nn, 1..mm] of double; {массивдлярассчетов}


all_basis: array [1..nn] of integer;{номерабазисныхпеременных}


f: text;{файловая переменная для отчета}


tochnost: double;


implementation


{$R *.dfm}


procedure Init;


{инициализация: ввод размеров системы}


Begin


form1.Button_Prev.Enabled:=false;


form1.Edit1.Enabled:=true;


form1.Edit2.Enabled:=true;


form1.Extrem.Enabled:=true;


form1.ScrollBox1.DestroyComponents;{расчищаемместоподтабличку}


table_changed:=true;


tochnost:=0.000000001;


assign(f, 'report.htm');


end;


procedure Step1;


{шаг первый: создание таблички и ввод значений}


var


i,j: integer;


nadpis: string;


begin


form1.Memo1.ReadOnly:=false;


form1.Memo1.Lines.Clear;


form1.Memo1.ReadOnly:=true;


form1.Extrem.Enabled:=true;


iftable_changed=truethen {если меняли количество эл-тов или ограничений,}


begin {то создаем новую табличку}


table_changed:=false;


m:=strtoint(form1.Edit1.Text);{считываемколичествопеременных}


n:=strtoi


nt(form1.Edit2.Text);{иограничений}


form1.Edit1.Enabled:=false;{блокируемполядляихввода}


form1.Edit2.Enabled:=false;


i:=0; {используем нулевую строку массива подписей для заголовков}


for j:=1 to 3 do {подписываемчто is что}


begin


podpis[i,j]:=TLabel.Create(Form1.ScrollBox1);


podpis[i,j].parent:=form1.ScrollBox1;


podpis[i,j].Left:=5;


podpis[i,j].Top:=32*(j-1); {расстояниемеждунадписями}


case j of


1: nadpis:='Целеваяфункция:';


2: nadpis:='F(x)=';


3: nadpis:='Система ограничений:';


end;


podpis[i,j].Caption:=nadpis;


end;


i:=n+1; {используем последнюю строку массива полей для целевой ф-ции}


for j:=1 to m+1 do


begin


pole[i,j]:=TEdit.Create(Form1.ScrollBox1);


pole[i,j].parent:=form1.ScrollBox1;


pole[i,j].Height:=20;


pole[i,j].Width:=40;


pole[i,j].Left:=80*(j-1)+30;


pole[i,j].Top:=30;


pole[i,j].Text:='0';


if j<=m then


begin


podpis[i,j]:=TLabel.Create(Form1.ScrollBox1);


podpis[i,j].parent:=form1.ScrollBox1;


podpis[i,j].Height:=20;


podpis[i,j].Width:=20;


podpis[i,j].Left:=pole[i,j].Left+pole[i,j].Width+2;


podpis[i,j].Top:=pole[i,j].Top+2;


podpis[i,j].Caption:='X['+inttostr(j)+']';


if j<>m+1 then podpis[i,j].Caption:=podpis[i,j].Caption+' +';


{если поле не последнее, то дописываем плюсик}


end;


end;


for i:=1 to n do {полядлявводаограничений}


for j:=1 to m+1 do


begin


pole[i,j]:=TEdit.Create(Form1.ScrollBox1);


pole[i,j].parent:=form1.ScrollBox1;


pole[i,j].Height:=20;


pole[i,j].Width:=40;


pole[i,j].Left:=80*(j-1)+5; {расстояние между соседними + отступ от края}


pole[i,j].Top:=40*(i-1)+100;


pole[i,j].Text:='0';


if j<=m then


begin


podpis[i,j]:=TLabel.Create(Form1.ScrollBox1);


podpis[i,j].parent:=form1.ScrollBox1;


podpis[i,j].Height:=20;


podpis[i,j].Width:=20;


podpis[i,j].Left:=pole[i,j].Left+pole[i,j].Width+2;


podpis[i,j].Top:=pole[i,j].Top+2;


podpis[i,j].Caption:='X['+inttostr(j)+']';


if j<>m then podpis[i,j].Caption:=podpis[i,j].Caption+' +'


{если поле не последнее, то дописываем плюсик; иначе пишем знак}


else begin


znak[i]:=TComboBox.Create(Form1.ScrollBox1);


znak[i].parent:=form1.ScrollBox1;


znak[i].Height:=20;


znak[i].Width:=40;


znak[i].Left:=podpis[i,j].Left+podpis[i,j].Width+25;


znak[i].Top:=pole[i,j].Top;


znak[i].Items.Insert( 0,'> ');


znak[i].Items.Insert( 1,'>=');


znak[i].Items.Insert( 2,' =');


znak[i].Items.Insert( 3,'<=');


znak[i].Items.Insert( 4,'< ');


znak[i].ItemIndex:=1;


end;


end else pole[i,j].Left:=pole[i,j].Left+70; //полядляправойчасти


//ограничений


end;


endelse {если табличку создавать не надо, то разблокируем поля}


begin


for i:=1 to n+1 do


for j:=1 to m+1 do


begin


pole[i,j].Enabled:=true;


if i<=n then znak[i].Enabled:=true;


end;


end;


end;


{/////////////////}


procedure write_system(strok,stolb: integer);


{записывает массив в виде уравнений}


var


i,j: integer;


begin


write(f,'<P>F(x) = ');


for j:=1 to stolb do


begin


write(f,matrix[strok,j]:0:3);


if j<stolb then


begin


write(f,'x<sub>',j,'</sub>');


if (kanon=true) and (j=stolb-1) then write(f,' = ') else


if (matrix[strok,j+1]>=0) then write(f,' + ') else write(f,' ');


end;


end;


writeln(f,'</P>');


writeln(f,'<P>При ограничениях:</P><P>');


for i:=1 to strok-1 do


begin


for j:=1 to stolb do


BEGIN


write(f,matrix[i,j]:0:3);


if j<stolb then write(f,'x<sub>',j,'</sub> ');


if j=stolb-1 then


if kanon=false then write(f,' ',znak[i].text,' ')


else write(f,' = ');


if (matrix[i,j+1]>=0) and (j<stolb-1) then write(f,'+');


end;


writeln(f,'<br>');


end;


writeln(f,'</P>');


end;


{/////////////////}


procedure zapisat(strok,stolb: integer; v_strok,v_stolb:integer);


{записывает массив в виде таблички}


var


i,j:integer;


begin


writeln(f,'<TABLE BORDER BORDERCOLOR=black CELLSPACING=0 CELLPADDING=5>');


for i:=0 to strok do


begin


writeln(f,'<TR>');


for j:=1 to stolb+1 do


begin


write(f,'<TD ');


if i=0 then


begin


if (i_basis<>0) and (j>m+y-i_basis) and (j<=m+y) then


write(f,'BGCOLOR=yellow ')


else


write(f,'BGCOLOR=green ');


end


else


if (i=v_strok) or (j=v_stolb) then write(f,'BGCOLOR=silver ') else


if (i=strok) or (j=stolb) then


if (j<>stolb+1) then write(f,'BGCOLOR=olive ');


write(f,'align=');


if (i=0) and (j<stolb) then write(f,'center>X<sub>',j,'<sub>') else


if (i=0) and (j=stolb) then write(f,'center>св. чл.') else


if (i=0) and (j=stolb+1) then write(f,'center>базис') else


if (j=stolb+1) then


if i<>n+1 then write(f,'center>X<sub>',all_basis[i],'</sub>') else


write(f,'center>&nbsp')


else


write(f,'right>',matrix[i,j]:1:3);


writeln(f,'</TD>');


end;


writeln(f,'</TR>');


end;


writeln(f,'</TABLE>');


end;


{/////////////////}


procedure findved;


{ищет ведущий элемент}


var


i,j,k: integer;


temp: double;


begin


done:=false;


solve:=false;


is_ok:=true;


temp:=100000;


i0:=0;


j0:=0;


i:=n+1;


for j:=1 to m+y do


if (i0=0) or (j0=0) then


if matrix[i,j]>0 then


begin


j0:=j;


for k:=1 to n do


if (matrix[k,j]>0) then


if (matrix[k,m+y+1]/matrix[k,j]<temp) then


begin


temp:=matrix[k,m+y+1]/matrix[k,j];


i0:=k;


end;


end;


if (j0=0) and (i0=0) then


for j:=1 to m do


if matrix[n+1,j]=0 then


for i:=1 to n do


if (matrix[i,j]<>0) and (matrix[i,j]<>1) then


begin


is_ok:=false;


j0:=j;


end;


if is_ok=false then


begin


temp:=100000;


for k:=1 to n do


if (matrix[k,j0]>0) then


if (matrix[k,m+y+1]/matrix[k,j0]<temp) then


begin


temp:=matrix[k,m+y+1]/matrix[k,j0];


i0:=k;


end;


end;


if (j0=0) and (i0=0) then


begin


writeln(f, '<P>Конецвычислений</P>');


done:=true;


solve:=true;


end


else if (j0<>0) and (i0=0) then


begin


writeln(f, '<P>Не удается решить систему</P>');


done:=true;


solve:=false;


end


else


if iter<>0 then


begin


writeln(f,'<P><b>Итерация ',iter,'</b></P>');


writeln(f, '<P>Найдем ведущий элемент:</P>');


zapisat(n+1,m+y+1,i0,j0);


writeln(f,'<P>Ведущий столбец: ',j0,'<br>Ведущая строка: ',i0,'</P>');


write(f,'<P>В строке ',i0,': базис ');


writeln(f,'X<sub>',all_basis[i0],'</sub> заменяем на X<sub>',j0,'</sub></P>');


all_basis[i0]:=j0;


end;


end;


{/////////////////}


procedure okr;


{округляетмелкиепогрешности}


var


i,j: integer;


begin


for i:=1 to n+1 do


for j:=1 to m+y+1 do


if abs(matrix[i,j]-round(matrix[i,j]))< tochnost then


matrix[i,j]:=round(matrix[i,j]);


end;


{/////////////////}


procedurepreobr;


{преобразует массив относительно ведущего элемента}


var


i,j,k,l,t: integer;


temp: double;


begin


if done=false then


begin


write(f, '<P>Пересчет:</P>');


temp:=matrix[i0,j0];


for j:=1 to m+y+1 do matrix[i0,j]:=matrix[i0,j]/temp;


for i:=1 to n+1 do


begin


temp:=matrix[i,j0];


for j:=1 to m+y+1 do


if (i<>i0) then


matrix[i,j]:=matrix[i,j]-matrix[i0,j]*temp;


end;


okr;


zapisat(n+1,m+y+1,-1,-1);


{/////////////////////////убираем искусственный базис/////////////////////}


ifi_basis>0 then {если он есть }


begin


t:=0;


forj:=m+y-i_basis+1 tom+ydo {от первого исскусственного элемеента до конца}


begin


need_i_basis:=false;{предполагаем, что элемент не нужен (*)}


fori:=1 tondo {просматриваем столбец}


ifall_basis[i]=jthen{и если элемент в базисе}


need_i_basis:=true;{тогда он все-таки нужен}


if need_i_basis=false then t:=j;


{если наши предположения (*) подтвердились, то запомним этот элемент}


end;


if t<>0 then


begin


for k:=1 to n+1 do {во всех строках}


begin


forl:=ttom+ydo {от текущего столбца до последнего}


matrix[k,l]:=matrix[k,l+1];{заменяем элемент на соседний}


matrix[k,m+y+1]:=0;{а последний убираем}


end;


{столбец удален! надо это запомнить}


y:=y-1;


i_basis:=i_basis-1;


ifi_basis>0 then {если остались еще искусственные переменные,}


forl:=m+y-i_basis+1 tom+ydo{то от первой из них до последней}


fori:=1 tondo {просматриваем строки в столбце}


if matrix[i,l]=1 then all_basis[i]:=l; {туда, где 1, заносим в базис}


writeln(f,'<P>Искусственная переменная исключена из базиса<br>');


writeln(f,'и может быть удалена из таблицы.');


writeln(f,'</P>');


zapisat(n+1,m+y+1,-1,-1);


end;


end;


{///////////////закончили убирать искусственный базис////////////////////}


end;


end;


{/////////////////}


procedure otvet;


{выводит ответ}


var


i,j: integer;


begin


writeln(f,'<P><b>ОТВЕТ:</b></P>');


form1.Memo1.ReadOnly:=false;


form1.Memo1.Lines.Clear;


form1.Memo1.Lines.Add('ОТВЕТ:');


form1.Memo1.Lines.Add('');


if (solve=true) and (i_basis=0) then


write(f,'F(');


form1.Memo1.Lines.Text:=form1.Memo1.Lines.Text+'F(';


if form1.Extrem.ItemIndex=0 then


begin


write(f,'max) = ',0-matrix[n+1,m+y+1]:0:3);


form1.Memo1.Lines.Text:=form1.Memo1.Lines.Text+'max) = ';


form1.Memo1.Lines.Text:=form1.Memo1.Lines.Text+floattostr(0-matrix[n+1,m+y+1]);


end


else


begin


write(f,'min) = ',matrix[n+1,m+y+1]:0:3);


form1.Memo1.Lines.Text:=form1.Memo1.Lines.Text+'min) = ';


form1.Memo1.Lines.Text:=form1.Memo1.Lines.Text+floattostr(matrix[n+1,m+y+1]);


end;


writeln(f,'<br>при значениях:<br>');


form1.Memo1.Lines.Add('');


form1.Memo1.Lines.Add('');


form1.Memo1.Lines.Add('при значениях:');


form1.Memo1.Lines.Add('');


for j:=1 to m do


begin


writeln(f,'x<sub>',j,'</sub> = ');


form1.Memo1.Lines.Text:=form1.Memo1.Lines.Text+'X[';


form1.Memo1.Lines.Text:=form1.Memo1.Lines.Text+inttostr(j);


form1.Memo1.Lines.Text:=form1.Memo1.Lines.Text+'] = ';


written:=false;


for i:=1 to n do


if all_basis[i]=j then


begin


writeln(f,matrix[i,m+y+1]:0:3,'<br>');


form1.Memo1.Lines.Text:=form1.Memo1.Lines.Text+floattostr(matrix[i,m+y+1]);


form1.Memo1.Lines.Add('');


form1.Memo1.Lines.Add('');


written:=true;


end;


if written=false then


begin


writeln(f,'0.000 <br>');


form1.Memo1.Lines.Text:=form1.Memo1.Lines.Text+'0';


form1.Memo1.Lines.Add('');


form1.Memo1.Lines.Add('');


end;


end;


end else


begin


writeln(f,'<P>Решениененайдено.(</P>');


form1.Memo1.Lines.Text:=form1.Memo1.Lines.Text+'Решениененайдено.';


end;


form1.Memo1.ReadOnly:=true;


end;


{/////////////////}


procedure Step2;


{шаг второй: решение задачи и формирование отчета}


var


i,j: integer;


k: integer;


begin


for i:=1 to n+1 do


for j:=1 to m+1 do


begin


matrix[i,j]:=strtofloat(pole[i,j].Text); {Вводимзначениявмассив}


pole[i,j].Enabled:=false; {Блокируемполя}


if i<=n then znak[i].Enabled:=false;{блокируемзнаки}


end;


form1.Extrem.Enabled:=false;


{////////////////////////////////////////////////////////////////////////////}


{ имеемматрицу [ n+1, m+1 ] }


rewrite(f);


writeln(f,'<HTML>');


writeln(f,'<HEAD>');


writeln(f,'<TITLE>Отчет</TITLE>');


writeln(f,'</HEAD>');


writeln(f,'<BODY>');


writeln(f,'<H1>Отчет</H1>');


write(f,'<P><b>Необходимо ');


if form1.Extrem.ItemIndex=0 then write(f,'макс') else write(f,'мин');


writeln(f,'имизировать целевую функцию:</b></P>');


kanon:=false;{еще не в канонической форме}


write_system(n+1,m+1);{Выведем ее в отчет}


{приведем ее к каноническому виду}


writeln(f,'<P><b>Приведем к каноническому виду:</b></P>');


y:=0;{количество дополнительных переменных}


need_basis:=false;


for i:=1 to n do


if znak[i].ItemIndex<>2 then {если ограничение не является равенством}


begin


y:=y+1; {вводим дополнительную переменную, для этого:}


for k:=1 to n+1 do begin {во всех ограничениях и в ЦФ}


{перед правой частью добавляем столбец}


matrix[k,m+y+1]:=matrix[k,m+y];


matrix[k,m+y]:=0;{состоящий из нулей}


end;


{а в текущем ограничении, если знак был > или >=}


if (znak[i].ItemIndex=0) or (znak[i].ItemIndex=1) then


begin


matrix[i,m+y]:=-1;{записываем -1}


need_basis:=true;


end


else {иначе, т.е. в случае < или <=}


matrix[i,m+y]:=1; {записываем 1}


end


else need_basis:=true;


{ЦФ приравнивается к нулю, а свободный член переносится в правую часть:}


matrix[n+1,m+y+1]:=0-matrix[n+1,m+y+1];


{правые части ограничений должны быть неотрицательны, проверим это:}


for i:=1 to n do {для всех ограничений}


if matrix[i,m+y+1]<0 then {если правая часть отрицательна,}


{то отнимаем всю строку от нуля}


for j:=1 to m+y+1 do matrix[i,j]:=(0-matrix[i,j]);


kanon:=true;{система приведена к каноническому виду}


{выведем ее в отчет}


write_system(n+1,m+y+1);


{если ф-ция на минимум, то нужно поменять знаки в последней строке}


if form1.Extrem.ItemIndex=1 then


for j:=1 to m+y+1 do matrix[n+1,j]:=0-matrix[n+1,j];


{////////////////////////////////////////////////////////////////////////////}


{////////////////////////// Тут надо ввести базис ///////////////////////////}


i_basis:=0;


fori:=1 tondo {то во всех ограничениях}


begin


is_basis:=false;


for j:=1 to m+y do


if (matrix[i,j]=1) then


if (is_basis=false) then


begin


all_basis[i]:=j;


is_basis:=true;


for k:=1 to n do


if k<>i then


if (matrix[k,j]<>0) then


if (is_basis=true) then


begin


is_basis:=false;


all_basis[i]:=0;


end;


end;


if is_basis=false then


begin


i_basis:=i_basis+1;


y:=y+1;


for k:=1 to n+1 do


begin {во всех ограничениях и в ЦФ}


{перед правой частью добавляем столбец}


matrix[k,m+y+1]:=matrix[k,m+y];


matrix[k,m+y]:=0;{состоящий из нулей}


end;


matrix[i,m+y]:=1;


all_basis[i]:=m+y;


end;


end;


{//////////////// Закончили ввод искусственного базиса //////////////////////}


{////////////////////////////////////////////////////////////////////////////}


{////////////////////////////////////////////////////////////////////////////}


{//////////////// теперь надо от него избавиться ////////////////////////////}


ifi_basis>0 then


begin


write(f, '<H2>Необходимо ввести искусственный базис</H2>');


zapisat(n+1,m+y+1,-1,-1);


writeln(f, '<P>Искусственный базис введен.<br>');


writeln(f, 'Избавившись от него, получим первое допустимое решение</P>');


iter:=0;

repeat


inc(iter);


findved;


preobr;


until (i_basis=0) or (iter=20) or (done=true);


if i_basis=0 then


begin


writeln(f,'<P>Искусственный базис выведен полностью.<br>');


writeln(f,'Получено первое допустимое решение!</P>');


end


else


begin


writeln(f,'<P>Не удалось вывести искусственный базис.<br>');


writeln(f,'Решение не найдено.</P>');


end;


end;


{//////////////////////// попытки избавленя окончены ////////////////////////}


{////////////////////////////////////////////////////////////////////////////}


{/////////////////////////////// SIMPLEX START /////////////////////////////}


if i_basis=0 then


begin


iter:=0;


findved;


if done=false then


begin


writeln(f,'<H2>Применяем симплекс метод</H2>');


repeat


inc(iter);


findved;


preobr;


until (done=true) or (iter=20);


end;


end;


otvet;


{/////////////////////////////// SIMPLEX END ///////////////////////////////}


writeln(f,'</BODY>');


writeln(f,'</HTML>');


CloseFile(f);


{////////////////////////////////////////////////////////////////////////////}


end;


{////////////////////////////////////////////////////////////////////////////}


{///////// все, что ниже, относится к переходам между шагами ////////////////}


{////////////////////////////////////////////////////////////////////////////}


procedure TForm1.ExitClick(Sender: TObject);


begin


Close();


end;


procedure TForm1.Button_NextClick(Sender: TObject);


begin


step:=step+1;


Form1.Button_Prev.Enabled:=true;


case step of


1:Step1;


2:begin


Step2;


Form1.Button_Next.Enabled:=false;


end;


else step:=step-1;


end;


form1.Caption:='Симплекс метод - шаг '+inttostr(step);


end;


procedure TForm1.Button_PrevClick(Sender: TObject);


begin


step:=step-1;


Form1.Button_Next.Enabled:=true;


case step of


0:begin


Init;


Form1.Button_Prev.Enabled:=false;


end;


1:Step1;


else step:=step+1;


end;


form1.Caption:='Симплекс метод - шаг '+inttostr(step);


end;


procedure TForm1.FormCreate(Sender: TObject);


begin


Init;


end;


Заключение

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


Таким образом, вычислительная техника в настоящее время находит широкое применение, как в общей математике, так и в одном из её разделов – математических методах.


Список используемой литературы

1. Зайченко Ю.П., Шумилова С.А. Исследование операций.


2. Лищенко «Линейное и нелинейное программирование», М. 2003


3. А.Н. Карасев, Н.Ш. Кремер, Т.Н. Савельева «Математические методы в экономике», М.2000


4. Орлов А.И. Теория принятия решений. Учебное пособие. - М.: Издательство "Март", 2004


5. Интернет

Сохранить в соц. сетях:
Обсуждение:
comments powered by Disqus

Название реферата: Решение задач линейного программирования симплекс методом

Слов:4737
Символов:52336
Размер:102.22 Кб.