C# SparseMatrix.SetRow方法代码示例

        /// <summary>
        /// List indexing is 2000x faster than Matrix.Row() or enumeration.
        /// </summary>
        public static void SpeedOfGetRow()
        {
            SparseMatrix myMatrix = new SparseMatrix(1000, 1000);
            SparseVector myVector = SparseVector.OfVector(Vector.Build.Random(1000));
            myVector.CoerceZero(1.8);
            for (int i = 0; i < 1000; i++)
            {
                myMatrix.SetRow(i, myVector);
            }
            List<Vector<double>> myList = new List<Vector<double>>(myMatrix.EnumerateRows());

            Utils.StartTimer();
            for (int repeat = 0; repeat < 10; repeat++)
            {
                for (int i = 0; i < 1000; i++)
                {
                    double foo = myMatrix.Row(i)[0];
                }
            }
            Utils.StopTimer();

            Utils.StartTimer();
            for (int repeat = 0; repeat < 10; repeat++)
            {
                foreach(var row in myMatrix.EnumerateRowsIndexed())
                {
                    double foo = row.Item2[0];
                }
            }
            Utils.StopTimer();

            Utils.StartTimer();
            for (int repeat = 0; repeat < 10; repeat++)
            {
                for (int i = 0; i < 1000; i++)
                {
                    double foo = myList[i][0];
                }
            }
            Utils.StopTimer();
        }

        /// <summary>
        /// Creates a new  <see cref="SparseMatrix"/> and inserts the given row at the given index.
        /// </summary>
        /// <param name="rowIndex">The index of where to insert the row.</param>
        /// <param name="row">The row to insert.</param>
        /// <returns>A new  <see cref="SparseMatrix"/> with the inserted column.</returns>
        /// <exception cref="ArgumentNullException">If <paramref name="row"/> is <see langword="null" />. </exception>
        /// <exception cref="ArgumentOutOfRangeException">If <paramref name="rowIndex"/> is &lt; zero or &gt; the number of rows.</exception>
        /// <exception cref="ArgumentException">If the size of <paramref name="row"/> != the number of columns.</exception>
        public override Matrix<double> InsertRow(int rowIndex, Vector<double> row)
        {
            if (row == null)
            {
                throw new ArgumentNullException("row");
            }

            if (rowIndex < 0 || rowIndex > RowCount)
            {
                throw new ArgumentOutOfRangeException("rowIndex");
            }

            if (row.Count != ColumnCount)
            {
                throw new ArgumentException(Resources.ArgumentMatrixSameRowDimension, "row");
            }

            var result = new SparseMatrix(RowCount + 1, ColumnCount);

            for (var i = 0; i < rowIndex; i++)
            {
                result.At(i, i, At(i, i));
            }

            result.SetRow(rowIndex, row);

            for (var i = rowIndex + 1; i < result.RowCount; i++)
            {
                result.At(i, i - 1, At(i - 1, i - 1));
            }

            return result;
        }

        /// <summary>
        /// 2D nested list is 10x faster than SparseMatrix and List<SparseVector>
        /// and 100x faster than Dictionary. However, 2D nested list is only for dense case.
        /// Note that Nested Dictionary is faster than Tuple dictionary! 
        /// it is the second fastest only 4 times slower than  2D list.
        /// </summary>
        public static void SpeedOfAccessRandomElement()
        {
            SparseMatrix myMatrix = new SparseMatrix(1000, 1000);
            SparseVector myVector = SparseVector.OfVector(Vector.Build.Random(1000));
            myVector.CoerceZero(1.8);
            for (int i = 0; i < 1000; i++)
            {
                myMatrix.SetRow(i, myVector);
            }

            List<Vector<double>> myList = new List<Vector<double>>(myMatrix.EnumerateRows());
            List<List<double>> my2DList = new List<List<double>>();

            Dictionary<Tuple<int, int>, double> myDict = new Dictionary<Tuple<int, int>, double>();
            Dictionary<int, Dictionary<int, double>> myDict2 = 
                new Dictionary<int, Dictionary<int, double>>();
            for (int i = 0; i < 1000; i++)
            {
                myDict2[i] = new Dictionary<int, double>();
                for (int j = 0; j < 1000; j++)
                {
                    myDict[new Tuple<int, int>(i, j)] = i;
                    myDict2[i][j] = i;
                }
            }

            for (int i = 0; i < 1000; i++)
            {
                my2DList.Add(new List<double>());
                for (int j = 0; j < 1000; j++)
                {
                    my2DList[i].Add(i);
                }
            }

            Utils.StartTimer();
            for (int i = 0; i < 1000; i++)
            {
                for (int j = 0; j < 1000; j++)
                {
                    double foo = myDict[new Tuple<int, int>(i, j)];
                    myDict[new Tuple<int, int>(i, j)] = foo+1;
                }
            }
            Utils.StopTimer();

            Utils.StartTimer();
            for (int i = 0; i < 1000; i++)
            {
                for (int j = 0; j < 1000; j++)
                {
                    double foo = myDict2[i][j];
                    myDict2[i][j] = foo + 1;
                }
            }
            Utils.StopTimer();

            Utils.StartTimer();
            for (int i = 0; i < 1000; i++)
            {
                for (int j = 0; j < 1000; j++)
                {
                    double foo = myMatrix[i, j];
                    myMatrix[i, j] = foo + 1;
                }
            }
            Utils.StopTimer();

            Utils.StartTimer();
            for (int i = 0; i < 1000; i++)
            {
                for (int j = 0; j < 1000; j++)
                {
                    double foo = myList[i][j];
                    myList[i][j] = foo + 1;
                }
            }
            Utils.StopTimer();

            Utils.StartTimer();
            for (int i = 0; i < 1000; i++)
            {
                for (int j = 0; j < 1000; j++)
                {
                    double foo = my2DList[i][j];
                    my2DList[i][j] = foo + 1;
                }
            }
            Utils.StopTimer();

            Utils.Pause();
        }

        public void SeesCorrectSubmatrixWhenTrainingWith0_5Coverage()
        {
            var inputsize = 10;
            var size = (uint)inputsize / 2;
            var coverage = 0.5;
            var layer = new Spatial2DLayer(SpatialLayerType.Gaussian, size, size, coverage, true, 1000);

            var list = from i in Enumerable.Range(0, inputsize)
                       select (double)i;

            var matrix = new SparseMatrix(inputsize, inputsize);
            for (int i = 0; i < matrix.RowCount; ++i)
            {
                matrix.SetRow(i, list.ToArray());
            }

            // for each node in the 2D layer
            for (int nodeRow = 0; nodeRow < layer.Height; nodeRow++)
            {
                for (int nodeCol = 0; nodeCol < layer.Width; nodeCol++)
                {
                    // Act
                    var subMatrix = layer.GetSubMatrixForNodeAt(nodeRow, nodeCol, matrix);

                    // check if its 2D input is ok
                    var width = inputsize / size + coverage * (inputsize - inputsize / size);
                    var delta = (inputsize - width) / (size - 1);

                    for (int i = 0; i < (int)width; i++)
                    {
                        for (int j = 0; j < (int)width; j++)
                        {

                            Assert.AreEqual(nodeCol * delta + j, subMatrix[i, j]);
                        }
                    }
                }
            }
        }

        public void SeesCorrectSubmatrixWhenCloneTrainingWith0Coverage()
        {
            var inputsize = 10;
            var size = (uint)inputsize / 2;
            var coverage = 0.0;
            var layer = new Spatial2DLayer(SpatialLayerType.Gaussian, size, size, coverage, true, 1000);

            var list = from i in Enumerable.Range(0, inputsize)
                       select (double)i;

            var matrix = new SparseMatrix(inputsize, inputsize);
            for (int i = 0; i < matrix.RowCount; ++i)
            {
                matrix.SetRow(i, list.ToArray());
            }

            // Act
            var subMatrix = layer.GetSubMatrixForNodeAt(layer.ClonedNodeRow, layer.ClonedNodeCol, matrix);

            //
            var width = inputsize / size + coverage * (inputsize - inputsize / size);
            var delta = (inputsize - width) / (size - 1);

            var centerRow = layer.Height / 2;
            var centerCol = layer.Width / 2;

            for (int i = 0; i < (int)width; i++)
            {
                for (int j = 0; j < (int)width; j++)
                {
                    Assert.AreEqual(centerCol * delta + j, subMatrix[i, j]);
                }
            }
        }