public void PlusMultiply_GENDATA_Test1()
        {
            var tileSize = 50;
            var blockMatrix1 = MatrixHelpers.Tile(Matrix<double>.CreateNewRandomDoubleMatrix(200, 200), tileSize);
            var blockMatrix2 = MatrixHelpers.Tile(Matrix<double>.CreateNewRandomDoubleMatrix(200, 200), tileSize);
            var blockMatrix3 = MatrixHelpers.Tile(Matrix<double>.CreateNewRandomDoubleMatrix(200, 200), tileSize);
            var clonedBlockMatrix1 = blockMatrix1.Clone();
            var clonedBlockMatrix2 = blockMatrix2.Clone();
            var clonedBlockMatrix3 = blockMatrix3.Clone();

            var opData1 = new OperationResult<double>(blockMatrix1);
            var opData2 = new OperationResult<double>(blockMatrix2);
            var opData3 = new OperationResult<double>(blockMatrix3);

            Matrix<Matrix<double>> expected = clonedBlockMatrix1.PlusMultiply(clonedBlockMatrix2, clonedBlockMatrix3);
            OperationResult<double> actual;
            var plusMultProducer = new PlusMultiply<double>(opData1, opData2, opData3, out actual);
            var pm = new Manager(plusMultProducer);
            pm.Start();
            pm.Join();

            MatrixHelpers.IsDone(actual);
            MatrixHelpers.Diff(expected, actual.Data);
            MatrixHelpers.Compare(expected, actual.Data);
        }
        public void PlusMultiply1500x1500()
        {
            var tileSize = 40;

            // prepare data
            var data1 = MatrixHelpers.Tile(Matrix<double>.DeSerializeFromFile(@"C:\Users\eh\Documents\KU\Inversion-of-Block-Tridiagonal-Matrices\Dataset\m1500x1500-a.mat"), tileSize);
            var data2 = MatrixHelpers.Tile(Matrix<double>.DeSerializeFromFile(@"C:\Users\eh\Documents\KU\Inversion-of-Block-Tridiagonal-Matrices\Dataset\m1500x1500-b.mat"), tileSize);
            var data3 = MatrixHelpers.Tile(Matrix<double>.DeSerializeFromFile(@"C:\Users\eh\Documents\KU\Inversion-of-Block-Tridiagonal-Matrices\Dataset\m1500x1500-c.mat"), tileSize);
            Matrix<Matrix<double>> expected = MatrixHelpers.Tile(Matrix<double>.DeSerializeFromFile(@"C:\Users\eh\Documents\KU\Inversion-of-Block-Tridiagonal-Matrices\Dataset\m1500x1500-a_b_c-PlusMultiply-result.mat"), tileSize);

            var opData1 = new OperationResult<double>(data1);
            var opData2 = new OperationResult<double>(data2);
            var opData3 = new OperationResult<double>(data3);
            OperationResult<double> actual;
            var mProducer = new PlusMultiply<double>(opData1, opData2, opData3, out actual);
            var pm = new Manager(mProducer);
            pm.Start();
            pm.Join();

            MatrixHelpers.IsDone(actual);
            MatrixHelpers.Diff(expected, actual.Data);
            MatrixHelpers.Compare(expected, actual.Data);
        }
            public static IEnumerable<Measurement> PlusMultiply()
            {
                foreach (int threadCount in ThreadCountGenerator())
                    foreach (int tileSize in TileSizeGenerator)
                        yield return new ThreeBlockMatrixMeasurement
                        {
                            TileSize = tileSize,
                            ThreadCount = threadCount,
                            Execute = (a, b, c, tc) =>
                            {
                                var opRes1 = new OperationResult<double>(a);
                                var opRes2 = new OperationResult<double>(b);
                                var opRes3 = new OperationResult<double>(c);

                                OperationResult<double> actual;
                                var producer = new PlusMultiply<double>(opRes1, opRes2,
                                                                        opRes3,
                                                                        out actual);
                                Runner(producer, tc);
                            }
                        };
            }