Графическое решение задач линейного программирования. Курсовая работа (т). Информационное обеспечение, программирование. 2014-05-08

Содержание

Введение

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

.1 Требования к функциям,
выполняемым системой

.2 Требования к
программно-аппаратному обеспечению

.3 Требования к техническому
обеспечению

.4 Требования к эргономике и
технической эстетике

.5 Требования к надежности и
хранению информации

. Основная часть

.1 Математическая модель

.2 Метод решения задачи

.3 Структурная схема программы

.4 Схема взаимодействия модулей

. Руководство программисту

. Руководство пользователю

.1 Общие сведения

.2 Работа с помощью

.3 Наиболее вероятные ошибки

Заключение

Список использованных источников

Приложение А – Текст программы

Приложение Б – Формы программы

Аннотация

Курсовой проект на тему «Графическое решение
задач линейного программирования» содержит введение, четыре главы, заключение и
приложения, которые состоят из текста, формы программы и диска с программой.

Программный продукт разработан в среде
программирования Borland Delphi 7. Данная программа предназначена для получения
практических навыков в разработке программных средств с использованием
современных алгоритмических языков программирования и информационных
технологий, стандартизации основных этапов жизненного цикла программных
средств, стандартизации документирования программных средств, обеспечении
надежности и качества функционирования программных средств, использовании
методов тестирования программного обеспечения.

Имеется удобный и понятный интерфейс для работы
с программой.

Введение

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

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

Задачи курсового проекта:

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

описать создание программного продукта по теме
работы.

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

Составить математическую модель графического
решения задач линейного программирования. Описать предъявляемые требования к
эргономике и технической эстетики для разработанного интерфейса программы.
Разработать программный продукт для графического решения задач линейного
программирования.

К основным параметрам функциональных задач в
постановке задачи относятся:

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

)условия решения задачи с использованием средств
вычислительной техники:

– процессор:
Pentium/Celeron/AMD K5- 2400 MHz;

– монитор SVGA, поддерживающий графический режим
1024*768;

размер ОЗУ 1024Мб;

свободное пространство на жестком диске не менее
20 Мб;

видео карта 512 Мб;

клавиатура;

мышь;

)содержание функций обработки входной информации
при решения задачи: по введенным данным будет производиться расчет задачи;

)требование к периодичности решения задачи:
данный программный продукт будет использоваться по требованию оператора;

)ограничение по срокам и точностям выходной
информации: информация предоставляется сразу после завершения процесса обработки
входной информации;

)состав и форма представления выходной
информации: выходные данные выводятся на экран;

)источники входной информации для решения
задачи: данные о технических характеристиках компьютеров;

)пользователи задачи: программный продукт рассчитан
на конечного пользователя.

.1 Требования к функциям, выполняемым системой

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

Обладать автоматизированным сбором информации,
представлять информацию в более удобном виде.

В программном продукте реализованы следующие
функции:

–   решение задачи;

–          справка.

1.2 Требования к программно-аппаратному
обеспечению

Программное обеспечение должно удовлетворять
следующим требованиям:

–          возможность
экономично и целесообразно использовать предоставляемую память;

–          включать в себя
проверку целостности данных;

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

Для корректной работы с программным продуктом
необходимо наличие следующих минимальных конфигураций аппаратного окружения :

–          операционная
система Windows XP, Windows
7 Ultimate;

–          Delphi 7;

–          Microsoft
Office 2003, 2007.

.3 Требования к техническому обеспечению

Для работы с программным продуктом необходимо
наличие следующих минимальных конфигураций аппаратного окружения:

–   процессор
Intel Atom N570 CPU 3.2 GHz;

–          RAM
– 1Gb;

–          HDD
– 120Gb;

–          мышь;

–          монитор
LG G2225HQ.

1.4 Требования к эргономике и технической
эстетике

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

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

Интерфейс должен быть рассчитан на
преимущественное использование манипулятора типа «мышь», то есть управление
системой должно осуществляться с помощью набора экранных меню, кнопок, значков
и т. п. элементов. Клавиатурный режим ввода должен используется главным образом
при заполнении и/или редактировании текстовых и числовых полей экранных форм.
Все надписи экранных форм, а также сообщения, выдаваемые пользователю (кроме
системных сообщений) должны быть на русском языке.

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

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

Экранные формы должны проектироваться с учетом
требований унификации:

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

–   для обозначения сходных
операций должны использоваться сходные графические значки, кнопки и другие
управляющие (навигационные) элементы. Термины, используемые для обозначения
типовых операций (добавление информационной сущности, редактирование поля
данных), а также последовательности действий пользователя при их выполнении,
должны быть унифицированы;

–        внешнее поведение сходных элементов
интерфейса (реакция на наведение указателя «мыши», переключение фокуса, нажатие
кнопки) должны реализовываться одинаково для однотипных элементов.

.5 Требования к надежности и хранению информации

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

Вся система должна обладать надёжностью,
необходимо предусмотреть, самые неожиданные действия пользователя и если они
неправильны, программа должна объяснить, как сделать то, чего хочет программа
от пользователя.

Данный программный продукт характеризуется
высокой степенью_ надежности хранения информации. При некорректных действиях

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

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

Хранение программного продукта может
осуществляться на любом магнитном или оптическом носителе информации. В нашем
случае применены компакт диски CD-R/DWD-R
и Flash – носители.

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

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

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

Программная документация, в
общем виде, должна удовлетворять следующим требованиям:

–   соответствие
требованиям стандартов единой системы программной документации;

–          понятность
документации;

–          полнота
документации;

–          возможность
освоения программного обеспечения по документации;

–          возможность
освоения программного обеспечения на контрольном примере;

–          легкость
установки и запуска программного обеспечения;

–          понятность
входных и выходных данных;

–          наличие
описания структуры функций программного обеспечения;

–          соответствие
функций программного обеспечения требованиям
техническому заданию;

–          наличие
описания функций программного обеспечения;

–          отсутствие
противоречий в реализации интерфейса с пользователем;

–          отсутствие
противоречий в диагностике системы;

–   обеспечение
помощи пользователю при затруднениях средствами
функции подсказки;

–   достаточность
документации для ввода программного обеспечения в
эксплуатации;

–          правильность
документации;

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

–          наличие
краткой аннотации программного обеспечения;

–          наличие
описания решаемых задач;

–          наличие
описания ограничении по применению;

–          наличие
описания алгоритмов.

2. Основная часть

.1 Математическая модель

Математическая модель – это математическое
представление реальности.

Математическое моделирование – это процесс
построения и изучения математических моделей.

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

Графический способ решения ЗЛП целесообразно
использовать для решения задач с двумя переменными, когда ограничения выражены
системой неравенств 1:

 (1)

x1 ≥ 0,
x2 ≥ 0

.2 Метод решения задачи

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

) Построить прямые уравнения, которые получаются
в результате замены в ограничения знаков неравенств на знаки равенств;

) Найти полуплоскости, определяемые каждым из
ограничений задачи;

) Определить многоугольник решений;

4) Построить вектор  = (c1;c2) – вектор
градиент;

) Построить прямую F = c1x1 c2x2 = 0,
проходящую через начало координат и перпендикулярную вектору ;

) Передвигать прямую F в
направлении вектора , в
результате чего либо находят точку, в которой целевая функция принимает
экстремум (максимум или минимум), либо устанавливают неограниченность функции
на множестве планов;

) Определить координаты точки
экстремума функции и вычислить значение целевой функции в этой точки.

