Exemple #1
0
        private static T[,] CalcReturnPartition <T>(ref T[,] matrixA, ref T[,] matrixB, MatrixIndices indicesA,
                                                    MatrixIndices indicesB, Boolean isAdd)
        {
            if (indicesA.RowIndices.GetLength() != indicesB.RowIndices.GetLength() || indicesA.ColumnIndices.GetLength() != indicesB.ColumnIndices.GetLength())
            {
                throw new ArgumentException("Matches size between A, B are not match.");
            }

            Int32 rowLength = indicesA.RowIndices.GetLength(), columnLength = indicesA.ColumnIndices.GetLength();

            T[,] result = new T[rowLength, columnLength];

            for (var i = 0; i < rowLength; i++)
            {
                for (var j = 0; j < columnLength; j++)
                {
                    result[i, j] = isAdd
                            ? (dynamic)matrixA[indicesA.RowIndices.Lower + i, indicesA.ColumnIndices.Lower + j] +
                                   matrixB[indicesB.RowIndices.Lower + i, indicesB.ColumnIndices.Lower + j]
                            : (dynamic)matrixA[indicesA.RowIndices.Lower + i, indicesA.ColumnIndices.Lower + j] -
                                   matrixB[indicesB.RowIndices.Lower + i, indicesB.ColumnIndices.Lower + j];
                }
            }

            return(result);
        }
