public IActionResult Index(int n = 2)
{
Matrix matrix = new Matrix(n, n);
MatrixWrapper matrixWrapper = new MatrixWrapper(matrix, new double[n], new double[n]);
return(View(matrixWrapper));
}
public override int[,] Multiply(MatrixWrapper matrixA, MatrixWrapper matrixB)
{
if (matrixA == null || matrixB == null)
{
return(null);
}
if (matrixA.ColCount != matrixB.RowCount)
{
throw new Exception("matrix cannot multiply");
}
int row = matrixA.RowCount;
int column = matrixB.ColCount;
int kLength = matrixA.ColCount;
int[,] resultMatrix = new int[row, column];
for (int i = 0; i < row; i++)
{
for (int j = 0; j < column; j++)
{
resultMatrix[i, j] = 0;
for (int k = 0; k < kLength; k++)
{
resultMatrix[i, j] += matrixA[i, k] * matrixB[k, j];
}
}
}
return(resultMatrix);
}
private int[,] MatrixMultipleByRecursive(MatrixWrapper matrixA, MatrixWrapper matrixB)
{
if (matrixA.ColCount != matrixB.RowCount)
{
throw new Exception($"cannot multiply two matrix. MatrixA column:{matrixA.ColCount} MatrixB Row: {matrixB.RowCount}");
}
// if any of matrix cannot be divided any more. Just use normal Algorithem to do the calculation.
if (matrixA.RowCount == 1 || matrixA.ColCount == 1 ||
matrixB.RowCount == 1 || matrixB.ColCount == 1)
{
MatrixMultiplyNormal normalAlgorithem = new MatrixMultiplyNormal();
return(normalAlgorithem.Multiply(matrixA, matrixB));
}
int[,] resultRawMatrix = new int[matrixA.RowCount, matrixB.ColCount];
MatrixDivideResult dividedMatrixA = new MatrixDivideResult(matrixA);
MatrixDivideResult dividedMatrixB = new MatrixDivideResult(matrixB);
// 11
this.CopyTo(MatrixAdd(MatrixMultipleByRecursive(dividedMatrixA.A11, dividedMatrixB.A11), MatrixMultipleByRecursive(dividedMatrixA.A12, dividedMatrixB.A21))
, new MatrixWrapper(resultRawMatrix, 0, dividedMatrixA.A11.RowCount - 1, 0, dividedMatrixA.A11.ColCount - 1));
// 12
this.CopyTo(MatrixAdd(MatrixMultipleByRecursive(dividedMatrixA.A11, dividedMatrixB.A12), MatrixMultipleByRecursive(dividedMatrixA.A12, dividedMatrixB.A22))
, new MatrixWrapper(resultRawMatrix, 0, dividedMatrixA.A11.RowCount - 1, dividedMatrixA.A11.ColCount, dividedMatrixA.A11.ColCount + dividedMatrixA.A12.ColCount - 1));
// 21
this.CopyTo(MatrixAdd(MatrixMultipleByRecursive(dividedMatrixA.A21, dividedMatrixB.A11), MatrixMultipleByRecursive(dividedMatrixA.A22, dividedMatrixB.A21))
, new MatrixWrapper(resultRawMatrix, dividedMatrixA.A11.RowCount, dividedMatrixA.A11.RowCount + dividedMatrixA.A21.RowCount - 1, 0, dividedMatrixA.A11.ColCount - 1));
// 22
this.CopyTo(MatrixAdd(MatrixMultipleByRecursive(dividedMatrixA.A21, dividedMatrixB.A12), MatrixMultipleByRecursive(dividedMatrixA.A22, dividedMatrixB.A22))
, new MatrixWrapper(resultRawMatrix, dividedMatrixA.A11.RowCount, dividedMatrixA.A11.RowCount + dividedMatrixA.A21.RowCount - 1, dividedMatrixA.A11.ColCount, dividedMatrixA.A11.ColCount + dividedMatrixA.A12.ColCount - 1));
return(resultRawMatrix);
}
/// <summary>
/// copy a raw sourceMatrix to the specified part of Matrix.
/// </summary>
/// <param name="sourceMatrix"></param>
/// <param name="toMatrix"></param>
public void CopyTo(int[, ] sourceMatrix, MatrixWrapper toMatrix)
{
for (int i = 0; i < sourceMatrix.GetLength(0); i++)
{
for (int j = 0; j < sourceMatrix.GetLength(1); j++)
{
toMatrix[i, j] = sourceMatrix[i, j];
}
}
}
public IActionResult Index(double[] numbers, double[] b, int n)
{
Matrix m = new Matrix(n, n, numbers);
ConjugateGradientMatrixSolver solver = new ConjugateGradientMatrixSolver();
Vector v = solver.Solve(m, new Vector(b), new Vector(new double[n]));
MatrixWrapper matrixWrapper = new MatrixWrapper(m, new double[n], new double[n]);
matrixWrapper.have_result = true;
matrixWrapper.result = v.GetCloneOfData();
matrixWrapper.b = b;
return(View(matrixWrapper));
}
public IActionResult Example1()
{
int n = 2;
Matrix matrix = new Matrix(n, n, new double[] {
2, -1,
-1, 2
});
double[] b = new double[] { 1, 0 };
double[] x0 = new double[n];
MatrixWrapper mw = new MatrixWrapper(matrix, b, x0);
return(View("Index", mw));
}
public IActionResult Example2()
{
int n = 3;
Matrix matrix = new Matrix(n, n, new double[] {
4, -1, 1,
-1, 4, -2,
1, -2, 4,
});
double[] b = new double[] { 12, -1, 5 };
double[] x0 = new double[n];
MatrixWrapper mw = new MatrixWrapper(matrix, b, x0);
return(View("Index", mw));
}
public static void Main(string[] args)
{
int[,] matrixA = { { 1, 2, 3, 4 }, { 3, 4, 5, 6 }, { 6, 7, 8, 9 }, { 6, 1, 8, 4 } };
int[,] matrixB = { { 4, 5, 6, 7 }, { 6, 7, 8, 9 }, { 3, 4, 5, 6 }, { 1, 2, 3, 4 } };
MatrixWrapper mA = new MatrixWrapper(matrixA, 0, matrixA.GetLength(0) - 1, 0, matrixA.GetLength(1) - 1);
MatrixWrapper mB = new MatrixWrapper(matrixB, 0, matrixB.GetLength(0) - 1, 0, matrixB.GetLength(1) - 1);
int[,] result = new MatrixMultiplyNormal().Multiply(mA, mB);
MatrixMultplyBase.PrintMatrix(result);
int[,] result2 = new MatrixMultiplyRecursive().Multiply(mA, mB);
MatrixMultplyBase.PrintMatrix(result2);
int[,] result3 = new MatrixMultiplyStrassen().Multiply(mA, mB);
MatrixMultplyBase.PrintMatrix(result3);
}
public void Init()
{
// clear
Clear();
// allocate
Grid = new MatrixWrapper <ANode>();
Grid.Allocate(GridSize.x, GridSize.y, (x, y) =>
{
var go = new GameObject($"Node: {x} {y}", typeof(ANode));
var node = go.GetComponent <ANode>();
// set position
go.transform.SetParent(transform);
go.transform.localPosition = new Vector3(x, y, 0);
return(node);
});
// make connection
foreach (var valuePair in Grid)
{
if (Grid.TryGetValue(valuePair.Key.x - 1, valuePair.Key.y, out var left))
{
valuePair.Value.Left = left;
}
if (Grid.TryGetValue(valuePair.Key.x + 1, valuePair.Key.y, out var right))
{
valuePair.Value.Right = right;
}
if (Grid.TryGetValue(valuePair.Key.x, valuePair.Key.y + 1, out var top))
{
valuePair.Value.Top = top;
}
if (Grid.TryGetValue(valuePair.Key.x, valuePair.Key.y - 1, out var bottom))
{
valuePair.Value.Bottom = bottom;
}
}
}
public abstract int[,] Multiply(MatrixWrapper matrixA, MatrixWrapper matrixB);
public static bool IsHomoMatrix(MatrixWrapper matrixA, MatrixWrapper matrixB)
{
return(matrixA.RowCount == matrixB.RowCount && matrixB.ColCount == matrixB.ColCount);
}
public void Clear()
{
gameObject.DestroyChildren();
FindPathProcess = null;
Grid = null;
}
private void OnValidate()
{
// format search coords
if (From.x < 0)
{
From.x = 0;
}
if (From.x >= GridSize.x)
{
From.x = GridSize.x - 1;
}
if (From.y < 0)
{
From.y = 0;
}
if (From.y >= GridSize.x)
{
From.y = GridSize.y - 1;
}
if (To.x < 0)
{
To.x = 0;
}
if (To.x >= GridSize.x)
{
To.x = GridSize.x - 1;
}
if (To.y < 0)
{
To.y = 0;
}
if (To.y >= GridSize.x)
{
To.y = GridSize.y - 1;
}
// reconnect nodes
if ((Grid?.Count ?? 0) == 0)
{
// organize node list
var nodeList = new List <Tuple <Vector2Int, ANode> >();
foreach (var child in gameObject.GetChildren())
{
var node = child.GetComponent <ANode>();
var coords = Regex.Matches(child.name, @" \d+").OfType <Match>().Select(n => int.Parse(n.Value))
.ToList();
nodeList.Add(new Tuple <Vector2Int, ANode>(new Vector2Int(coords[0], coords[1]), node));
}
// initialize grid
var w = nodeList.Max(n => n.Item1.x) + 1;
var h = nodeList.Max(n => n.Item1.y) + 1;
Grid = new MatrixWrapper <ANode>();
Grid.Allocate(w, h);
// fill grid
foreach (var(pos, node) in nodeList)
{
Grid[pos] = node;
}
}
}
private int[,] MultiplyByStrassen(MatrixWrapper matrixA, MatrixWrapper matrixB)
{
// if any of matrix cannot be divided any more. Just use normal Algorithem to do the calculation.
if (matrixA.RowCount == 1 || matrixA.ColCount == 1 ||
matrixB.RowCount == 1 || matrixB.ColCount == 1)
{
MatrixMultiplyNormal normalAlgorithem = new MatrixMultiplyNormal();
return(normalAlgorithem.Multiply(matrixA, matrixB));
}
// Step 1 Divide matrix.
MatrixDivideResult matrixDividedA = new MatrixDivideResult(matrixA);
MatrixDivideResult matrixDividedB = new MatrixDivideResult(matrixB);
// step 2 create the 10 S matrixs.
int[,] S1 = new int[matrixDividedA.A11.RowCount, matrixDividedA.A11.ColCount];
int[,] S2 = new int[matrixDividedA.A11.RowCount, matrixDividedA.A11.ColCount];
int[,] S3 = new int[matrixDividedA.A11.RowCount, matrixDividedA.A11.ColCount];
int[,] S4 = new int[matrixDividedA.A11.RowCount, matrixDividedA.A11.ColCount];
int[,] S5 = new int[matrixDividedA.A11.RowCount, matrixDividedA.A11.ColCount];
int[,] S6 = new int[matrixDividedA.A11.RowCount, matrixDividedA.A11.ColCount];
int[,] S7 = new int[matrixDividedA.A11.RowCount, matrixDividedA.A11.ColCount];
int[,] S8 = new int[matrixDividedA.A11.RowCount, matrixDividedA.A11.ColCount];
int[,] S9 = new int[matrixDividedA.A11.RowCount, matrixDividedA.A11.ColCount];
int[,] S10 = new int[matrixDividedA.A11.RowCount, matrixDividedA.A11.ColCount];
S1 = MatrixSubtract(matrixDividedB.A12.ToRawMatrix(), matrixDividedB.A22.ToRawMatrix());
S2 = MatrixAdd(matrixDividedA.A11.ToRawMatrix(), matrixDividedA.A12.ToRawMatrix());
S3 = MatrixAdd(matrixDividedA.A21.ToRawMatrix(), matrixDividedA.A22.ToRawMatrix());
S4 = MatrixSubtract(matrixDividedB.A21.ToRawMatrix(), matrixDividedB.A11.ToRawMatrix());
S5 = MatrixAdd(matrixDividedA.A11.ToRawMatrix(), matrixDividedA.A22.ToRawMatrix());
S6 = MatrixAdd(matrixDividedB.A11.ToRawMatrix(), matrixDividedB.A22.ToRawMatrix());
S7 = MatrixSubtract(matrixDividedA.A12.ToRawMatrix(), matrixDividedA.A22.ToRawMatrix());
S8 = MatrixAdd(matrixDividedB.A21.ToRawMatrix(), matrixDividedB.A22.ToRawMatrix());
S9 = MatrixSubtract(matrixDividedA.A11.ToRawMatrix(), matrixDividedA.A21.ToRawMatrix());
S10 = MatrixAdd(matrixDividedB.A11.ToRawMatrix(), matrixDividedB.A12.ToRawMatrix());
// step3 call multiply Recursive.
int[,] P1 = MultiplyByStrassen(matrixDividedA.A11, new MatrixWrapper(S1));
int[,] P2 = MultiplyByStrassen(new MatrixWrapper(S2), matrixDividedB.A22);
int[,] P3 = MultiplyByStrassen(new MatrixWrapper(S3), matrixDividedB.A11);
int[,] P4 = MultiplyByStrassen(matrixDividedA.A22, new MatrixWrapper(S4));
int[,] P5 = MultiplyByStrassen(new MatrixWrapper(S5), new MatrixWrapper(S6));
int[,] P6 = MultiplyByStrassen(new MatrixWrapper(S7), new MatrixWrapper(S8));
int[,] P7 = MultiplyByStrassen(new MatrixWrapper(S9), new MatrixWrapper(S10));
// step4 matrix add
int[,] C11 = MatrixListAdd(new List <int[, ]>()
{
P5, P4, MatrixMultiplyConst(P2, -1), P6
});
int[,] C12 = MatrixAdd(P1, P2);
int[,] C21 = MatrixAdd(P3, P4);
int[,] C22 = MatrixListAdd(new List <int[, ]>()
{
P5, P1, MatrixMultiplyConst(P3, -1), MatrixMultiplyConst(P7, -1)
});
int[,] resultRawMatrix = new int[matrixA.RowCount, matrixB.ColCount];
// step5 merge all the partial matrix to a whole
// 11
this.CopyTo(C11, new MatrixWrapper(resultRawMatrix, 0, matrixDividedA.A11.RowCount - 1, 0, matrixDividedA.A11.ColCount - 1));
// 12
this.CopyTo(C12, new MatrixWrapper(resultRawMatrix, 0, matrixDividedA.A11.RowCount - 1, matrixDividedA.A11.ColCount, matrixDividedA.A11.ColCount + matrixDividedA.A12.ColCount - 1));
// 21
this.CopyTo(C21, new MatrixWrapper(resultRawMatrix, matrixDividedA.A11.RowCount, matrixDividedA.A11.RowCount + matrixDividedA.A21.RowCount - 1, 0, matrixDividedA.A11.ColCount - 1));
// 22
this.CopyTo(C22, new MatrixWrapper(resultRawMatrix, matrixDividedA.A11.RowCount, matrixDividedA.A11.RowCount + matrixDividedA.A21.RowCount - 1, matrixDividedA.A11.ColCount, matrixDividedA.A11.ColCount + matrixDividedA.A12.ColCount - 1));
return(resultRawMatrix);
}
public override int[,] Multiply(MatrixWrapper matrixA, MatrixWrapper matrixB)
{
return(MultiplyByStrassen(matrixA, matrixB));
}
public override int[,] Multiply(MatrixWrapper matrixA, MatrixWrapper matrixB)
{
return(MatrixMultipleByRecursive(matrixA, matrixB));
}