Пример. Предприятие изготавливает два вида
продукции – П1 и П2, которая поступает в оптовую продажу. Для производства
продукции используются два вида сырья – А и В. Максимально возможные запасы
сырья в сутки составляют 9 и 13 единиц соответственно. Расход сырья на единицу
продукции вида П1 и вида П2 дан в таблице 1.

Таблица 1 – Расход сырья продукции

Опыт работы показал, что суточный спрос на
продукцию П1 никогда не превышает спроса на продукцию П2 более чем на 1 ед.
кроме того, известно, что спрос на продукцию П2 никогда не превышает 2 ед. в
сутки.

Оптовые цены единицы продукции равны: 3д.е. –
для П1 4 д.е. для П2.

Какое количество продукции каждого вида должно
производить предприятие, чтобы доход от реализации продукции был максимальным?

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

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

х1 3х2 £ 9;

х1 2х2 £ 13;

х1 – х2 £ 1;                                                                                             (2)

х2 £ 2;

х1 £ 0; х2 £
0.

Доход от реализации х1 единиц продукции П1 и х2
продукции П2 составит F
= 3×1 4×2.

Таким образом, мы приходим к следующей
математической задаче: среди всех неотрицательных решений данной системы
линейных неравенств требуется найти такое, при котором функция F
принимает максимальное значение Fmax
.

Найдем решение данной задачи графическим
способом.

Построим многоугольник решений. Для этого в
системе координат Х10Х2 на плоскости изобразим граничные прямые L1,
L2, L3,
L4:

х1 3х2 = 9 (L1);

х1 2х2 = 13 (L2);

х1 – х2 = 1 (L3);

х2 = 2 (L4).

Для построения прямой Z
= 3х1 4х2 = 0 строим вектор-градиент С = (3;4) и через точку 0 проводим
прямую, перпендикулярную ему. Построенную прямую Z
= 0 перемещаем параллельно самой себе в направление вектора С. Из рисунка 9
следует, что по отношению к многоугольнику решений опорной эта прямая
становится в точке С, где функция принимает максимальное значение. Точка С
лежит на пересечении прямых L1
и L3. для определения
ее координат решим систему уравнений 1:

х1 3х2 = 9;

х1 – х2 = 1.                                                                                             (1)

Оптимальный план задачи х1 = 2,4; х2 = 1,4.
подставляя значения х1 и х2 в линейную функцию, получим равенство 1:

Zmax = 3 * 2,4
4 * 1,4 = 12,8.     (1)

Полученное решение означает, что объем
производства продукции П1 должен быть равен 2,4 ед., а продукции П2 – 1,4 ед.
доход, получаемый в этом случае, составит: Z
= 12,8 д.е. Ответ показан на рисунке 1:

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

.3 Структурная схема программы

Программный продукт имеет конструкцию построения
– состав и взаимосвязь программный модулей. Пример структурной схемы программы
представлен на рисунке 2.

Рисунок 2 – Структурная схема программы

.4 Схема взаимодействия модулей

Программа содержит 4 модуля. Схема
взаимодействия модулей программы изображена на рисунке 3.

Рисунок 3 – Схема взаимодействия модулей

3. Руководство программисту

Данный программный продукт написан в среде
визуального программирования Borland
Delphi 7 и был основан на
модульном программировании. В программе используются стандартные компоненты Delphi,
с помощью которых осуществляется её реализация. Программа включает в себя
следующие файлы:

–   graph_simplex.dpr
– содержит общее описание проекта;

–          graph_simplex.cfg
– содержит параметры и настройки компилятора;

–          graph_simplex.dof
– содержит параметры и настройки проекта;

–          graph_simplex.res
– файл
ресурсов;

–          graph_simplex.exe
– исполнимый
файл;

–          файлы с расширением
*.pas – файлы модулей
которые содержат код программы;

–          файлы с расширением
*.dfm – файлы в которых
находится описание окон;

–          файлы с расширением
*.dcu – результат
преобразования текста модулей в машинные инструкции.

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

Программы включает в себя 4 модуля каждый из
которых выполняют определенные функции:

MainForm
– рабочая среда программы;

NewTaskForm
– новая задача ;- новая симплекс – таблица ;

AboutForm
– вызов справки

Для начала работы с программой нужно запустить
файл graph_simplex.exe.

Текст программы представлен в приложении А.

4. Руководство пользователю

.1 Общие сведения

Данная программа предназначена для графического
решения задач линейного программирования.

Для начала работы с программой необходимо
запустить файл graph_simplex.exe.

Для запуска программы выбрать вкладку «Задача».
В появившемся окне ввести информацию из задачи в новую симплекс-таблицу, после
чего нажать «ОК». Далее следует выбрать выбрать критерий минимизации и
максимизации, после чего на главном окне появятся графическое решение и
уравнения решения данной задачи

Для получения справочной информации по программе
следует после запуска программы щелкнуть по вкладке «Справка».

Работу программы можно посмотреть в приложении
Б.

.2 Работа с помощью

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

Для вызова справки нужно выбрать на панели
инструментов пункт «Справка».

1)   Справка «О программе»
(рисунок
4).

Рисунок 4 – Справка «О программе»

.3 Наиболее вероятные ошибки

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

Окно ошибки при не правильном выборе количества
ограничений показано на рисунке 5:

Рисунок 5 – Окно ошибки при не
правильном выборе количества ограничений

Заключение

В курсовом проекте изложен теоретический
материал по теме «Графическое решение задач линейного программирования»,
приведен пример решения задач данным методом.

Результатом курсового проекта является
программный продукт, выполненный в среде программирования Borland Delphi 7, с
использованием дополнительных компонентов, и разработан по всем правилам
разработки программного продукта.

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

Приложение A

Текст программы

program
graph_simplex;

{$IFDEF
VER240}

{$R ‘theory.res’
‘..docstheory.rc’}

{$ELSE}

{$R ‘..bintheory.res’}

{$ENDIF},in
‘formsNewTaskFormNewTaskFormUnit.pas’ {NewTaskForm},in ‘formsMainFormMainFormUnit.pas’
{MainForm},in ‘formsTaskSizeFormTaskSizeFormUnit.pas’ {TaskSizeForm},in
‘formsAboutFormAboutFormUnit.pas’ {AboutForm};

{$R *.res}.Initialize;

{$IF CompilerVersion >
18.5}.MainFormOnTaskbar := True;

{$IFEND}.CreateForm(TMainForm, MainForm);.Run;.MainFormUnit;,
Messages, SysUtils, Variants, Classes,, Controls, Forms, Dialogs, Menus,
ExtCtrls,, StdCtrls, MSimplexMath, ComCtrls,, ToolWin, ImgList, Buttons,
OleCtrls, ActiveX,, SHDocVw;= record: Double;: Double;;= class(TForm):
TMainMenu;: TMenuItem;: TMenuItem;: TMenuItem;: TMenuItem;: TPanel;:
TPaintBox;: TMenuItem;: TMenuItem;: TActionList;: TAction;: TPanel;:
TTrackBar;: TLabel;: TRichEdit;: TPanel;: TCheckBox;: TCheckBox;: TBevel;:
TBevel;: TToolBar;: TToolButton;: TToolButton;: TToolButton;: TCheckBox;:
TImageList;: TMenuItem;: TAction;: TSaveDialog;: TSpeedButton;: TSpeedButton;:
TPanel;: TWebBrowser;: TCheckBox;: TComboBox;miExitClick(Sender:
TObject);FormCreate(Sender: TObject);FormDestroy(Sender:
TObject);FormResize(Sender: TObject);PaintBoxPaint(Sender:
TObject);acNewTaskExecute(Sender: TObject);miAboutClick(Sender:
TObject);tbScaleChange(Sender: TObject);cbDrawDirectFunctionDomainClick(Sender:
TObject);cbDrawGridClick(Sender: TObject);cbDrawFunctionDomainClick(Sender:
TObject);acSaveBmpExecute(Sender: TObject);cbDrawDirectVectorClick(Sender:
TObject);TaskSpeedButtonClick(Sender: TObject);TheorySpeedButtonClick(Sender:
TObject);TaskTypeComboBoxChange(Sender: TObject);: Integer;: Integer;:
TMatrix;: TVector;: TVector;: array of Integer;