Exemple #2
0
        public static void Copy <T>(ref T[,] source, ref T[,] target, MatrixIndices indicesTarget)
        {
            Int32 rowLength = source.GetLength(0), columnLength = source.GetLength(1);

            for (var i = 0; i < rowLength; i++)
            {
                for (var j = 0; j < columnLength; j++)
                {
                    target[indicesTarget.RowIndices.Lower + i, indicesTarget.ColumnIndices.Lower + j] = source[i, j];
                }
            }
        }
        private T[,] RecursivelyCalculate(ref T[,] matrixA,
                                          ref T[,] matrixB,
                                          MatrixIndices indicesA,
                                          MatrixIndices indicesB)
        {
            var length = indicesA.RowIndices.GetLength();

            T[,] matrixC = new T[length, length];

            if (indicesA.HasOnlyOneElement() && indicesB.HasOnlyOneElement())
            {
                //C11 = A11 * B11
                matrixC[0, 0] = (dynamic)matrixA[indicesA.RowIndices.Lower, indicesA.ColumnIndices.Lower] *
                                matrixB[indicesB.RowIndices.Lower, indicesB.ColumnIndices.Lower];
            }
            else
            {
                Int32 middleRowIndexA =
                    (Int32)Math.Floor((indicesA.RowIndices.Lower + indicesA.RowIndices.Upper) / 2.0),
                      middleColumnIndexA =
                    (Int32)Math.Floor((indicesA.ColumnIndices.Lower + indicesA.ColumnIndices.Upper) / 2.0),
                      middleRowIndexB =
                    (Int32)Math.Floor((indicesB.RowIndices.Lower + indicesB.RowIndices.Upper) / 2.0),
                      middleColumnIndexB =
                    (Int32)Math.Floor((indicesB.ColumnIndices.Lower + indicesB.ColumnIndices.Upper) / 2.0),
                      middleIndexC = (Int32)Math.Floor((length - 1) / 2.0);

                #region Sub Matrix Bound Indices
                //A11 index bound
                var indicesA11 = new MatrixIndices(
                    new IndexBound(indicesA.RowIndices.Lower, middleRowIndexA),
                    new IndexBound(indicesA.ColumnIndices.Lower, middleColumnIndexA));
                //A12 index bound
                var indicesA12 = new MatrixIndices(
                    new IndexBound(indicesA.RowIndices.Lower, middleRowIndexA),
                    new IndexBound(middleColumnIndexA + 1, indicesA.ColumnIndices.Upper));
                //A21 index bound
                var indicesA21 = new MatrixIndices(
                    new IndexBound(middleRowIndexA + 1, indicesA.RowIndices.Upper),
                    new IndexBound(indicesA.ColumnIndices.Lower, middleColumnIndexA));
                //A22 index bound
                var indicesA22 = new MatrixIndices(
                    new IndexBound(middleRowIndexA + 1, indicesA.RowIndices.Upper),
                    new IndexBound(middleColumnIndexA + 1, indicesA.ColumnIndices.Upper));
                //B11 index bound
                var indicesB11 = new MatrixIndices(
                    new IndexBound(indicesB.RowIndices.Lower, middleRowIndexB),
                    new IndexBound(indicesB.ColumnIndices.Lower, middleColumnIndexB));
                //B12 index bound
                var indicesB12 = new MatrixIndices(
                    new IndexBound(indicesB.RowIndices.Lower, middleRowIndexB),
                    new IndexBound(middleColumnIndexB + 1, indicesB.ColumnIndices.Upper));
                //B21 index bound
                var indicesB21 = new MatrixIndices(
                    new IndexBound(middleRowIndexB + 1, indicesB.RowIndices.Upper),
                    new IndexBound(indicesB.ColumnIndices.Lower, middleColumnIndexB));
                //B22 index bound
                var indicesB22 = new MatrixIndices(
                    new IndexBound(middleRowIndexB + 1, indicesB.RowIndices.Upper),
                    new IndexBound(middleColumnIndexB + 1, indicesB.ColumnIndices.Upper));
                //C11 index bound
                var indicesC11 = new MatrixIndices(
                    new IndexBound(0, middleIndexC),
                    new IndexBound(0, middleIndexC));
                //C12 index bound
                var indicesC12 = new MatrixIndices(
                    new IndexBound(0, middleIndexC),
                    new IndexBound(middleIndexC + 1, length - 1));
                //C21 index bound
                var indicesC21 = new MatrixIndices(
                    new IndexBound(middleIndexC + 1, length - 1),
                    new IndexBound(0, middleIndexC));
                //C22 index bound
                var indicesC22 = new MatrixIndices(
                    new IndexBound(middleIndexC + 1, length - 1),
                    new IndexBound(middleIndexC + 1, length - 1));
                #endregion

                var matrixA11B11 = RecursivelyCalculate(ref matrixA, ref matrixB, indicesA11, indicesB11);
                var matrixA12B21 = RecursivelyCalculate(ref matrixA, ref matrixB, indicesA12, indicesB21);
                var matrixA11B12 = RecursivelyCalculate(ref matrixA, ref matrixB, indicesA11, indicesB12);
                var matrixA12B22 = RecursivelyCalculate(ref matrixA, ref matrixB, indicesA12, indicesB22);
                var matrixA21B11 = RecursivelyCalculate(ref matrixA, ref matrixB, indicesA21, indicesB11);
                var matrixA22B21 = RecursivelyCalculate(ref matrixA, ref matrixB, indicesA22, indicesB21);
                var matrixA21B12 = RecursivelyCalculate(ref matrixA, ref matrixB, indicesA21, indicesB12);
                var matrixA22B22 = RecursivelyCalculate(ref matrixA, ref matrixB, indicesA22, indicesB22);

                //C11 = A11*B11 + A12*B21
                MatrixUtil.Add(ref matrixA11B11, ref matrixA12B21, ref matrixC, indicesC11);
                //C12 = A11*B12 + A12*B22
                MatrixUtil.Add(ref matrixA11B12, ref matrixA12B22, ref matrixC, indicesC12);
                //C21 = A21*B11 + A22*B21
                MatrixUtil.Add(ref matrixA21B11, ref matrixA22B21, ref matrixC, indicesC21);
                //C22 = A21*B12 + A22*B22
                MatrixUtil.Add(ref matrixA21B12, ref matrixA22B22, ref matrixC, indicesC22);
            }

            return(matrixC);
        }
