Changes in version 1.8-0                        

Installation

    o   Matrix >= 1.8-0 depends on R >= 4.5.

    o   Compilation uses preprocessor options -DSTRICT_R_HEADERS,
	-DR_NO_REMAP, and -DR_NO_REMAP_RMATH.

    o   Warnings surfaced by -Wconversion (but not those originating in
	SuiteSparse) are squashed.

Deprecated and Defunct

    o   Coercions to dpoMatrix or dppMatrix are deprecated.  Coerce to
	new virtual class posdefMatrix instead.

Significant User-Visible Changes

    o   Methods for cov2cor coerce the (symmetrized) argument to new
	virtual class posdefMatrix before scaling.  Hence an error is
	signaled where the (symmetrized) argument is not positive
	definite.  Use dimScale (introduced in Matrix 1.5-2) for more
	general scaling.

    o   <Matrix> + <0-length-vector> and other such zero-extent
	arithmetic (Arith) or more general binary operations (Ops) now
	behave base R compatibly in returning a zero-length vector or
	matrix, respectively.

    o   Similarly, <Matrix> o <Matrix> operations now also error when
	the matrix dimensions do not match exactly, as it has been in R
	for several years.  Previously, only nrow(.) needed to match
	for the two matrices.

    o   Methods for %*%, crossprod, and tcrossprod with signature
	c(x="ANY", y="Matrix") or c(x="ANY", y="sparseVector") return
	the value of a call to the next method if x has a class
	attribute, ceding priority to methods available for that class,
	including S3 methods and the internal default method.

Classes

    o   New virtual class posdefMatrix representing positive
	_semi_definite matrices.  It extends virtual class
	symmetricMatrix and is extended by nonvirtual classes
	[dz]p[CRTop]Matrix, of which dp[CRT]Matrix and zp[CRTop]Matrix
	are new.  posdefMatrix are typically obtained as the result of
	crossprod(x) or tcrossprod(x) for Matrix x.  Coercions to
	posdefMatrix attempt Cholesky factorization, which can fail for
	near-singular positive semidefinite matrices.

    o   New virtual classes idenseMatrix and isparseMatrix representing
	dense and sparse integer matrices.  They extend iMatrix (which
	existed “forever” without an implementation) and are extended
	by new nonvirtual classes i(ge|sy|sp|tr|tp|[gst][CRT])Matrix.

    o   New nonvirtual class idiMatrix extending diagonalMatrix and
	iMatrix, for diagonal integer matrices.

    o   New virtual classes zdenseMatrix and zsparseMatrix representing
	dense and sparse complex matrices.  They extend zMatrix (which
	existed “forever” without an implementation) and are extended
	by new nonvirtual classes z(ge|sy|sp|tr|tp|[gst][CRT])Matrix.
	zs[CRTyp]Matrix have a trans slot with value "C" or "T", used
	to distinguish between complex Hermitian and complex symmetric
	matrices.  They are extended by zp[CRTop]Matrix, which
	represent complex positive semidefinite matrices (and so are
	contrained to have trans="C")

    o   New nonvirtual class zdiMatrix extending diagonalMatrix and
	zMatrix, for diagonal complex matrices.

Generic Functions

    o   New generic function ct for the conjugate transpose.  ct(x) is
	equivalent to t(x) except for complex x, for which it is
	intended to be at least as efficient as Conj(t(x)).

    o   The formal argument list of generic function forceSymmetric is
	changed from (x, uplo) to (x, ...), allowing methods to accept
	further arguments.  The generic function now dispatches only on
	x.

    o   The formal argument list of generic function nnzero is changed
	from (x, na.counted) to (x, ...), allowing methods to accept
	further arguments.

    o   The formal argument lists of generic functions symmpart,
	skewpart, isDiagonal, and isTriangular gain ..., allowing
	methods to accept further arguments.