что
x1 >= 0; x2 >= 0;X2Positive: boolean;, sy: Double;: Boolean;: Boolean;:
Integer;: Integer;: Double;: TBitMap;:
Boolean;DrawGraph;SolveTask;DrawFunctionDomain;DrawGrid;TestForInfinite(ALine1,
ALine2: TVector; AMinMaxValue: Double): Boolean;DrawDirectVector;LineToPoint(a1,
b1, c1: Double; a2, b2, c2: Double; var x,y: Double):Boolean;GetSignStr(Index:
Integer): string;PointBelongsRest(x, y: Double; ARestIndex: Integer;
x1x2positive: boolean): boolean;PointBelongsRestDomain(x, y: Double;
x1x2positive: boolean): boolean;WMErasebkgnd(var Msg: TWMErasebkgnd); message
WM_ERASEBKGND;GetGraphScale: Double;GraphScale: Double read GetGraphScale;;:
TMainForm;

{$R *.dfm}, NewTaskFormUnit,
AboutFormUnit;GetTempDirPath: string;: string;: integer;(EnvStr, 256);:=GetEnvironmentVariable(‘temp’,
PChar(EnvStr), 256);(EnvStr, returnsize);returnsize > 0 then
begin:=EnvStr;else begin:=”;;;CheckForSlash(AString: string): string;:
string;AString <> ” then begin:=Trim(AString);LString[Length(LString)]
<> PathDelim then begin:=LString PathDelim;;:=LString;else
begin:=”;;;WriteInRichEd(RichEd: TRichEdit; S: string; Color: TColor; ASize:
Integer; Style: TFontStyles);.SelStart :=
Length(RichEd.Text);.SelAttributes.Color := Color;.SelAttributes.Style :=
Style;.SelAttributes.Size := ASize;.SelText := S;;PointInRect(APoint: TPoint;
ARect: TRect): Boolean;:= (APoint.X > ARect.Left) and (APoint.Y >
ARect.Top) and (APoint.X < ARect.Right) and (APoint.Y <
ARect.Bottom);;CheckForNil(AValue: Double): Double;AValue = 0 then:= 1;else:=
AValue;;;CheckOne(AValue: Double): string;AValue = 1 then:= ”;elseAValue = – 1
then:= ‘-‘;else:= FloatToStr(AValue);;;;CheckMinusPlus(AValue: Double):
string;AValue < 0 then:= CheckOne(AValue);else:= ‘ ‘
CheckOne(AValue);;;TMainForm.GetSignStr(Index: Integer): string;S[Index] of

: Result := ‘=’;

: Result := ‘>=’;

: Result :=
‘<=’;;;,TMainForm.LineToPoint(a1, b1, c1: Double; a2, b2, c2: Double; var
x,y: Double):Boolean;: Double;: Double;: Double;:= a1 * b2 – b1 * a2;d <>
0 then:= true;:= -c1 * b2 b1 * c2;:= -a1 * c2 c1 * a2;:= – dx / d;:= – dy /
d;else:= false;;;TMainForm.acNewTaskExecute(Sender: TObject);: Integer;:
TNewTaskForm;: TTaskSizeForm;:=
TTaskSizeForm.Create(nil);LTaskSizeForm.ShowModal = mrOk then:=
TNewTaskForm.Create(nil);.N := 2;:= LTaskSizeForm.M;.M :=
LTaskSizeForm.M;LNewTaskForm.ShowModal = mrOk then.Enabled := true;:=
LNewTaskForm.cbTaskType.ItemIndex;.ItemIndex :=
LNewTaskForm.cbTaskType.ItemIndex;(S, FM);i := 0 to FM – 1 do[i] :=
LNewTaskForm.Sign[i];;:= LNewTaskForm.NMatrix;:= LNewTaskForm.Vectorb;:=
LNewTaskForm.Vectorc;;:=
true;;;.Free;;;.Free;;;TMainForm.acSaveBmpExecute(Sender:
TObject);SaveDialog.Execute
then.SaveToFile(SaveDialog.FileName);;;TMainForm.cbDrawDirectFunctionDomainClick(Sender:
TObject);;;TMainForm.cbDrawDirectVectorClick(Sender:
TObject);;;TMainForm.cbDrawFunctionDomainClick(Sender:
TObject);;;TMainForm.cbDrawGridClick(Sender: TObject);;;

// Процедура
рисования направляющего вектораTMainForm.DrawDirectVector;,
y: Double;, y1: Double;, y2: Double;, y3: Double;, yp: Double;: Double;, yp1:
Double;(C[0] = 0) and (C[1] = 0) then;;:= C[0];:= C[1];x <> 0 then x1 :=
x / sqrt(sqr(x) sqr(y));y <> 0 then y1 := y / sqrt(sqr(x) sqr(y));:=
x1;:= y1;FWidthdiv2 < FHeightdiv2 then:= FWidthdiv2 (x * FWidthdiv2);:=
FHeightdiv2 ( – y * FWidthdiv2);else:= FWidthdiv2 (x * FHeightdiv2);:=
FHeightdiv2 ( – y * FHeightdiv2);;

// Рисуем линию.Canvas.Pen.Width
:= 2;.Canvas.Pen.Color := clRed;.Canvas.Font.Color := clRed;.Canvas.MoveTo(FWidthdiv2,
FHeightdiv2);.Canvas.LineTo(Round(xp), Round(yp));

// Рисуем стрелки:=
– 1 * x * 20;:= y * 20;:= 15 * pi / 180;:= xp1 * Cos(LAlpha) – yp1 *
Sin(LAlpha);:= xp1 * Sin(LAlpha) yp1 * Cos(LAlpha);:= xp x;:= yp y;.Canvas.MoveTo(Round(xp),
Round(yp));.Canvas.LineTo(Round(x2), Round(y2));:= x2;:= y2;:= – 15 * pi /
180;:= xp1 * Cos(LAlpha) – yp1 * Sin(LAlpha);:= xp1 * Sin(LAlpha) yp1 *
Cos(LAlpha);:= xp x;:= yp y;.Canvas.MoveTo(Round(xp), Round(yp));.Canvas.LineTo(Round(x2),
Round(y2));.Canvas.MoveTo(Round(x2), Round(y2));.Canvas.LineTo(Round(x3),
Round(y3));;TMainForm.DrawFunctionDomain;: Integer;, y: Double;: Double;, y1:
Double;, y2: Double;, y3: Double;, p2: TPoint;: Double;, OfsY: Double;:
Integer;: Double;: Integer;: array[1..4] of TPointd;(x1; y1) Рё
P2(x2; y2)= (x1 x2) / 2; y = (y1 y2) / 2;

{P1P2}.

(l,m): l(x-x0) m(y-y0)=0.j := 0 to
FM – 1 do(A[j, 0] = 0) and (A[j, 1] = 0) then;;

