News for R Package Matrix

Changes in version 1.7-4 (2025-08-27, svn r5172)

Installation

• Warnings surfaced by -Wtautological-overlap-compare are squashed. These revealed two typos in ‘src/matmult.c’ causing optimizations for crossprod(.sRMatrix, y) and tcrossprod(x, .sRMatrix) to be skipped. Thanks to Brian Ripley and Michael Chirico for the reports.

Bug Fixes

• Methods for band, triu, and tril with signature x="matrix" returned a formally invalid .geMatrix (with x slot of class "matrix") in some no-op cases, where no bands are set to zero.

Changes in version 1.7-3 (2025-03-05, svn r5126)

Bug Fixes

• <matrix> o <sparseVector> binary "Ops" work again, returning a matrix (of "Matrix").

• - new("lgeMatrix") and more - <Matrix> now work.

• Use int instead of Rboolean in 2x2 cases in ‘utils-R.c’.

Changes in version 1.7-2 (2025-01-20, svn r5115)

Installation

• Matrix can be installed with parallel bmake. Thanks to Sebastian Meyer for the report and patch in Matrix PR#6861.

Misc

• Test in ‘tests/matprod.R’ comparing t(x) %*% x and crossprod(x) is amended to tolerate small numerical differences seen under ‘⁠aarch64⁠’ Linux.

Changes in version 1.7-1 (2024-10-17, svn r4948)

Installation

• Installation under architecture-specific builds of R works again. It was broken in Matrix version 1.7-0, where changes to ‘src/Makevars’ resulted in CPPFLAGS not including -I"${R_INCLUDE_DIR}${R_ARCH}".

SuiteSparse

• Internal SuiteSparse and METIS library sources are patched to avoid possible use of illegal entry points.

C-Level API

• Registered routine sexp_as_cholmod_factor no longer calls cholmod_check_factor before returning, leaving the decision to check to the caller. Accordingly, most cholmod_check_* are registered; packages wanting to use them need LinkingTo: Matrix (>= 1.7-1).

Misc

• Non-API entry points OBJECT, IS_S4_OBJECT, SET_OBJECT, ATTRIB, and SET_ATTRIB are no longer used.

Changes in version 1.7-0 (2024-03-16, svn r4662)

Installation

• Matrix \ge 1.7-0 depends on R \ge 4.4.

Linking

• The Matrix ABI version is incremented from 1 to 2.

• Reverse LinkingTo built under earlier versions of Matrix should be rebuilt from sources by users and maintainers of binary repositories.

SuiteSparse

• The internal SuiteSparse library sources are updated from version 5.10.1 to version 7.6.0. We have so far identified one backwards incompatible change: since SuiteSparse version 7.3.0, cholmod_sort(A) sorts but does not pack the matrix A. It seems that now cholmod_sort and cholmod_copy must be used in conjuction if a sorted and packed result is desired. This change affects only reverse LinkingTo relying on the old behaviour. It seems that currently there are no such packages on CRAN or Bioconductor.

• CHOLMOD component Partition is compiled along with its dependencies (METIS, CAMD, CCOLAMD).

• CXSparse is compiled instead of CSparse, which did not support complex matrices.

• The internal SuiteSparse and METIS library sources are patched to squash a significant number of warnings surfaced by -Wall.

Significant User-Visible Changes

• The diagonal elements of the R factor computed by qr(<sparseMatrix>) are no longer constrained to be non-negative, due to differences in the implementation of function cs_house between SuiteSparse libraries CSparse and CXSparse.

Classes

• indMatrix no longer extends virtual class compMatrix and so no longer inherits a (never used) factors slot. Objects serialized under Matrix < 1.7-0 and unserialized under Matrix \ge 1.7-0 remain valid, retaining a harmless factors attribute.

• Unexported class union replValueSp is effectively removed, now having zero members. Actual removal is delayed until package binaries caching the old definition are rebuilt under Matrix version 1.7-0.

• The validity method for class sparseQR no longer requires non-negative diag(R).

Bug Fixes

• The unary subscript x[i] is correct again for x of class .s[CT]Matrix and logical i indexing entries outside of the stored triangle.

Changes in version 1.6-5 (2024-01-06, svn r4560)

C-Level API

• Registered routine cholmod_triplet_as_sexp transposes entries “opposite” the stype when that is nonzero, following CHOLMOD.

• cholmod_defaults is registered so that calls to API function M_cholmod_defaults actually work.

Bug Fixes

• x[] works for x inheriting from virtual class sparseVector.

• length(x) is always an integer for x inheriting from virtual class sparseVector. Truncation did not occur for x@length of type "double" equal to or greater than .Machine[["integer.max"]] + 1.

• tril(<n-by-n>, -n) now works again.

• tri[ul](<indMatrix>, k) now works correctly for k != 0.

Misc

• %||% is defined in the Matrix namespace only for R < 4.4.0.

Changes in version 1.6-4 (2023-11-29, svn r4523)

Installation

• Warnings surfaced by -Wformat are squashed.

C-Level API

• API function M_chm_triplet_to_SEXP, removed in Matrix version 1.6-2, is restored (as a macro). It was “covertly” used by package Rmosek.

Bug Fixes

• better deprecation message for ..2dge().

Changes in version 1.6-3 (2023-11-13, svn r4513)

Misc

• With an R built with configure option --disable-long-double, prod(M) now very slightly differs for two differently classed versions of M.

• checkMatrix() from ‘test-tools-Matrix.R’ gets optional MSG argument for suppressing prod() differences.

Changes in version 1.6-2 (2023-11-05, svn r4503)

Compatibility

• Matrix did not pass its checks under R version 3.5.0, implicitly violating Depends: R (>= 3.5). This release restores compatibility.

Linking

• Support is added for an ABI version relevant to packages that link against Matrix. The ABI version is 1 in this release and will be incremented by 1 in each future release that changes the ABI. It is implicitly 0 in previous releases. Versions and their components are defined in a header for use by packages with LinkingTo: Matrix (>= 1.6-2) in their ‘DESCRIPTION’. See ‘inst/include/Matrix/version.h’ and (below) Matrix.Version.

• Reverse LinkingTo built under earlier versions of Matrix should be rebuilt from sources by users and maintainers of binary repositories.

C-Level API

• API headers are organized under ‘inst/include/Matrix/’ for easier namespacing. Packages should start using LinkingTo: Matrix (>= 1.6-2) and include the API headers with, e.g., #include <Matrix/Matrix.h>.

• Packages including API headers can define macro R_MATRIX_INLINE, typically with #define R_MATRIX_INLINE inline, in order to allow the compiler to inline stubs for registered routines.

• Some API function prototypes and macros not used by any reverse LinkingTo are removed or remapped.

• Several API function prototypes used const qualifiers where the registered routines do not.

• The prototype of API function M_cholmod_band_inplace did not match that of registered routine cholmod_band_inplace. The prototype of cholmod_band was copied by mistake.

Significant User-Visible Changes

• Methods for generic functions rbind2, cbind2, %*%, %&%, crossprod, and tcrossprod determine the class of the result using more strict rules, designed to avoid “surprising” coercions where possible. Notably, operations involving RsparseMatrix now return an RsparseMatrix in more cases. TsparseMatrix and diagonalMatrix may be handled as CsparseMatrix or as RsparseMatrix, depending on context.

Classes

• New nonvirtual class ndiMatrix representing diagonal nonzero pattern matrices. It extends virtual classes diagonalMatrix and nMatrix. ndiMatrix are typically obtained as the result of is.na, is.nan, or is.infinite applied to a diagonalMatrix or as the result of coercing a diagonalMatrix to nMatrix. (The result of that coercion used to be an ntCMatrix. It is still possible to obtain an ntCMatrix by coercion to nsparseMatrix.)

• The validity method for class sparseVector requires length not exceeding 2^53, which on most platforms is the minimum positive integer k such that k + 1 is not exactly representable in double precision.

• A dsparseVector with x slot of type "integer" is formally invalid, as always intended.

• Certain never or seldom used class unions are removed.

New Features

• mean(<sparseVector>, trim=) now works efficiently for nonzero values of trim.

• rep(<sparseVector>, each=) now works efficiently, avoiding rep(., times = rep(each, times = length(.))).

• .m2dense and .m2sparse gain an argument trans indicating if vectors that are not matrices should be coerced to 1-row matrices rather than 1-column matrices.

• .m2dense and .m2sparse can be called with one argument. Their class arguments admit new default values ".ge" and ".gC".

• .diag2dense and .diag2sparse gain an argument kind indicating the “kind” of the result.

• New exports .M2V and .m2V, for coercing Matrix and matrix (and in fact vector) to sparseVector.

• New exports isUniqueT and asUniqueT, with optional argument byrow allowing for row-major ordering of entries. asUniqueT supercedes uniqTsparse, which is no longer documented.

• New export aggregateT, for aggregating TsparseMatrix without sorting.

• Methods for all.equal now report the packages where S4 classes are defined.

• sum(x) and prod(x) no longer require a coercion from symmetricMatrix to generalMatrix. Results where coercions are now avoided may differ numerically due to reordering of adds and multiplies, most commonly on systems where sizeof(long double) == sizeof(double).

Bug Fixes

• Methods for cbind2 and rbind2 did not in all cases handle vectors as 1-column and 1-row matrices, respectively.

• Methods for cbind2 and rbind2 did not handle 0-length vectors (including NULL) correctly where the result would have 0 rows and columns, respectively.

• Methods for cbind2 and rbind2 did not handle NA in the x slot of ndenseMatrix correctly (i.e., as TRUE).

• cbind2(<ndenseMatrix>, <ldenseMatrix>) gave ngeMatrix instead of lgeMatrix. cbind2(<lsparseMatrix>, <lsparseMatrix>) gave dgCMatrix instead of lgCMatrix. Methods for rbind2 had similar problems.

• rcond(<0-by-0>) now returns Inf; see PR#18543.

• round(<dp[op]Matrix>) and signif(<dp[op]Matrix>) now return ds[yp]Matrix rather than dp[op]Matrix and now discard factors.

• Methods for length now return integer rather than double if the result does not exceed INT_MAX.

• Methods for subscripting sparseVector did not behave compatibly with base when supplied with fractional, NA, or out-of-bounds subscripts.

• symmpart(x), skewpart(x), band(x, k1, k2), triu(x, k), and tril(x, k) now always return a .diMatrix for x inheriting from diagonalMatrix.

• colSums(<(n|l|ind)Matrix>) and rowSums(<(n|l|ind)Matrix>) now always give a result of type "integer". Methods differed previously, some giving "double" (as base does, suboptimally, traditional matrices of type "logical").

• Some methods for generic function lu did not transmit Dimnames to the result.

• Some methods for group generic function Summary ignored arguments matching .... Other methods did not ignore the “garbage” elements of the x slot of dense, triangular matrices.

• kronecker(<n.TMatrix>, <diagonalMatrix>) threw an error for attempting to access the nonexistent x slot of its first argument.

• Matrix products now behave exactly as base when testing for conformable arguments.

• Numeric products (%*%) did not always return a dMatrix.

• Methods for all.equal now “see” attributes of S4 objects that are not slots. This can be disabled by setting argument check.attributes to NA, which is otherwise equivalent to TRUE.

• prod(x) is computed more diligently for x inheriting from sparseMatrix, sparseVector, or .t[rp]Matrix, i.e., those x that can be understood to have “structural” zeros. Now, multiplication by zero occurs at the position of the first structural zero in the matrix or vector (when traversed by row in the case of RsparseMatrix). An exception is TsparseMatrix, for which multiplication by zero occurs before multiplication by any stored entry, regardless of the position of the first structural zero in the corresponding sorted matrix (to avoid the cost of sorting).

• tri[ul](<.t[rp]Matrix>, k) was often wrong for nonzero k, setting too many bands to zero.

• C-level tCsparse_diag (formerly diag_tC) now handles structural zeros and NaN on the main diagonal correctly. Option "diagBack" now works correctly.

• expm(x) failed for x of class dtpMatrix or dspMatrix, since Matrix version 1.6-1.

• .m2dense(x, ".ge") allocated unnecessarily for x without attributes.

Misc

• C code now refers to the symbol factors as Matrix_factorsSym, rather than Matrix_factorSym.