New Features

    o   Methods for generic functions isSymmetric, forceSymmetric,
	symmpart, and skewpart gain argument trans to support Hermitian
	and symmetric modes for complex matrices.

    o   Methods for generic function symmpart gain argument uplo for
	control over the uplo slot of the result of
	symmpart(<generalMatrix>).

    o   sort(x, ...) works for x inheriting from virtual class Matrix
	or virtual class sparseVector.  It is possible now that sort is
	an implicit generic function in package methods.

    o   A method is defined for kappa(z, ...) for z inheriting from
	virtual class Matrix.  It computes the reciprocal of rcond(z,
	...) and thus supports all of the optional arguments of methods
	for rcond.  Hence, in Matrix (unlike in base), kappa and rcond
	have “consistent” interfaces.

    o   Methods for rcond gain arguments exact, inverse, and warn
	providing more precise control over behaviour and an interface
	more similar to the default method for kappa in base.

    o   All methods for rcond support the 2-norm.

    o   Methods for Cholesky(A=<sparseMatrix>, ...) gain a logical
	argument force, indicating which of forceSymmetric(A) and
	tcrossprod(A) is factorized when A is not formally symmetric.

    o   Methods for expm(x=<denseMatrix>) are revised to diagonalize
	Hermitian x and to employ Higham's (2005) implementation of the
	scaling and squaring algorithm for non-Hermitian x.  The result
	for Hermitian x is now formally positive definite.

    o   Methods for crossprod and tcrossprod gain argument trans with
	valid values "C" and "T" indicating conjugate transpose and
	transpose, respectively.  For backwards compatibility, the
	default value is "T", whereas methods for isSymmetric and other
	generic functions use "C" by default.

    o   Method for toeplitz(x=<sparseVector>) gain argument r enabling
	construction of asymmetric Toeplitz matrices, following the
	function in base.

    o   isDiagonal() now also works for table(X, Y) tables.

    o   diagN2U(<diagonalMatrix>) now works, too.

    o   Internal replTmat() keeps triangulartiy now.

Bug Fixes

    o   Methods for isSymmetric(<[dz]Matrix>) consistently pass countEQ
	= FALSE, check.attributes = FALSE, and check.class = FALSE to
	all.equal.numeric.  Methods for isSymmetric(<[dz]sparseMatrix>)
	consistently require a symmetric nonzero pattern.

    o   diag(<ndenseMatrix>) replaces NA with TRUE.

    o   If the exact result of prod(dim(x)) is not representable in
	double precision, then the result of length(x) is truncated
	towards zero and gets an attribute off such that the exact
	result of length(x) + off is the exact result of prod(dim(x)).

    o   The meaning of option checkDense in diagU2N(), diagN2U(),
	.diagU2N() and .diagN2U() has been swapped back such that
	checking for "denseMatrix" again only happens when the option
	is true.  The defaults have been swapped to TRUE for diagU2N()
	and diagN2U() whereas the default checkDense = FALSE remains
	for the faster low-level versions .diagU2N() and .diagN2U().

    o   The method for initialize with signature .Object="sparseVector"
	behaved wrongly when the lengths of arguments i and x were not
	equal.

    o   updown(., C, L) treated formally symmetric C as triangular when
	L was unpivoted.

Misc

    o   C code uses new (since R 4.4.0) OBJSXP in place of deprecated
	S4SXP and TYPEOF(.) == OBJSXP in place of (not specific enough)
	isS4(.).

    o   C code is simplified using definitions in new header M5.h for
	templated dispatch on object “kind” [nlidz].

    o   test-tools-1.R: update relErrV(), and use it and relErr()
	unconditionally to improve strict reproducibility.

                 Changes in version 1.7-5 (2026-03-21)                  

Misc

    o   Non-API entry point Rf_findVarInFrame is no longer used.

                 Changes in version 1.7-4 (2025-08-28)                  

Installation

    o   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

    o   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-11)                  

Bug Fixes

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

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

    o   Use int instead of Rboolean in 2x2 cases in utils-R.c.

                 Changes in version 1.7-2 (2025-01-23)                  

Installation

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

Misc

    o   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-18)                  

Installation

    o   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

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