// 0 – ‘=’;

// 1 – ‘>=’;

// 2 – ‘<=’;S[j] <> 0
then:= 1;A[j, 1] <> 0 then:= FWidthdiv2 / GraphScale;:= (B[j] – (A[j, 0]
* x)) / A[j, 1];Abs(y) <= (FHeightdiv2 / GraphScale) then[LPointIndex].x :=
x;[LPointIndex].y := y;:= LPointIndex 1;;;A[j, 1] <> 0 then:= –
FWidthdiv2 / GraphScale;:= (B[j] – (A[j, 0] * x)) / A[j, 1];Abs(y) <=
(FHeightdiv2 / GraphScale) then[LPointIndex].x := x;[LPointIndex].y := y;:=
LPointIndex 1;;;A[j, 0] <> 0 then:= FHeightdiv2 / GraphScale;:= (B[j] –
(A[j, 1] * y)) / A[j, 0];Abs(x) <= (FWidthdiv2 / GraphScale)
then[LPointIndex].x := x;[LPointIndex].y := y;:= LPointIndex 1;;;A[j, 0]
<> 0 then:= – FHeightdiv2 / GraphScale;:= (B[j] – (A[j, 1] * y)) / A[j,
0];Abs(x) <= (FWidthdiv2 / GraphScale) then[LPointIndex].x :=
x;[LPointIndex].y := y;;;:= LPoints[1].x;:= LPoints[1].y;:= LPoints[2].x;:= LPoints[2].y;A[j,
0] <> 0 then:= x1 0.25;:= ((x – x1) / A[j, 0]) * A[j, 1] y1;else:= y1
0.25;:= ((y – y1) / A[j, 1]) * A[j, 0] x1;;S[j] of

: begin // 1 – ‘>=’;((A[j, 0] *
x) (A[j, 1] * y)) >= B[j] then:= 1;else:= – 1;;;

: begin // 2 – ‘<=’;((A[j, 0] *
x) (A[j, 1] * y)) <= B[j] then:= 1;else:= – 1;;;;.Canvas.Pen.Width :=
1;.Canvas.Pen.Color := clBlue;.Canvas.Pen.Style := psSolid;x1 > x2 then:=
x2;:= y2;:= x1;:= y1;:= x3;:= y3;;:= x1 * GraphScale;:= y1 * GraphScale;:=
Sqrt(Sqr(y2 – y1) Sqr(x2 – x1));cbDrawFunctionDomain.Checked then:= 0;True
do:= OfsX (x2 – x1) * LAlpha;:= OfsY (y2 – y1) * LAlpha;:= LAlpha 7 /
LSegmentLength;A[j, 0] <> 0 then:= x3 2 * LDomainDirection;:= ((x – x3)
/ A[j, 0]) * A[j, 1] y3;else:= y3 2 * LDomainDirection;:= ((y – y3) / A[j,
1]) * A[j, 0] x3;;.X := FWidthdiv2 Round(x3);.Y := FHeightdiv2 Round(-
y3);.X := FWidthdiv2 Round(x);.Y := FHeightdiv2 Round(-
y);(PointBelongsRestDomain(x / GraphScale, y / GraphScale, FX1X2Positive)) or

(PointBelongsRest(x / GraphScale, y
/ GraphScale, j, FX1X2Positive) and (not FTaskSolved) and (not FTaskInfinite))
thenFPaintBuffer.Canvas.Pixels[p2.X, p2.Y] <> clMoneyGreen
then.Canvas.Brush.Color := clMoneyGreen;.Canvas.Brush.Style :=
bsSolid;.Canvas.FloodFill(p2.X, p2.Y, clWhite, fsSurface);;;y2 < y1
then(p2.X > FPaintBuffer.Width) or (p2.Y > FPaintBuffer.Height)
then;;else(p2.X > FPaintBuffer.Width) or (p2.Y < 0)
then;;;;;cbDrawDirectFunctionDomain.Checked then:= 0;True do:= OfsX (x2 – x1)
* LAlpha;:= OfsY (y2 – y1) * LAlpha;:= LAlpha 7 / LSegmentLength;A[j, 0]
<> 0 then:= ArcTan(A[j, 1] / A[j, 0]) * 180 / pi;Abs(LAngle) <= 45
thenLAngle < 0 then x := x3 10 * – LDomainDirection else x := x3 10 *
LDomainDirection;:= ((x – x3) / A[j, 0]) * A[j, 1] y3;elseLAngle < 0 then
y := y3 10 * – LDomainDirection else y := y3 10 * LDomainDirection;:= ((y –
y3) / A[j, 1]) * A[j, 0] x3;;else:= y3 10 * LDomainDirection;:= ((y – y3) /
A[j, 1]) * A[j, 0] x3;;.X := FWidthdiv2 Round(x3);.Y := FHeightdiv2
Round(- y3);.X := FWidthdiv2 Round(x);.Y := FHeightdiv2 Round(-
y);.Canvas.MoveTo(p1.X, p1.Y);.Canvas.LineTo(p2.X, p2.Y);y2 < y1 then(p2.X
> FPaintBuffer.Width) or (p2.Y > FPaintBuffer.Height) then;;else(p2.X
> FPaintBuffer.Width) or (p2.Y < 0) then;;;;;;;;TMainForm.DrawGraph;: Double;:
Double;, y: Double;, y1: Double;, y2: Double;, j: Integer;: Double;: Double;:
Integer;: array[1..4] of TPointd;FDrawTaskGraph then

// Вычисляем масштаб
графика:=
0;:= 0;i := 0 to FM – 1 do(A[i, 0] = 0) and (A[i, 1] = 0) then;;A[i, 0]
<> 0 then:= B[i] / A[i, 0];else:= 0;;A[i, 1] <> 0 then:= B[i] /
A[i, 1];else:= 0;;Abs(x) > MaxX then:= Abs(x);;Abs(y) > MaxY then:=
Abs(y);;;MaxX <> 0 then:= (FWidthdiv2 div 2) / MaxX;else:= 1.7e308;;MaxY
<> 0 then:= (FHeightdiv2 div 2) / MaxY;else:= 1.7e308;;MaxValue1 <
MaxValue2 then:= MaxValue1;else:= MaxValue2;;FGraphScale >= 1000 then:=
(FWidthdiv2 div 2) / 3;;else:= 50;;

// Рисуем сетку;

// Рисуем ось координат.Canvas.Pen.Width
:= 3;.Canvas.Pen.Color := clBlack;.Canvas.Font.Color :=
clBlack;.Canvas.Font.Style := [fsBold];.Canvas.MoveTo(FWidthdiv2,
FPaintBuffer.Height);.Canvas.LineTo(FWidthdiv2, 0);.Canvas.LineTo(FWidthdiv2 –
5, 10);.Canvas.LineTo(FWidthdiv2 5, 10);.Canvas.LineTo(FWidthdiv2,
0);.Canvas.TextOut(FWidthdiv2 15, 2, ‘x2’);.Canvas.MoveTo(0,
FHeightdiv2);.Canvas.LineTo(FPaintBuffer.Width,
FHeightdiv2);.Canvas.LineTo(FPaintBuffer.Width – 10, FHeightdiv2 –
5);.Canvas.LineTo(FPaintBuffer.Width – 10, FHeightdiv2
5);.Canvas.LineTo(FPaintBuffer.Width, FHeightdiv2);.Canvas.TextOut(FPaintBuffer.Width
– 20, FHeightdiv2 – 25, ‘x1’);.Canvas.Font.Style := [];FDrawTaskGraph then

