public void TestEmptyAdd(int rows, int columns)
        {
            var A = new SymbolicColumnStorage(rows, columns, 0, true);
            var B = new SymbolicColumnStorage(rows, columns, 0, true);

            var C = A.Add(B);

            Assert.IsNotNull(C);
        }
Exemple #2
0
        // Construct matrix C
        private static SymbolicColumnStorage ConstructMatrix(SymbolicColumnStorage A, ColumnOrdering order)
        {
            SymbolicColumnStorage result = null;

            // Compute A'
            var AT = A.Transpose();

            int m = A.RowCount;
            int n = A.ColumnCount;

            if (order == ColumnOrdering.MinimumDegreeAtPlusA)
            {
                if (n != m)
                {
                    throw new ArgumentException(Resources.MatrixSquare, "A");
                }

                // Return A+A'
                result = A.Add(AT);
            }
            else if (order == ColumnOrdering.MinimumDegreeStS)
            {
                // Drop dense columns from AT
                int dense, p, p2 = 0;

                // Find dense threshold
                dense = Math.Max(16, 10 * (int)Math.Sqrt(n));
                dense = Math.Min(n - 2, dense);

                var colptr = AT.ColumnPointers;
                var rowind = AT.RowIndices;

                for (int j = 0; j < m; j++)
                {
                    // Column j of AT starts here.
                    p = colptr[j];

                    // New column j starts here.
                    colptr[j] = p2;

                    if (colptr[j + 1] - p > dense)
                    {
                        // Skip dense column j
                        continue;
                    }

                    for (; p < colptr[j + 1]; p++)
                    {
                        rowind[p2++] = rowind[p];
                    }
                }
                colptr[m] = p2;

                // Return A'*A with no dense rows
                result = AT.Multiply(AT.Transpose());
            }
            else
            {
                // Return A'*A
                result = AT.Multiply(A);
            }

            // Drop diagonal entries.
            result.Keep(KeepOffDiag);

            return(result);
        }