C-Level API

    o   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

    o   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-04-26)                  

Installation

    o   Matrix >= 1.7-0 depends on R >= 4.4.

Linking

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

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

SuiteSparse

    o   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.

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

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

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

Significant User-Visible Changes

    o   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

    o   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
	>= 1.7-0 remain valid, retaining a harmless factors
	_attribute_.

    o   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.

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

Bug Fixes

    o   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-11)                  

C-Level API

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

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

Bug Fixes

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

    o   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.

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

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

Misc

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

                 Changes in version 1.6-4 (2023-11-30)                  

Installation

    o   Warnings surfaced by -Wformat are squashed.

C-Level API

    o   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

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

                 Changes in version 1.6-3 (2023-11-14)                  

Misc

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

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

                 Changes in version 1.6-2 (2023-11-07)                  

Compatibility

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

Linking

    o   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.

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

C-Level API

    o   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>.

    o   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.

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

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

    o   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

    o   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

    o   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.)

    o   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.

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

    o   Certain never or seldom used class unions are removed.

New Features

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

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

    o   .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.

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

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

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

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

    o   New export aggregateT, for aggregating TsparseMatrix _without_
	sorting.

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

    o   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

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

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

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

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

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

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

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

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

    o   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.

    o   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").

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

    o   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.

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

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

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

    o   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.

    o   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).

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

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

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

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

Misc

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

    o   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].

    o   All matrix product code has been migrated to products.[Rch].

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

    o   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-18)                 

Misc

    o   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-14)                  

C-Level API

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

Memory

    o   Four Valgrind-detected memory bugs are fixed.

Classes

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

New Features

    o   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.

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

    o   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

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

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

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

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

    o   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

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

    o   Most coercion code has been migrated to coerce.[Rch] from
	elsewhere.

    o   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.

    o   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-07-08)                  

Dependencies

    o   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.

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

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

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

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

Significant User-Visible Changes

    o   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

    o   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.

    o   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.

    o   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.

    o   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.

    o   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.

    o   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.

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

    o   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.

    o   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.

    o   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.

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

    o   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

    o   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

    o   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.

    o   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.

    o   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.

    o   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.

    o   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.

    o   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").

    o   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.

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

    o   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.

    o   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

    o   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.

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

    o   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.

    o   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.

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

    o   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.

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

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

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

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

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

    o   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.

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

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

    o   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.

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

    o   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.

    o   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

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

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