// Рисуем прямые
ограниченийj
:= 0 to FM – 1 do(A[j, 0] = 0) and (A[j, 1] = 0) then;;:= 1;A[j, 1] <> 0
then:= FWidthdiv2 / GraphScale;:= (B[j] – (A[j, 0] * x)) / A[j, 1];Abs(y) <=
(FHeightdiv2 / GraphScale) then[LPointIndex].x := x;[LPointIndex].y := y;:=
LPointIndex 1;;;A[j, 1] <> 0 then:= – FWidthdiv2 / GraphScale;:= (B[j]
– (A[j, 0] * x)) / A[j, 1];Abs(y) <= (FHeightdiv2 / GraphScale)
then[LPointIndex].x := x;[LPointIndex].y := y;:= LPointIndex 1;;;A[j, 0]
<> 0 then:= FHeightdiv2 / GraphScale;:= (B[j] – (A[j, 1] * y)) / A[j,
0];Abs(x) <= (FWidthdiv2 / GraphScale) then[LPointIndex].x :=
x;[LPointIndex].y := y;:= LPointIndex 1;;;A[j, 0] <> 0 then:= –
FHeightdiv2 / GraphScale;:= (B[j] – (A[j, 1] * y)) / A[j, 0];Abs(x) <=
(FWidthdiv2 / GraphScale) then[LPointIndex].x := x;[LPointIndex].y := y;;;:=
LPoints[1].x;:= LPoints[1].y;:= LPoints[2].x;:= LPoints[2].y;.Canvas.Pen.Width
:= 2;.Canvas.MoveTo(FWidthdiv2 Round(x1 * GraphScale), FHeightdiv2 Round(-
y1 * GraphScale));.Canvas.LineTo(FWidthdiv2 Round(x2 * GraphScale),
FHeightdiv2 Round(- y2 * GraphScale));.Canvas.Font.Color :=
clRed;.Canvas.Font.Style := [fsBold];.Canvas.Brush.Style := bsClear;A[j, 1]
<> 0 then:= 0;:= (B[j] – (A[j, 0] * x1)) / A[j,
1];.Canvas.Ellipse((FWidthdiv2 Round(x1 * GraphScale)) – 3, FHeightdiv2
Round(- y1 * GraphScale) – 3, (FWidthdiv2 Round(x1 * GraphScale)) 3,
FHeightdiv2 Round(- y1 * GraphScale) 3);.Canvas.TextOut((FWidthdiv2
Round(x1 * GraphScale)) – 20, FHeightdiv2 Round(- y1 * GraphScale),
Chr(Ord(‘A’) j) ‘1’);;A[j, 0] <> 0 then:= 0;:= (B[j] – (A[j, 1] *
y2)) / A[j, 0];.Canvas.Ellipse((FWidthdiv2 Round(x2 * GraphScale)) – 3,
FHeightdiv2 Round(- y2 * GraphScale) – 3, (FWidthdiv2 Round(x2 *
GraphScale)) 3, FHeightdiv2 Round(- y2 * GraphScale)
3);.Canvas.TextOut((FWidthdiv2 Round(x2 * GraphScale)) – 3, FHeightdiv2
Round(- y2 * GraphScale) – 20, Chr(Ord(‘A’) j)
‘2’);;;;cbDrawDirectVector.Checked then;;(FTaskSolved) and
(cbDrawDirectVector.Checked) and ((C[0] <> 0) or (C[1] <> 0))
thenC[1] <> 0 then:= – Round(FWidthdiv2 / GraphScale);C[1] <> 0
then y1 := (- C[0] * (x1 – sx)) / C[1] sy;:= Round(FWidthdiv2 /
GraphScale);C[1] <> 0 then y2 := (- C[0] * (x2 – sx)) / C[1] sy;else:=
– Round(FHeightdiv2 / GraphScale);C[0] <> 0 then x1 := (- C[1] * (y1 –
sy)) / C[0] sx;:= Round(FHeightdiv2 / GraphScale);C[0] <> 0 then x2 :=
(- C[1] * (y2 – sy)) / C[0] sx;;.Canvas.Pen.Width := 2;.Canvas.Pen.Color :=
clRed;.Canvas.MoveTo(FWidthdiv2 Round(x1 * GraphScale), FHeightdiv2 Round(-
y1 * GraphScale));.Canvas.LineTo(FWidthdiv2 Round(x2 * GraphScale),
FHeightdiv2 Round(- y2 * GraphScale));;.Canvas.Pen.Color :=
clGreen;.Canvas.Brush.Color := clGreen;.Canvas.Ellipse((FWidthdiv2 Round(sx *
GraphScale)) – 3, FHeightdiv2 Round(- sy * GraphScale) – 3, (FWidthdiv2
Round(sx * GraphScale)) 3, FHeightdiv2 Round(- sy * GraphScale)
3);;;TMainForm.DrawGrid;: Integer;: Double;: Integer;: Double;i := 1 to 30 do:=
GraphScale * i;((LGridStep >= 25) and (LGridStep <= 30)) or (LGridStep
> 30) then;;;:= LGridStep / GraphScale;FHeightdiv2 > FWidthdiv2 then:=
Round(FHeightdiv2 / LGridStep);else:= Round(FWidthdiv2 / LGridStep);;.Canvas.Font.Color
:= clBlack;.Canvas.Pen.Color := clBlue;.Canvas.Pen.Style :=
psDot;.Canvas.Pen.Width := 1;cbDrawGrid.Checked theni := 1 to LGridCount do

// Горизонтальные
линии.Canvas.MoveTo(0,
FHeightdiv2 – Round(LGridStep) * i);.Canvas.LineTo(FPaintBuffer.Width,
FHeightdiv2 – Round(LGridStep) * i);.Canvas.MoveTo(0, FHeightdiv2
Round(LGridStep) * i);.Canvas.LineTo(FPaintBuffer.Width, FHeightdiv2
Round(LGridStep) * i);

// Вертикальные
линии.Canvas.MoveTo(FWidthdiv2
– Round(LGridStep) * i, 0);.Canvas.LineTo(FWidthdiv2 – Round(LGridStep) * i,
FPaintBuffer.Height);.Canvas.MoveTo(FWidthdiv2 Round(LGridStep) * i,
0);.Canvas.LineTo(FWidthdiv2 Round(LGridStep) * i, FPaintBuffer.Height);;;i
:= 1 to LGridCount do.Canvas.TextOut(FWidthdiv2 – Round(LGridStep) * i,
FHeightdiv2, IntToStr(Round(- i * LScaleFactor)));.Canvas.TextOut(FWidthdiv2
Round(LGridStep) * i, FHeightdiv2, IntToStr(Round(i * LScaleFactor)));.Canvas.TextOut(FWidthdiv2
5, FHeightdiv2 – Round(LGridStep) * i, IntToStr(Round(i *
LScaleFactor)));.Canvas.TextOut(FWidthdiv2 5, FHeightdiv2 Round(LGridStep)
* i, IntToStr(Round(- i * LScaleFactor)));;;TMainForm.FormCreate(Sender:
TObject);:= TBitMap.Create;:= false;:= false;X2Positive :=
true;;TMainForm.WMErasebkgnd(var Msg:
TWMErasebkgnd);;TMainForm.miAboutClick(Sender: TObject);: TAboutForm;:=
TAboutForm.Create(nil);.ShowModal;.Free;;;TMainForm.miExitClick(Sender:
TObject);;;TMainForm.PaintBoxPaint(Sender: TObject);.Canvas.Pen.Color :=
clWhite;.Canvas.Brush.Color := clWhite;.Canvas.Rectangle(0, 0,
FPaintBuffer.Width, FPaintBuffer.Height);;.Canvas.Draw(0, 0,
FPaintBuffer);;TMainForm.PointBelongsRest(x, y: Double; ARestIndex: Integer;
x1x2positive: boolean): boolean;(x1x2positive) and ((x < 0) or (y < 0))
then:= False;;;:= True;S[ARestIndex] of

