private static void TestIndexer()
{
Matrix dense = Matrix.CreateFromArray(SparseRectangular10by5.Matrix);
DokColMajor dok = CreateDok(SparseRectangular10by5.Matrix);
comparer.AssertEqual(dense, dok);
}
/// <summary>
/// Reads a general sparse matrix from the file specified by <paramref name="path"/>. Even if the matrix is symmetric,
/// the file must contain both the upper and lower triangle.
/// </summary>
/// <param name="path">The absolute path of the array.</param>
/// <exception cref="IOException">Thrown if there is no such file or if the dimensions of the matrix specified in the
/// first line are invalid.</exception>
public DokColMajor ReadFileAsDokColMajor(string path)
{
using (var reader = new StreamReader(path))
{
(int numRows, int numCols, int nnz) = ReadMatrixDimensions(reader);
var builder = DokColMajor.CreateEmpty(numRows, numCols);
ReadMatrixEntries(reader, nnz, builder);
return(builder);
}
}
internal static CscMatrix GetSubmatrixCsc(double[] skyValues, int[] skyDiagOffsets, int[] rowsToKeep, int[] colsToKeep)
{
if ((rowsToKeep.Length == 0) || (colsToKeep.Length == 0))
{
return(CscMatrix.CreateFromArrays(rowsToKeep.Length, colsToKeep.Length, new double[0], new int[0],
new int[1] {
0
}, false));
}
var submatrix = DokColMajor.CreateEmpty(rowsToKeep.Length, colsToKeep.Length);
for (int subCol = 0; subCol < colsToKeep.Length; ++subCol)
{
int col = colsToKeep[subCol];
int diagOffset = skyDiagOffsets[col];
int colHeight = skyDiagOffsets[col + 1] - diagOffset - 1; // excluding diagonal
for (int subRow = 0; subRow < rowsToKeep.Length; ++subRow)
{
int row = rowsToKeep[subRow];
if (row <= col)
{
int entryHeight = col - row; // excluding diagonal
if (entryHeight <= colHeight) // inside stored non zero pattern
{
double val = skyValues[diagOffset + entryHeight];
if (val != 0.0)
{
submatrix[subRow, subCol] = val; // Skyline format stores many unnecessary zeros.
}
}
}
else // Transpose row <-> col. The cached column height and offset must be recalculated.
{
int transposedDiagOffset = skyDiagOffsets[row];
int transposedColHeight = skyDiagOffsets[row + 1] - transposedDiagOffset - 1; // excluding diagonal
int entryHeight = row - col; // excluding diagonal
if (entryHeight <= transposedColHeight) // inside stored non zero pattern
{
double val = skyValues[transposedDiagOffset + entryHeight];
if (val != 0.0)
{
submatrix[subRow, subCol] = val; // Skyline format stores many unnecessary zeros.
}
}
}
}
}
return(submatrix.BuildCscMatrix(true));
}
private static void TestBuildCSR()
{
var dense = Matrix.CreateFromArray(SparseRectangular10by5.Matrix);
DokColMajor dok = CreateDok(SparseRectangular10by5.Matrix);
// CSR with sorted col indices of each row
CscMatrix cscSorted = dok.BuildCscMatrix(true);
comparer.AssertEqual(dense, cscSorted);
// CSR without sorting
CscMatrix cscUnsorted = dok.BuildCscMatrix(false);
comparer.AssertEqual(dense, cscUnsorted);
}
private static void TestPosDefSystemSolution()
{
double pivotTolerance = 0.5;
int order = SparsePosDef10by10.Order;
var skyline = SkylineMatrix.CreateFromArrays(order, SparsePosDef10by10.SkylineValues,
SparsePosDef10by10.SkylineDiagOffsets, true, true);
var dok = DokColMajor.CreateFromSparseMatrix(skyline);
var b = Vector.CreateFromArray(SparsePosDef10by10.Rhs);
var xExpected = Vector.CreateFromArray(SparsePosDef10by10.Lhs);
(double[] cscValues, int[] cscRowIndices, int[] cscColOffsets) = dok.BuildCscArrays(true);
var factor = LUCSparseNet.Factorize(order, cscValues.Length, cscValues, cscRowIndices, cscColOffsets, pivotTolerance);
Vector xComputed = factor.SolveLinearSystem(b);
comparer.AssertEqual(xExpected, xComputed);
}
private static DokColMajor CreateDok(double[,] matrix)
{
int m = matrix.GetLength(0);
int n = matrix.GetLength(1);
var dok = DokColMajor.CreateEmpty(m, n);
for (int i = 0; i < m; ++i)
{
for (int j = 0; j < n; ++j)
{
if (matrix[i, j] != 0.0)
{
dok[i, j] = matrix[i, j];
}
}
}
return(dok);
}
private static void TestNonsymmSystemSolution()
{
double pivotTolerance = 0.5;
int order = SquareInvertible10by10.Order;
var b = Vector.CreateFromArray(SquareInvertible10by10.Rhs);
var xExpected = Vector.CreateFromArray(SquareInvertible10by10.Lhs);
var dok = DokColMajor.CreateEmpty(order, order);
for (int j = 0; j < order; ++j)
{
for (int i = 0; i < order; ++i)
{
dok[i, j] = SquareInvertible10by10.Matrix[i, j];
}
}
(double[] cscValues, int[] cscRowIndices, int[] cscColOffsets) = dok.BuildCscArrays(true);
var factor = LUCSparseNet.Factorize(order, cscValues.Length, cscValues, cscRowIndices, cscColOffsets,
pivotTolerance);
Vector xComputed = factor.SolveLinearSystem(b);
comparer.AssertEqual(xExpected, xComputed);
}
private void CalculateTransformationMatrix()
{
var e = (IEmbeddedElement)(embeddedElement.ElementType);
int row = 0;
int col = 0;
int totalRows = embeddedElement.ElementType.DofEnumerator.GetDofTypesForMatrixAssembly(embeddedElement).SelectMany(x => x).Count();
//var matrix = new double[totalRows, superElementMap.Count];
var transformationMatrixOriginal = DokColMajor.CreateEmpty(totalRows, superElementMap.Count);
foreach (var embeddedNode in e.EmbeddedNodes)
{
var localTransformationMatrix = transformation.GetTransformationVector(embeddedNode);
var localHostDOFs = transformation.GetDOFTypesOfHost(embeddedNode);
int nodeOrderInEmbeddedElement = embeddedElement.Nodes.FindFirstIndex(embeddedNode.Node);
var embeddedNodeDOFQuantity = embeddedElement.ElementType.DofEnumerator.GetDofTypesForMatrixAssembly(embeddedElement)[nodeOrderInEmbeddedElement].Count;
int dependentDOFs = transformation.GetDependentDOFTypes.Count;
for (int i = 0; i < dependentDOFs; i++)
{
col = 0;
for (int j = 0; j < localHostDOFs.Count; j++)
{
for (int k = 0; k < localHostDOFs[j].Count; k++)
{
var superelement = new SuperElementDof()
{
DOF = localHostDOFs[j][k], Element = embeddedNode.EmbeddedInElement, EmbeddedNode = embeddedNode.Node, HostNode = embeddedNode.EmbeddedInElement.Nodes[j]
};
transformationMatrixOriginal[40 + row + i, superElementMap[superelement]] = localTransformationMatrix[i][col];
col++;
}
}
}
row += dependentDOFs;
var independentEmbeddedDOFs = embeddedElement.ElementType.DofEnumerator.GetDofTypesForMatrixAssembly(embeddedElement)[nodeOrderInEmbeddedElement].Except(embeddedNode.DependentDOFs).ToArray();
for (int j = 0; j < independentEmbeddedDOFs.Length; j++)
{
var superelement = new SuperElementDof()
{
DOF = independentEmbeddedDOFs[j], Element = null, HostNode = null, EmbeddedNode = embeddedNode.Node
};
transformationMatrixOriginal[40 + row, superElementMap[superelement]] = 1;
row++;
}
}
foreach (var node in embeddedElement.Nodes.Except(e.EmbeddedNodes.Select(x => x.Node)))
{
int nodeOrderInEmbeddedElement = embeddedElement.Nodes.FindFirstIndex(node);
var currentNodeDOFs = embeddedElement.ElementType.DofEnumerator.GetDofTypesForMatrixAssembly(embeddedElement)[nodeOrderInEmbeddedElement];
for (int j = 0; j < currentNodeDOFs.Count; j++)
{
var superelement = new SuperElementDof()
{
DOF = currentNodeDOFs[j], Element = null, HostNode = null, EmbeddedNode = node
};
transformationMatrixOriginal[row - 24, superElementMap[superelement]] = 1;
row++;
}
}
//StreamWriter sw = File.CreateText(String.Format("TransformationMatrix{0}.txt", embeddedElement.ID));
//for (int i = 0; i < totalRows; i++)
//{
// var line = String.Empty;
// for (int j = 0; j < superElementMap.Count; j++)
// line += matrix[i,j].ToString() + ";";
// sw.WriteLine(line);
//}
//sw.Close();
//transformationMatrixOriginal = new Matrix2D(matrix);
transformationMatrix = transformationMatrixOriginal.BuildCscMatrix(true);;
}
