Міністерство освіти і науки України

Вінницький національний технічний університет

Факультет інтелектуальних інформаційних технологій та автоматизації
Кафедра КН

Лабораторна робота №2
з дисципліни «ММДО»
Розробка алгоритму і програми для розв’язання задач лінійного програмування
симплекс-методом.

Виконав: ст. гр. КН-22мс. Бойко А.В.

Перевірив асистент: Ваховська Л.М.

Вінниця 2022
Мета: набути навичок практичного розв’язання ЗЛП табличним симплекс-
методом та його програмної реалізації.

Хід роботи

Практичні завдання

Варіант 28.

Умова:

Розв’язання:
 Блок-схема програми для обчислення визначника матриці:

Рис. 2 – блок-схема алгоритму програми.

 Опис програми

Дана програма призначена для розв’язання задач лінійного

програмування за допомогою симплекс-методу. Інтерфейс програми
розроблено за допомогою веб-технологій, а саме HTML, CSS та Svelte.
Програма містить функції отримання даних із форми сайту, визначення
оптимальності даного рішення, отримання номеру обраного стовпця,
отримання номеру обраного рядка та функцію обрахунку.

Рис. 3 – Результат тестування програми.

Висновки: на лабораторній роботі було набуто навичок практичного

розв’язання ЗЛП табличним симплекс-методом та було реалізовано його
програмну реалізацію, результати розрахунків якої зійшлись із практичним
розв’язанням ЗЛП.
 Додаток 1

Інструкція користувача

Для початку роботи із програмою необхідно вписати бажану кількість змінних

та обмежень задачі. Кількість змінних та обмежень задачі вписуються у поля
зображені на рисунку 3.

Рис. 4 – поля характеристик задачі.

У дані поля можна ввести значення лише більше нуля. За замовчуванням у

полях встановлено значення “3”

Після введення кількості змінних та обмежень задачі необхідно ввести

коефіцієнти невідомих у полях зображених на рисунку 5.

Рис. 5 – поля введення коефіцієнтів.

Для отримання результату необхідно натиснути на кнопку “Обрахувати”

Додаток 2

Лістинг програми
<script>

let variablesCount = 3;

let limitationCount = 3;

let resultVariables = [];

let resultF;

let resultIsInfinity = false;

function Calculate(){

let Fdata = GetFData();

let matrix = GetMatrix();

//let Fdata = [-5, 1, -1, 0, 0, 0, 0];

//let matrix = [[1, 2, 0, 1, 0, 0, 18], [2, -1, -1, 0, 1, 0, 12], [-1,

5, 7, 0, 0, 1, 40]];

let basis = [];