: begin // 1 – ‘=’;not
(((A[ARestIndex, 0] * x) (A[ARestIndex, 1] * y)) = B[ARestIndex]) then:=
False;;;

: begin // 1 – ‘>=’;not
(((A[ARestIndex, 0] * x) (A[ARestIndex, 1] * y)) >= B[ARestIndex]) then:=
False;;;

: begin // 2 – ‘<=’;not
(((A[ARestIndex, 0] * x) (A[ARestIndex, 1] * y)) <= B[ARestIndex]) then:=
False;;;;;TMainForm.PointBelongsRestDomain(x, y: Double; x1x2positive:
boolean): boolean;: Integer;(x1x2positive) and ((x < 0) or (y < 0))
then:= False;;;:= True;i := 0 to FM – 1 doS[i] of

: begin // 1 – ‘=’;not (((A[i, 0] *
x) (A[i, 1] * y)) = B[i]) then:= False;;;

: begin // 1 – ‘>=’;not (((A[i,
0] * x) (A[i, 1] * y)) >= B[i]) then:= False;;;

: begin // 2 – ‘<=’;not (((A[i,
0] * x) (A[i, 1] * y)) <= B[i]) then:= False;;;;;;

// Процедура
решения задачиTMainForm.SolveTask;,
y: Double;, j: Integer;: TVector;: TVector;: Double;GetLine(ALine1: TVector;
Andex: Integer);[0] := A[Andex, 0];[1] := A[Andex, 1];[2] :=
B[Andex];;.Clear;(TaskRichEdit, ‘Уравнения ограничений:
‘, clNavy, 12, [fsBold]);.Lines.Add(”);.Lines.Add(”);i := 0 to FM – 1 doA[i,
0] <> 0 then(TaskRichEdit, CheckOne(A[i, 0]), clNavy, 12, []);(TaskRichEdit,
‘x1’, clBlack, 12, []);A[i, 1] <> 0 then(TaskRichEdit,
CheckMinusPlus(A[i, 1]), clNavy, 12, []);(TaskRichEdit, ‘x2’, clBlack, 12,
[]);;elseA[i, 1] <> 0 then(TaskRichEdit, CheckOne(A[i, 1]), clNavy, 12,
[]);(TaskRichEdit, ‘x2’, clBlack, 12, []);;;(TaskRichEdit, GetSignStr(i),
clNavy, 12, []);(TaskRichEdit, FloatToStr(B[i]), clNavy, 12, []);(A[i, 0]
<> 0) and (A[i, 1] <> 0) then(TaskRichEdit, ‘ (‘ Chr(Ord(‘A’)
i) ‘1’, clRed, 8, [fsBold]);(TaskRichEdit, Chr(Ord(‘A’) i) ‘2)’, clRed,
8, [fsBold]);else(A[i, 0] <> 0) then(TaskRichEdit, ‘ (‘ Chr(Ord(‘A’)
i) ‘2)’, clRed, 8, [fsBold]);;(A[i, 1] <> 0) then(TaskRichEdit, ‘ (‘
Chr(Ord(‘A’) i) ‘1)’, clRed, 8,
[fsBold]);;;.Lines.Add(”);;.Lines.Add(”);(TaskRichEdit, ‘x1>=’, clBlack,
12, []);(TaskRichEdit, ‘0’, clNavy, 12, []);(TaskRichEdit, ‘; x2>=’,
clBlack, 12, []);(TaskRichEdit, ‘0’, clNavy, 12, []);(TaskRichEdit, ‘;’,
clBlack, 12, []);.Lines.Add(”);.Lines.Add(”);(TaskRichEdit, ‘Целевая функция:
‘, clNavy, 12, [fsBold]);.Lines.Add(”);.Lines.Add(”);C[0] <> 0
then(TaskRichEdit, CheckOne(C[0]), clNavy, 12, []);(TaskRichEdit, ‘x1’,
clBlack, 12, []);C[1] <> 0 then(TaskRichEdit, CheckMinusPlus(C[1]),
clNavy, 12, []);(TaskRichEdit, ‘x2’, clBlack, 12, []);;elseC[1] <> 0
then(TaskRichEdit, CheckOne(C[1]), clNavy, 12, []);(TaskRichEdit, ‘x2’,
clBlack, 12, []);;;FTaskType = 0 then(TaskRichEdit, ‘->Max’, clBlack, 12,
[]);else(TaskRichEdit, ‘->Min’, clBlack, 12, []);;

// Находим решение
задачи:=
false;

:= 1.7e308;FTaskType of

: LMinMaxValue := -1.7e308;

: LMinMaxValue := 1.7e308;;(LLine1,
3);(LLine2, 3);i := 0 to FM – 1 doj := 0 to FM – 1 doi <> j
thenLineToPoint(A[i, 0], A[i, 1], B[i], A[j, 0], A[j, 1], B[j], x, y)
thenPointBelongsRestDomain(x, y, FX1X2Positive) then

//
ShowMessage(FloatToStr(LMinMaxValue) ‘ : ‘ FloatToStr(x * C[0] y *
C[1]));((LMinMaxValue < (x * C[0] y * C[1])) and (FTaskType = 0)) or

((LMinMaxValue > (x * C[0] y *
C[1])) and (FTaskType = 1)) then:= x;:= y;:= true;:= x * C[0] y * C[1];(LLine1,
i);(LLine2, j);;;;;;j := 0 to FM – 1 do:= 0;A[j, 1] <> 0 then:= B[j] /
CheckForNil(A[j, 1]);PointBelongsRestDomain(x, y, FX1X2Positive)
then((LMinMaxValue < (x * C[0] y * C[1])) and (FTaskType = 0)) or

((LMinMaxValue > (x * C[0] y *
C[1])) and (FTaskType = 1)) then:= x;:= y;:= true;:= x * C[0] y *
C[1];(LLine1, j);[0] := 1;[1] := 0;[2] := 0;;;;:= B[j] / CheckForNil(A[j,
0]);:= 0;A[j, 0] <> 0 thenPointBelongsRestDomain(x, y, FX1X2Positive)
then((LMinMaxValue < (x * C[0] y * C[1])) and (FTaskType = 0)) or

((LMinMaxValue > (x * C[0] y *
C[1])) and (FTaskType = 1)) then:= x;:= y;:= true;:= x * C[0] y *
C[1];(LLine1, j);[0] := 0;[1] := 1;[2] := 0;;;;;;:= 0;:=
0;PointBelongsRestDomain(x, y, FX1X2Positive) then((LMinMaxValue < (x * C[0]
y * C[1])) and (FTaskType = 0)) or

