Нижче показаний код програмної реалізації симплекс-методу (разом з

коментарями).
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>

class SimplexSolver {
public:
SimplexSolver(const std::vector<std::vector<double>>& A,
const std::vector<double>& b,
const std::vector<double>& c)
: A_(A), b_(b), c_(c) {
m_ = A.size(); // Кількість обмежень
n_ = c.size(); // Кількість змінних

// Додати штучні змінні для задачі в стандартній формі

for (int i = 0; i < m_; ++i) {
if (b_[i] < 0) {
for (int j = 0; j < m_; ++j) {
A_[j].push_back(i == j ? -1 : 0);
}
c_.push_back(0);
n_++;
}
}
}

// Функція для вирішення задачі лінійного програмування

void Solve() {
while (true) {
// Знайдіть вхідну змінну
int pivot_col = FindEnteringVariable();

// Якщо не знайдено вхідну змінну, оптимізація завершена

if (pivot_col == -1) {
PrintSolution();
return;
 }

// Знайдіть вихідну змінну

int pivot_row = FindLeavingVariable(pivot_col);

// Якщо не знайдено вихідну змінну, задача необмежена

if (pivot_row == -1) {
std::cout << "Задача не має обмеженого розв'язку." << std::endl;
return;
}

// Оптимізувати таблицю
Pivot(pivot_row, pivot_col);
}
}

private:
int m_; // Кількість обмежень
int n_; // Кількість змінних
std::vector<std::vector<double>> A_; // Матриця обмежень
std::vector<double> b_; // Вектор правих частин обмежень
std::vector<double> c_; // Вектор коефіцієнтів цільової функції

// Допоміжні функції симплекс-методу

int FindEnteringVariable() {
// Знайти вхідну змінну з найменшим від'ємним коефіцієнтом цільової функції
int entering_col = -1;
for (int i = 0; i < n_; ++i) {
if (c_[i] < 0 && (entering_col == -1 || c_[i] < c_[entering_col])) {
entering_col = i;
}
}
return entering_col;
}

int FindLeavingVariable(int entering_col) {

// Знайти вихідну змінну за правилом мінімального відношення
int leaving_row = -1;
double min_ratio = -1.0;
for (int i = 0; i < m_; ++i) {
 if (A_[i][entering_col] > 0) {
double ratio = b_[i] / A_[i][entering_col];
if (leaving_row == -1 || ratio < min_ratio) {
leaving_row = i;
min_ratio = ratio;
}
}
}
return leaving_row;
}

void Pivot(int pivot_row, int pivot_col) {

// Оновити таблицю симплекс-методу
double pivot_element = A_[pivot_row][pivot_col];
for (int i = 0; i < m_; ++i) {
for (int j = 0; j < n_; ++j) {
if (i != pivot_row || j != pivot_col) {
A_[i][j] -= A_[pivot_row][j] * A_[i][pivot_col] / pivot_element;
}
}
}
for (int j = 0; j < n_; ++j) {
if (j != pivot_col) {
c_[j] -= c_[pivot_col] * A_[pivot_row][j] / pivot_element;
}
}
for (int i = 0; i < m_; ++i) {
if (i != pivot_row) {
b_[i] -= A_[i][pivot_col] * b_[pivot_row] / pivot_element;
}
}
A_[pivot_row][pivot_col] = 1.0 / pivot_element;
std::swap(b_[pivot_row], c_[pivot_col]);
}

void PrintSolution() {
std::cout << "Оптимальний розв'язок знайдено:" << std::endl;
for (int i = 0; i < m_; ++i) {
std::cout << "x[" << i + 1 << "] = " << (i < n_ ? b_[i] : 0) << std::endl;
}
 std::cout << "Значення цільової функції: " << c_[n_] << std::endl;
}
};

int main() {
// Введіть ваші дані для лінійної програми тут
std::vector<std::vector<double>> A = {{2, 1}, {1, 3}};
std::vector<double> b = {4, 6};
std::vector<double> c = {-3, -5};

SimplexSolver solver(A, b, c);

solver.Solve();

return 0;
}
До роботи прикріплено source.cpp файл з кодом програми.