// удаление "опорного" столбца из таблицы
private static void Step_deleteColumn(LinearProgrammingProblem lpp, int column, int columns, int rows,
Fraction[,] matrix, string method)
{
Fraction[,] matrixResult = new Fraction[columns - 1, rows];
for (int j = 0; j < column; j++)
{
for (int i = 0; i < rows; i++)
{
matrixResult[j, i] = matrix[j, i];
}
}
for (int j = column; j < columns - 1; j++)
{
for (int i = 0; i < rows; i++)
{
matrixResult[j, i] = matrix[j + 1, i];
}
}
switch (method)
{
case "MAB":
lpp.methodOfArtificialBasis.Add(matrixResult);
lpp.nowNumMatrixMAB++;
break;
case "SM":
break;
}
}
// для чтения из файла (для функции menuItemOpen_Click)
// заполнение gridG
private static void FullGridG(MainWindow w, string[] linesSelectedFile)
{
// gridG
int columnsG = w.gridG.ColumnDefinitions.Count;
int rowsG = w.gridG.RowDefinitions.Count;
// заполнить коэф. цел. ф-ии
for (int i = 0; i < rowsG; i++)
{
string[] texts;
if (!linesSelectedFile[4 + Convert.ToInt32(linesSelectedFile[1]) + i].Equals(""))
{
texts = linesSelectedFile[4 +
Convert.ToInt32(linesSelectedFile[1]) + i].Trim(new
char[] { ';' }).Split(new char[] { ';' });
}
else
{
MessageBox.Show("ошибка при чтении файла");
return;
}
for (int j = 0; j < columnsG - 2; j += 2)
{
TextBox t = (TextBox)w.gridG.Children[i * (columnsG) + i + j];
t.Text = texts[j / 2];
CheckBox ch = (CheckBox)w.gridGF.Children[i * (columnsG) + i + j];
ch.IsChecked = true;
if (LinearProgrammingProblem.ReadText(t.Text).Numerator == 0)
{
ch.IsChecked = false;
}
}
}
return;
}
private static void TransformMatrixColumnPart2(LinearProgrammingProblem lpp,
Fraction[,] matrix, int column, int row, Label mes)
{
// вычитаем
for (int i = 1; i < row; i++)
{
SubtractRow(matrix, i, row, column, mes);
matrix[0, 0].Text = "№" + (lpp.nowNumMatrixG + 1);
lpp.methodGauss.Add(CopyMatrix(matrix));
lpp.nowNumMatrixG++;
}
}
// выбор опорного элемента
public static void SelectSupportElem(LinearProgrammingProblem lpp,
out int column, out int row, string method, Fraction[,] matrixIn)
{
column = -1;
row = -1;
Fraction[,] matrix = (Fraction[, ])matrixIn.Clone();
int columns = matrix.GetLength(0);
int rows = matrix.GetLength(1);
Fraction[] supportElementsIndex = new Fraction[columns];
for (int i = 1; i < columns - 1; i++)
{
supportElementsIndex[i] = MAB_SM.FindSupportMinRatio(i, matrix);
}
bool flagSupportElem = false;
for (int y = 0; y < rows && !flagSupportElem; y++)
{
for (int x = 0; x < columns; x++)
{
Fraction ratio = matrix[columns - 1, y] / matrix[x, y];
if (x != 0 && x != columns - 1 &&
y != 0 && y != rows - 1 &&
supportElementsIndex[x] != null &&
supportElementsIndex[x].IsEquals(ratio) &&
matrix[x, y] > 0 &&
!flagSupportElem)
{
switch (method)
{
case "MAB":
if (matrix[0, y] >= lpp.matrix2.GetLength(0))
{
column = x;
row = y;
flagSupportElem = true;
}
break;
case "SM":
column = x;
row = y;
flagSupportElem = true;
break;
}
}
}
}
}
public static void Step(LinearProgrammingProblem lpp, int column, int row,
string method, int nowNum, List <Fraction[, ]> matrixs)
{
int columns = matrixs[nowNum].GetLength(0);
int rows = matrixs[nowNum].GetLength(1);
Fraction[,] matrix = Step_do(lpp, column, row, columns, rows, method);
switch (method)
{
case "MAB":
Step_deleteColumn(lpp, column, columns, rows, matrix, method);
break;
case "SM":
break;
}
}
private static void NormalizeString(LinearProgrammingProblem lpp,
Fraction[,] matrix, int column, int row)
{
Fraction elem = matrix[column, row];
if (elem.IsEquals(new Fraction(1)))
{
return;
}
int columns = matrix.GetLength(0);
for (int j = 1; j < columns; j++)
{
matrix[j, row] = matrix[j, row] / elem;
}
matrix[0, 0].Text = "№" + (lpp.nowNumMatrixG + 1);
lpp.methodGauss.Add(CopyMatrix(matrix));
lpp.nowNumMatrixG++;
}
public MainWindow()
{
lpp = new LinearProgrammingProblem();
InitializeComponent();
// заполнить comboBoxColumn
if (comboBoxColumn != null)
{
comboBoxColumn.Items.Clear();
int columns = lpp.maxDimension;
for (int i = 1; i <= columns; i++)
{
comboBoxColumn.Items.Add(i.ToString());
}
}
selectedMethod = "MAB";
SelectedMethod();
comboBoxColumn.SelectedIndex = 0;
comboBoxRow.SelectedIndex = 0;
}
// calculateButton кнопка перехода к 1 части решения
private void calculateButton_Click(object sender, RoutedEventArgs e)
{
message.Content = "";
message2.Content = "";
messageAnswer.Content = "";
messageAnswer2.Content = "";
// заполнить массивы с коэф-ми цел. ф-ии и условий
LinearProgrammingProblem.ReadTextGrid(this, lpp.matrix1, lpp.matrix2, lpp.matrixG, lpp.matrixGFlag);
// запомнить min или max ищем
int columns1 = grid1.ColumnDefinitions.Count;
ComboBox cB = (ComboBox)grid1.Children[columns1 - 1];
lpp.extremum = (string)cB.SelectionBoxItem;
// проверка ранга
GaussMethod MatrixsG = new GaussMethod(lpp.matrix2.GetLength(0), lpp.matrix2.GetLength(1), lpp.matrix2);
if (MatrixsG.Rank == MatrixsG.m)
{
// очистить матрицы симпл. метода
ClearSM();
// скрыть/ сделать недоступными кнопки навигации
Display.ChangePropertiesButton_EnabledFalse_1(this);
Display.ChangePropertiesButton_VisibilityCollapsed_2(this);
// очистить для новых записей
ClearMAB();
ClearG();
// 1 часть Гаусс/ мет иск. баз.
switch (selectedMethod)
{
case "Gauss":
CalculateG();
break;
case "MAB":
CalculateMAB();
break;
}
}
else
{
MessageBox.Show("ошибка: условий больше, чем требуется");
}
}
public static int getNowNum(LinearProgrammingProblem lpp, string method)
{
int nowNum = 0;
switch (method)
{
case "MAB":
if (lpp.nowNumMatrixMAB % 2 != 0)
{
lpp.nowNumMatrixMAB++;
}
nowNum = lpp.nowNumMatrixMAB;
break;
case "SM":
nowNum = lpp.nowNumMatrixSM;
break;
}
return(nowNum);
}
// автоматическое сохранение задачи (в меню пункт menuItemSave),
// в случае необходимости раскомментировать
//
//private void menuItemSave_Click(object sender, RoutedEventArgs e)
//{
// List<string> tasks = SaveTask();
// // добавить к имени дату для уникальности
// string dateTime = DateTime.Now.ToString("_yyyyMMdd_HHmmss");
// // сохранить
// File.WriteAllLines((Directory.GetCurrentDirectory() + "/tasks/task" + dateTime + ".txt"), tasks);
// MessageBox.Show("Задача сохранена под именем\ntask" + dateTime);
//}
// для сохранения задачи
private List <string> SaveTask()
{
List <string> tasks = new List <string>();
Fraction[,] matrix1Save;
Fraction[,] matrix2Save;
Fraction[,] matrixGSave;
bool[,] matrixGFlagSave;
String extremumSave = "";
// размер матрицы
int m1rows = 1;
int m1columns = 1;
int m2rows = 1;
int m2columns = 1;
if (comboBoxColumn != null)
{
m2columns = comboBoxColumn.SelectedIndex + 2;
m1columns = m2columns;
}
if (comboBoxRow != null)
{
m2rows = comboBoxRow.SelectedIndex + 1;
}
// создать матрицу
matrix1Save = new Fraction[m1columns, m1rows];
matrix2Save = new Fraction[m2columns, m2rows];
matrixGSave = new Fraction[m1columns, m1rows];
matrixGFlagSave = new bool[m1columns, m1rows];
// заполнить массивы с коэф-ми цел. ф-ии и условий
LinearProgrammingProblem.ReadTextGrid(this, matrix1Save, matrix2Save, matrixGSave, matrixGFlagSave);
// запомнить min или max ищем
int columns1 = grid1.ColumnDefinitions.Count;
ComboBox cB = (ComboBox)grid1.Children[columns1 - 1];
extremumSave = (string)cB.SelectionBoxItem;
// заполнить список строк задачи
FullTasks(tasks, matrix1Save, matrix2Save, matrixGSave, extremumSave, m1rows, m1columns, m2rows, m2columns);
return(tasks);
}
public static void TransformMatrix(LinearProgrammingProblem lpp,
Fraction[,] matrixBasis, bool[,] matrixFlag, List <Fraction[, ]> matrixs, Label mes)
{
Fraction[,] matrix = CopyMatrix(matrixs[matrixs.Count - 1]);
int columns = matrix.GetLength(0);
int rows = matrix.GetLength(1);
int count = 1;
int countM = lpp.matrix2.GetLength(1);
// проверка коол-ва условий и кол-ва баз. переменных
for (int i = 1; i < columns - 1; i++)
{
if (matrixFlag[i - 1, 0])
{
if (count > countM)
{
mes.Content = "Количество условий и базисных переменных не совпадает (много)";
return;
}
count++;
}
}
count--;
if (count != countM)
{
mes.Content = "Количество условий и базисных переменных не совпадает (мало)";
return;
}
// метод гаусса
count = 1;
// двежение слева направо
for (int i = 1; i < columns - 1; i++)
{
if (matrixFlag[i - 1, 0])
{
if (matrix[i, count].IsEquals(new Fraction(0)))
{
for (int k = count + 1; k <= rows && matrix[i, count].IsEquals(new Fraction(0)); k++)
{
if (k == rows)
{
mes.Content = "Базис не совпал. Выразить через базисные переменные не удалось";
return;
}
SwapRows2(matrix, count, k);
matrix[0, 0].Text = "№" + (lpp.nowNumMatrixG + 1);
lpp.methodGauss.Add(CopyMatrix(matrix));
lpp.nowNumMatrixG++;
}
}
// нормирование строки
NormalizeString(lpp, matrix, i, count);
// обнуление столбца снизу под баз. эл.
TransformMatrixColumnPart1(lpp, matrix, i, count, mes);
count++;
}
}
count--;
// движение справа налево
for (int i = columns - 2; i >= 1; i--)
{
if (matrixFlag[i - 1, 0])
{
// обнуление столбца сверху над баз.эл.
TransformMatrixColumnPart2(lpp, matrix, i, count, mes);
count--;
}
}
int n = lpp.matrix2.GetLength(0);
Fraction[] arr = new Fraction[n];
for (int i = 0; i < arr.Length; i++)
{
arr[i] = new Fraction(0);
}
// проверка на совпадение введенного базиса и полученного
countM = 1;
for (int i = 1; i < columns - 1; i++)
{
if (matrixFlag[i - 1, 0])
{
if (!matrixBasis[i - 1, 0].IsEquals(matrix[columns - 1, countM]))
{
mes.Content = "Базис не совпал";
return;
}
countM++;
}
}
}
private static Fraction[,] Step_do(LinearProgrammingProblem lpp,
int column, int row, int columns, int rows, string method)
{
int nowNum = -1;
List <Fraction[, ]> matrixs = new List <Fraction[, ]>();
switch (method)
{
case "MAB":
nowNum = lpp.nowNumMatrixMAB;
matrixs = lpp.methodOfArtificialBasis;
break;
case "SM":
nowNum = lpp.nowNumMatrixSM;
matrixs = lpp.simplexMethod;
break;
}
Fraction[,] matrix = new Fraction[columns, rows];
matrix[0, 0] = new Fraction();
matrix[0, 0].Text = "№" + (nowNum + 1);
matrix[0, rows - 1] = new Fraction();
matrix[0, rows - 1].Text = " ";
matrix[columns - 1, 0] = new Fraction();
matrix[columns - 1, 0].Text = " ";
for (int i = 1; i < columns - 1; i++)
{
matrix[i, 0] = new Fraction();
matrix[i, 0] = matrixs[nowNum][i, 0];
}
for (int i = 1; i < rows - 1; i++)
{
matrix[0, i] = new Fraction();
matrix[0, i] = matrixs[nowNum][0, i];
}
matrix[column, 0] = matrixs[nowNum][0, row];
matrix[0, row] = matrixs[nowNum][column, 0];
Fraction fr1 = new Fraction(1);
// опорный элемент
matrix[column, row] = fr1 / matrixs[nowNum][column, row];
matrix[column, row].IsSupport = true;
// строки
for (int i = 1; i < columns; i++)
{
if (i != column)
{
matrix[i, row] = matrixs[nowNum][i, row] * matrix[column, row];
}
}
// столбцы
for (int i = 1; i < rows; i++)
{
if (i != row)
{
matrix[column, i] = (-1) * matrixs[nowNum][column, i] * matrix[column, row];
}
}
// остальное
for (int i = 1; i < rows; i++)
{
for (int j = 1; j < columns; j++)
{
if (i != row && j != column)
{
matrix[j, i] = matrixs[nowNum][j, i] - matrixs[nowNum][column, i] * matrix[j, row];
}
}
}
switch (method)
{
case "MAB":
lpp.methodOfArtificialBasis.Add(matrix);
lpp.nowNumMatrixMAB++;
break;
case "SM":
lpp.simplexMethod.Add(matrix);
lpp.nowNumMatrixSM++;
break;
}
return(matrix);
}