((LMinMaxValue > (x * C[0] y *
C[1])) and (FTaskType = 1)) then:= x;:= y;:= true;:= x * C[0] y * C[1];[0] :=
1;[1] := 0;[2] := 0;[0] := 0;[1] := 1;[2] := 0;;;:= TestForInfinite(LLine1,
LLine2, LMinMaxValue);(LLine2);(LLine1);(C[0] = 0) and (C[1] = 0)
then.Lines.Add(”);.Lines.Add(‘————————-‘);(TaskRichEdit, ‘Целевая функция РЅРµ
задана!’,
clMaroon, 12, [fsBold]);elseFTaskSolved thenFTaskInfinite then:=
false;.Lines.Add(”);.Lines.Add(‘————————-‘);(TaskRichEdit, .’,
clMaroon, 12,
[fsBold]);else.Lines.Add(”);.Lines.Add(‘————————-‘);(TaskRichEdit’,
clNavy, 12, [fsBold]);.Lines.Add(”);.Lines.Add(”);FTaskType = 0
then(TaskRichEdit, ‘Целевая функция достигает
своего максимального значения РІ точке:’,
clNavy, 10, [fsBold]);else(TaskRichEdit, ‘Целевая функция достигает
своего минимального значения РІ точке:’,
clNavy, 10, [fsBold]);;.Lines.Add(”);.Lines.Add(”);(TaskRichEdit, ‘x1’,
clBlack, 12, []);(TaskRichEdit, ‘=’ FloatToStr(sx), clNavy, 12,
[]);.Lines.Add(”);(TaskRichEdit, ‘x2’, clBlack, 12, []);(TaskRichEdit, ‘=’
FloatToStr(sy), clNavy, 12, []);.Lines.Add(”);.Lines.Add(”);(TaskRichEdit, ‘Р-начение
целевой
функции:’,
clNavy, 10, [fsBold]);.Lines.Add(”);.Lines.Add(”);(TaskRichEdit, ‘f(x1, x2) =
‘, clBlack, 12, []);(TaskRichEdit, FloatToStr(LMinMaxValue), clNavy, 12,
[]);;else.Lines.Add(”);.Lines.Add(‘————————-‘);(TaskRichEdit,
‘Р-адача
РЅРµ
имеет
допустимого решения!
Рў.Рє.
ее
ограничения несовместны.’,
clMaroon, 12, [fsBold]);;;;TMainForm.TaskSpeedButtonClick(Sender:
TObject);.Visible := False;.Visible := True;.Width := PaintBox.Width;.Height :=
PaintBox.Height;:= FPaintBuffer.Width div 2;:= FPaintBuffer.Height div
2;;;TMainForm.TaskTypeComboBoxChange(Sender: TObject);FTaskType <>
TaskTypeComboBox.ItemIndex then:=
TaskTypeComboBox.ItemIndex;;;;;TMainForm.TestForInfinite(ALine1, ALine2:
TVector; AMinMaxValue: Double): Boolean;, y: Double;, j: Integer;, y1: Double;,
y2: Double;: Double;: Double;: array[0..1] of TVector;:= False;[0] :=
ALine1;[1] := ALine2;j := 0 to 1 do(LLines[j][0] <> 0) or (LLines[j][1]
<> 0) then

// ALine1[0]*x ALine1[1]*y =
ALine1[2]LLines[j][1] <> 0 then:= – 1;:= (LLines[j][2] – LLines[j][0] *
x1) / LLines[j][1];:= 1;:= (LLines[j][2] – LLines[j][0] * x2) / LLines[j][1];else:=
– 1;:= (LLines[j][2] – LLines[j][1] * y1) / LLines[j][0];:= 1;:= (LLines[j][2]
– LLines[j][1] * y2) / LLines[j][0];;;:= 0;:= 0;i := 0 to 1000 do:= x1 (x2 –
x1) * LAlpha1;:= y1 (y2 – y1) * LAlpha1;:= LAlpha1
10;PointBelongsRestDomain(x, y, FX1X2Positive) thenFTaskType = 0 then:= (x *
C[0] y * C[1]) >= AMinMaxValue;else begin:= (x * C[0] y * C[1]) <=
AMinMaxValue;;Result then;;;:= x1 (x2 – x1) * LAlpha2;:= y1 (y2 – y1) *
LAlpha2;:= LAlpha2 – 10;PointBelongsRestDomain(x, y, FX1X2Positive)
thenFTaskType = 0 then:= (x * C[0] y * C[1]) >= AMinMaxValue;else begin:=
(x * C[0] y * C[1]) <= AMinMaxValue;;Result
then;;;;;;TMainForm.TheorySpeedButtonClick(Sender: TObject);: string;:
TResourceStream;.Visible := False;.Visible := True;:= TResourceStream.Create(HInstance,
‘THEORY’, RT_RCDATA);:= CheckForSlash(GetTempDirPath);.SaveToFile(LTempDirPath
‘theory.mht’);.Navigate(LTempDirPath
‘theory.mht’);.Free;;;TMainForm.tbScaleChange(Sender:
TObject);;;TMainForm.FormResize(Sender: TObject);.Width :=
PaintBox.Width;.Height := PaintBox.Height;:= FPaintBuffer.Width div 2;:=
FPaintBuffer.Height div 2;;TMainForm.GetGraphScale: Double;:= FGraphScale
(tbScale.Position – 25) / (25 / FGraphScale);;TMainForm.FormDestroy(Sender:
TObject);.Free;;.AboutFormUnit;, SysUtils, Classes, Graphics, Forms, Controls,
StdCtrls,, ExtCtrls, ShellApi;= class(TForm): TPanel;: TImage;: TLabel;:
TButton;: TLabel;: TBevel;: TLabel;: TMemo;AuthorEmailLabelClick(Sender:
TObject);ProgramHomepageLabelClick(Sender: TObject);Label4Click(Sender:
TObject);

{ Private declarations }

{ Public declarations };

{$R
*.dfm}TAboutForm.AuthorEmailLabelClick(Sender: TObject);(0, ‘open’,
PChar(‘mailto: ‘ AuthorEmailLabel.Caption), nil, nil,
SW_SHOW);;TAboutForm.Label4Click(Sender: TObject);(0, ‘open’,
PChar(Label4.Caption), nil, nil,
SW_SHOW);;TAboutForm.ProgramHomepageLabelClick(Sender: TObject);(0, ‘open’,
PChar(ProgramHomepageLabel.Caption), nil, nil, SW_SHOW);;.NewTaskFormUnit;,
Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,, StdCtrls,
Grids, Contnrs, MSimplexMath, ExtCtrls;= class(TForm): TStringGrid;:
TStringGrid;: TButton;: TButton;: TStringGrid;: TLabel;: TLabel;: TLabel;:
TBevel;: TComboBox;: TLabel;FormShow(Sender:
TObject);VectorbGridDrawCell(Sender: TObject; ACol, ARow: Integer;: TRect;
State: TGridDrawState);MatrixNGridDrawCell(Sender: TObject; ACol, ARow:
Integer;: TRect; State: TGridDrawState);VectorCGridDrawCell(Sender: TObject;
ACol, ARow: Integer;: TRect; State: TGridDrawState);OKButtonClick(Sender: TObject);FormCreate(Sender:
TObject);FormDestroy(Sender: TObject);: Integer;: Integer;

//
Матрица коэффициентов ограничений: TMatrix;

//
Вектор коэффициентов свободных членов: TVector;

//
Вектор коэффициентов целевой функции: TVector;

FSigns: TObjectList;GetSign(Index:
Integer): Integer;GetSignStr(Index: Integer): string;N: Integer read FN write
FN;M: Integer read FM write FM;Sign[Index: Integer]: Integer read
GetSign;SignStr[Index: Integer]: string read GetSignStr;Vectorb: TVector read
FVectorb write FVectorb;Vectorc: TVector read FVectorc write FVectorc;NMatrix:
TMatrix read FNMatrix write FNMatrix;;