• The content of ‘src/Mutils.[ch]’ has been migrated to more transparently named files: ‘src/attrib.[ch]’, ‘src/objects.[ch]’, etc. Similarly, much of ‘src/factorizations.[ch]’ have been migrated to ‘src/solve.[ch]’ and ‘src/determinant.[ch]’.

• All matrix product code has been migrated to ‘products.[Rch]’.

• Files in ‘po/’ and ‘inst/po/’ have been updated due to more frequent use of gettextf in ‘R/*.R’.

• C code is prepared to handle complex matrices and their factorizations. Notably, new machinery in ‘src/cs-etc.[ch]’ will enable linking the CXSparse library instead of the CSparse library, the latter supporting numeric types but not complex ones.

Changes in version 1.6-1.1 (2023-09-08, hotfix)

Misc

• Export the generics crossprod() and tcrossprod() explicitly, needed for R-devel when they become primitive internal generics.

Changes in version 1.6-1 (2023-08-11, svn r4228)

C-Level API

• Registered routine chm_sparse_to_SEXP sorts and packs its first argument before assigning any struct members to variables, preventing use-after-free.

Memory

• Four Valgrind-detected memory bugs are fixed.

Classes

• Validity methods for classes Cholesky and pCholesky test for a valid perm slot.

New Features

• Several new coercion utilities, exported and documented in help("fastMisc"). Some of these supercede ones made available (experimentally) in Matrix 1.5-4; for example, .M2m makes both .dense2m and .sparse2m redundant. The superceded ones are not yet formally deprecated, but are no longer documented.

• drop0 is now implemented independently of CHOLMOD, becoming more efficient notably for logical arguments, no longer requiring a coercion to double.

• drop0 gains an argument give.Csparse to complement is.Csparse. FALSE indicates that RsparseMatrix, TsparseMatrix, and indMatrix arguments should be handled directly, without a coercion to CsparseMatrix. The default value is TRUE, for backwards compatibility.

Bug Fixes

• <diagonalMatrix> %*% <RsparseMatrix> works again.

• diag(<non-square RsparseMatrix>) <- value works again, no longer giving a p slot of length Dim[2] rather than Dim[1].

• as(<diagonalMatrix>, "symmetricMatrix") now checks for symmetric Dimnames, for consistency.

• as(<indMatrix>, "[nld](sparse)?Matrix") now returns a .gRMatrix or a .gCMatrix depending on the margin slot.

• as(<[CR]sparseMatrix>, "generalMatrix") now checks if the number of nonzero entries in the result would exceed INT_MAX and throws an error in that case.

Misc

• Run speed-measuring tests only if(doExtras): these were too slow when run under Valgrind.

• Most coercion code has been migrated to ‘coerce.[Rch]’ from elsewhere.

• The number of methods for generic functions coerce and as.* has been reduced substantially, from 306 to 194 (not counting deprecated ones), partly as a result of efforts to do more fine-grained dispatch in C code.

• Files in ‘po/’ and ‘inst/po/’ have been updated (again), as many more C level messages now use format strings as a result of vsnprintf usage in ‘src/validity.c’.

Changes in version 1.6-0 (2023-06-30, svn r4125)

Dependencies

• The following “weak” dependencies, needed only for a small number of Rd cross references, are removed: MatrixModels, expm, igraph, maptools, sp, spdep. Links to CRAN or Bioconductor in Rd files are preserved.

• sfsmisc is moved from Enhances to Suggests, as Matrix does not formally enhance it with methods or links to documentation.

• grDevices and datasets are added to Imports and Suggests, respectively, as Matrix does import from grDevices and (in vignettes) does load data from datasets.

• Example, test, and vignette code no longer fails when R_DEFAULT_PACKAGES is set to NULL.

• Example code uses requireNamespace instead of require to preserve the user's search path.

Significant User-Visible Changes

• Methods for generic function chol that previously returned an object of class p?Cholesky now return an equivalent object of class dtrMatrix or dtpMatrix. Existing code that relied (correctly) on chol to return the upper triangular Cholesky factor as a Matrix can be expected to work as before.

Classes

• Class indMatrix gains a margin slot with value 1L or 2L (1L being the prototype and previously implicit value), indicating that the object represents a row or column index matrix, with ones at [i, perm[i]] or [perm[j], j], respectively.
  
  Methods with indMatrix or its subclass pMatrix in the signature have been adjusted to account for the new slot. Notably, multiplication on the right by an indMatrix with margin = 2 is now implemented as a column subscript, and the transpose of an indMatrix is now the same object but with “opposite” margin.

• Virtual class MatrixFactorization gains a Dimnames slot. Now all factorizations preserve the Dimnames of the original, factorized Matrix, whereas previously classes Schur, sparseLU, sparseQR, dCHMsimpl, and dCHMsuper did not. Users can get the value of the new Dimnames slot with dimnames(.) and set it with dimnames(.) <- value.

• Classes p?BunchKaufman and p?Cholesky no longer extend dtrMatrix or dtpMatrix and in turn no longer extend Matrix. They retain slots Dim, Dimnames, uplo, and x, but not diag. This change implies that virtual classes Matrix and MatrixFactorization no longer intersect.

• Classes p?Cholesky gain a perm slot with prototype integer(0L) to support representation of pivoted factorizations, as typically computed by LAPACK routine dpstrf. perm of length 0 is valid and equivalent to the identity permutation.

• New nonvirtual class pcorMatrix extending dppMatrix. It is the counterpart of corMatrix using packed storage, supporting more efficient storage of dense correlation matrices. Now pack(<corMatrix>) gives a pcorMatrix preserving the sd slot, rather than a dppMatrix without an sd slot.

• New virtual classes BunchKaufmanFactorization, SchurFactorization, and QR, extended by existing nonvirtual classes p?BunchKaufman, Schur, and sparseQR, respectively. These are parallel to the existing virtual classes CholeskyFactorization and LU. Packages defining new factorization classes may extend these.

• Virtual class CHMfactor and its subclasses gain formal validity methods.

• The validity method for class sparseQR now tests that the V slot is lower trapezoidal and that the R slot has non-negative diagonal elements.

• The validity method for class corMatrix now tolerates nonfinite elements in the sd slot. It no longer tolerates nonunit diagonal elements in the x slot.

• The prototype of the Dim slot of virtual class MatrixFactorization is now integer(2L). It was previously integer(0L), with the result that validObject(new(<nonvirtual>)) was always an error.

• The prototype of the L slot of class sparseLU is now formally lower triangular, so that validObject(new("sparseLU")) is not an error.

• The prototypes of the Q and T slots of class Schur are now 0-by-0 dgeMatrix, so that validObject(new("Schur")) is not an error.

Generic Functions

• New generic functions expand1 and expand2, intended to replace expand and coercions from (subclasses of) MatrixFactorization to (subclasses of) Matrix. expand1 is used as expand1(<MatrixFactorization>, <character string>) and constructs by name factors appearing in the factorization. expand2 is used as expand2(<MatrixFactorization>) and returns a named list of all factors appearing in the factorization, in order and with row names on the first factor and column names on the last factor. The result can be used to reconstruct the factorized Matrix as the product of the elements of the list, namely Reduce(`%*%`, expand2(.)).
  
  expand and its methods are retained for backwards compatibility. They may be formally deprecated in the future, hence new code should use expand1 and expand2. Notably, expand1 and expand2 have methods for all factorizations in Matrix, whereas expand continues to have methods only for denseLU, sparseLU, and CHMfactor. See help("expand-methods") for a list of methods, including useful optional arguments.

New Features

• Methods for subscripting Matrix now use the more systematic code in ‘R/subscript.R’ and ‘src/subscript.c’, becoming more efficient for all lsparseMatrix (no longer coercing to dsparseMatrix and back), sparse symmetricMatrix (no longer coercing to generalMatrix and back when i in x[i, i] is monotone), unpackedMatrix (no longer coercing to matrix and back), and RsparseMatrix (no longer coercing to TsparseMatrix, then to CsparseMatrix, then back to TsparseMatrix [!]).
  
  x[i, j, drop = FALSE] preserves the class of x in more cases where x is a triangularMatrix, diagonalMatrix, or pMatrix, doing more complete checks on i and j.
  
  Notably, for x inheriting from RsparseMatrix, the result is now always an RsparseMatrix, rather than always a TsparseMatrix.

• NULL subscripts, as in x[NULL], x[NULL, j], and x[i, NULL], are now supported for x inheriting from Matrix. They are handled as integer(0), consistent with base.

• Generic function Cholesky gains methods for denseMatrix returning an object of class p?Cholesky. The method for subclass dsyMatrix admits an argument perm indicating if the pivoted factorization should be computed. The corresponding chol method gains an argument pivot indicating the same. By default, Cholesky pivots and chol does not.

• Many subclasses of MatrixFactorization can now be coerced to “nearby” subclasses of Matrix. The resulting Matrix reflects the internal representation of the factorization and not necessarily a particular matrix factor. The new coercions are: as(<denseLU>, "dgeMatrix"), as(<BunchKaufman>, "dtrMatrix"), as(<pBunchKaufman>, "dtpMatrix"), as(<Cholesky>, "dtrMatrix"), as(<pCholesky>, "dtpMatrix"), as(<CHMsimpl>, "dtCMatrix"), and as(<CHMsuper>, "dgCMatrix"). See help("denseLU-class") (and similar) for details.

• determinant(x, ...) and solve(a, b, ...) now work for x and a inheriting from MatrixFactorization, behaving as if x and a were replaced by the factorized Matrix. The exception is x inheriting from CHMfactor, where for backwards compatibility the default behaviour is still to compute the determinant of the Cholesky factor. This exception should be considered temporary, hence defensive code will call determinant with (new) optional argument sqrt set to TRUE or FALSE explicitly, to not rely on the current default value. See help("CHMfactor-class") for details.

• Generic function diag gains methods for p?Cholesky and CHMfactor. The result is a numeric vector containing the diagonal entries of the diagonal matrix D, as defined in help("Cholesky-class") and help("CHMfactor-class").

• The lu and qr methods for class dgCMatrix now admit an order argument with value in 0:3, allowing the expert user to choose among all ordering methods made available by the CSparse library.

• solve(<dgCMatrix>, b, sparse = TRUE) is now handled entirely in C code via cs_spsolve from the CSparse library.

• New utilities invertPerm, signPerm, isPerm, and asPerm for computing the inverse and sign of a permutation vector, testing if an integer vector is a permutation vector, and coercing a transposition vector to a permutation vector. invertPerm is a more general version of the already exported function invPerm, which is retained as a wrapper around invertPerm for backwards compatibility.

• The qr.R method for class sparseQR gains a backPermute argument with default FALSE, for compatibility with base. Function qrR, which existed primarily to provide a back-permuting option, is retained for backwards compatibility.

Bug Fixes

• x[integer(0), ] and x[, integer(0)] now give a generalMatrix result when x is a 0-by-0 diagonalMatrix, for consistency with all other cases of x[seq_len(n), ] and x[, seq_len(n)], where x is an n-by-n triangular, symmetric, or diagonal matrix.

• For x inheriting from RsparseMatrix, subassignment of the form x[i, ] <- value is now correctly distinguished from x[i] <- value.

• rownames(x[integer(0), , drop = FALSE]) and colnames(x[, integer(0), drop = FALSE]) are now always NULL and never character(0), consistent with the implementation in base.

• Subscript operations on Matrix now correctly error whenever the formal argument ... is matched, as in x[i, j, drop], where x[i, j, drop = drop] is almost always intended.

• x[i, ] now correctly drops dimensions when x is a 1-by-n Matrix and i is TRUE.

• Methods for solve now obey the following rules much more strictly:

  • solve(a=<Matrix>, b=<vector>) must return a vector.

  • solve(a=<denseMatrix>, b=<Matrix>) must return a denseMatrix.

  • solve(a=<sparseMatrix>, b=<Matrix>, sparse=FALSE) must return a denseMatrix.

  • solve(a=<sparseMatrix>, b=<Matrix>, sparse=TRUE) must return a sparseMatrix.

  resolving some longstanding incompatibilities with base.
  
  Note that methods for sparse a and missing or sparse b have default sparse = TRUE, while methods for sparse a and dense b have default sparse = FALSE.

• solve(<symmetricMatrix>) now always gives a symmetricMatrix result. solve(<dpoMatrix>) and solve(<dppMatrix>) preserve formal positive definiteness, giving a dpoMatrix and dppMatrix, respectively.

• BunchKaufman(<matrix>) now works when argument uplo (documented to be optional) is missing.

• Coercions to corMatrix now set the diagonal elements of the result to 1, consistent with cov2cor.

• dimnames(x) <- value now validates x@Dim before value to avoid undefined behaviour in C-level check.

• chol2inv(x) now ignores the lower triangular part of x not inheriting from triangularMatrix.

• chol2inv(x) now computes crossprod(solve(x)) instead of tcrossprod(solve(x)) for all formally lower triangular x. Previously, crossprod was used only for dense x.

• rcond(x, norm) throws a nicer error for x of length 0.

• Error messages due to invalid norm in rcond(x, norm) now refer to the argument as norm rather than type.

• rcond(x, norm) now validates norm also for x of class d(sy|sp|po|pp)Matrix, even if for such x all valid norm give the same result.

• which(<[RT]sparseMatrix>, ...) now gives indices in column-major order in all cases, to be consistent with help("which").

• Factorizations inheriting from virtual class LU are now cached under the name denseLU or sparseLU, depending on the nonvirtual class, rather than always under the name LU. Note that user code should not rely on the details of the cache and should instead rely on functions such as lu to retrieve cached factorizations.

• Errors signaled by as(<dsyMatrix>, "dpoMatrix") and as(<dspMatrix>, "dppMatrix") now clarify that the coercions do not attempt to test for positive semidefiniteness when the matrix is not positive definite.

Memory

• invPerm(p) no longer segfaults for p that are not valid permutation vectors. invPerm(NA) was enough to trigger a segfault.

• C code interfacing the CSparse library tests in more places for failed allocations inside of cs_*.

Misc

• Help pages for matrix factorization classes and methods have been broadly expanded and updated to use consistent notation.

• The length of the Matrix namespace has been reduced by ~15%. More than 100 unused symbols have been removed.

• Updates to ‘po/*.{po,pot}’ and ‘inst/po/*’ for translators.

Changes in version 1.5-4.1 (2023-05-16, hotfix)

Installation

• ‘src/Lapack-etc.h’ uses #ifdef PR18534fixed, adapting to PR#18534 without breaking installation under R < 4.3.1.

Changes in version 1.5-4 (2023-04-02, svn r3837)

Compatibility

• sequence.default is defined for R < 4.0.0.

C-Level API

• ‘Rinternals.h’ is included in ‘inst/include/Matrix.h’ instead of deprecated ‘Rdefines.h’. The inclusion is done outside of extern "C".

Deprecated and Defunct

• The following low level coercion utilities, which were previously exported but always “hidden” and undocumented, are now deprecated: ..2dge, .C2nC, .T2Cmat, .asmatrix, .dense2sy, .diag2mat, .diag2sT, .diag2tT, .dsy2dsp, .dsy2mat, .dxC2mat, .m2dgC, .m2lgC, .m2ngC, .m2ngCn, .m2ngTn, .n2dgT, .nC2d, .nC2l.
  
  The deprecations follow efforts to define more general and more systematic (but still fast) coercion utilities, to allow expert users to bypass S4 dispatch in more cases. The subset of these currently exported is documented under help("fastMisc"). Deprecation warnings will suggest an appropriate replacement, mostly from that list.
  
  It is not always the case that the replacement can be “dropped in”, hence users should consult the relevant documentation when changing their code.

• Warnings signaled by coercion methods deprecated in Matrix 1.5-0 now correctly inherit from class deprecatedWarning.

Memory

• Calls to sprintf are replaced by equivalent calls snprintf to avoid potential buffer overflow.

Misc

• C-level utilities Matrix_memset() and Matrix_memcpy(), both new, are now used in many places instead of API macros Memzero() and Memcpy() which never check for overflow. C-level macro AZERO() is no longer defined.

• C-level macro Calloc_or_Alloca_TO() now zero-initializes also in the alloca-using case.

Changes in version 1.5-3 (2022-11-10, svn r3772)

Dependencies

• methods is moved from Imports to Depends as suggested in the WRE manual. Now as and other basic S4 machinery are available whenever Matrix is attached. This change affects R processes started with environment variable R_DEFAULT_PACKAGES set to NULL (or any list not containing methods).

Compatibility

• Test involving sparse POSIXlt in ‘tests/Simple.R’ is adapted to possible (unconditional since R version 4.3.0) existence of character component zone.

Bug Fixes

• dimScale(x) with argument d1 missing is no longer an error. (The default value had diag(x, FALSE) instead of diag(x, names = FALSE).)

• (dim|row|col)Scale(x) is no longer an error for traditional matrices x without a dimnames attribute.

• Our cov2cor() methods now again preserve (symmetrized!) dimnames, fixing Matrix PR#6783 reported by Ben Bolker.

• colSums() and friends now always give a named result when the marginal Dimnames are non-NULL. (Names were “forgotten” for diagonalMatrix and indMatrix arguments.)

• colSums() and friends now respect na.rm when handling diagonalMatrix with NA diagonal entries.

• expand(<denseLU>) now “copies-on-modify”, no longer duplicating the m*n-length x slot in the m == n case, when it can be used directly.

• lu(<m-by-0>), lu(<0-by-n>), and BunchKaufman(<0-by-0>) now give sensible (0-extent) results, rather than a LAPACK error, for denseMatrix.

New Features

• Diagonal() gets a new optional names argument.

• diag(x) <- value is now done in C also for [CRT]sparseMatrix.

• .diagU2N() gets fast counterpart .diagN2U().

• colSums() and friends are now implemented more efficiently for denseMatrix and [CRT]sparseMatrix. Notably, methods for triangular and symmetric matrices no longer go via generalMatrix, and methods for [CRT]sparseMatrix now handle nonzero pattern and logical matrices directly (no longer coercing to double, a constraint of the earlier implementation using CHOLMOD).

• determinant(<ds[yp]Matrix>) is now computed via the Bunch-Kaufman factorization. Factorizations are cached in the factors slot for future reuse.

Misc

• C-level wrappers for LAPACK d..trf routines gain an argument warn indicating how to handle info > 0: warn <= 0 is silent, warn = 1 is a warning, and warn > 1 is an error. In the case of dp[op]trf, for which info > 0 implies an incomplete factorization, info is now returned as a length-1 integer.

Changes in version 1.5-2 (2022-10-21, svn r3702)

Classes

• The validity methods for classes l[st]CMatrix now correctly test for structurally nonzero entries on the wrong side of the main diagonal, and fail in that case. Previously, this test was performed only for d[st]Matrix.

• The validity method for virtual class sparseVector is more diligent, catching more edge cases such as NA in the length or i slot.

• New validity methods for n[st][CRT]Matrix, Schur, denseLU, p?BunchKaufman, p?Cholesky, sparseLU, and sparseQR. Notably, the following properties of factorizations are now checked: the dimensions of each factor, the orientation of each triangular (or trapezoidal) factor, and the validity of each permutation vector.

Bug Fixes

• lu(x)@L@uplo is now "L", not "U", for 0-by-0 and 1-by-1 dgCMatrix x.

• The validity method for corMatrix now throws a better error when the sd slot is of type "integer" rather than "double".

• .sparseDiagonal() now agrees with Diagonal() when called with no arguments, returning a 0-by-0 (rather than 1-by-1) diagonal Matrix.

• sparseMatrix(i, j) with 0-length i and j now returns a 0-by-0 matrix rather than throwing a perplexing error.

• sparseMatrix(dims = <list>) and sparseMatrix(x = <dMatrix>) now produce errors.

• diag(x) <- value now coerces diagonalMatrix x if typeof(value) is “higher” than typeof(x@x) in the usual hierarchy, for consistency with methods for denseMatrix and with base::`diag<-`.

• Methods for kronecker() no longer ignore the make.dimnames argument.

• Printing a sparseMatrix with NA row or column names is no longer an error.

• Products of two pMatrix objects x and y are now computed correctly. Previously, y %*% x was returned instead of x %*% y!

• Products x %*% y with x a diagonalMatrix or indMatrix and y a traditional matrix or vector, or with x a traditional matrix or vector and y a diagonalMatrix or pMatrix, now treat the unclassed argument as a .geMatrix and return a .geMatrix, for greater consistency with other products involving one Matrix and one non-Matrix.

• Similarly, kronecker(x, y) with one of x and y a Matrix and the other a traditional matrix or vector now treats the unclassed argument as a .geMatrix.

• dimnames(solve(x)) is now rev(dimnames(x)) for denseMatrix x, consistent with the handling of dimnames by solve.default. Methods for sparseMatrix x have not been addressed (yet).

Memory

• In many more (but not yet all) places, C functions protect the values of R_do_slot, Rf_getAttrib, Rf_mkString, etc. from garbage collections, squashing many new and some old rchk warnings.

New Features

• is.nan(x) is now implemented for all x inheriting from virtual class Matrix or sparseVector.

• Diagonal(n=, x=) now recycles x of any positive length to length n. Previously, recycling was supported only for x of length 1.

• Products involving diagonalMatrix or indMatrix have been broadly improved as follows:

  • dimnames(A %*% B) is now always c(dimnames(A)[1], dimnames(B)[2]).

  • t?crossprod() methods involving indMatrix or its subclass pMatrix gain a boolArith argument.

  • Numeric and boolean products are always returned as dMatrix and nMatrix, respectively, except in a few special cases where the product can be represented as an indMatrix. (Previously, coercions were skipped when one of the operands was unit diagonal.)

  • Products of diagonalMatrix with dense triangularMatrix now correctly give a triangularMatrix result (and without unpacking).

  • Products of diagonalMatrix with [RT]sparseMatrix now preserve storage, no longer coercing to CsparseMatrix.

  • crossprod(x, y) no longer requires the product of ncol(x) and ncol(y) to be less than 2^31 when both x and y are indMatrix. (The new implementation now always gives a dgTMatrix result, whereas previously the result would typically but not always be a dgCMatrix.)

• kronecker(<Matrix>, <Matrix>) now gives the correct “shape” (general, [unit] triangular, symmetric, diagonal) in all cases where it can be known without checking.

• kronecker(<[CR]sparseMatrix>, <Matrix>) now retains the storage of the first argument, no longer coercing to TsparseMatrix.

• New exported functions dimScale, rowScale, and colScale, for scaling rows and columns of a [mM]atrix without losing dimnames and where appropriate without losing symmetry.

Changes in version 1.5-1 (2022-09-12, svn r3642)

Memory

• ASan-detected memory bugs are fixed in C functions Tsparse_as_CRsparse and pMatrix_validate. The former was triggered by .T2C(<0-by-0>) and the latter was triggered by as(<length-10000 integer>, "pMatrix").

Changes in version 1.5-0 (2022-09-09, svn r3636)

Deprecated and Defunct

• With a few exceptions, direct coercions to non-virtual subclasses of Matrix (e.g., dsCMatrix) have been formally deprecated. For now, these will continue to work as before, but with a warning indicating how to accomplish the desired coercion via virtual classes (e.g., symmetricMatrix) alone. How such warnings are signaled is controlled by the global option Matrix.warnDeprecatedCoerce.

  0 or less

  is to be silent.

  1

  is to signal a warning with each deprecated coercion.

  2 or greater

  is to signal an error with each deprecated coercion.

  NA

  is to signal a message or warning (see below) with the next deprecated coercion and be silent after that.

  If unset or invalid, then the value of the environment variable R_MATRIX_WARN_DEPRECATED_COERCE (NA if unset) is used. This is cached when the Matrix namespace is loaded.
  
  Option values are coerced to integer before use.
  
  To reduce disruption to existing code, the NA case signals messages rather than warnings with coercions to the most-used non-virtual subclasses of Matrix, namely dg.Matrix and d.CMatrix. This may change in the future.

Classes

• New virtual class unpackedMatrix representing dense matrices in unpacked format. It extends denseMatrix and is extended by [nld](ge|sy|tr)Matrix, i.e., the subclasses of denseMatrix not extending packedMatrix.

• The validity method for dppMatrix requires non-negative diagonal elements, matching the validity method for dpoMatrix.

• The validity method for Matrix tolerates vector types other than "character" for Dimnames[[i]].

Bug Fixes

• Symmetrization of <Matrix>@Dimnames and dimnames(<matrix>) now goes through C utility symmDN() in most places, resolving some earlier inconsistencies.

• Many more validity methods now correctly operate under the assumption that methods for superclasses have already been called, eliminating many redundant checks.

• Validation of <Matrix>@Dim now looks at type before length, avoiding a misleading error message.

• Validation of <Matrix>@Dimnames now avoids isNewList, which had allowed an error message suggesting that NULL is a list.

• Setting a factor on a compMatrix is now to install the factor itself, not a copy, for efficiency and consistency with the semantics of <compMatrix>@factors[[name]] <- value.

• Long vector support in methods for packing and unpacking denseMatrix, and others.

• diag<- incorrectly preserved the class of dense matrices, so that, e.g., `diag<-`(x=<dpoMatrix>, value=-1) was still a dpoMatrix. Now the result is always one of the more general .(ge|tr|sy|tp|sp)Matrix.

• t(<corMatrix>) no longer clears the sd slot. t(<p?BunchKaufman>) now returns one of the more general dt[rp]Matrix, rather than preserving class and clearing the perm slot.

• t(<symmetricMatrix>) no longer reverses the Dimnames slot. Symmetrization of dn <- x@Dimnames and t(x)@Dimnames had given different results when dn[[1]] and dn[[2]] were non-NULL and asymmetric.

• isTriangular(x, upper) had incorrectly returned FALSE for x of class triangularMatrix when upper = TRUE and x@uplo = "L" or when upper = FALSE and x@uplo = "U". isTriangular is now equivalent to isDiagonal in those cases.

• isSymmetric() was equivalent to isDiagonal() for triangular matrices, not allowing numerical fuzz via an argument tol. A tol argument is now implemented for all subclasses of dMatrix except for those inheriting from symmetricMatrix or diagonalMatrix.

• Methods for isSymmetric now also look at Dimnames and names(Dimnames), following isSymmetric.matrix from base. See also New Features.

• band(x, -k, k) for sparse x used isSymmetric(x) (which tolerates numerical fuzz) to test for symmetry, resulting in loss of information in some cases. Now it tests that x inherits from symmetricMatrix, and so returns symmetricMatrix in fewer cases.

• triu(x, k) and tril(x, k) incorrectly required k <= m (instead of k <= n), for m-by-n sparse x. They now accept all k from -m to n, with fewer errors in the m < n case.

• crossprod(<Rsparse>, <Tsparse>) and similar now work again (optional boolArith was not passed on), fixing Matrix PR#6766 by David Cortes. Ditto for tcrossprod(), where the old result was even wrong when it had “worked”, before Matrix 1.2-0.

• as(<matrix>, "nMatrix") can now be sparse or dense, going via Matrix(), for greater consistency with coercions to dMatrix and lMatrix. (Previously, the result was always an ngTMatrix.)

• forceSymmetric(<[RT]sparseMatrix>) are now more efficient, returning symmetric [RT]sparseMatrix without intermediate coercions to CsparseMatrix.

• tcrossprod(a, b) for unit triangular sparse matrices now works correctly.

• !<ltrMatrix> is no longer an error in the 0-by-0 unit diagonal case.

• Coercions among [CRT]sparseMatrix preserve the factors slot in more cases.

• Coercions of overallocated l.TMatrix to denseMatrix or CsparseMatrix now give TRUE instead of NA in the NA || TRUE case, following conventional logic.

• Methods for unpacking and indexing packedMatrix and for coercing from [CRT]sparseMatrix to denseMatrix now check more consistently for overflow of R_XLEN_T_MAX.

• solve(<ddenseMatrix>, <ANY>) is removed from the method list. It had allowed infinite recursion, e.g., with solve(new("dgeMatrix"), NULL).

• is.na(<ndenseMatrix>) gave TRUE where the x slot had NA. Now the result is always a zero matrix.

• is.na(<.t[rp]Matrix>) and is.infinite(<.t[rp]Matrix>) ignored the diag slot, behaving always as though diag == "N". They now give FALSE on the diagonal in the diag != "N" case.

• Now only “nontrivial” matrix elements determine whether is.na(<denseMatrix>) is an ndenseMatrix or an nsparseMatrix.

• is.na(<ddenseMatrix>) coerced to lMatrix. This unnecessary step is avoided now, saving a potentially nontrivial allocation.

• solve(<ddenseMatrix>, b) coerced the first argument to dgeMatrix when b was not a ddenseMatrix or traditional matrix. This unnecessary step is avoided now, so that specialized methods for d(tr|sy|po|tp|sp|pp)Matrix are used where possible (including for b inheriting from [ln]denseMatrix, sparseMatrix, or numLike).

• `dim<-`(x, -x@Dim) is now an error, no longer yielding an invalid Matrix object.

• `dim<-`(x, x@Dim) is now faster, returning x without allocation in all cases.

• `dim<-`(x, value) gives a better error when value contains NA or elements exceeding INT_MAX.

• `dim<-`(<RsparseMatrix>, value) is now an RsparseMatrix, rather than a TsparseMatrix.

• For consistency with other methods, symmpart(<diagonalMatrix>) now always inherits from both dMatrix and symmetricMatrix, and skewpart(<diagonalMatrix>) now always has symmetric Dimnames.

• Zeros on the diagonal of skewpart(<[CRT]sparseMatrix>) are now structural.

• as(<ndenseMatrix>, "(vector|matrix|[dl]Matrix)") and nnzero(<ndenseMatrix>) now correctly treat NA in the x slot as TRUE.

• as(<[nl].TMatrix>, "dMatrix") now correctly handles the overallocated case: data for each unique [i,j] pair are aggregated logically (x1 || ... || xn) rather than arithmetically (x1 + ... + xn), so that elements of the result are restricted to the set c(0, 1, NA). This bug had also affected the result of sum(<[nl].TMatrix>).

• dimnames(as(x, "matrix")) is now NULL for all x inheriting from Matrix, when x@Dimnames is the trivial list(NULL, NULL).

• .bdiag(<named list>) no longer propagates names to the Dim slot of the result.

• as(<named vector>, "denseMatrix") now correctly propagates names to the result.

• as(<d.[CR]Matrix>, "lMatrix") no longer drops non-structural zeros, for greater consistency with analogous coercions.

• Matrix(x, doDiag) now behaves as documented for diagonal matrices x with asymmetric dimnames, returning a diagonalMatrix when doDiag = TRUE, rather than a triangularMatrix.

• Matrix(<n-dimensional table>) now works for n != 2.

• Matrix(<sparseVector>) now works for vector lengths other than 1, no longer giving an error about length mismatch when neither of nrow and ncol are supplied.

• Matrix(<diagonalMatrix>, doDiag = FALSE) is now a symmetricMatrix, not a diagonalMatrix, matching the documentation of doDiag.

• Matrix(<.geMatrix>, sparse = TRUE, forceCheck) and Matrix(<.g[CRT]Matrix>, sparse = FALSE, forceCheck) now respect forceCheck = FALSE by always returning generalMatrix, i.e., not testing for symmetric or triangular structure.

• Matrix(0, nrow, ), Matrix(0, , ncol) now throw (correct) errors for nrow, ncol in the interval [0,1), consistent with base::matrix().

• sparseDefault(<sparseMatrix>) now counts zeros without coercing to matrix, making Matrix(<sparseMatrix>, sparse = NULL) much more efficient.

• Methods for group generic Math no longer preserve x@diag == "U" or lose x@Dimnames when f(0) == 0 and f(1) != 1. (The former happened for triangularMatrix x and the latter for diagonalMatrix x.)

• image(Z) for a completely “empty” (all 0) sparseMatrix works again (?!).

• x[i, ] <- value and y[, j] <- value is now an error in more cases for m-by-0 CsparseMatrix x and 0-by-n CsparseMatrix y. In these cases, subassignment gave a (formally) invalid result.

• chol(<ds[yp]Matrix>) now calls the underlying C-level routine exactly once. Previously, it was called an extra time in order to test for positive definiteness, with the result thrown away (!). Hence these methods should become approximately two times faster.

• dimnames(chol(x)) is identical to dimnames(x) in all cases, now even when chol(x) is constructed from a cached MatrixFactorization, for greater consistency with base::chol.default().

• chol(<generalMatrix>) no longer looks at Dimnames when testing for symmetry.

• lu(<dtCMatrix>) no longer returns an invalid sparseLU object in the lower triangular case.

• lu(x) had sometimes incorrectly cached its return value as element "lu" (rather than "LU") of x@factors. Now it is always "LU".

• Compare operators, e.g., a > b, x != y, now work correctly in more dense unitriangular and sparse 0-extent cases.

• !<nMatrix> is now always an nMatrix, never an lMatrix.

• !<ndenseMatrix> and which(<ndenseMatrix>) now correctly handle NA as TRUE.

• anyNA(<denseMatrix>) had incorrectly returned anyNA(.@x) in many cases, giving false positives for some .(tr|sy)Matrix and ndenseMatrix. Now methods respect the “rules” of these classes.

• The boolean arithmetic product A %&% B and e.g., crossprod(A, B, boolArith=TRUE) now should behave as if drop0(A) and drop0(B) were used, i.e., for formally sparse matrices, the boolean product results should be stable with respect to non-structural vs structural zeros.

• t(<symmetricMatrix>) now retains the factors slot, avoiding recomputation.

• Fixed the (quite long standing) Matrix PR#6777, reported by Manuel Koller: tcrossprod(<matrix>, <[dln]sCMatrix>) has been wrong in some cases.

Memory

• qr(<big sparse>) could segfault due to integer overflow inside of cs_multiply. Now an error is signaled indicating “out of memory”. Reported by Benjamin Tyner as Matrix PR#6610.

• Valgrind warning originating in cholmod_sdmult is squashed. Reported by David Cortes as Matrix PR#6726.

New Features

• KhatriRao() gets new sparseY = TRUE option and also works for more Matrix classes.

• Virtual class packedMatrix gains methods for pack, unpack, isSymmetric, isTriangular, and isDiagonal implemented in C, replacing those defined for many subclasses individually.

• Virtual class unpackedMatrix gains methods for pack, unpack, isSymmetric, isTriangular, isDiagonal, t, diag, and diag<- implemented in C, replacing those defined for many subclasses individually.

• isTriangular and isDiagonal are now implemented in C also for [CRT]sparseMatrix and standard matrix. isSymmetric is now implemented in C for all denseMatrix and all [CRT]sparseMatrix, though these C routines are currently only called when testing for exact symmetry (always for [ln]Matrix, only when tol = 0 for dMatrix).

• Methods for isSymmetric gain an argument checkDN = TRUE indicating whether symmetry of Dimnames should be checked. For backwards compatibility and consistency with isSymmetric.matrix from base, the actual condition is checkDN && check.attributes.

• isTriangular(x, upper) now has a kind attribute if and only if x is triangular and upper is NA.

• diag(<unpackedMatrix>) <- value now behaves like diag(<packedMatrix>) <- value, supporting coercions depending on typeof(value), consistent with diag<- from base.

• pack and unpack are now identity functions for packedMatrix and unpackedMatrix arguments, respectively (previously an error). pack(<.geMatrix>) (previously an error) now behaves as pack(<matrix>), i.e., by checking for symmetry or triangularity before packing. unpack(<matrix>) now works and is equivalent to as(<matrix>, "unpackedMatrix"), with result inheriting from .(ge|tr|sy)Matrix, as appropriate.

• Many more validity methods implemented in C, for efficiency, including methods for Matrix, compMatrix, diagonalMatrix, indMatrix, pMatrix, corMatrix, [liz]Matrix, and ndenseMatrix.

• band(x, k1, k2) is optimized further for both dense and sparse x, returning triangularMatrix, symmetricMatrix, and packedMatrix in more cases.

• band() is now implemented also for diagonalMatrix (only tri[ul]() worked before).

• Coercions .ge<->.g[CRT], .t[rp]<->.t[CRT], .s[yp]<->.s[CRT], and ..[CRT]<->matrix are now fully implemented and optimized, with minimal intermediate allocations. These (and others) no longer rely on CHOLMOD, which had handled integer types as double and required preprocessing in many cases (with diagU2N(), etc.).

• Fixes in group methods (e.g., >, &, |), notably for matrices inheriting from class symmetricMatrix, triangularMatrix, lMatrix, or nMatrix.

• as.vector, as.numeric, and as.logical are now implemented for all Matrix.

• Subassignment to indMatrix is no longer prohibited, now going via TsparseMatrix.

• indMatrix gains methods for isTriangular, isDiagonal, diag, diag<-, band, tri[ul], and forceSymmetric. It also gains coercions to more virtual classes (notably denseMatrix) and a coercion to pMatrix.

• solve(<ddenseMatrix>, <numLike>) now works in all cases.

• determinant(<ds[yp]Matrix>) is now much faster in the positive definite case, no longer going via dgeMatrix.

• diag(<[CRT]sparseMatrix>) is now done in C and is highly optimized in the .[ts][CR]Matrix case.

• symmpart and skewpart are now done in C for all denseMatrix and all [CRT]sparseMatrix. Both now more faithfully preserve the “storage” of their argument. (Previously, symmpart(<packedMatrix>) was an unpackedMatrix, and (symm|skew)part(<[RT]sparseMatrix>) was a CsparseMatrix.)

• as(<vector|matrix>, "([dln]?dense|[dlnCRT]?sparse)Matrix") are now fully and more consistently implemented. In the vector case, the result is now always a length-by-1 generalMatrix. In the matrix case, structure is now always examined, hence the result is a symmetricMatrix or triangularMatrix in more cases.

• Matrix(<classed matrix>) now works for classes other than table.

• lu(<dt[rpCRT]Matrix>) and lu(<ddiMatrix>) now behave more consistently. In the diagonal, upper triangular, and unit lower triangular cases, the result is obtained “directly”, i.e., without pivoting. In the non-unit lower triangular case, it is obtained with pivoting. (Previously, pivoting was never done for dtCMatrix and always done for dt[rpRT]Matrix and ddiMatrix.)

• lu(x) now caches its return value also for all ds.Matrix x (by default).

• readMM() now warns if the number of entries found is less than number reported in the header.

• x[i] now works for nMatrix i, just as for lMatrix i. This supports constructions such as x[is.na(x)], where the logical operation produces an nMatrix because it is never NA.

Misc

• AZERO() and friends gain an argument specifying a zero constant (0 for int arrays, 0.0 for double arrays).

• C-level utilities (R_)?[gs]et_factors() have been renamed (R_)?[gs]et_factor(), as they only ever get and set one factor.

• The signature of set_factor() has been changed to match other set*() functions: to (object,name,value) from (object,value,name).

• For clarity, set_factor() now returns void and is used like other set*() functions (i.e., for its side effect). The R interface is unchanged: R_set_factor() continues to return the value being set.

• C-level utilities make_[di]_matrix_(triangular|symmetric)(), packed_to_full_(double|int)(), full_to_packed_(double|int)(), and install_diagonal(_int)?() are replaced by safer, more consistently named ones. Previous versions allowed integer overflow.

• C-level utilities dup_mMatrix_as_d?geMatrix() are replaced by the more general dense_as_general(), which takes arguments controlling memory allocation and the “kind” of the .geMatrix result.

• New C-level utility DimNames_is_symmetric() with R interface isSymmetricDN(), which should be used consistently to test for symmetry of [dD]imnames. Note that these are intended to behave consistently with symmetricMatrix_validate(), by allowing, e.g., list(NULL, nms), but not, e.g., list(A = NULL, B = nms).

• Coercions to triangularMatrix and symmetricMatrix are now almost all inherited from Matrix, whose methods simply call tri[ul]() and forceSymmetric() if isTriangular() and isSymmetric(), respectively, return TRUE.

• Many of the exported .*2* utilities have been redefined as aliases or wrappers of new, more general functions (see below). These not-yet-deprecated functions have been centralized in ‘R/denseMatrix.R’ and ‘R/sparseMatrix.R’.

• New C-level utilities R_(dense|sparse)_as_kind() for coercion from one “kind” to another; R_(dense|sparse)_as_general() for coercion from triangular and symmetric to general; R_(dense|sparse)_band() for coercion to triangular (and other banded); R_(unpacked*|packed*|sparse)_force_symmetric() for coercion to symmetric; R_(dense|sparse)_as_(sparse|dense)() for coercion between dense and sparse of the same “kind” and “structure”; R_diagonal_as_sparse() for coercion from diagonalMatrix to any [CRT]sparseMatrix; R_(dense|sparse|geMatrix)_as_(matrix|vector)() for coercion to base matrix and vector; and tCRsparse_as_RCsparse() for the idioms as(t(<[CR]sparseMatrix>), "[RC]sparseMatrix"). These all have not-yet-exported R wrappers.

• indTri() and indDiag() now in C, with a new argument packed for efficiently indexing packedMatrix. indDiag() now behaves sensibly in the n = 0 case.

• .M.kind(), .M.shape(), and (new) .M.repr() are now done in C via R_check_class_etc(), requiring a class definition only in “rare” cases.

Changes in version 1.4-1 (2022-03-21, svn r3446)

Installation

• Some warnings surfaced by -Wconversion are squashed.

Compatibility

• tryInvokeRestart is defined for R < 4.0.0. Thanks to Michael Chirico for the report.

SuiteSparse

• The patch for header ‘SuiteSparse_config/SuiteSparse_config.h’ is improved for Windows.

Classes

• New virtual class packedMatrix representing dense matrices in packed format. It extends denseMatrix and is extended by [nld](sp|tp)Matrix.

Memory

• Protection stack imbalances detected by rchk are fixed.

Bug Fixes

• diag(x) methods now mostly also keep names from dimnames(x) by default and obey names=* more generally.

New Features

• Methods for subscripting packedMatrix, including diag(), notably keeping names by default and for t() which are memory efficient, i.e., do not work via unpacking, thanks to Mikael Jagan.

• New dmperm() implementing a Dulmage-Mendelsohn decomposition, thanks to the persistency of Mauricio Vargas (@uc.cl).

• Export more low-level conversion utilities: .n2dgT, .m2ngCn, .m2ngTn.

• Provide some matrix multiplication methods for RsparseMatrix.

Misc

• Our C sources now use R_Calloc(), R_Free() etc, instead of the shorter versions without 'R_'. Consequently, we get closer to STRICT_R_HEADERS. Also, include <float.h> for DBL_EPSILON.

• Modified AZERO() to work with R_xlen_t and new AZEROs() for size_t.

Changes in version 1.4-0 (2021-12-08, svn r3419)

Compatibility

• ‘inst/test-tools-1.R’: Sys.memGB returns NA.value = 2.10201 on Windows, no longer calling memory.limit which is a stub since R version 4.2.0.

Memory

• Several low level functions are adjusted to avoid integer overflow in i+j*m or similar. Reported by Dario Strbenac on the R-devel mailing list (“dgTMatrix Segmentation Fault”, June 10, 2021).

• Leak in as(<dtCMatrix>, "denseMatrix") when the argument is unit triangular is fixed. Thanks to Bill Dunlap for the report and patch in PR#18204.

• Leak in crossprod(<dsCMatrix>) is fixed. Thanks to Bill Dunlap for the report and patch in PR#18205.

• Leaks in solve(<dgCMatrix>, <ddenseMatrix>) and lu(<dgCMatrix>) and when the argument is near-singular (or when memory is exhausted) are fixed. Thanks to Bill Dunlap for the report and patch in PR#18206.

• Leaks in [cr]bind2(x, y) when both arguments are sparse and exactly one is nonzero pattern are fixed. Thanks to Bill Dunlap for the report and patch in PR#18210.

• solve(<dsCMatrix>, ...) restarts after catching warnings signaled from dsCMatrix_*_solve so that memory is freed rather than leaked. Thanks to Bill Dunlap for the report and patch in PR#18214.

Bug Fixes

• sparse.model.matrix(.., contrasts.arg = <.. ddiMatrix ..>) now works correctly, fixing Matrix PR#6673 by Davor Josipovic.

• sparse.model.matrix(..) now also works in cases the contrast matrix has become a denseMatrix; e.g., in a case using poly(.) in the formula; now works correctly, fixing Matrix PR#6657 and useful suggestions by Nick Hanewinckel.

• Fixed the internal attr.all_Mat() auxiliary for all.equal(), notably for the case when exactly one of the matrices is a base matrix.

• Fixed long-standing bug in the rbind2() method for logical dense matrices, specifically lgeMatrix, thanks to the notice by Aaron Lun.

• band(M, k1, k2) now also works when k1 * k2 is larger than 2^31-1, the maximal integer, fixing Matrix PR#6743 by Ariel Paulson. Further, it works when M is a sparse symmetricMatrix but the band is not symmetric, k1 != -k2.

• sparseVector(i=integer(), length=2^33) now does show/print, after fixing a bug in the head() method for empty sparseVectors. Reported by David Cortes as Matrix PR#6745.

• ss <- <sparseVector>[i] gave an invalid sparseVector ss as ss@i was not necessarily sorted; thanks to a report by Quran Wu.

• as(<dsyMatrix>, "generalMatrix") and similar, sometimes did not use (C-level) symmetric_Dimnames() etc; report (to R's PR#18250 by Mikael Jagan); fixed all on C level. As a consequence, you will now see more preserved dimnames after matrix transformations or operations which involved symmetric matrices.

• as(<ddiMatrix>, "matrix") no longer loses dimnames, thanks to Mikael Jagan's report as Matrix PR#6751.

Misc

• No longer include ‘Rdefines.h’ as it is somewhat deprecated.

Changes in version 1.3-4 (2021-05-24, svn r3392)

Compatibility

• Tests are further revised for length mismatch warning in matrix(data, nrow, ncol) under R \ge 4.2.0.

Changes in version 1.3-3 (2021-05-01, svn r3390)

Installation

• Matrix \ge 1.3-3 depends on R \ge 3.5, relaxing the dependency on R \ge 3.6 introduced in Matrix version 1.3-0.

Compatibility

• Tests are revised for length mismatch warning in matrix(data, nrow, ncol) under R \ge 4.2.0.

C-Level API

• ‘inst/include/cholmod.h’ and ‘inst/include/Matrix_stubs.c’ needed adjustment after the SparseSuite update in Matrix version 1.3-0. Matrix PR#6714 reported by Kasper Kristensen, who maintains TMB.

Deprecated and Defunct

• cBind() and rBind() are now defunct: simply use cbind() and rbind() instead.

Classes

• Class unions Mnumeric and numericVectors are removed. These were unexported and unused but nonetheless visible to users, appearing as superclasses of many basic classes. Notably, a proposed change to the validity method for Mnumeric would have broken class factor, which extended Mnumeric but would not have been valid under the proposal.

Bug Fixes

• Fixed a thinko (in 1.3-2): Now direct coercion from ddiMatrix to dgCMatrix, and hence, e.g., as(Matrix(1, sparse=TRUE), "dgCMatrix") now works.

• Fixed error message in <dtrMatrix> multiplication.

• Fixed long-standing bug in R[,j] <- v when R is an RsparseMatrix, Matrix PR#6709 by David Cortes.

• as.matrix() and as.array() now work for sparseVector as expected; see Matrix PR#6708.

• M[,] (and similar) now work as in base R; Matrix PR#6720 by David Cortes.

• -S now works also when S has no factors slot. It signalled an error, e.g., for sparse triangular matrices S; Matrix PR#6656, reported by Chun Fung (Jackson) Kwok.

• M*2 and similar no longer keep cached factorizations (in 'factors' slot), but drop them via internal new .empty.factors(). Matrix PR#6606, reported by Thomas Lumley.

• removed a few duplicated .alias{.} from ‘man/*.Rd’.

Misc

• translation updates (of outlines only); finally added Italian (by Daniele Medri) to svn; updated French (by Philippe Grosjean), forgotten (R part of) Korean. New Lithuanian translations by Gabriele Stupuriene & Rimantas Zakauskas.

• In internal diagOdiag() method, no longer use matrix(x, n,n) when x is longer than n*n.

• Eliminating the need for ‘ftp://*’, add the very small jgl009 MatrixMarket example to our ‘external/’ files.

Changes in version 1.3-2 (2021-01-05, svn r3362)

Installation

• USE_FC_LEN_T is defined before ‘Rconfig.h’ is included. Under R \ge 3.6.2, the effect is that FC_LEN_T is defined when ‘R_ext/BLAS.h’ is included, and the result is that ‘R_ext/BLAS.h’ defines FCONE as a nonempty value suitable for passing character lengths from C to Fortran.

Memory

• matrix_trf protects two more objects from garbage collection, squashing two rchk warnings.

Bug Fixes

• rankMatrix() tweaks for the singular values based methods, notably method = "maybeGrad".

• as(new("dtCMatrix", diag="U"), "matrix") now works, as C-level diagU2N() now also works for 0-dimensional triangular matrices; this also fixes a subsetting (“indexing”) bug of such 0-dimensional matrices, thanks to a report by Aaron Lun.

• logical subsetting of 0-dim. (diagonal/triangular) matrices fixes.

• chol(<diagonal dt[CRT]Matrix>) now works.

Changes in version 1.3-1 (2020-12-23, svn r3352)

Bug Fixes

• rankMatrix(<dense>, method="qr.R") no longer assumes non-negative diagonal entries of the R matrix.

Changes in version 1.3-0 (2020-12-15, svn r3351)

Installation

• Matrix \ge 1.3-0 depends on R \ge 3.6.

• Macro FCONE is defined and used to pass character lengths from C to Fortran under R \ge 3.6.2 (without breaking installation under older R). Thanks to Brian Ripley.

SuiteSparse

• The internal SuiteSparse library sources are updated from version 4.2.1 to version 5.7.1. The change is visible in .SuiteSparse_version().

Significant User-Visible Changes

• Matrix(*, doDiag=TRUE) where doDiag=TRUE has always been the default is now obeyed also in the sparse case, as all diagonalMatrix are also sparseMatrix.
  
  Matrix(0, 3,3) returns a ddiMatrix instead of a dsCMatrix previously. The latter is still returned from Matrix(0, 3,3, doDiag=FALSE), and e.g., .symDiagonal(3,pi).
  
  Also a triangular matrix, e.g., dtrMatrix is detected now in cases with NAs.
  
  This is both a bug fix and an API change which breaks code that assumes Matrix(.) to return a CsparseMatrix in cases where it now returns a diagonalMatrix (which does extend sparseMatrix).

New Features

• Subassignment to diagonalMatrix now returns sparse triangularMatrix more often; also (sparse) symmetricMatrix.

• nearPD() gets new option: If base.matrix = TRUE, the resulting mat component is a base matrix, as often used desired when nearPD() is used outside the Matrix package context.

• Factored out new qr2rankMatrix() utility from rankMatrix().

• New BunchKaufman(<matrix>) method.

• Added wrld_1deg sparse matrix example to distributed version of Matrix (no longer excluding it via ‘.Rbuildignore’).

• New (simple) mat2triplet() function to be used instead of summary(<sparseMatrix>) in code.

• Internal .diag2tT() gains new option drop0 = TRUE and hence now by default drops zero diagonal entries. Consequently, e.g., as(<diagonalMatrix>, "CsparseMatrix") now drops such zeros, too.

• sparseMatrix() gets new argument repr = "C", superseding the (now deprecated) giveCsparse = TRUE. Allows to return RsparseMatrix.

  Similarly, rsparsematrix(), fac2sparse() and fac2Sparse() get the new repr argument and their giveCsparse is deprecated, sometimes only informally for now.

• sparse.model.matrix() gets option sep = "", with, e.g., sep = ":" allowing to get easier column names; from Matrix PR#6581, by Vitalie Spinu.

Memory

• The second argument in calls to cholmod_factorize_p from internal_chm_factor was a pointer to 1 double instead of a double array of length 2, resulting in buffer overflow there.

Bug Fixes

• rankMatrix(<sparse>, method="qr") now returns NA (or NaN) instead of signalling an error in the case the sparse Q R decomposition gave NAs in diag(R).

• Coercion (as(., .)) from e.g., lsyMatrix to CsparseMatrix silently made asymmetric dimnames symmetric, as did the internal forceCspSymmetric(*, dimNames) which may be called from forceSymmetric().

• Matrix PR#6659, reported by Georg Kindermann: <sparseVector>[i] <- val bug is fixed.

• Matrix PR#6666, reported by Ezra Tucker: which(<ldiMatrix>, array.ind=TRUE) thinko is fixed.

• For R-devel Dec 4, 2020: adapt all.equal() check of sparse matrix images (which contain panel functions with environments).

Changes in version 1.2-18 (2019-11-26, svn r3300)

Compatibility

• ‘inst/test-tools-1.R’: a bug-fixed canCoerce is used under R < 3.6.2.

Memory

• ddense_skewpart protects another object from garbage collection, squashing a remaining rchk warning.

Bug Fixes

• as(m, "dgTMatrix") does not lose dimnames anymore when m is a (traditional) matrix.

• M[logical(0), ] now has dimension 0 x k for sparse M as for base matrices.

• log(M, base) (the 2-argument version of log()) wrongly gave the result for base = exp(1), i.e., the 1-argument default.

• ‘test-tools-Matrix.R’: Qidentical() no longer assumes class(<matrix>) to be of length 1.

Changes in version 1.2-17 (2019-03-20, svn r3294)

Compatibility

• isFALSE is defined for R < 3.5.0.

Memory

• C functions protect more objects from garbage collection, squashing several rchk warnings.

Changes in version 1.2-16 (2019-03-04, svn r3291)

New Features

• regression tests depending on sample() now are future proof reproducible, via RNGversion(.).

• give information about #{rows} and #{columns} that are suppressed in print()ing if the matrix is larger than max.print.

Bug Fixes

• data(<Matrix-data>) no longer attaches Matrix to the search path.

• Ops group methods, i.e., Arith, Compare, Logic, now should all work with 0-extent matrices as well, thanks to bug reports by Aaron Lun, University of Cambridge.

• when printing and formatting sparse matrices, see formatSpMatrix(), the maxp option, e.g., from getOption("max.print"), is “rounded up” to 100, as very small values are very rarely appropriate.

Changes in version 1.2-15 (2018-08-20, svn r3283)

New Features

• image() gets new optional argument border.color.

Bug Fixes

• image(Matrix(0, n,m)) now works.

Changes in version 1.2-14 (2018-04-08, svn r3278)

New Features

• German translation updates.

Memory

• dgCMatrix_cholsol protects one more object from garbage collection, squashing an rchk warning.

Changes in version 1.2-13 (2018-03-25, svn r3275)

New Features

• Faster as(<matrix>, "sparseMatrix") and coercion to dgCMatrix, ngCMatrix, etc, via new direct C matrix_to_Csparse() which does not go via dgeMatrix. This also works for large matrices m, i.e., when length(m) >= .Machine$integer.max.

  Also provide low-level R functions .m2dgC(), .m2lgC(), and .m2ngC() for these.

Memory

• C functions protect more objects from garbage collection, to be “rather safe than sorry”. Thanks to Tomas Kalibera's rchk tools.

Bug Fixes

• cbind(NULL,<Matrix>) no longer return NULL; analogously for rbind(), rbind2(), cbind2(), fixing very long standing typo in the corresponsing cbind2() and rbind2() methods.

• The deprecation warning (once per session) for cBind() and rBind() finally works (fixing a simple thinko).

• cbind() and rbind() for largish sparse matrices no longer gives an error because of integer overflow (in the default case where sparse is not been specified hence is chosen by a nnzero() based heuristic).

• .symDiagonal(5, 5:1) and .trDiagonal(x = 4:1) now work as expected.

• Sp[i] now is much more efficient for large sparse matrices Sp, notably when the result is short.

• <sparseVector>[ <negative integer> ] now also gives the correct answer when the result is “empty”, i.e., all zero or false.

• large dspMatrix and dtpMatrix objects can now be constructed via new(*, Dim = *, x = *) also when length(x) is larger than 2^31 (as the C internal validation method no longer suffers from integer overflow).

Changes in version 1.2-12 (2017-11-10, svn r3239)

New Features

• crossprod(x,y) and kronecker(x,y) have become considerably more efficient for large indMatrix objects x, y, thanks to private nudging by Boris Vaillant.

Bug Fixes

• Matrix PR#6185: c < 0 now also works for derived sparse Matrices (which only contain Matrix classes); via improving hidden MatrixClass(). Part of such derived matrices only work in R \ge 3.5.0.

• using Authors@R in ‘../DESCRIPTION’ to list all contributors.

• solve(-m) no longer should use a cached Cholesky factorization (of m).

Changes in version 1.2-11 (2017-08-10, svn r3225)

Compatibility

• length(<NULL>) <- value is avoided as it is deprecated in R \ge 3.5.0.

New Features

• S4 method dispatch no longer emits ambiguity notes (by default) for everybody, apart from the package maintainer. You can reactivate them by options(Matrix.ambiguityNotes = TRUE)

Bug Fixes

• rankMatrix(<matrix of all 0>) now gives zero for all methods, as it should be.

• qr.coef(<sparseQR>, y) now finally has correct (row) names (from pivot back permutation).

• .trDiagonal() utility is now exported.

Changes in version 1.2-10 (2017-04-19, svn r3216)

Memory

• C functions protect more objects from garbage collection. Thanks to Tomas Kalibera's rchk tools.

Changes in version 1.2-9 (2017-03-08, svn r3211)

New Features

• Ops between table, xtabs, and our matrices now work.

• as(matrix(diag(3), 3, dimnames=rep(list(c("A","b","c")),2)), "diagonalMatrix")@x is no longer named.

• norm(x, "2") now works as well (and equivalently to base::norm).

• sparseVector() now also works without x argument.

• c.sparseVector() method for c() of sparseVectors (and available as regular function on purpose).

Bug Fixes

• as(Diagonal(3), "denseMatrix") no longer returns a non-dense ddiMatrix.

• S[sel,] <- value and similar no longer segfault, but give a "not (yet?) supported" error for sparse matrices S and logical sel when sel contains NAs.

  The same error (instead of a low-level one) is signalled for indexing (with NA-containing logical sel), i.e., S[sel,].

• which(x, arr.ind=TRUE, *) (when x is a lMatrix or nMatrix) now works the same as base::which, obeying an optional useNames argument which defaults to TRUE. Previously, the resulting two-column matrix typically had empty dimnames.

Changes in version 1.2-8 (2017-01-16, svn r3201)

Compatibility

• Methods for Ops handle 0-length operands more consistently, matching changes planned for R version 3.4.0.

SuiteSparse

• SuiteSparse_long is defined as int64_t on all platforms. Hence we now include C99 header ‘inttypes.h’.

• The internal CSparse library sources are patched to avoid buffer overflow in cs_usolve and cs_utsolve when U is singular.

Bug Fixes

• x[.] <- value now also works for sparseVector, both as x and as value.

• x[FALSE] <- value now also works for sparseVector.

• rep(x, *) now works for sparseVector and sparse and dense Matrix-classed matrices x.

Changes in version 1.2-7.1 (2016-08-29, svn r3187)

Installation

• _POSIX_C_SOURCE is defined conditionally with #ifdef __GLIBC__.

Changes in version 1.2-7 (2016-08-27, svn r3185)

New Features

• cBind() and rBind() have been almost silently deprecated in R \ge 3.2.0 and now give a warning, “once per session” only.

• bandSparse(*, k=k, *) now returns matrices inheriting from triangularMatrix when obvious from the diagonal indices k.

Bug Fixes

• KhatriRao(X,Y) now also works when X or Y is completely zero.

Changes in version 1.2-6 (2016-04-27, svn r3175)

Bug Fixes

• The 0-dim. Matrix multiplication fix in 1.2-5 did trigger wrong warnings in other diagonal matrix multiplications.

Changes in version 1.2-5 (2016-04-14, svn r3170)

New Features

• isSymmetric(m) now also works for indMatrix m.

• isSymmetric(m) is faster for large dense asymmetric matrices.

Bug Fixes

• Matrix multiplications (A %*% B) now work correctly when one of the matrices is diagonal and the other has a zero dimension.

Changes in version 1.2-4 (2016-02-29, svn r3162)

New Features

• sparseMatrix() gets new argument triangular and a smarter default for dims when symmetric or triangular is true.

• as(<sparse>, "denseMatrix") now works in more cases when prod(dim(.)) is larger than 2^{31} - 1. Hence, e.g., !S now works for much larger sparse matrices S.

Bug Fixes

• creating very large dense matrices, e.g., by as(<sparseM.>, "matrix") would segfault (in case it could allocate enough storage).

Changes in version 1.2-3 (2015-11-19, svn r3155)

C-Level API

• ‘inst/include/Matrix.h’ tries harder to define ‘⁠alloca⁠’ correctly for compilers that do not define __GNUC__.

New Features

• MatrixClass() is exported now.

• More exports of semi-internal functions (for speed, named .<foo>, i.e., inofficial API), such as .solve.dgC.lu().

• more Korean translations

Bug Fixes

• extended n?CMatrix classes (e.g., from setClass(., contains="ngCMatrix")) now can be coerced via as(.) to d.CMatrix.

• The printing of largish sparse matrices is improved, notably in the case where columns are suppressed, via new fitWidth = TRUE option in printSpMatrix2().

• cbind2() and rbind2() no longer fail to determine sparse when it is unspecified and hence NA, fixing Matrix PR#6259.

Changes in version 1.2-2 (2015-07-03, svn r3131)

Dependencies

• Objects are more systematically imported from “base” packages like stats. It is no longer assumed that those packages are attached.

Bug Fixes

• Our colSums(x), rowMeans(y), ..., methods now “keep names”, i.e., if the result is a numeric vector, and the matrix x has column or row names, these become the names(.) of the result, fixing Matrix PR#6018.

Changes in version 1.2-1 (2015-05-30, svn r3127)

New Features

• Matrix now has an initialization() method coercing 0-length dimnames components to NULL and other non-NULL dimnames to character. Before, e.g., numeric dimnames components partially worked, even though it has always been documented that non-NULL dimnames should be character.

• as.vector(<sparseVector>) etc, now work, too.

• lu(<sparseMatrix>) now keeps dimnames.

• better ‘NEWS.Rd’ (which pleases Kurt and tidy;-)

Memory

• Using alloca to perform large allocations could overflow the stack, leading in some cases to a segfault. Now alloca is used only for small allocations. Thanks to a report on the R-help mailing list (“does segfault mean (always) a bug?”, May 5, 2015).

Bug Fixes

• S[] <- T and S[] <- spV now work (in more cases) for sparse matrices S, T and sparseVector spV.

• Optional arguments in image(), e.g., main=<..>) now also work for lgCMatrix, nMatrix etc; thanks to a 4.5 years old report by Mstislav Elagin.

• dimnames(A) <- val now resets the factors slot to empty, as the factorizations now keep dimnames more often.

• crossprod(<matrix>, Diagonal(<n>)) works again (and these are tested more systematically).

• Matrix products (%*%, crossprod, and tcrossprod) for dtrMatrix are correct in all cases, including keeping dimnames.

• Matrix(d) (and other coercions to Matrix) now correctly keeps dimnames also when d is a traditional diagonal matrix.

Changes in version 1.2-0 (2015-04-03, svn r3096)

Generic Functions

• New generic function %&% for boolean matrix multiplication: that is, matrix multiplication using boolean arithmetic.

New Features

• New argument boolArith = NA in crossprod() and tcrossprod(). boolArith = TRUE now forces boolean arithmetic, where boolArith = FALSE forces numeric one. Several of these products are more efficient thanks to new C functionality based on our new chm_transpose_dense(), and others based on geMatrix_crossprod, geMatrix_matrix_mm, etc.

• Most dense matrix products, also for non-dgeMatrix, including l..Matrix and n..Matrix ones are now directly handled by new .Call()s.

• dMatrix (numeric) and lMatrix (logical) matrices can now be coerced to nMatrix (non-zero pattern or “boolean”) even when they contain NAs, which then become TRUEs.

• More thorough checking of cbind2() and rbind2() methods, notably as they are called from cbind() and rbind() from R \ge 3.2.0.

  rbind2(<dense>, <dense>) is faster, being based on new C code.

• symmetric Matrices (i.e., inheriting from symmetricMatrix) are allowed to have dimnames of the form list(NULL, <names>) and now print correctly and get correctly coerced to general matrices.

• indMatrix object (“index matrices”) no longer need to be “skinny”.

• rsparseMatrix() now accepts rand.x = NULL and then creates a random pattern matrix (nsparseMatrix).

• anyDuplicatedT() and uniqTsparse() low level utilities are exported now.

• Partial Korean translations of messages.

Deprecated and Defunct

• For R \ge 3.2.0, cBind() and rBind() are deprecated, as they are no longer needed since cbind() and rbind() do work automatically.

Bug Fixes

• Fix some rbind2() methods.

• t() now transposes the dimnames even for symmetric matrices.

• diag(M) <- val did not always recycle val to full length, e.g., when M was a dtrMatrix.

• crossprod(<indMatrix>) was wrong in cases where the matrix had all-zero columns.

• Matrix products (%*%, crossprod, and tcrossprod) with one sparse and one dense argument now return numeric (a dMatrix) when they should, i.e., unless the new setting boolArith = TRUE is applied.

Changes in version 1.1-5 (2015-01-18, svn r3037)

Compatibility

• Methods for matrix multiplication (%*%, crossprod, tcrossprod) are revised to match the behaviour of R \ge 3.2.0, which better tolerates matrix-vector products.

New Features

• More use of anyNA() (for speedup).

• isTriangular() gets new optional argument upper = NA.

Bug Fixes

• crossprod() and tcrossprod() fixes for several <diagonal> o <sparse> combinations.

• rowMeans(<dgeMatrix>, na.rm=TRUE) was wrong sometimes.

• fix and speedup of coercions (as(., .)) from and to symmetric or triangular matrices.

• invPerm() coercion to integer

• dimnames( solve(.,.) ) fix [r3036]

• tril() and triu() now return correct uplo.

• names(dimnames(.)) now preserved, e.g. in symmpart() or subsetting (A[i,j]).

Changes in version 1.1-4 (2014-06-14, svn r2994)

New Features

• new rsparsematrix() for random sparse Matrices.

• improved warnings, notably for unused arguments previously swallowed into ....

Bug Fixes

• crossprod(<vec>, <dsyMatrix>) fixed.

• crossprod() and kronecker() fixes for some <indMatrix> cases.

Changes in version 1.1-3 (2014-03-30, svn r2982)

New Features

• %*% and crossprod() now also work with sparseVectors.

• speedup of crossprod(v, <sparseM>), thanks to nudge by Niels Richard Hansen.

• new help page for all such matrix products (‘../man/matrix-products.Rd’).

Bug Fixes

• image() now gets correct ylim again.

• More consistent matrix products.

Changes in version 1.1-2-2 (2014-03-04, svn r2966)

Bug Fixes

• correct adaption to R 3.1.0

• using tolerance (and not ‘tol’) in all.equal()

Changes in version 1.1-2 (2014-01-28, svn r2962)

New Features

• export fast power-user coercion utilities .dsy2mat(), .dxC2mat(), .T2Cmat(), ..2dge().

Bug Fixes

• matrix products now (mostly) work with sparseVectors; and correctly in some more cases.

Changes in version 1.1-1.1 (2013-12-30, svn r2957)

Installation

• Matrix \ge 1.1-1.1 depends on R \ge 2.15.2 to ease checking.

Compatibility

• ‘inst/test-tools-1.R’: assertCondition is defined for R < 3.0.2 and used by assertWarning there.

Changes in version 1.1-1 (2013-12-28, svn r2933)

New Features

• image(.., xlim, ylim): nicer defaults for the axis limits, and ylim is sorted decreasingly; not strictly back-compatible but should never harm.

• rankMatrix(*, method="qr") now using tol

• T2graph() and graph2T() export old functionality explicitly. Tweaks in conversions between graph and sparseMatrix objects. Notably, as(<graph>, <Matrix>) now more often returns a (0/1 pattern) n..Matrix.

• sparseMatrix(): new use.last.ij argument.

Bug Fixes

• KhatriRao(): fix rownames (X <-> Y)

• qr.coef(), qr.fitted, and qr.resid now also work with sparse RHS y.

• sparse matrix “sub assignments”, e.g., M[ii] <- v, speedup and fixes.

• bug fixes also in M[negative indices] <- value and <sparseMatrix>[cbind(i,j)].

Changes in version 1.1-0 (2013-10-21, svn r2930)

Dependencies

• methods, stats, utils, and lattice are moved from Depends to Imports.

SuiteSparse

• The internal SuiteSparse library sources are updated to the latest version. Use new function .SuiteSparse_version to get the version in use.

C-Level API

• ‘inst/include/cholmod.h’ is updated to reflect changes in SuiteSparse. Notably, there were changes in the layout of the various cholmod_*_struct.

New Features

• fac2sparse and fac2Sparse now exported, with a new giveCsparse option.

Bug Fixes

• fixed long lasting undetected solve(<dsCMatrix>, *) bug.

• Our all.equal() methods no longer sometimes return c("TRUE", "....difference..").

• rankMatrix(<matrix>): fix the internal x.dense definition.

Changes in version 1.0-14 (2013-09-12, svn r2907)

Bug Fixes

• Revert some wrong changes to solve(<sparse>, *) from 1.0-13 (“stop gap fix” for R 3.0.2).

Changes in version 1.0-13 (2013-09-10, svn r2904)

Classes

• New nonvirtual class indMatrix representing row index matrices, i.e., matrices whose rows are standard unit vectors. It extends sparseMatrix and is extended by pMatrix, the class of permutation matrices.

Generic Functions

• New generic functions isTriangular and isDiagonal for testing if the argument is (upper or lower) triangular or diagonal. These were defined previously but never exported or documented.

New Features

• Many methods for pMatrix are generalized to support indMatrix. All (initial) functionality was contributed by Fabian Scheibl, Univ. Munich.

• New (efficient) KhatriRao() function by Michael Cysouw

• rankMatrix(M, method="qr") no longer needs sval which makes it considerably more useful for large sparse M.

• Start providing anyNA methods for R \ge 3.1.0.

• solve(<sparse> a, <sparse> b): if a is symmetric, now compute sparse result.

• nearPD() gets new option conv.norm.type = "I".

• determinant(<dpoMatrix>) now uses chol(), and hence also an existing (‘cached’) Cholesky factor.

• 3 new C -> R utilities (including hidden R function .set.factors() for caching also from R, not just in C).

Bug Fixes

• M[] <- v for unitriangular M now correct.

• lu(.) no longer sometimes returns unsorted columns.

Changes in version 1.0-12 (2013-03-26, svn r2872)

New Features

• .

Bug Fixes

• .

Changes in version 1.0-11 (2013-02-02)

New Features

• .

Bug Fixes

• as(<csr>, "dgCMatrix") (from package SparseM) now works again.

• .

Changes in version 1.0-10 (2012-10-22)

New Features

• .sparseDiagonal(): new unitri argument, and more flexibility;

• new solve(<dsCMatrix>, <missing>) via efficient C code.

Bug Fixes

• .

Changes in version 1.0-9 (2012-09-05)

New Features

• new sparseVector() constructor function.

• is.finite() is.infinite() now work for our matrices and sparseVector objects.

• diag(.) <- V now preserves symmetricity, triangularity and even uni-triangularity sometimes.

Bug Fixes

• Quite a few fixes for Ops (arithmetic, logic, etc) group methods.

• Ditto for diagonalMatrix methods.

Changes in version 1.0-6 (2012-03-16)

New Features

• .

Bug Fixes

• .

Changes in version 1.0-5 (2012-03-15)

New Features

• .

Bug Fixes

• .

Changes in version 1.0-4 (2012-02-21)

New Features

• .

Bug Fixes

• .

Changes in version 1.0-3 (2012-01-13)

New Features

• .

Bug Fixes

• .

Changes in version 1.0-2 (2011-11-19)

New Features

• .

Bug Fixes

• .

Changes in version 1.0-1 (2011-10-18)

New Features

• .

Bug Fixes

• .

Changes in version 1.0-0 (2011-10-04)

New Features

• .

Bug Fixes

• .

Changes in version 0.9996875-3 (2011-08-13)

New Features

• .

Bug Fixes

• .

Changes in version 0.9996875-2 (2011-08-09)

New Features

• .

Bug Fixes

• .

Changes in version 0.9996875-1 (2011-08-08)

New Features

• .

Bug Fixes

• .

Changes in version 0.999375-50 (2011-04-08)

New Features

• .

Bug Fixes

• .

Changes in version 0.95-1 (2005-02-18, svn r561)

Authorship

• During Douglas Bates' sabbatical in Zurich, Martin Maechler becomes co-author of Matrix.

New Features

• Beginning of class reorganization with a more systematic naming scheme.

Bug Fixes

• More (correct) coercions as(<from>, <to>).

Changes in version 0.9-1 (2005-01-24, svn r451)

New Features

• lme4 / lmer specific R code moved out to lme4 package.

Bug Fixes

• .

Changes in version 0.8-2 (2004-04-05, svn r51)

Description

• Matrix version 0.8-2 is a full refactor. Classes, generic functions, and methods are newly implemented in S4. S3 machinery is removed. The remaining items in this section describe the state of things in version 0.8-2 rather than changes since version 0.3-26.

• Matrix \ge 0.8-2 depends on R \ge 1.9.0.

• Depends: methods is added to ‘DESCRIPTION’.

• Douglas Bates becomes the sole author of Matrix.

• The package is retitled “Classes and Methods for Numerical Linear Algebra using LAPACK, LDL, TAUCS, METIS, and UMFPACK”.

• The package sources are now maintained in a Subversion repository.

Changes in version 0.3-26 (2003-11-03)

Bug Fixes

• The default expressions of formal arguments transpose and left of generic function facmul are changed from F and T to FALSE and TRUE, as only the latter are reserved words.

Changes in version 0.3-25 (2003-10-30)

Deprecated and Defunct

• S3 generic function determinant is removed as it was ported to R \ge 1.8.0.

Significant User-Visible Changes

• A namespace for Matrix is defined using directives in ‘NAMESPACE’.

• S3 generic functions eigen, expand, facmul, lu, norm, rcond, schur, and unpack are exported.

• S3 methods are registered and not exported, hence they continue to be available but only through calls to exported S3 generic functions.

• Functions Matrix, SVD, as.Matrix, diagDet, and hilbert are exported.

• Functions Matrix.class, *.test, and is.* are exported but intended only for internal use.

• Functions asObject and prependClass are not exported.

• Load hook .First.lib is removed and replaced by a useDynLib directive in ‘NAMESPACE’.

Changes in version 0.3-24 (2003-04-20)

Significant User-Visible Changes

• S3 generic function det is renamed determinant.

Methods

• determinant.Matrix (formerly det.Matrix) computes the LU factorization of its argument instead of the QR factorization.

Changes in version 0.3-23 (2003-03-30)

Description

• Matrix \ge 0.3-23 depends on R \ge 1.7.0.

Installation

• ‘configure’, ‘configure.in’, ‘configure.win’, ‘cleanup’, ‘src/Makevars.in’, and ‘src/Makevars.win’ are removed and replaced by a simple ‘src/Makevars’ arranging for Matrix to use R's LAPACK_LIBS and BLAS_LIBS. The simplification is made possible by R version 1.7-0, which is configured by default to build, link against, and install a shared LAPACK.

Changes in version 0.3-22 (2003-02-03)

Bug Fixes

• Empty directory ‘data’ is removed.

Changes in version 0.3-21 (2002-10-25)

Description

• The package is retitled “Classes and Methods for Numerical Linear Algebra using LAPACK”.

Installation

• ‘configure.win’ and ‘src/Makevars.win’ are added to support installation under Windows, thanks to Brian Ripley.

• More #undef in the C++ sources to support installation under Windows, thanks to Brian Ripley.

Changes in version 0.3-20 (2002-10-08)

Installation

• ‘configure.ac’ sets CFLAGS before expanding AC_PROG_CC and sets FLIBS before expanding ACX_BLAS and ACX_LAPACK.

• Autoconf macro OCTAVE_BLAS_LIBS, which is no longer used, is removed from ‘aclocal.m4’.

Bug Fixes

• Unwanted Autoconf output is removed from ‘aclocal.m4’.

Changes in version 0.3-19 (2002-07-22)

Bug Fixes

• PACKAGE = "Matrix" is passed to .Call to restrict name lookup to Matrix.

• The C++ sources use qualified name lookup (as in std::<name>) in more places.

• The C++ sources get pointers to matrix data without taking the address of the first element, which is wrong for a matrix of length 0.

Changes in version 0.3-18 (2002-05-03)

Compatibility

• *_ELT macros are no longer defined for R < 1.2.0 as Matrix depends on R \ge 1.5.0.

Changes in version 0.3-17 (2002-04-30)

Description

• Matrix \ge 0.3-17 depends on R \ge 1.5.0.

Installation

• ‘configure.in’ is replaced by ‘configure.ac’ contributed by Kurt Hornik. ‘configure.ac’ makes use of R CMD config, a utility added in R version 1.5-0.

• Autoconf macros ACX_BLAS and ACX_LAPACK, written by Steven G. Johnson, are added to ‘aclocal.m4’ and expanded in ‘configure.ac’.

• The configured value of LAPACK_LIBS is prepended to PKG_LIBS in ‘src/Makevars.in’.

Changes in version 0.3-16 (2001-12-10)

Documentation

• A preliminary ‘ChangeLog’.

Compatibility

• Rd files are adapted to use \method{}{} markup introduced in R version 1.2.2.

• One usage of .Alias, deprecated in R version 1.4.1, is removed.

Bug Fixes

• S3 methods gain formal argument ... where needed to match the generic function.

• The name of a class member function in ‘src/tgmd.h’ was was spuriously qualified.

Changes in version 0.3-15 (2001-05-15)

Installation

• The configured value of BLAS_LIBS is prepended to PKG_LIBS in ‘src/Makevars.in’.

Changes in version 0.3-13 (2001-05-10)

Installation

• The C++ sources undefine macros length and append in many places to allow for class member functions with those names.

Changes in version 0.3-10 (2001-05-04)

Bug Fixes

• The C++ sources use qualified name lookup (as in std::<name>) in more places.

Changes in version 0.3-9 (2001-03-09)

Bug Fixes

• The C++ sources no longer write to stderr and (in most places) stdout, no longer use the assert macro, and no longer call exit.

Changes in version 0.3-8 (2001-01-10)

Description

• ‘DESCRIPTION’ gets a Maintainer field and Douglas Bates is named there.

Bug Fixes

• Removes around 100 non-source files wrongly bundled in Matrix version 0.3-7.

Changes in version 0.3-7 (2000-12-03)

Installation

• FLIBS is appended to PKG_LIBS in ‘src/Makevars.in’.

Documentation

• A basic ‘README’.

Changes in version 0.3-6 (2000-10-30)

Description

• Matrix \ge 0.3-6 depends on R \ge 1.1.1.

Installation

• ‘configure’ makes use of HAVE_F77_UNDERSCORE in ‘Rconfig.h’.

• PKG_LIBS and PKG_LDFLAGS to the configured values of LIBS and LDFLAGS in ‘src/Makevars.in’.

Changes in version 0.3-5 (2000-08-20)

Deprecated and Defunct

• eigen.Matrix argument schur, which was unused, is removed.

Methods

• An S3 method schur.Matrix interfacing LAPACK routine dgeesx. It returns list(values, schur, vectors).

• For arguments not inheriting from Matrix subclass Hermitian, eigen.Matrix is now an interface to LAPACK routine dgeevx, and its optional arguments balance and rcond, which were unused, can now be used to request balancing and the reciprocal condition numbers of the eigenvalues and right eigenvectors. The return value is now list(values, vectors, rcond) with vectors = list(left, right) and rcond = list(values, vectors).

Changes in version 0.3-3 (2000-08-11)

Installation

• ‘configure’ skips the check for BLAS in the Sun Performance Library if the C compiler is gcc.

Compatibility

• STRING_ELT, SET_STRING_ELT, VECTOR_ELT, and SET_VECTOR_ELT are used in place of STRING and VECTOR. *_ELT macros are defined for R < 1.2.0 to not break compatibility.

Significant User-Visible Changes

• SVD(x, nu = 0, nv)$u and SVD(x, nu, nv = 0)$vt are NULL rather than empty matrices.

Methods

• An S3 method lu.Matrix interfacing LAPACK routine dgetrf. It returns list(l, u, permutation), with attribute norms = list(one, infinity) containing the one and infinity norms. An optional argument is provided to disable computation of one and infinity.

Bug Fixes

• SVD(x, nu, nv) allocated for the right singular values a matrix with dimensions c(ncol(x), nv) instead of c(nv, ncol(x)). Buffer overflow could occur in LAPACK routine dgesvd if nv < ncol(x).

Changes in version 0.3-1 (2000-07-24)

Generic Functions

• S3 generic function eigen.

Methods

• An S3 method eigen.Matrix interfacing LAPACK routines dgeev and dsyev, the latter only for arguments inheriting from Matrix subclass Hermitian. It returns list(values, vectors), where vectors is list(left, right) for non-Hermitian arguments and a numeric matrix for Hermitian arguments. An optional argument is provided to disable computation of vectors.

• S3 methods det.Matrix, det.UpperTriangular, det.UnitUpperTriangular, det.LowerTriangular, and det.UnitLowerTriangular computing the modulus of the determinant or its logarithm. These return list(modulus, sign). Component modulus has a logical attribute logarithm indicating if the determinant is sign * exp(modulus) or sign * modulus. det.Matrix computes the QR factorization of its argument using LAPACK routine dgeqrf.

Bug Fixes

• Matrix.class(x) could be incomplete or contain bad elements for orthogonal x.

New Features

• A function as.Matrix for coercing an object to class Matrix, parallel to as.matrix. The return value inherits from subclasses of Matrix if tests for structure are satisfied.

• Functions asObject and prependClass for setting and prepending to the class attribute of the argument.

• A function diagDet for computing the determinant of a triangular matrix given the diagonal entries.

Changes in version 0.2-4 (2000-07-18)

Installation

• A ‘configure’ script detecting options for linking BLAS and LAPACK. It is generated from ‘configure.in’ which makes use of an Autoconf macro OCTAVE_BLAS_LIBS defined in ‘aclocal.m4’.

• ‘src/Makevars’ is now generated from ‘src/Makevars.in’.

• A ‘cleanup’ script removing generated files.

Documentation

• A Texinfo manual ‘R-Matrix.texi’ containing implementation details and describing how LAPACK++ was modified for Matrix.

Methods

• An S3 method rcond.Matrix interfacing LAPACK routines d*con.

Bug Fixes

• Exceptions thrown by LAPACK++ are caught and handled as R errors.

• UpperTriangular.test and LowerTriangular.test returned a maximum rather than a maximum modulus for real arguments.

Changes in version 0.2-1 (2000-07-15)

Description

• Matrix version 0.2-1 is the first one to be distributed by CRAN.

• The package is titled “A Matrix Library for R”.

• Douglas Bates is the maintainer and principal author. Saikat DebRoy is a co-author.

• Matrix \ge 0.2-1 depends on R \ge 1.1.0.

Installation

• A modified LAPACK++ (Linear Algebra PACKage in C++, version 1.1a) is compiled alongside the Matrix sources. LAPACK++ is a C++ interface to LAPACK originally developed by Roldan Pozo.

Classes

• S3 class Matrix with subclasses Hermitian, UpperTriangular (recursively, UnitUpperTriangular), and LowerTriangular (recursively, UnitLowerTriangular). Objects are traditional numeric matrices with a class attribute indicating their structural properties. Objects are interfaced in C++ using the parallel class hierarchy defined by LAPACK++.

Generic Functions

• S3 generic functions det, expand, facmul, lu, norm, rcond, schur, and unpack.

Methods

• An S3 method norm.Matrix interfacing LAPACK routines dlan*.

• An S3 method solve.Matrix interfacing LAPACK routines d*trf and d*trs.

• An S3 method as.matrix.Matrix just dropping the class attribute.

• An S3 method print.Matrix just printing the as.matrix result.

New Features

• A function Matrix constructing objects of class Matrix from numeric vectors and matrices, parallel to base function matrix.

• A function Matrix.class returning a character vector containing the subclasses of Matrix that would be valid for the argument.

• Functions Hermitian.test, UpperTriangular.test, LowerTriangular.test, Orthogonal.test, and Orthonormal.test returning a maximum modulus distance useful for testing the respective property.

• Functions is.Hermitian, is.UpperTriangular, is.LowerTriangular, and is.Orthonormal testing if the *.test value does not exceed a tolerance.

• Function SVD interfacing LAPACK routine dgesvd. SVD(x, nu, nv) returns list(d, u, vt) containing the singular values (sorted non-increasingly), first nu left singular vectors (stored column-wise), and first nv right singular vectors (stored row-wise).

• Function hilbert constructing the n-by-n Hilbert matrix.