private void FirstPhaseHalfPivot(MatrixEquasion <double> eq)
{
//Pierwsza faza eliminacji Gaussa, z częściowym wyborem elementu podstawowego
//Tworzy z macierzy A macierz trójkątną górną oraz dzieli wiersze tak, aby uzyskać jedynki wiodące
//Przenosi operacje na macierz B
for (int i = 0; i < eq.A.ColCount; i++)
{
//Wybór wiodącego elementu
int max = FindMaxInColumn(eq.A, i, i, eq.A.RowCount);
eq.A.SwapRows(i, max);
eq.B.SwapRows(i, max);
eq.B.ValueMatrix[i] = Matrix <double> .MultiplyRow(eq.B.ValueMatrix[i], (eq.A.ValueMatrix[i][i].GetInverse()));
eq.A.ValueMatrix[i] = Matrix <double> .MultiplyRow(eq.A.ValueMatrix[i], (eq.A.ValueMatrix[i][i].GetInverse()));
for (int j = i + 1; j < eq.A.RowCount; j++)
{
eq.B.ValueMatrix[j] = Matrix <double> .SubtractRows(eq.B.ValueMatrix[j], Matrix <double> .MultiplyRow(eq.B.ValueMatrix[i], eq.A.ValueMatrix[j][i]));
eq.A.ValueMatrix[j] = Matrix <double> .SubtractRows(eq.A.ValueMatrix[j], Matrix <double> .MultiplyRow(eq.A.ValueMatrix[i], eq.A.ValueMatrix[j][i]));
}
}
}
public Result Perform(MatrixEquasion <double> eq)
{
Stopwatch st = new Stopwatch();
MatrixEquasion <double> temp = new MatrixEquasion <double>(eq);
st.Start();
FirstPhaseHalfPivot(temp);
SecondPhase(temp);
st.Stop();
double error = Matrix <double> .GetNormOfDiffrence(eq.A.Multiply(temp.B), eq.B);
return(new Result("GaussianHalfPivotOptimalized", error, st.ElapsedMilliseconds, 1, temp.B));
}
private void SecondPhase(MatrixEquasion <double> eq)
{
//Druga faza eliminacji Gaussa
//Sprowadza macierz A do macierzy jednostkowej
//Po tej operacji macierz B to wyliczony X, błąd to | ||B|| - ||X|| |
for (int i = eq.A.ColCount - 1; i >= 0; i--)
{
for (int j = i - 1; j >= 0; j--)
{
eq.B.ValueMatrix[j] = Matrix <double> .SubtractRows(eq.B.ValueMatrix[j], Matrix <double> .MultiplyRow(eq.B.ValueMatrix[i], eq.A.ValueMatrix[j][i]));
eq.A.ValueMatrix[j] = Matrix <double> .SubtractRows(eq.A.ValueMatrix[j], Matrix <double> .MultiplyRow(eq.A.ValueMatrix[i], eq.A.ValueMatrix[j][i]));
}
}
}
public Result Perform(MatrixEquasion <double> eq)
// Eliminacja Gaussa z częściowym wyborem elementu
// Brak optymalizacji
{
Stopwatch st = new Stopwatch();
MatrixEquasion <double> temp = new MatrixEquasion <double>(eq);
st.Start();
FirstPhaseHalfPivot(temp);
SecondPhase(temp);
st.Stop();
double error = Matrix <double> .GetNormOfDiffrence(eq.A.Multiply(temp.B), eq.B);
return(new Result("GaussianHalfPivot", error, st.ElapsedMilliseconds, 1, temp.B));
}
private void SecondPhase(MatrixEquasion <double> eq)
{
//Druga faza eliminacji Gaussa
//Sprowadza macierz A do macierzy jednostkowej
for (int i = eq.A.ColCount - 1; i >= 0; i--)
{
for (int j = i - 1; j >= 0; j--)
{
if (eq.A.ValueMatrix[j][i].CompareTo(MatrixDouble.ZERO) != 0)
{
eq.B.ValueMatrix[j] = Matrix <double> .SubtractRows(eq.B.ValueMatrix[j], Matrix <double> .MultiplyRow(eq.B.ValueMatrix[i], eq.A.ValueMatrix[j][i]));
eq.A.ValueMatrix[j] = Matrix <double> .SubtractRows(eq.A.ValueMatrix[j], Matrix <double> .MultiplyRow(eq.A.ValueMatrix[i], eq.A.ValueMatrix[j][i]));
}
}
}
}
private void JacobianIteration(MatrixEquasion <Double> eq, Matrix <Double> oldMatrix, Matrix <Double> newMatrix, int i)
{
IMatrixDataType <Double> x = new MatrixDouble(0);
for (int j = 0; j < eq.A.ColCount; j++)
{
if (i != j)
{
x = (x.Add(eq.A.ValueMatrix[i][j].Multiply(oldMatrix.ValueMatrix[j][0])));
}
}
x = x.Multiply(MatrixDouble.MINUSONE);
x = x.Add(eq.B.ValueMatrix[i][0]);
x = x.Divide(eq.A.ValueMatrix[i][i]);
newMatrix.ValueMatrix[i][0] = x;
}
private void GaussSeidelIteration(MatrixEquasion <Double> eq, Matrix <Double> newVector, int i)
{
IMatrixDataType <double> x = new MatrixDouble(0);
for (int j = 0; j < eq.A.ColCount; j++)
{
if (i != j)
{
x = (x.Add(eq.A.ValueMatrix[i][j].Multiply(newVector.ValueMatrix[j][0])));
}
}
x = x.Multiply(MatrixDouble.MINUSONE);
x = x.Add(eq.B.ValueMatrix[i][0]);
x = x.Divide(eq.A.ValueMatrix[i][i]);
newVector.ValueMatrix[i][0] = x;
}
public Result Perform(MatrixEquasion <double> eq)
{
int NOfEquasions = 0;
for (int i = 0; i <= NOfAgents; i++)
{
for (int j = 0; j <= NOfAgents - i; j++)
{
NOfEquasions++;
}
}
MatrixDouble[][] raw = new MatrixDouble[NOfEquasions][];
for (int i = 0; i < NOfEquasions; i++)
{
raw[i] = new MatrixDouble[1];
}
Stopwatch st = new Stopwatch();
int iteration = 0;
st.Start();
for (int i = 0; i <= NOfAgents; i++)
{
for (int j = 0; j <= NOfAgents - i; j++)
{
raw[iteration][0] = new MatrixDouble(GetProbability(i, j));
iteration++;
}
}
st.Stop();
Matrix <double> probVector = new Matrix <double>(raw);
double error = Matrix <double> .GetNormOfDiffrence(eq.A.Multiply(probVector), eq.B);
long time = st.ElapsedMilliseconds;
return(new Result("MonteCarlo", error, time, 100000, probVector));
}
public Result Perform(MatrixEquasion <Double> eq)
{
MatrixEquasion <double> temp = new MatrixEquasion <double>(eq);
Matrix <double> oldVector = new Matrix <double>(eq.B);
for (int i = 0; i < oldVector.RowCount; i++)
{
oldVector.ValueMatrix[i][0] = MatrixDouble.ZERO;
}
Matrix <double> newVector = new Matrix <double>(eq.B);
int iterations = 0;
Matrix <double> old = new Matrix <double>(newVector);;
Stopwatch st = new Stopwatch();
st.Start();
while (Matrix <double> .GetNormOfDiffrence(oldVector, newVector) > this.precision)
{
oldVector = new Matrix <double>(newVector);
iterations++;
for (int i = 0; i < eq.A.RowCount; i++)
{
JacobianIteration(eq, oldVector, newVector, i);
}
}
st.Stop();
double error = Matrix <double> .GetNormOfDiffrence(eq.A.Multiply(newVector), eq.B);
return(new Result($"Jacobian (p:{this.precision})", error, st.ElapsedMilliseconds, iterations, newVector));
}
public MatrixEquasion(MatrixEquasion <T> prototype) : this(new Matrix <T>(prototype.A), prototype.X != null?new Matrix <T>(prototype.X):null, new Matrix <T>(prototype.B))
{
}