{$R
*.dfm}ValidateDecimalSeparator(AFloatStr: string): string;: Integer;:=
AFloatStr;:= Pos(‘.’, Result);LDotPos > 0 do[LDotPos] := ‘,’;:= Pos(‘.’,
Result);;;InitStringGrid(AStringGrid: TStringGrid);, j: Integer;i := 0 to
AStringGrid.ColCount – 1 doj := 0 to AStringGrid.RowCount – 1 do.Cells[i, j] :=
‘0’;;;GetMatrix(AStringGrid: TStringGrid): TMatrix;, j: Integer;(Result,
AStringGrid.RowCount, AStringGrid.ColCount);i := 0 to AStringGrid.RowCount – 1
doj := 0 to AStringGrid.ColCount – 1 do[i, j] :=
StrToFloat(ValidateDecimalSeparator(AStringGrid.Cells[j,
i]));;;;GetVector(AStringGrid: TStringGrid): TVector;:
Integer;AStringGrid.RowCount = 1 then(Result, AStringGrid.ColCount);i := 0 to
AStringGrid.ColCount – 1 do[i] :=
StrToFloat(ValidateDecimalSeparator(AStringGrid.Cells[i, 0]));;(Result,
AStringGrid.RowCount);i := 0 to AStringGrid.RowCount – 1 do[i] :=
StrToFloat(ValidateDecimalSeparator((AStringGrid.Cells[0, i])));;;;AdjustStringGrid(AStringGrid:
TStringGrid);: Integer;: Integer;: Integer;:= 0;i := 0 to AStringGrid.ColCount
– 1 do:= LWidth AStringGrid.ColWidths[i];;:= 0;i := 0 to AStringGrid.RowCount
– 1 do:= LHeight AStringGrid.RowHeights[i];;.Width := LWidth AStringGrid.ColCount
1;.Height := LHeight AStringGrid.RowCount
1;;TNewTaskForm.FormCreate(Sender: TObject);:=
TObjectList.Create;;TNewTaskForm.FormDestroy(Sender:
TObject);.Free;;TNewTaskForm.FormShow(Sender: TObject);: Integer;: Integer;:
TComboBox;.RowCount := FM;.ColCount := FN;(MatrixNGrid);(MatrixNGrid);.RowCount
:= FM;(VectorbGrid);(VectorbGrid);.ColCount := FN;(VectorCGrid);(VectorCGrid);i
:= 0 to FM – 1 do:= TComboBox.Create(Self);.Parent := Self;.Style :=
csDropDownList;.AddItem(‘=’, nil);.AddItem(‘>=’, nil);.AddItem(‘<=’,
nil);.ItemIndex := 0;.Width := 50;:= MatrixNGrid.Left MatrixNGrid.Width
25;.Left := LLeft;.Top := MatrixNGrid.Top (i *
LComboBox.Height);.Add(LComboBox);;i := 0 to MatrixNGrid.RowCount – 1
do.RowHeights[i] := TComboBox(FSigns.Items[i]).Height – 1;;(MatrixNGrid);i := 0
to VectorbGrid.RowCount – 1 do.RowHeights[i] :=
TComboBox(FSigns.Items[i]).Height – 1;;(VectorbGrid);i := 0 to
VectorCGrid.RowCount – 1 do.RowHeights[i] := TComboBox(FSigns.Items[i]).Height
– 1;;(VectorCGrid);.Left := LLeft 70;.Top := MatrixNGrid.Top
MatrixNGrid.Height 15;.Top := Label3.Top Label3.Height 5;.Left :=
VectorbGrid.Left;.Top := VectorCGrid.Top VectorCGrid.Height 10;.Top :=
VectorCGrid.Top VectorCGrid.Height 30;.Width := CancelButton.Left
CancelButton.Width – Bevel1.Left;:= VectorbGrid.Left VectorbGrid.Width
100;:= Bevel1.Top Bevel1.Height OKButton.Height
20;;TNewTaskForm.GetSign(Index: Integer): Integer;:=
TComboBox(FSigns.Items[Index]).ItemIndex;;TNewTaskForm.GetSignStr(Index:
Integer): string;Sign[Index] of

: Result := ‘=’;

: Result := ‘>=’;

: Result :=
‘<=’;;;TNewTaskForm.MatrixNGridDrawCell(Sender: TObject; ACol, ARow:
Integer; Rect: TRect; State: TGridDrawState);Sender = ActiveControl then;not
(gdSelected in State) then;Sender as TStringGrid do.Brush.Color :=
Color;.Font.Color := Font.Color;.TextRect(Rect, Rect.Left 2, Rect.Top
2,[ACol, ARow]);;;TNewTaskForm.OKButtonClick(Sender: TObject);: Integer;:
Boolean;:= True;i:= 0 to FM – 1 doTComboBox(FSigns.Items[i]).ItemIndex > 0
then:= False;;;:= GetMatrix(MatrixNGrid);:= GetVector(VectorbGrid);:=
GetVector(VectorcGrid);not LCanonicalForm theni := 0 to FM – 1
doTComboBox(FSigns.Items[i]).ItemIndex of

: begin(FN);(FVectorc, FN);[FN – 1]
:= 0;(FNMatrix, FM, FN);[i, FN – 1] := – 1;;;;;:=
mrOk;;TNewTaskForm.VectorbGridDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);Sender = ActiveControl then;not (gdSelected
in State) then;Sender as TStringGrid do.Brush.Color := Color;.Font.Color :=
Font.Color;.TextRect(Rect, Rect.Left 2, Rect.Top 2,[ACol,
ARow]);;;TNewTaskForm.VectorCGridDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);Sender = ActiveControl then;not (gdSelected
in State) then;Sender as TStringGrid do.Brush.Color := Color;.Font.Color :=
Font.Color;.TextRect(Rect, Rect.Left 2, Rect.Top 2,[ACol,
ARow]);;;.TaskSizeFormUnit;, Messages, SysUtils, Variants, Classes, Graphics,
Controls, Forms,, StdCtrls, Spin, Buttons;_WRONG_NUMBER_RANGE = ‘Число должно быть в диапазоне:
1..10’;_WRONG_NUMBER_FORMAT = ‘Неправильный формат числа!’;=
class(TForm): TLabel;: TLabel;: TBitBtn;: TGroupBox;: TBitBtn;:
TSpinEdit;FormShow(Sender: TObject);OkBitBtnClick(Sender: TObject);

private:
Integer; // Кол-во ограничений

function GetM: Integer;M: Integer
read GetM;;

{$R
*.dfm}TTaskSizeForm.FormShow(Sender: TObject);OkBitBtn.CanFocus
then.SetFocus;;;TTaskSizeForm.GetM: Integer;:=
FM;;TTaskSizeForm.OkBitBtnClick(Sender: TObject);: Integer;:= StrToInt(seM.Text);(LValue
< 1) or (LValue > 10) then(STR_WRONG_NUMBER_RANGE, mtError, [mbOK],
0);else:= LValue;:= mrOk;;(STR_WRONG_NUMBER_FORMAT, mtError, [mbOK], 0);

end;;.

информация безопасность программа модуль

Приложение
Б

Формы
программы

Рисунок
6 – Главная форма

)
Окно задания размера новой таблицы (рисунок 7).

Рисунок
7 – Окно задания размера новой таблицы

3) Окно заполнения таблицы данными (рисунок 8).

Рисунок 8 – Окно заполнения таблицы данными