Exemple #4
0
        private T[,] RecursivelyCalculate(ref T[,] matrixA,
                                          ref T[,] matrixB,
                                          MatrixIndices indicesA,
                                          MatrixIndices indicesB)
        {
            var length = indicesA.RowIndices.GetLength();

            T[,] matrixC = new T[length, length];

            if (indicesA.HasOnlyOneElement() && indicesB.HasOnlyOneElement())
            {
                //C11 = A11 * B11
                matrixC[0, 0] = (dynamic)matrixA[indicesA.RowIndices.Lower, indicesA.ColumnIndices.Lower] *
                                matrixB[indicesB.RowIndices.Lower, indicesB.ColumnIndices.Lower];
            }
            else
            {
                Int32 middleRowIndexA =
                    (Int32)Math.Floor((indicesA.RowIndices.Lower + indicesA.RowIndices.Upper) / 2.0),
                      middleColumnIndexA =
                    (Int32)Math.Floor((indicesA.ColumnIndices.Lower + indicesA.ColumnIndices.Upper) / 2.0),
                      middleRowIndexB =
                    (Int32)Math.Floor((indicesB.RowIndices.Lower + indicesB.RowIndices.Upper) / 2.0),
                      middleColumnIndexB =
                    (Int32)Math.Floor((indicesB.ColumnIndices.Lower + indicesB.ColumnIndices.Upper) / 2.0),
                      middleIndexC = (Int32)Math.Floor((length - 1) / 2.0);

                #region Sub Matrix Bound Indices
                //A11 index bound
                var indicesA11 = new MatrixIndices(
                    new IndexBound(indicesA.RowIndices.Lower, middleRowIndexA),
                    new IndexBound(indicesA.ColumnIndices.Lower, middleColumnIndexA));
                //A12 index bound
                var indicesA12 = new MatrixIndices(
                    new IndexBound(indicesA.RowIndices.Lower, middleRowIndexA),
                    new IndexBound(middleColumnIndexA + 1, indicesA.ColumnIndices.Upper));
                //A21 index bound
                var indicesA21 = new MatrixIndices(
                    new IndexBound(middleRowIndexA + 1, indicesA.RowIndices.Upper),
                    new IndexBound(indicesA.ColumnIndices.Lower, middleColumnIndexA));
                //A22 index bound
                var indicesA22 = new MatrixIndices(
                    new IndexBound(middleRowIndexA + 1, indicesA.RowIndices.Upper),
                    new IndexBound(middleColumnIndexA + 1, indicesA.ColumnIndices.Upper));
                //B11 index bound
                var indicesB11 = new MatrixIndices(
                    new IndexBound(indicesB.RowIndices.Lower, middleRowIndexB),
                    new IndexBound(indicesB.ColumnIndices.Lower, middleColumnIndexB));
                //B12 index bound
                var indicesB12 = new MatrixIndices(
                    new IndexBound(indicesB.RowIndices.Lower, middleRowIndexB),
                    new IndexBound(middleColumnIndexB + 1, indicesB.ColumnIndices.Upper));
                //B21 index bound
                var indicesB21 = new MatrixIndices(
                    new IndexBound(middleRowIndexB + 1, indicesB.RowIndices.Upper),
                    new IndexBound(indicesB.ColumnIndices.Lower, middleColumnIndexB));
                //B22 index bound
                var indicesB22 = new MatrixIndices(
                    new IndexBound(middleRowIndexB + 1, indicesB.RowIndices.Upper),
                    new IndexBound(middleColumnIndexB + 1, indicesB.ColumnIndices.Upper));
                //C11 index bound
                var indicesC11 = new MatrixIndices(
                    new IndexBound(0, middleIndexC),
                    new IndexBound(0, middleIndexC));
                //C12 index bound
                var indicesC12 = new MatrixIndices(
                    new IndexBound(0, middleIndexC),
                    new IndexBound(middleIndexC + 1, length - 1));
                //C21 index bound
                var indicesC21 = new MatrixIndices(
                    new IndexBound(middleIndexC + 1, length - 1),
                    new IndexBound(0, middleIndexC));
                //C22 index bound
                var indicesC22 = new MatrixIndices(
                    new IndexBound(middleIndexC + 1, length - 1),
                    new IndexBound(middleIndexC + 1, length - 1));
                #endregion

                #region Create 10 Assistant Matrixes S1 - S10
                //S1 = B12 - B22
                var S1 = MatrixUtil.Substract(ref matrixB, ref matrixB, indicesB12, indicesB22);
                //S2 = A11 + A12
                var S2 = MatrixUtil.Add(ref matrixA, ref matrixA, indicesA11, indicesA12);
                //S3 = A21 + A22
                var S3 = MatrixUtil.Add(ref matrixA, ref matrixA, indicesA21, indicesA22);
                //S4 = B21 - B11
                var S4 = MatrixUtil.Substract(ref matrixB, ref matrixB, indicesB21, indicesB11);
                //S5 = A11 + A22
                var S5 = MatrixUtil.Add(ref matrixA, ref matrixA, indicesA11, indicesA22);
                //S6 = B11 + B22
                var S6 = MatrixUtil.Add(ref matrixB, ref matrixB, indicesB11, indicesB22);
                //S7 = A12 - A22
                var S7 = MatrixUtil.Substract(ref matrixA, ref matrixA, indicesA12, indicesA22);
                //S6 = B21 + B22
                var S8 = MatrixUtil.Add(ref matrixB, ref matrixB, indicesB21, indicesB22);
                //S9 = A11 - A21
                var S9 = MatrixUtil.Substract(ref matrixA, ref matrixA, indicesA11, indicesA21);
                //S10 = B11 + B12
                var S10 = MatrixUtil.Add(ref matrixB, ref matrixB, indicesB11, indicesB12);
                #endregion

                #region Create 7 Further Assistant Matrixes P1 - P7
                //P1 = A11 * S1 = A11 * B12 - A11 * B22
                var P1 = RecursivelyCalculate(ref matrixA, ref S1,
                                              indicesA11,
                                              new MatrixIndices(new IndexBound(0, S1.GetLength(0) - 1), new IndexBound(0, S1.GetLength(1) - 1)));
                //P2 = S2 * B22 = A11 * B22 + A12 * B22
                var P2 = RecursivelyCalculate(ref S2, ref matrixB,
                                              new MatrixIndices(new IndexBound(0, S2.GetLength(0) - 1), new IndexBound(0, S2.GetLength(1) - 1)),
                                              indicesB22);
                //P3 = S3 * B11 = A21 * B11 + A22 * B11
                var P3 = RecursivelyCalculate(ref S3, ref matrixB,
                                              new MatrixIndices(new IndexBound(0, S3.GetLength(0) - 1), new IndexBound(0, S3.GetLength(1) - 1)),
                                              indicesB11);
                //P4 = A22 * S4 = A22 * B21 - A22 * B11
                var P4 = RecursivelyCalculate(ref matrixA, ref S4,
                                              indicesA22,
                                              new MatrixIndices(new IndexBound(0, S4.GetLength(0) - 1), new IndexBound(0, S4.GetLength(1) - 1)));
                //P5 = S5 * S6 = A11 * B11 + A11 * B22 + A22 * B11 + A22 * B22
                var P5 = RecursivelyCalculate(ref S5, ref S6,
                                              new MatrixIndices(new IndexBound(0, S5.GetLength(0) - 1), new IndexBound(0, S5.GetLength(1) - 1)),
                                              new MatrixIndices(new IndexBound(0, S6.GetLength(0) - 1), new IndexBound(0, S6.GetLength(1) - 1)));
                //P6 = S7 * S8 = A12 * B21 + A12 * B22 - A22 * B21 - A22 * B22
                var P6 = RecursivelyCalculate(ref S7, ref S8,
                                              new MatrixIndices(new IndexBound(0, S7.GetLength(0) - 1), new IndexBound(0, S7.GetLength(1) - 1)),
                                              new MatrixIndices(new IndexBound(0, S8.GetLength(0) - 1), new IndexBound(0, S8.GetLength(1) - 1)));
                //P7 = S9 * S10 = A11 * B11 + A11 * B12 - A21 * B11 - A21 * B12
                var P7 = RecursivelyCalculate(ref S9, ref S10,
                                              new MatrixIndices(new IndexBound(0, S9.GetLength(0) - 1), new IndexBound(0, S9.GetLength(1) - 1)),
                                              new MatrixIndices(new IndexBound(0, S10.GetLength(0) - 1), new IndexBound(0, S10.GetLength(1) - 1)));
                #endregion

                #region Calculate the four subparts of matrix C

                /*
                 * C11 = P5 + P4 - P2 + P6
                 *
                 * As follows:
                 *   P5:   A11 * B11 + A11 * B22 + A22 * B11 + A22 * B22
                 * + P4:                         - A22 * B11             + A22 * B21
                 * - P2:             - A11 * B22                                     - A12 * B22
                 * + P6:                                     - A22 * B22 - A22 * B21 + A12 * B22 + A12 * B21
                 * ------------------------------------------------------------------------------------------
                 * =       A11 * B11                                                             + A12 * B21
                 */
                var tempresult = MatrixUtil.Add(ref P5, ref P4);
                tempresult = MatrixUtil.Substract(ref tempresult, ref P2);
                tempresult = MatrixUtil.Add(ref tempresult, ref P6);
                MatrixUtil.Copy(ref tempresult, ref matrixC, indicesC11);

                /*
                 * C12 = P1 + P2
                 *
                 * As follows:
                 *   P1:   A11 * B12 - A11 * B22
                 * + P2:             + A11 * B22 + A12 * B22
                 * ------------------------------------------------------------------------------------------
                 * =       A11 * B12             + A12 * B22
                 */
                tempresult = MatrixUtil.Add(ref P1, ref P2);
                MatrixUtil.Copy(ref tempresult, ref matrixC, indicesC12);

                /*
                 * C21 = P3 + P4
                 *
                 * As follows:
                 *   P3:   A21 * B11 - A22 * B11
                 * + P4:             + A22 * B11 + A22 * B21
                 * ------------------------------------------------------------------------------------------
                 * =       A21 * B11             + A22 * B21
                 */
                tempresult = MatrixUtil.Add(ref P3, ref P4);
                MatrixUtil.Copy(ref tempresult, ref matrixC, indicesC21);

                /*
                 * C22 = P5 + P1 - P3 - P7
                 *
                 * As follows:
                 *   P5:   A11 * B11 + A11 * B22 + A22 * B11 + A22 * B22
                 * + P1:             - A11 * B22                         + A11 * B12
                 * - P3:                         - A22 * B11                         - A21 * B11
                 * - P7: - A11 * B11                                     - A11 * B12 + A21 * B11 + A21 * B12
                 * ------------------------------------------------------------------------------------------
                 * =                                           A22 * B22                         + A21 * B12
                 */
                tempresult = MatrixUtil.Add(ref P5, ref P1);
                tempresult = MatrixUtil.Substract(ref tempresult, ref P3);
                tempresult = MatrixUtil.Substract(ref tempresult, ref P7);
                MatrixUtil.Copy(ref tempresult, ref matrixC, indicesC22);

                #endregion
            }
            return(matrixC);
        }