for(let i = variablesCount, j = 0; i < variablesCount+limitationCount, j

< limitationCount; i++, j++){

basis[j] = i;

while(!IsOptimal(Fdata)){

let minIndexOfFData = GetMinIndex(Fdata);

let biaij = [];

for(let i = 0; i < limitationCount; i++) {

biaij[i] = matrix[i][variablesCount+limitationCount] /
matrix[i][minIndexOfFData];

console.log(biaij[i]+" =
"+matrix[i][variablesCount+limitationCount]+' / '+matrix[i][minIndexOfFData]);

}
 let currentRowIndex = GetCurrentRowIndex(biaij);

console.log(currentRowIndex);

console.table(biaij);

if(currentRowIndex == undefined){

resultIsInfinity = true;

break;

basis[currentRowIndex] = minIndexOfFData;

if(matrix[currentRowIndex][minIndexOfFData] != 1){

let divider = matrix[currentRowIndex][minIndexOfFData];

for(let i = 0; i < matrix[currentRowIndex].length; i++){

matrix[currentRowIndex][i] /= divider;

let currentRowCopy = matrix[currentRowIndex].slice();

let multiple;

for(let j = 0; j <limitationCount; j++){

console.log(currentRowIndex+" : "+j);

console.log(matrix[j][currentRowIndex]);

if(currentRowIndex == j) continue;

if(matrix[j][minIndexOfFData] == 0) continue;

multiple = -(matrix[j][minIndexOfFData] /
currentRowCopy[minIndexOfFData]);

for(let i = 0; i < variablesCount + limitationCount + 1; i++){

matrix[j][i] += currentRowCopy[i] * multiple;

multiple = -(Fdata[minIndexOfFData] /
currentRowCopy[minIndexOfFData]);

for(let i = 0; i < variablesCount + limitationCount + 1; i++){

 Fdata[i] += currentRowCopy[i] * multiple;

console.table(Fdata);

console.table(matrix);

if(!resultIsInfinity) {

let variables = [];

for(let j = 0; j <limitationCount; j++){

variables[j] = [];

variables[j][0] = basis[j];

variables[j][1] = matrix[j][variablesCount+limitationCount];

for(let i = 0; i < variablesCount + limitationCount; i++){

for(let j = 0; j <limitationCount; j++){

if(variables[j][0] == i){

resultVariables[i] = variables[j][1];

break;

}else resultVariables[i] = 0;

resultF = Fdata[variablesCount + limitationCount];

console.table(resultVariables);

console.log(resultF);

function GetFData(){

console.log();

console.table();

let Fdata = [];

 for(let i = 0; i<variablesCount; i++) {

Fdata[i] = Number(document.getElementById("FVariable-"+i).value);

let select = document.getElementById('VectorF');

if(select.options[select.selectedIndex].value == "max") Fdata[i] *=

-1;

for(let i = variablesCount; i<variablesCount+limitationCount+1; i++) {

Fdata[i] = 0;

console.table(Fdata);

return Fdata;

function GetMatrix(){

let matrix = [];

for(let i = 0; i<limitationCount; i++) matrix[i] = Array(variablesCount

+ limitationCount + 1);

for(let r = 0; r < limitationCount; r++){

for(let c = 0; c < variablesCount + limitationCount + 1; c++){

if(c < variablesCount) matrix[r][c] =

Number(document.getElementById("LimVariable-"+r+"-"+c).value);

if(c >= variablesCount && c < variablesCount+limitationCount)

matrix[r][c] = 0;

if(c == variablesCount + r) matrix[r][c] = 1;

if(c == variablesCount + limitationCount) matrix[r][c] =

Number(document.getElementById("LimEqual-"+r).value);

let select = document.getElementById('sign-'+r);

if(select.options[select.selectedIndex].value == "≥" && c <

variablesCount) if(matrix[r][c] != 0) matrix[r][c] *= -1;

if(select.options[select.selectedIndex].value == "≥" && c ==

variablesCount + limitationCount) if(matrix[r][c] != 0) matrix[r][c] *= -1;

}
 }

console.table(matrix);

return matrix;

function IsOptimal(array){

let isOptimal = true;

for(let i = 0; i < array.length; i++) {

if(array[i] < 0) {

isOptimal = false;

break;

return isOptimal;

function GetMinIndex(array){

let min = 999;

let minIndex = 0;

for(let i = 0; i < array.length; i++) {

if(array[i] < min) {

min = array[i];

minIndex = i;

return minIndex;

function GetCurrentRowIndex(array){

let min = 999;

let minIndex;

for(let i = 0; i < array.length; i++) {

 if(array[i] < 0) continue;

if(array[i] == Infinity || array[i] == -Infinity) continue;

if(array[i] < min) {

min = array[i];

minIndex = i;

return minIndex;

</script>

<header>

<h1>Знаходження оптимального рішення задачі Симплекс методом</h1>

<h2>Бойко А.В. КН-22мс</h2>

</header>

<main>

<div class="countSelectors">

<label for="variablesCounter">Кількість змінних: </label>

<input type="number" id="variablesCounter" min=1

bind:value={variablesCount}>

<label for="limitationCounter">Кількість обмежень: </label>

<input type="number" id="limitationCounter" min=1

bind:value={limitationCount}>

</div><br>

<div class="inequalitiesContainer">

<div class="inequalityFx">

F(x) =

{#each Array(variablesCount) as variable, varId}

<input type="number" id="FVariable-{varId}"> X{varId+1}

{/each}

<select id="VectorF">
 <option value="max">max</option>

<option value="min">min</option>

</select>

</div><br><br>

<div class="inequalitiesLimitation">

{#each Array(limitationCount) as limitation, limId}

Нерівність {limId+1}:

{#each Array(variablesCount) as variable, varId}

<input type="number" id="LimVariable-{limId}-{varId}">

X{varId+1}

{/each}

<select id="sign-{limId}">

<option value="≤">≤</option>

<option value="≥">≥</option>

</select>

<input type="number" id="LimEqual-{limId}">

<br><br>

{/each}

</div>

<div class="button" on:click={Calculate}>Обрахунок</div>

{#if resultF != undefined}

<br><br>

<div class="resultContainer">

F* = {Math.round(resultF*100)/100}

<br><br>

X* = (

{#each resultVariables as variable}

{Math.round(variable*100)/100},&nbsp;&nbsp;&nbsp;

{/each}

)
 </div>

{/if}

{#if resultIsInfinity}

<br><br>

<div class="resultContainer">

Функція необмежена. Оптимальне рішення відсутнє.

</div>

{/if}

</div>

</main>