411 lines
10 KiB
C++
411 lines
10 KiB
C++
#include <iostream>
|
|
#include <functional>
|
|
#include "tools/matrix.h"
|
|
#include "tools/math.h"
|
|
#include "simplex.h"
|
|
|
|
void _printInitialInputs(Vector &C, Matrix &A, Vector &b, double eps, bool maximize)
|
|
{
|
|
std::cout << "Running for the following inputs:" << std::endl
|
|
<< std::endl;
|
|
std::cout << "epsilon: " << eps << std::endl;
|
|
if (maximize)
|
|
{
|
|
std::cout << "Maximize" << std::endl;
|
|
}
|
|
else
|
|
{
|
|
std::cout << "Minimize" << std::endl;
|
|
}
|
|
std::cout << "z = ";
|
|
bool previousIsZero = true;
|
|
bool lastNonZero = false;
|
|
for (int i = 0; i < C.size(); i++)
|
|
{
|
|
bool isNegative = false;
|
|
|
|
for (int k = i; k < C.size(); k++)
|
|
{
|
|
if (C[k] == 0)
|
|
{
|
|
lastNonZero = true;
|
|
} else{
|
|
lastNonZero = false;
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
if (!previousIsZero && !lastNonZero){
|
|
std::cout << " + ";
|
|
}
|
|
|
|
if (C[i] != 0){
|
|
if (C[i] != 1) {
|
|
if (C[i] < 0){
|
|
isNegative = true;
|
|
std::cout << "(";
|
|
}
|
|
std::cout << C[i] << " * ";
|
|
}
|
|
std::cout << "x" << i + 1;
|
|
if (isNegative){
|
|
std::cout << ")";
|
|
}
|
|
previousIsZero = false;
|
|
}else {
|
|
previousIsZero = true;
|
|
}
|
|
|
|
}
|
|
std::cout << std::endl
|
|
<< "subject to the constrains:" << std::endl;
|
|
std::cout << std::endl;
|
|
for (int i = 0; i < b.size(); i++)
|
|
{
|
|
bool previousIsZero = true;
|
|
bool lastNonZero = false;
|
|
|
|
for (int j = 0; j < A.getColumns(); j++)
|
|
{
|
|
bool isNegative = false;
|
|
|
|
for (int k = j; k < A[i].size(); k++)
|
|
{
|
|
if (A[i][k] == 0)
|
|
{
|
|
lastNonZero = true;
|
|
} else{
|
|
lastNonZero = false;
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
if (!previousIsZero && !lastNonZero){
|
|
std::cout << " + ";
|
|
}
|
|
|
|
if (A[i][j] != 0) {
|
|
if (A[i][j] != 1) {
|
|
if (A[i][j] < 0) {
|
|
isNegative = true;
|
|
std::cout << "(";
|
|
}
|
|
std::cout << A[i][j] << " * ";
|
|
}
|
|
std::cout << "x" << j + 1;
|
|
if (isNegative) {
|
|
std::cout << ")";
|
|
}
|
|
previousIsZero = false;
|
|
|
|
}else {
|
|
previousIsZero = true;
|
|
}
|
|
}
|
|
std::cout << " <= " << b[i] << std::endl;
|
|
}
|
|
}
|
|
|
|
int printResult(Result result)
|
|
{
|
|
if (result.state == unsolvable)
|
|
{
|
|
std::cout << "The method is not applicable!" << std::endl;
|
|
}else if (result.state == unbounded ) {
|
|
std::cout << "Unbounded problem!" << std::endl;
|
|
}
|
|
else
|
|
{
|
|
std::cout << "SOLVED!" << std::endl;
|
|
std::cout << "Decision variables: [";
|
|
|
|
for (int i = 0; i < result.solution.size(); i++)
|
|
{
|
|
std::cout << result.solution[i];
|
|
if (i != result.solution.size() - 1)
|
|
{
|
|
std::cout << ", ";
|
|
}
|
|
}
|
|
std::cout << "]";
|
|
std::cout << std::endl;
|
|
if (result.maximize)
|
|
{
|
|
std::cout << "Maximum ";
|
|
}
|
|
else
|
|
{
|
|
std::cout << "Minimum ";
|
|
}
|
|
std::cout << "objective function value: " << result.objective_function_value << std::endl;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool check_eq(double a, double b, double relativeEpsilon = 0.0001)
|
|
{
|
|
double diff = std::abs(a - b);
|
|
a = std::abs(a);
|
|
b = std::abs(b);
|
|
double largest = (b > a) ? b : a;
|
|
|
|
return diff <= largest * relativeEpsilon;
|
|
}
|
|
|
|
int TEST_GENERAL_CASE()
|
|
{
|
|
std::cout << "----------------------------RUNNING_TEST_GENERAL_CASE----------------------------" << std::endl;
|
|
Vector C = {5, 4};
|
|
Matrix A = {
|
|
{6, 4},
|
|
{1, 2},
|
|
{-1, 1},
|
|
{0, 1}};
|
|
Vector b = {24, 6, 1, 2};
|
|
_printInitialInputs(C, A, b, 0.01, true);
|
|
auto result = simplex(C, A, b);
|
|
|
|
if (!(result.state == bounded))
|
|
{
|
|
std::string state_name;
|
|
switch (result.state)
|
|
{
|
|
case unsolvable:
|
|
state_name = "unsolvable";
|
|
break;
|
|
case unbounded:
|
|
state_name = "unbounded";
|
|
break;
|
|
default:
|
|
state_name = "bounded";
|
|
break;
|
|
}
|
|
std::cout << "Incorrect state type. Expected bounded. Got " << state_name << std::endl;
|
|
return 0;
|
|
}
|
|
|
|
if (!check_eq(result.objective_function_value, 21))
|
|
{
|
|
std::cout << "Incorrect objective function value. Expected 21. Got "
|
|
<< result.objective_function_value << std::endl;
|
|
return 0;
|
|
}
|
|
|
|
if (!(check_eq(result.solution[0], 3) && check_eq(result.solution[1], 1.5)))
|
|
{
|
|
std::cout << "Incorrect desire variables. Expected 3 and 1.5. Got "
|
|
<< result.solution;
|
|
return 0;
|
|
}
|
|
|
|
printResult(result);
|
|
return 1;
|
|
}
|
|
|
|
int TEST_MINIMIZE_CASE()
|
|
{
|
|
std::cout << "----------------------------RUNNING_TEST_MINIMIZE_CASE----------------------------" << std::endl;
|
|
Vector C = {-2, 2, -6};
|
|
Matrix A = {
|
|
{2, 1, -2},
|
|
{1, 2, 4},
|
|
{1, -1, 2}};
|
|
Vector b = {24, 23, 10};
|
|
_printInitialInputs(C, A, b, 0.01, false);
|
|
auto result = simplex(C, A, b, 0.01, false);
|
|
|
|
if (!(result.state == bounded))
|
|
{
|
|
std::string state_name;
|
|
switch (result.state)
|
|
{
|
|
case unsolvable:
|
|
state_name = "unsolvable";
|
|
break;
|
|
case unbounded:
|
|
state_name = "unbounded";
|
|
break;
|
|
default:
|
|
state_name = "bounded";
|
|
break;
|
|
}
|
|
std::cout << "Incorrect state type. Expected bounded. Got " << state_name << std::endl;
|
|
return 0;
|
|
}
|
|
|
|
if (!check_eq(result.objective_function_value, -30.75))
|
|
{
|
|
std::cout << "Incorrect objective function value. Expected -30.75. Got "
|
|
<< result.objective_function_value << std::endl;
|
|
return 0;
|
|
}
|
|
|
|
if (!(check_eq(result.solution[0], 0) && check_eq(result.solution[1], 0.75) && check_eq(result.solution[2], 5.375)))
|
|
{
|
|
std::cout << "Incorrect desire variables. Expected 3 and 1.5. Got "
|
|
<< result.solution;
|
|
return 0;
|
|
}
|
|
|
|
printResult(result);
|
|
|
|
return 1;
|
|
}
|
|
|
|
int TEST_WITH_SLACK_CASE()
|
|
{
|
|
std::cout << "----------------------------RUNNING_TEST_WITH_SLACK_CASE----------------------------" << std::endl;
|
|
|
|
Vector C = {2, -1, 0, -1};
|
|
Matrix A = {
|
|
{1, -2, 1, 0},
|
|
{-2, -1, 0, -2},
|
|
{3, 2, 0, 1}};
|
|
Vector b = {10, 18, 36};
|
|
|
|
_printInitialInputs(C, A, b, 0.01, true);
|
|
|
|
auto result = simplex(C, A, b);
|
|
|
|
if (!(result.state == bounded))
|
|
{
|
|
std::string state_name;
|
|
switch (result.state)
|
|
{
|
|
case unsolvable:
|
|
state_name = "unsolvable";
|
|
break;
|
|
case unbounded:
|
|
state_name = "unbounded";
|
|
break;
|
|
default:
|
|
state_name = "bounded";
|
|
break;
|
|
}
|
|
std::cout << "Incorrect state type. Expected bounded. Got " << state_name << std::endl;
|
|
return 0;
|
|
}
|
|
|
|
if (result.objective_function_value != 22.25)
|
|
{
|
|
std::cout << "Incorrect objective function value. Expected 22.25. Got "
|
|
<< result.objective_function_value << std::endl;
|
|
return 0;
|
|
}
|
|
|
|
if (!((result.solution[0] == 11.5) || (result.solution[1] == 0.75) ||
|
|
(result.solution[2] == 0) || (result.solution[3] == 0)))
|
|
{
|
|
std::cout << "Incorrect desire variables. Expected 11.5, 0.75, 0, and 0. Got "
|
|
<< result.solution;
|
|
return 0;
|
|
}
|
|
|
|
printResult(result);
|
|
|
|
return 1;
|
|
}
|
|
|
|
int TEST_UNBOUNDED_CASE()
|
|
{
|
|
std::cout << "----------------------------RUNNING_TEST_UNBOUNDED_CASE----------------------------" << std::endl;
|
|
|
|
Vector C = {2, 1};
|
|
Matrix A = {
|
|
{1, -1},
|
|
{2, 0}};
|
|
Vector b = {10, 40};
|
|
|
|
_printInitialInputs(C, A, b, 0.01, true);
|
|
|
|
auto result = simplex(C, A, b);
|
|
|
|
if (!(result.state == unbounded))
|
|
{
|
|
std::string state_name;
|
|
switch (result.state)
|
|
{
|
|
case unsolvable:
|
|
state_name = "unsolvable";
|
|
break;
|
|
case unbounded:
|
|
state_name = "unbounded";
|
|
break;
|
|
default:
|
|
state_name = "bounded";
|
|
break;
|
|
}
|
|
std::cout << "Incorrect state type. Expected unbounded. Got " << state_name << std::endl;
|
|
return 0;
|
|
}
|
|
|
|
printResult(result);
|
|
|
|
return 1;
|
|
}
|
|
|
|
int TEST_UNSOLVABLE_CASE()
|
|
{
|
|
std::cout << "----------------------------RUNNING_TEST_UNSOLVABLE_CASE----------------------------" << std::endl;
|
|
|
|
Vector C = {5, 4, 0, -5, 13};
|
|
Matrix A = {
|
|
{6, 4, 1, 3, 4},
|
|
{1, 2, 0, 0, 2},
|
|
{-1, 0, 0, 10, 0},
|
|
{0, 1, 1, -5, 1}};
|
|
Vector b = {-24, 6, 1, 2};
|
|
|
|
_printInitialInputs(C, A, b, 0.01, true);
|
|
|
|
auto result = simplex(C, A, b);
|
|
|
|
if (!(result.state == unsolvable))
|
|
{
|
|
std::string state_name;
|
|
switch (result.state)
|
|
{
|
|
case unsolvable:
|
|
state_name = "unsolvable";
|
|
break;
|
|
case unbounded:
|
|
state_name = "unbounded";
|
|
break;
|
|
default:
|
|
state_name = "bounded";
|
|
break;
|
|
}
|
|
std::cout << "Incorrect state type. Expected unsolvable. Got " << state_name << std::endl;
|
|
return 0;
|
|
}
|
|
|
|
printResult(result);
|
|
|
|
return 1;
|
|
}
|
|
|
|
int main()
|
|
{
|
|
std::vector<std::function<int(void)>> tests = {
|
|
TEST_GENERAL_CASE,
|
|
TEST_MINIMIZE_CASE,
|
|
TEST_WITH_SLACK_CASE,
|
|
TEST_UNBOUNDED_CASE,
|
|
TEST_UNSOLVABLE_CASE};
|
|
|
|
int counter = 0;
|
|
|
|
for (auto &test : tests)
|
|
{
|
|
counter += test();
|
|
}
|
|
|
|
std::cout << "----------------------------RESULTS----------------------------" << std::endl;
|
|
std::cout << "Total number of tests: " << tests.size() << std::endl;
|
|
std::cout << "Total number of passed tests: " << counter << std::endl;
|
|
|
|
return 0;
|
|
}
|