Exemple #5
0
 public static void Add <T>(ref T[,] matrixA, ref T[,] matrixB, ref T[,] result, MatrixIndices indicesResult)
 {
     Calc(ref matrixA, ref matrixB, ref result, indicesResult, true);
 }
Exemple #6
0
        private static void Calc <T>(ref T[,] matrixA, ref T[,] matrixB, ref T[,] result, MatrixIndices indicesResult, Boolean isAdd)
        {
            if (matrixA.GetLength(0) != matrixB.GetLength(0) || matrixA.GetLength(1) != matrixB.GetLength(1) ||
                matrixA.GetLength(0) != indicesResult.RowIndices.GetLength() || matrixA.GetLength(1) != indicesResult.ColumnIndices.GetLength())
            {
                throw new ArgumentException("Matches size between A, B and Result are not match.");
            }

            Int32 rowLength = matrixA.GetLength(0), columnLength = matrixA.GetLength(1);

            for (var i = 0; i < rowLength; i++)
            {
                for (var j = 0; j < columnLength; j++)
                {
                    result[indicesResult.RowIndices.Lower + i, indicesResult.ColumnIndices.Lower + j] =
                        isAdd ? (dynamic)matrixA[i, j] + matrixB[i, j] : (dynamic)matrixA[i, j] - matrixB[i, j];
                }
            }
        }
Exemple #7
0
 public static T[,] Substract <T>(ref T[,] matrixA, ref T[,] matrixB, MatrixIndices indicesA,
                                  MatrixIndices indicesB)
 {
     return(CalcReturnPartition(ref matrixA, ref matrixB, indicesA, indicesB, false));
 }
Exemple #8
0
 public static void Substract <T>(ref T[,] matrixA, ref T[,] matrixB, ref T[,] result, MatrixIndices indicesA,
                                  MatrixIndices indicesB, MatrixIndices indicesResult)
 {
     CalcPartion(ref matrixA, ref matrixB, ref result, indicesA, indicesB, indicesResult, false);
 }
Exemple #9
0
 public static T[,] Add <T>(ref T[,] matrixA, ref T[,] matrixB, MatrixIndices indicesA,
                            MatrixIndices indicesB)
 {
     return(CalcReturnPartition(ref matrixA, ref matrixB, indicesA, indicesB, true));
 }