Misc

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

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

    o   Updates to po/*.{po,pot} and inst/po/* for translators.

                Changes in version 1.5-4.1 (2023-05-18)                 

Installation

    o   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-04)                  

Compatibility

    o   sequence.default is defined for R < 4.0.0.

C-Level API

    o   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

    o   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.

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

Memory

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

Misc

    o   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.

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

                 Changes in version 1.5-3 (2022-11-11)                  

Dependencies

    o   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

    o   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

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

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

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

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

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

    o   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.

    o   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

    o   Diagonal() gets a new optional names argument.

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

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

    o   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).

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

Misc

    o   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                        

Classes

    o   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.

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

    o   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

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

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

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

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

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

    o   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<-`.

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

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

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

    o   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.

    o   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.

    o   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

    o   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

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

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

    o   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.)

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

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

    o   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-13)                  

Memory

    o   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-10)                  

Deprecated and Defunct

    o   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

    o   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.

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

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

Bug Fixes

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

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

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

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

    o   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.

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

    o   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.

    o   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.

    o   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.

    o   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.

    o   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.

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

    o   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.

    o   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.

    o   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.

    o   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.)

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

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

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

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

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

    o   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.

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

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

    o   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.

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

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

    o   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).

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

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

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

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

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

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

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

    o   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>).

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

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

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

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

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

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

    o   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.

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

    o   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.

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

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

    o   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.)

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

    o   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.

    o   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.

    o   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().

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

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

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

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

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

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

    o   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.

    o   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.

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

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

Memory

    o   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.

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

New Features

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

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

    o   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.

    o   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).

    o   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.

    o   isTriangular(x, upper) now has a kind attribute _if and only
	if_ x is triangular and upper is NA.

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

    o   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.

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

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

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

    o   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.).

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

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

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

    o   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.

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

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

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

    o   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.)

    o   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.

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

    o   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.)

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

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

    o   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

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

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

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

    o   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.

    o   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.

    o   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.

    o   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).

    o   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.

    o   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.

    o   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.

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

    o   .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-23)                  

Installation

    o   Some warnings surfaced by -Wconversion are squashed.

Compatibility

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

SuiteSparse

    o   The patch for header SuiteSparse_config/SuiteSparse_config.h is
	improved for Windows.

Classes

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

Memory

    o   Protection stack imbalances detected by rchk are fixed.

Bug Fixes

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

New Features

    o   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.

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

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

    o   Provide some matrix multiplication methods for RsparseMatrix.

Misc

    o   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.

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

                 Changes in version 1.4-0 (2021-12-08)                  

Compatibility

    o   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

    o   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).

    o   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.

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

    o   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.

    o   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.

    o   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

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

    o   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.

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

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

    o   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.

    o   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.

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

    o   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.

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

Misc

    o   No longer include Rdefines.h as it is somewhat deprecated.

                 Changes in version 1.3-4 (2021-06-01)                  

Compatibility

    o   Tests are further revised for length mismatch warning in
	matrix(data, nrow, ncol) under R >= 4.2.0.

                 Changes in version 1.3-3 (2021-05-04)                  

Installation

    o   Matrix >= 1.3-3 depends on R >= 3.5, relaxing the dependency on
	R >= 3.6 introduced in Matrix version 1.3-0.

Compatibility

    o   Tests are revised for length mismatch warning in matrix(data,
	nrow, ncol) under R >= 4.2.0.

C-Level API

    o   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

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

Classes

    o   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

    o   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.

    o   Fixed error message in <dtrMatrix> multiplication.

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

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

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

    o   -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.

    o   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.

    o   removed a few duplicated .alias{.} from man/*.Rd.

Misc

    o   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.

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

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

                 Changes in version 1.3-2 (2021-01-06)                  

Installation

    o   USE_FC_LEN_T is defined before Rconfig.h is included.  Under R
	>= 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

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

Bug Fixes

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

    o   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.

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

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

                        Changes in version 1.3-1                        

Bug Fixes

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

                 Changes in version 1.3-0 (2020-12-22)                  

Installation

    o   Matrix >= 1.3-0 depends on R >= 3.6.

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

SuiteSparse

    o   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

    o   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

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

    o   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.

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

    o   New BunchKaufman(<matrix>) method.

    o   Added wrld_1deg sparse matrix example to _distributed_ version
	of Matrix (no longer excluding it via .Rbuildignore).

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

    o   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.

    o   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.

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

Memory

    o   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

    o   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).

    o   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().

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

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

    o   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-27)                 

Compatibility

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

Memory

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

Bug Fixes

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

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

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

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

                 Changes in version 1.2-17 (2019-03-22)                 

Compatibility

    o   isFALSE is defined for R < 3.5.0.

Memory

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

                 Changes in version 1.2-16 (2019-03-08)                 

New Features

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

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

Bug Fixes

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

    o   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.

    o   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-11-01)                 

New Features

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

Bug Fixes

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

                 Changes in version 1.2-14 (2018-04-09)                 

New Features

    o   German translation updates.

Memory

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

                 Changes in version 1.2-13 (2018-04-02)                 

New Features

    o   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

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

Bug Fixes

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

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

    o   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).

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

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

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

    o   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-15)                 

New Features

    o   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

    o   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 >= 3.5.0.

    o   using Authors@R in ../DESCRIPTION to list all contributors.

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

                 Changes in version 1.2-11 (2017-08-16)                 

Compatibility

    o   length(<NULL>) <- value is avoided as it is deprecated in R >=
	3.5.0.

New Features

    o   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

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

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

    o   .trDiagonal() utility is now exported.

                 Changes in version 1.2-10 (2017-04-28)                 

Memory

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

                 Changes in version 1.2-9 (2017-03-14)                  

New Features

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

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

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

    o   sparseVector() now also works without x argument.

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

Bug Fixes

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

    o   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,].

    o   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-20)                  

Compatibility

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

SuiteSparse

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

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

Bug Fixes

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

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

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

                Changes in version 1.2-7.1 (2016-09-01)                 

Installation

    o   _POSIX_C_SOURCE is defined _conditionally_ with #ifdef
	__GLIBC__.

                 Changes in version 1.2-7 (2016-08-28)                  

New Features

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

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

Bug Fixes

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

                 Changes in version 1.2-6 (2016-05-02)                  

Bug Fixes

    o   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-17)                  

New Features

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

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

Bug Fixes

    o   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-03-01)                  

New Features

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

    o   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

    o   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-28)                  

C-Level API

    o   inst/include/Matrix.h tries harder to define alloca correctly
	for compilers that do not define __GNUC__.

New Features

    o   MatrixClass() is exported now.

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

    o   more Korean translations

Bug Fixes

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

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

    o   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-08)                  

Dependencies

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

Bug Fixes

    o   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-06-01)                  

New Features

    o   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.

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

    o   lu(<sparseMatrix>) now keeps dimnames.

    o   better NEWS.Rd (which pleases Kurt and tidy;-)

Memory

    o   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

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

    o   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.

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

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

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

    o   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-04)                  

Generic Functions

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

New Features

    o   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.

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

    o   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.

    o   More thorough checking of cbind2() and rbind2() methods,
	notably as they are called from cbind() and rbind() from R >=
	3.2.0.
	
	rbind2(<dense>, <dense>) is faster, being based on new C code.

    o   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.

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

    o   rsparseMatrix() now accepts rand.x = NULL and then creates a
	random _patter*n*_ matrix (nsparseMatrix).

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

    o   Partial Korean translations of messages.

Deprecated and Defunct

    o   For R >= 3.2.0, cBind() and rBind() are deprecated, as they are
	no longer needed since cbind() and rbind() do work
	automatically.

Bug Fixes

    o   Fix some rbind2() methods.

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

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

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

    o   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)                  

Compatibility

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

New Features

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

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

Bug Fixes

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

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

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

    o   invPerm() coercion to integer

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

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

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

                 Changes in version 1.1-4 (2014-06-15)                  

New Features

    o   new rsparsematrix() for random sparse Matrices.

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

Bug Fixes

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

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

                 Changes in version 1.1-3 (2014-03-31)                  

New Features

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

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

    o   new help page for all such matrix products
	(../man/matrix-products.Rd).

Bug Fixes

    o   image() now gets correct ylim again.

    o   More consistent matrix products.

                Changes in version 1.1-2-2 (2014-03-04)                 

Bug Fixes

    o   correct adaption to R 3.1.0

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

                 Changes in version 1.1-2 (2014-01-28)                  

New Features

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

Bug Fixes

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

                Changes in version 1.1-1.1 (2013-12-30)                 

Installation

    o   Matrix >= 1.1-1.1 depends on R >= 2.15.2 to ease checking.

Compatibility

    o   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-29)                  

New Features

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

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

    o   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.

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

Bug Fixes

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

    o   qr.coef(), qr.fitted, and qr.resid now also work with _sparse_
	RHS y.

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

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

                 Changes in version 1.1-0 (2013-10-25)                  

Dependencies

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

SuiteSparse

    o   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

    o   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

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

Bug Fixes

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

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

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

                 Changes in version 1.0-14 (2013-09-13)                 

Bug Fixes

    o   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-11)                 

Classes

    o   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

    o   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

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

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

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

    o   Start providing anyNA methods for R >= 3.1.0.

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

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

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

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

Bug Fixes

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

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

                 Changes in version 1.0-12 (2013-03-26)                 

New Features

    o   .

Bug Fixes

    o   .

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

New Features

    o   .

Bug Fixes

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

    o   .

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

New Features

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

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

Bug Fixes

    o   .

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

New Features

    o   new sparseVector() constructor function.

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

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

Bug Fixes

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

    o   Ditto for diagonalMatrix methods.

                 Changes in version 1.0-6 (2012-06-18)                  

New Features

    o   .

Bug Fixes

    o   .

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

New Features

    o   .

Bug Fixes

    o   .

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

New Features

    o   .

Bug Fixes

    o   .

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

New Features

    o   .

Bug Fixes

    o   .

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

New Features

    o   .

Bug Fixes

    o   .

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

New Features

    o   .

Bug Fixes

    o   .

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

New Features

    o   .

Bug Fixes

    o   .

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

New Features

    o   .

Bug Fixes

    o   .

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

New Features

    o   .

Bug Fixes

    o   .

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

New Features

    o   .

Bug Fixes

    o   .

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

New Features

    o   .

Bug Fixes

    o   .

                 Changes in version 0.95-1 (2005-02-18)                 

Authorship

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

New Features

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

Bug Fixes

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

                 Changes in version 0.9-1 (2005-01-24)                  

New Features

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

Bug Fixes

    o   .

                 Changes in version 0.8-2 (2004-04-06)                  

Description

    o   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.

    o   Matrix >= 0.8-2 depends on R >= 1.9.0.

    o   Depends: methods is added to DESCRIPTION.

    o   Douglas Bates becomes the sole author of Matrix.

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

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

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

Bug Fixes

    o   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

    o   S3 generic function determinant is removed as it was ported to
	R >= 1.8.0.

Significant User-Visible Changes

    o   A namespace for Matrix is defined using directives in
	NAMESPACE.

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

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

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

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

    o   Functions asObject and prependClass are not exported.

    o   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

    o   S3 generic function det is renamed determinant.

Methods

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

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

Description

    o   Matrix >= 0.3-23 depends on R >= 1.7.0.

Installation

    o   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 (2002-02-03)                 

Bug Fixes

    o   Empty directory data is removed.

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

Description

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

Installation

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

    o   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

    o   configure.ac sets CFLAGS before expanding AC_PROG_CC and sets
	FLIBS before expanding ACX_BLAS and ACX_LAPACK.

    o   Autoconf macro OCTAVE_BLAS_LIBS, which is no longer used, is
	removed from aclocal.m4.

Bug Fixes

    o   Unwanted Autoconf output is removed from aclocal.m4.

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

Bug Fixes

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

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

    o   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

    o   *_ELT macros are no longer defined for R < 1.2.0 as Matrix
	depends on R >= 1.5.0.

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

Description

    o   Matrix >= 0.3-17 depends on R >= 1.5.0.

Installation

    o   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.

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

    o   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

    o   A preliminary ChangeLog.

Compatibility

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

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

Bug Fixes

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

    o   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

    o   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

    o   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

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

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

Bug Fixes

    o   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

    o   DESCRIPTION gets a Maintainer field and Douglas Bates is named
	there.

Bug Fixes

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

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

Installation

    o   FLIBS is appended to PKG_LIBS in src/Makevars.in.

Documentation

    o   A basic README.

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

Description

    o   Matrix >= 0.3-6 depends on R >= 1.1.1.

Installation

    o   configure makes use of HAVE_F77_UNDERSCORE in Rconfig.h.

    o   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-11)                  

Deprecated and Defunct

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

Methods

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

    o   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

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

Compatibility

    o   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

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

Methods

    o   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

    o   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

    o   S3 generic function eigen.

Methods

    o   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.

    o   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

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

New Features

    o   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.

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

    o   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

    o   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.

    o   src/Makevars is now generated from src/Makevars.in.

    o   A cleanup script removing generated files.

Documentation

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

Methods

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

Bug Fixes

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

    o   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

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

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

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

    o   Matrix >= 0.2-1 depends on R >= 1.1.0.

Installation

    o   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

    o   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

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

Methods

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

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

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

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

New Features

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

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

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

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

    o   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).

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