public static MyMatrix gauss(MyMatrix AB, bool optimise)
{
if (AB.rowCount != AB.columnCount - 1)
{
throw new Exception("Matrix N x (N+1) is required for Gaussian Eliminations!");
}
int n = AB.rowCount;
for (int i = 0; i < n; i++)
{
double max = Math.Abs(AB[i, i]);
int maxRow = i;
for (int k = i + 1; k < n; k++)
{
if (Math.Abs(AB[k, i]) > max)
{
max = Math.Abs(AB[k, i]);
maxRow = k;
}
}
for (int k = i; k < n + 1; k++)
{
double tmp = AB[maxRow, k];
AB[maxRow, k] = AB[i, k];
AB[i, k] = tmp;
}
for (int k = i + 1; k < n; k++)
{
double c = (default(double) - AB[k, i]) / AB[i, i];
if (optimise == true && c == default(double))
{
continue;
}
for (int j = i; j < n + 1; j++)
{
if (i == j)
{
AB[k, j] = default(double);
}
else
{
AB[k, j] += c * AB[i, j];
}
}
}
}
MyMatrix X = countVariables(AB);
return(X);
}
private static void swapRows(MyMatrix matrix, int row1, int row2)
{
if (row1 == row2)
{
return;
}
for (int i = 0; i < matrix.columnCount; i++)
{
double tmp = matrix[row1, i];
matrix[row1, i] = matrix[row2, i];
matrix[row2, i] = tmp;
}
return;
}
public MyMatrix generateVector()
{
int size = allStates.Count();
MyMatrix vector = new MyMatrix(size, 1);
foreach (var state in allStates)
{
if (state.win)
{
vector[state.index, 0] = 1.0;
}
}
return(vector);
}
private static int findBiggestRowInColumn(MyMatrix matrix, int column)
{
double max = 0.0;
int row = 0;
for (int i = 0; i < matrix.rowCount; i++)
{
if (matrix[i, column] > max)
{
max = matrix[i, column];
row = i;
}
}
return(row);
}
private static MyMatrix countVariables(MyMatrix AB)
{
int n = AB.rowCount;
MyMatrix X = new MyMatrix(AB.rowCount, 1);
for (int i = n - 1; i >= 0; i--)
{
X[i, 0] = AB[i, n] / AB[i, i];
for (int k = i - 1; k >= 0; k--)
{
AB[k, n] -= AB[k, i] * X[i, 0];
}
}
return(X);
}
public static double CountVariable(MyMatrix equation, double variable)
{
string tmp = "";
double result = 0;
for (int i = 0; i < equation.rowCount; i++)
{
result += equation[i, 0] * Math.Pow(variable, i);
tmp += "(" + equation[i, 0] + "* x^" + i + ")";
if (i != equation.rowCount - 1)
{
tmp += " + ";
}
}
Console.WriteLine(tmp);
return(result);
}
private MyMatrix resultByQueue(MyMatrix vector, List <int> queue)
{
MyMatrix tmp = new MyMatrix(vector.rowCount, 1);
for (int i = 0; i < vector.rowCount; i++)
{
for (int j = 0; j < vector.columnCount; j++)
{
tmp[i, j] = vector[i, j];
}
}
for (int i = 0; i < vector.rowCount; i++)
{
vector[queue[i], 0] = tmp[i, 0];
}
return(vector);
}
public static MyMatrix CountEquation(double[,] data, int power)
{
if (data.GetLength(1) != 2 || data.GetLength(0) < 1)
{
throw new Exception("Wrong data table! Count requires 2 columns of data.");
}
int dataLength = data.GetLength(0);
int sCount = (2 * power) + 1;
int tCount = power + 1;
int size = power + 1;
double[,] sTab = new double[dataLength, sCount];
double[,] tTab = new double[dataLength, tCount];
double[] sResults = new double[sCount];
double[] tResults = new double[tCount];
for (int i = 0; i < sTab.GetLength(0); i++) //GetLength(0) == dataLen == rowsy
{
for (int j = 0; j < sTab.GetLength(1); j++) //GetLength(1) == sCount == kolumny
{
sTab[i, j] = Math.Pow(data[i, 0], j);
sResults[j] += sTab[i, j];
}
for (int j = 0; j < tTab.GetLength(1); j++)
{
tTab[i, j] = data[i, 1] * sTab[i, j];
tResults[j] += tTab[i, j];
}
}
MyMatrix matrix = new MyMatrix(size, size);
MyMatrix vector = new MyMatrix(size, 1);
int helper = 0;
for (int i = 0; i < size; i++)
{
vector[i, 0] = tResults[i];
for (int j = 0; j < size; j++)
{
matrix[i, j] = sResults[j + helper];
}
helper++;
}
MyMatrix resultVector = MyMatrix.gauss(MyMatrix.matrixJoinVector(matrix, vector), true);
return(resultVector);
}
private static void swapColumns(MyMatrix matrix, int column1, int column2, List <int> queue)
{
if (column1 == column2)
{
return;
}
int tmp = queue[column1];
queue[column1] = queue[column2];
queue[column2] = tmp;
for (int i = 0; i < matrix.rowCount; i++)
{
double Tmp = matrix[i, column1];
matrix[i, column1] = matrix[i, column2];
matrix[i, column2] = Tmp;
}
return;
}
public static void saveVectorOfNonZeroElements(string filename, MyMatrix matrix)
{
MyMatrix vector = new MyMatrix(matrix.rowCount, 1);
int counter = 0;
for (int j = 0; j < matrix.columnCount; j++)
{
counter = 0;
for (int i = 0; i < matrix.rowCount; i++)
{
if (matrix[i, j] != 0.0)
{
counter++;
}
}
vector[j, 0] = counter;
}
saveMatrix(filename, vector);
}
public static MyMatrix operator -(MyMatrix a, MyMatrix b)
{
if (a.rowCount != b.rowCount || a.columnCount != b.columnCount)
{
Console.WriteLine("Matrices sizes are incorrect for operation : a + b!");
return(null);
}
MyMatrix c = new MyMatrix(a.rowCount, a.columnCount);
for (int i = 0; i < a.rowCount; i++)
{
for (int j = 0; j < a.columnCount; j++)
{
c.matrix[i, j] = a.matrix[i, j] - b.matrix[i, j];
}
}
return(c);
}
public static void saveMatrix(string filename, MyMatrix matrix)
{
CultureInfo customCulture = (CultureInfo)Thread.CurrentThread.CurrentCulture.Clone();
customCulture.NumberFormat.NumberDecimalSeparator = ".";
Thread.CurrentThread.CurrentCulture = customCulture;
using (TextWriter tw = new StreamWriter(filename)) {
tw.WriteLine(matrix.rowCount + " " + matrix.columnCount);
for (int i = 0; i < matrix.rowCount; i++)
{
for (int j = 0; j < matrix.columnCount; j++)
{
tw.Write(matrix[i, j] + " ");
}
tw.WriteLine();
}
}
customCulture.NumberFormat.NumberDecimalSeparator = ",";
Thread.CurrentThread.CurrentCulture = customCulture;
}
public static MyMatrix gaussSeidel(MyMatrix A, MyMatrix B)
{
int n = A.rowCount;
if (A.rowCount != B.rowCount || A.rowCount != A.columnCount)
{
throw new Exception("Matrix A must be n*n! A rowCount must be equal B rowCount!");
}
MyMatrix X = new MyMatrix(n, 1);
double sum = 0.0;
while (true)
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < i; j++)
{
sum -= A[i, j] * X[j, 0];
}
for (int j = i + 1; j < n; j++)
{
sum -= A[i, j] * X[j, 0];
}
if (A[i, i] == 0.0)
{
int row = findBiggestRowInColumn(A, i);
swapRows(A, i, row);
swapRows(B, i, row);
}
X[i, 0] = (B[i, 0] + sum) / A[i, i];
sum = 0.0;
}
double norm1 = (B - (A * X)).countNorm();
double norm2 = B.countNorm();
if (norm1 / norm2 < epsilon)
{
break;
}
}
return(X);
}
private static void findBiggestValue(MyMatrix AB, int index, List <int> queue)
{
double max = AB[index, index];
int rowIndex = index;
int columnIndex = index;
for (int i = index; i < AB.rowCount; i++)
{
for (int j = index; j < AB.columnCount - 1; j++)
{
if (Math.Abs(AB[i, j]) > max)
{
max = Math.Abs(AB[i, j]);
rowIndex = i;
columnIndex = j;
}
}
}
swapRows(AB, index, rowIndex);
swapColumns(AB, index, columnIndex, queue);
}
public static MyMatrix operator *(MyMatrix a, MyMatrix b)
{
if (a.columnCount != b.rowCount)
{
Console.WriteLine("Matrices sizes are incorrect for operation : a * b!");
return(null);
}
MyMatrix c = new MyMatrix(a.rowCount, b.columnCount);
for (int i = 0; i < a.rowCount; i++)
{
for (int j = 0; j < b.columnCount; j++)
{
c.matrix[i, j] = default(double);
for (int k = 0; k < b.rowCount; k++)
{
c.matrix[i, j] += a.matrix[i, k] * b.matrix[k, j];
}
}
}
return(c);
}
public MyMatrix generateMatrix()
{
int size = allStates.Count();
MyMatrix matrix = new MyMatrix(size, size);
foreach (var state in allStates)
{
if (state.win)
{
matrix[state.index, state.index] = 1.0;
}
else
{
matrix[state.index, state.index] = -1.0;
}
foreach (var subState in state.equation)
{
matrix[state.index, subState.index] = (double)state.countSameStates(subState, dice) / dice.probabilitySum;
}
}
return(matrix);
}
public static void countInfo(MyMatrix matrix, MyMatrix vector, double generationTime)
{
double[] executionTime = new double[3];
int size = matrix.rowCount;
Stopwatch stopWatch = new Stopwatch();
MyMatrix result;
MyMatrix matrixTMP;
MyMatrix vectorTMP;
Console.WriteLine("-------------------------GAUSS PARTIAL BEZ OPTYMALIZACJI-------------------------");
matrixTMP = MyMatrix.matrixJoinVector(matrix, vector);
stopWatch.Start();
result = MyMatrix.gauss(matrixTMP, false);
stopWatch.Stop();
Console.WriteLine("Wynik : " + result[0, 0]);
Console.WriteLine("Czas : " + stopWatch.ElapsedMilliseconds);
executionTime[0] = stopWatch.ElapsedMilliseconds;
Console.WriteLine("-------------------------GAUSS PARTIAL Z OPTYMALIZACJA-------------------------");
matrixTMP = MyMatrix.matrixJoinVector(matrix, vector);
stopWatch.Restart();
result = MyMatrix.gauss(matrixTMP, true);
stopWatch.Stop();
Console.WriteLine("Wynik : " + result[0, 0]);
Console.WriteLine("Czas : " + stopWatch.ElapsedMilliseconds);
executionTime[1] = stopWatch.ElapsedMilliseconds;
Console.WriteLine("-------------------------GAUSS ITERACYJNY : SEIDEL-------------------------");
matrixTMP = new MyMatrix(matrix);
vectorTMP = new MyMatrix(vector);
stopWatch.Restart();
result = MyMatrix.gaussSeidel(matrixTMP, vectorTMP);
stopWatch.Stop();
Console.WriteLine("Wynik : " + result[0, 0]);
Console.WriteLine("Czas : " + stopWatch.ElapsedMilliseconds);
executionTime[2] = stopWatch.ElapsedMilliseconds;
FileHelper.saveStatsAprox(infoOutput, size, generationTime, executionTime);
}
public static MyMatrix gaussIterative(MyMatrix A, MyMatrix B, int version, out int saver)
{
int n = A.rowCount;
if (A.rowCount != B.rowCount || A.rowCount != A.columnCount)
{
throw new Exception("Matrix A must be n*n! A rowCount must be equal B rowCount!");
}
if (version == 1)
{ //JACOBI
MyMatrix X_NEW = new MyMatrix(n, 1);
MyMatrix X_OLD = new MyMatrix(n, 1);
double sum = 0.0;
int iter = 0;
while (true)
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
{
if (j != i)
{
sum -= A[i, j] * X_OLD[j, 0];
}
}
if (A[i, i] == 0.0)
{
int row = findBiggestRowInColumn(A, i);
swapRows(A, i, row);
swapRows(B, i, row);
}
X_NEW[i, 0] = (B[i, 0] + sum) / A[i, i];
sum = 0.0;
}
double norm1 = (B - (A * X_NEW)).countNorm();
double norm2 = B.countNorm();
if ((norm1 / norm2) < epsilon)
{
break;
}
for (int i = 0; i < n; i++)
{
X_OLD[i, 0] = X_NEW[i, 0];
}
iter++;
}
saver = iter;
return(X_NEW);
}
else if (version == 2)
{ //SEIDEL
MyMatrix X = new MyMatrix(n, 1);
double sum = 0.0;
int iter = 0;
while (true)
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < i; j++)
{
sum -= A[i, j] * X[j, 0];
}
for (int j = i + 1; j < n; j++)
{
sum -= A[i, j] * X[j, 0];
}
if (A[i, i] == 0.0)
{
int row = findBiggestRowInColumn(A, i);
swapRows(A, i, row);
swapRows(B, i, row);
}
X[i, 0] = (B[i, 0] + sum) / A[i, i];
sum = 0.0;
}
double norm1 = (B - (A * X)).countNorm();
double norm2 = B.countNorm();
if (norm1 / norm2 < epsilon)
{
break;
}
iter++;
}
saver = iter;
return(X);
}
else
{
throw new Exception("Unknown Gauss elimination version! 1 - base, 2 - partial, 3 - full");
}
}
