public static IEnumerable <Movement> LINQ(string[] lines)
{
IEnumerable <Movement> enumerable()
{
foreach (var Lu in lines.Skip(1))
{
var split = Lu.Split(';');
yield return(new Movement
{
Date = split[0],
Object_A = split[1],
Type_A = split[2],
Object_B = split[3],
Type_B = split[4],
Direction = split[5],
Color = split[6],
Intensity = int.Parse(split[7]),
LatitudeA = double.Parse(split[8], CultureInfo.InvariantCulture),
LongitudeA = double.Parse(split[9], CultureInfo.InvariantCulture),
LatitudeB = double.Parse(split[10], CultureInfo.InvariantCulture),
LongitudeB = double.Parse(split[11], CultureInfo.InvariantCulture)
});
if (checkPressed == true)
{
break;
}
lineValue++;
}
}
var data = enumerable();
return(data.ToList());;
}
public static double[,] SolveWith(double[,] matrix, double[] v, Lu lu)
{
int nrows = matrix.GetLength(0);
int ncols = matrix.GetLength(1);
if (!IsSquare(matrix))
{
throw new Exception("SolveWith requires a square matrix.");
}
if (nrows != v.Length)
{
throw new Exception("Wrong number of results in solution vector.");
}
double[,] b = new double[nrows, ncols];
for (int i = 0; i < nrows; i++)
{
b[lu.pi[i], 0] = v[i];
}
if (lu.llu == null)
{
lu.llu = LuDecomposition(lu.l);
}
double[,] z = ForwardSubstitution(lu.l, lu.llu, b);
if (lu.ulu == null)
{
lu.ulu = LuDecomposition(lu.u);
}
double[,] x = BackwardSubstitution(lu.u, lu.ulu, z);
return(x);
}
public void FailOnDecomposeNonSquareMatrix()
{
// Arrange
var nonSquareMatrix = new double[, ] {
{ 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 }, { 0, 0, 0 }
};
// Act
void Act(double[,] source) => Lu.Decompose(source);
// Assert
Assert.Throws <ArgumentException>(() => Act(nonSquareMatrix));
}
public void EliminateIdentityEquation()
{
// Arrange
var identityMatrix = new double[, ] {
{ 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 }
};
var coefficients = new double[] { 1, 2, 3 };
// Act
var solution = Lu.Eliminate(identityMatrix, coefficients);
// Assert
Assert.AreEqual(coefficients, solution);
}
public void FailOnEliminateEquationWithNonSquareMatrix()
{
// Arrange
var nonSquareMatrix = new double[, ] {
{ 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 }, { 0, 0, 0 }
};
var coefficients = new double[] { 1, 2, 3, 4 };
// Act
void Act(double[,] source, double[] c) => Lu.Eliminate(source, c);
// Assert
Assert.Throws <ArgumentException>(() => Act(nonSquareMatrix, coefficients));
}
public virtual double Determinant()
{
if (Lu.RowCount() != Lu.ColumnCount())
{
throw new ArgumentException("Matrix must be square.");
}
double d = PivotSign;
for (int j = 0; j < Lu.ColumnCount(); j++)
{
d *= Lu[j, j];
}
return(d);
}
public static double[,] Invert(double[,] matrix, Lu lu)
{
int nrows = matrix.GetLength(0);
int ncols = matrix.GetLength(1);
double[,] inv = new double[nrows, ncols];
for (int i = 0; i < nrows; i++)
{
double[] ei = new double[nrows];
ei[lu.pi[lu.pi[i]]] = 1;
double[,] col = SolveWith(matrix, ei, lu);
SetColumn(inv, ExtractColumn(col, 0), i);
}
return(inv);
}
public void EliminateEquation_Case3X3()
{
// Arrange
var source = new double[, ] {
{ 2, 1, -1 }, { -3, -1, 2 }, { -2, 1, 2 }
};
var coefficients = new double[] { 8, -11, -3 };
var expectedSolution = new double[] { 2, 3, -1 };
// Act
var solution = Lu.Eliminate(source, coefficients);
// Assert
Assert.IsTrue(VectorMembersAreEqual(expectedSolution, solution));
}
public static double[,] BackwardSubstitution(double[,] a, Lu alu, double[,] b)
{
int n = a.GetLength(0);
double[,] x = new double[n, 1];
for (int i = n - 1; i > -1; i--)
{
x[i, 0] = b[i, 0];
for (int j = n - 1; j > i; j--)
{
x[i, 0] -= a[i, j] * x[j, 0];
}
x[i, 0] = x[i, 0] / a[i, i];
}
return(x);
}
public static double[,] ForwardSubstitution(double[,] a, Lu alu, double[,] b)
{
int n = a.GetLength(0);
double[,] x = new double[n, 1];
for (int i = 0; i < n; i++)
{
x[i, 0] = b[i, 0];
for (int j = 0; j < i; j++)
{
x[i, 0] -= a[i, j] * x[j, 0];
}
x[i, 0] = x[i, 0] / a[i, i];
}
return(x);
}
/// <summary>Solve A*X = B</summary>
/// <param name="B">
/// A Matrix with as many rows as A and any number of columns.
/// </param>
/// <returns>
/// X so that L*U*X = B(piv,:)
/// </returns>
/// <exception cref="System.ArgumentException">
/// Matrix row dimensions must agree.
/// </exception>
/// <exception cref="System.SystemException">
/// Matrix is singular.
/// </exception>
public virtual double[,] Solve(double[,] B)
{
if (B.RowCount() != Lu.RowCount())
{
throw new ArgumentException("Matrix row dimensions must agree.");
}
if (!IsNonSingular)
{
throw new SystemException("Matrix is singular.");
}
int n = Lu.ColumnCount();
// Copy right hand side with pivoting
int nx = B.ColumnCount();
double[,] X = B.Submatrix(Pivot, 0, nx - 1);
// Solve L*Y = B(piv,:)
for (int k = 0; k < n; k++)
{
for (int i = k + 1; i < n; i++)
{
for (int j = 0; j < nx; j++)
{
X[i, j] -= X[k, j] * Lu[i, k];
}
}
}
// Solve U*X = Y;
for (int k = n - 1; k >= 0; k--)
{
for (int j = 0; j < nx; j++)
{
X[k, j] /= Lu[k, k];
}
for (int i = 0; i < k; i++)
{
for (int j = 0; j < nx; j++)
{
X[i, j] -= X[k, j] * Lu[i, k];
}
}
}
return(X);
}
public void EliminateEquation_Case4X4()
{
// Arrange
var source = new[, ]
{
{ 1.0, 2.0, -3.0, -1.0 },
{ 0.0, -3.0, 2.0, 6.0 },
{ 0.0, 5.0, -6.0, -2.0 },
{ 0.0, -1.0, 8.0, 1.0 },
};
var coefficients = new[] { 0.0, -8.0, 0.0, -8.0 };
var expectedSolution = new[] { -1.0, -2.0, -1.0, -2.0 };
// Act
var solution = Lu.Eliminate(source, coefficients);
// Assert
Assert.IsTrue(VectorMembersAreEqual(expectedSolution, solution));
}
private void radButton1_Click(object sender, EventArgs e)
{
double Hus, Bwu, Hds, Bds, QU, Lu;
//up stream retaing wall
Hus = h + He + (double)0.5;
Bwu = (double)2 / 3 * Hus;
//down stream retaing wall
Hds = d2 + 0.5;
Bds = (double)2 / 3 * Hds;
QU = X * Qp;
Lu = QU / ((double)1.71 * (Math.Pow(Hd + h, (double)3 / 2)));
undersluiceradTextBox1.Text = Lu.ToString();
HeightradTextBox1.Text = Hus.ToString();
BottomwidthradTextBox3.Text = Bwu.ToString();
downheightradTextBox4.Text = Hds.ToString();
downbottomradTextBox2.Text = Bds.ToString();
}
public void DecomposeMatrix_Case3X3()
{
// Arrange
var source = new double[, ] {
{ 2, 1, 4 }, { 7, 1, 1 }, { 4, 2, 9 }
};
var expectedLower = new[, ] {
{ 1, 0, 0 }, { 3.5, 1, 0 }, { 2, 0, 1 }
};
var expectedUpper = new[, ] {
{ 2, 1, 4 }, { 0, -2.5, -13 }, { 0, 0, 1 }
};
// Act
(double[,] lower, double[,] upper) = Lu.Decompose(source);
// Assert
Assert.AreEqual(expectedLower, lower);
Assert.AreEqual(expectedUpper, upper);
Assert.AreEqual(lower.Multiply(upper), source);
}
public void DecomposeIdentityMatrix()
{
// Arrange
var identityMatrix = new double[, ] {
{ 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 }
};
var expectedLower = new double[, ] {
{ 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 }
};
var expectedUpper = new double[, ] {
{ 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 }
};
// Act
(double[,] lower, double[,] upper) = Lu.Decompose(identityMatrix);
// Assert
Assert.AreEqual(expectedLower, lower);
Assert.AreEqual(expectedUpper, upper);
Assert.AreEqual(lower.Multiply(upper), identityMatrix);
}
public void DecomposeMatrix_Case4X4()
{
// Arrange
var source = new[, ] {
{ 1, 2, 4.5, 7 }, { 3, 8, 0.5, 2 }, { 2, 6, 4, 1.5 }, { 4, 14, 2, 10.5 }
};
var expectedLower = new[, ] {
{ 1, 0, 0, 0 }, { 3, 1, 0, 0 }, { 2, 1, 1, 0 }, { 4, 3, 2.875, 1 }
};
var expectedUpper = new[, ] {
{ 1, 2, 4.5, 7 }, { 0, 2, -13, -19 }, { 0, 0, 8, 6.5 }, { 0, 0, 0, 20.8125 }
};
// Act
(double[,] lower, double[,] upper) = Lu.Decompose(source);
// Assert
Assert.AreEqual(expectedLower, lower);
Assert.AreEqual(expectedUpper, upper);
Assert.AreEqual(lower.Multiply(upper), source);
}
public static Lu LuDecomposition(double[,] matrix)
{
if (!IsSquare(matrix))
{
throw new Exception("LU decomposition requires a square matrix");
}
int nrows = matrix.GetLength(0);
int ncols = matrix.GetLength(1);
Lu lu = new Lu {
l = Identity(nrows, ncols), u = (double[, ])matrix.Clone(), pi = new int[nrows]
};
for (int i = 0; i < nrows; i++)
{
lu.pi[i] = i;
}
int k0 = 0;
lu.determinantOfPi = 1;
for (int k = 0; k < ncols - 1; k++)
{
double p = 0;
// find the row with the biggest pivot
for (int i = k; i < nrows; i++)
{
if (Math.Abs(lu.u[i, k]) > p)
{
p = Math.Abs(lu.u[i, k]);
k0 = i;
}
}
if (p == 0)
{
throw new Exception("The matrix is singular!");
}
// switch two rows in permutation matrix
int pom1 = lu.pi[k];
lu.pi[k] = lu.pi[k0];
lu.pi[k0] = pom1;
for (int i = 0; i < k; i++)
{
double pom2 = lu.l[k, i];
lu.l[k, i] = lu.l[k0, i];
lu.l[k0, i] = pom2;
}
if (k != k0)
{
lu.determinantOfPi *= -1;
}
// Switch rows in U
for (int i = 0; i < ncols; i++)
{
double pom2 = lu.u[k, i];
lu.u[k, i] = lu.u[k0, i];
lu.u[k0, i] = pom2;
}
for (int i = k + 1; i < nrows; i++)
{
lu.l[i, k] = lu.u[i, k] / lu.u[k, k];
for (int j = k; j < ncols; j++)
{
lu.u[i, j] = lu.u[i, j] - lu.l[i, k] * lu.u[k, j];
}
}
}
return(lu);
}
