NEWS | R Documentation |
x[]
works for x
inheriting from virtual class
sparseVector
.
length(x)
is always an integer for x
inheriting from virtual class sparseVector
. Truncation
did not occur for x@length
of type "double"
equal to or greater than .Machine[["integer.max"]] + 1
.
tril(<n-by-n>, -n)
now works again.
tri[ul](<indMatrix>, k)
now works correctly for
k != 0
.
C API function cholmod_triplet_as_sexp
transposes entries “opposite” the stype
when that
is nonzero, following CHOLMOD.
R_init_Matrix
did not register cholmod_defaults
,
so calls to the corresponding stub did not work.
%||%
is defined in the Matrix namespace
only for R versions less than 4.4.0.
printf
format mismatches detected by R-devel
are fixed in 3 ‘src/*.c’.
better deprecation message for ..2dge()
.
Entry point M_chm_triplet_to_SEXP
, removed
in Matrix version 1.6-2, is restored (as a macro).
It was “covertly” used by package Rmosek.
With an R built with configure
option
--disable-long-double, prod(M)
now very slightly
differs for two differently classed versions of M
.
checkMatrix()
from ‘test-tools-Matrix.R’ gets
optional MSG
argument for suppressing prod()
differences.
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.
New R function Matrix.Version
, taking no arguments
and returning list(package, abi, suitesparse)
, a list
containing the numeric versions of the package, its ABI, and the
internal SuiteSparse library. ABI versioning is new: the version
is 1 in this release and will be incremented by 1 in each future
release that changes the ABI. Versions and their components are
defined in a header for use by packages with LinkingTo: Matrix
in ‘DESCRIPTION’. See ‘inst/include/Matrix/version.h’.
New nonvirtual class ndiMatrix
, extending virtual
classes diagonalMatrix
and nMatrix
, for nonzero
pattern diagonal matrices. It is used to represent the result
of is.na
, is.nan
, is.infinite
applied to
diagonalMatrix
, as well as diagonal boolean products.
Coercions as(<diagonalMatrix>, "nMatrix")
now give
ndiMatrix
instead of ntCMatrix
. The latter can
for now still be obtained by coercing to nsparseMatrix
instead of nMatrix
.
New C-level validity methods for sparseVector
and
[nlidz]sparseVector
, now requiring length
not
exceeding 2^53
, which on most platforms is the maximum
integer representable exactly as double
.
mean(<sparseVector>, trim=)
now works efficiently
for nonzero values of trim
.
rep(<sparseVector>, each=)
now works efficiently,
avoiding rep(., times = rep(each, times = length(.)))
.
.m2dense
and .m2sparse
gain an argument
trans
indicating if vectors that are not matrices should
be coerced to 1-row matrices rather than 1-column matrices.
.m2dense
and .m2sparse
can be called
with one argument. Their class
arguments admit new
default values ".ge"
and ".gC"
.
.diag2dense
and .diag2sparse
gain an
argument kind
indicating the “kind” of the
result.
New exports .M2V
and .m2V
, for coercing
Matrix
and matrix
(and in fact vector
)
to sparseVector
.
New exports isUniqueT
and asUniqueT
, with
optional argument byrow
allowing for row-major ordering
of entries. asUniqueT
supercedes uniqTsparse
,
which is no longer documented.
New export aggregateT
, for aggregating
TsparseMatrix
without sorting.
Methods for all.equal
now report the packages
where S4 classes are defined.
sum(x)
and prod(x)
no longer require a
coercion from symmetricMatrix
to generalMatrix
.
Results where coercions are now avoided may differ numerically
due to reordering of adds and multiplies, most commonly on
systems where sizeof(long double) == sizeof(double)
.
Methods for cbind2
and rbind2
did not in all
cases handle vectors as 1-column and 1-row matrices, respectively.
Methods for cbind2
and rbind2
did not handle
0-length vectors (including NULL
) correctly where the result
would have 0 rows and columns, respectively.
Methods for cbind2
and rbind2
did not handle
NA
in the x
slot of ndenseMatrix
correctly
(i.e., as TRUE
).
cbind2(<ndenseMatrix>, <ldenseMatrix>)
gave
ngeMatrix
instead of lgeMatrix
.
cbind2(<lsparseMatrix>, <lsparseMatrix>)
gave
dgCMatrix
instead of lgCMatrix
.
Methods for rbind2
had similar problems.
rcond(<0-by-0>)
now returns Inf
; see PR#18543.
round(<dp[op]Matrix>)
and signif(<dp[op]Matrix>)
now return ds[yp]Matrix
rather than dp[op]Matrix
and
now discard factors
.
Methods for length
now return integer
rather
than double
if the result does not exceed INT_MAX
.
dsparseVector
with x
slot of type
integer
are now formally invalid, as always intended.
Methods for subscripting sparseVector
did not behave
compatibly with base when supplied with fractional, NA
,
or out-of-bounds subscripts.
symmpart(x)
, skewpart(x)
,
band(x, k1, k2)
, triu(x, k)
, and
tril(x, k)
now always return a .diMatrix
for x
inheriting from diagonalMatrix
.
colSums(<(n|l|ind)Matrix>)
and
rowSums(<(n|l|ind)Matrix>)
now always give a result
of type "integer"
. Methods differed previously,
some giving "double"
(as base does, suboptimally,
traditional matrices of type "logical"
).
Some methods for generic function lu
did not transmit
Dimnames
to the result.
Some methods for group generic function Summary
ignored arguments matching ...
. Other methods did
not ignore the “garbage” elements of the x
slot
of dense, triangular matrices.
kronecker(<n.TMatrix>, <diagonalMatrix>)
threw
an error for attempting to access the nonexistent x
slot
of its first argument.
Matrix products now behave exactly as base when testing for conformable arguments.
Numeric products (%*%
) did not always return a
dMatrix
.
Methods for all.equal
now “see” attributes
of S4 objects that are not slots. This can be disabled
by setting argument check.attributes
to NA
,
which is otherwise equivalent to TRUE
.
prod(x)
is computed more diligently for x
inheriting from sparseMatrix
, sparseVector
, or
.t[rp]Matrix
, i.e., those x
that can be understood
to have “structural” zeros. Now, multiplication by zero
occurs at the position of the first structural zero in the matrix
or vector (when traversed by row in the case of RsparseMatrix
).
An exception is TsparseMatrix
, for which multiplication
by zero occurs before multiplication by any stored entry,
regardless of the position of the first structural zero in the
corresponding sorted matrix (to avoid the cost of sorting).
tri[ul](<.t[rp]Matrix>, k)
was often wrong for
nonzero k
, setting too many bands to zero.
C-level tCsparse_diag
(formerly diag_tC
)
now handles structural zeros and NaN
on the main diagonal
correctly. Option "diagBack"
now works correctly.
The prototype of API function M_cholmod_band_inplace
was wrongly copied from cholmod_band
,
instead of from cholmod_band_inplace
.
Many API function prototypes wrongly used const
qualifiers where the registered routines do not.
expm(x)
failed for x
of class dtpMatrix
or dspMatrix
, since Matrix version 1.6-1.
.m2dense(x, ".ge")
allocated unnecessarily
for x
without attributes.
C code now refers to the symbol factors
as
Matrix_factorsSym
, rather than Matrix_factorSym
.
Certain never or seldom used class unions are removed.
The content of ‘src/Mutils.[ch]’ has been migrated to more transparently named files: ‘src/attrib.[ch]’, ‘src/objects.[ch]’, etc. Similarly, much of ‘src/factorizations.[ch]’ have been migrated to ‘src/solve.[ch]’ and ‘src/determinant.[ch]’.
All matrix product code has been migrated to ‘products.[Rch]’.
Files in ‘po/’ and ‘inst/po/’ have been updated
due to more frequent use of gettextf
in ‘R/*.R’.
C code is prepared to handle complex matrices and their factorizations. Notably, new machinery in ‘src/cs-etc.[ch]’ will enable linking the CXSparse library instead of the CSparse library, the latter supporting numeric types but not complex ones.
Some API declarations and macros not used by any
reverse LinkingTo
are removed or remapped.
API headers are now nested under ‘inst/include/Matrix/’
for better namespacing. Where possible, packages should start to
use LinkingTo: Matrix (>= 1.6-2)
and include files from the
new subdirectory, e.g., with #include <Matrix/Matrix.h>
.
Users including API headers can define macro
R_MATRIX_INLINE
,
typically with #define R_MATRIX_INLINE inline
,
to allow the compiler to inline stubs for registered routines.
Matrix did not pass its checks under R 3.5.0,
implicitly violating Depends: R (>= 3.5.0)
. This release
restores compatibility.
Export the generics crossprod()
and tcrossprod()
explicitly, needed for R-devel when they become primitive internal
generics.
Several new coercion utilities, exported and documented
in help("fastMisc")
. Some of these supercede ones made
available (experimentally) in Matrix 1.5-4; for example,
.M2m
makes both .dense2m
and .sparse2m
redundant. The superceded ones are not yet formally deprecated,
but are no longer documented.
drop0
is now implemented independently
of CHOLMOD
, becoming more efficient notably for
logical arguments, no longer requiring a coercion to double.
drop0
gains an argument give.Csparse
to complement is.Csparse
. FALSE
indicates
that RsparseMatrix
, TsparseMatrix
, and
indMatrix
arguments should be handled directly,
without a coercion to CsparseMatrix
. The default
value is TRUE
, for backwards compatibility.
Fix four Valgrind-detected memory bugs.
<diagonalMatrix> %*% <RsparseMatrix>
works again.
diag(<non-square RsparseMatrix>) <- value
works again, no longer giving a p
slot of length
Dim[2]
rather than Dim[1]
.
as(<diagonalMatrix>, "symmetricMatrix")
now checks
for symmetric Dimnames
, for consistency.
as(<indMatrix>, "[nld](sparse)?Matrix") now returns
a .gRMatrix
or a .gCMatrix
depending on the
margin
slot.
as(<[CR]sparseMatrix>, "generalMatrix")
now checks
if the number of nonzero entries in the result would exceed
INT_MAX
and throws an error in that case.
Validity checks on the perm
slot of classes
Cholesky
and pCholesky
have been enabled
(forgotten in Matrix 1.6-0).
API C function chm_sparse_to_SEXP
now sorts and
packs its first argument before assigning struct members
to variables, no longer accessing blocks of memory freed by
cholmod_sort
.
Run speed-measuring tests only if(doExtras)
:
these were too slow when run under Valgrind.
Most coercion code has been migrated to ‘coerce.[Rch]’ from elsewhere.
The number of methods for generic functions coerce
and as.*
has been reduced substantially, from 306 to 194
(not counting deprecated ones), partly as a result of efforts to
do more fine-grained dispatch in C code.
Files in ‘po/’ and ‘inst/po/’ have been updated
(again), as many more C level messages now use format strings
as a result of vsnprintf
usage in ‘src/validity.c’.
Class indMatrix
gains a margin
slot with value
1L
or 2L
(1L
being the prototype and
previously implicit value), indicating that the object represents
a row or column index matrix, with ones at [i, perm[i]]
or
[perm[j], j]
, respectively.
Methods with indMatrix
or its subclass pMatrix
in the signature have been adjusted to account for the new slot.
Notably, multiplication on the right by an indMatrix
with
margin = 2
is now implemented as a column subscript, and
the transpose of an indMatrix
is now the same object but
with “opposite” margin
.
Virtual class MatrixFactorization
gains a
Dimnames
slot. Now all factorizations preserve the
Dimnames
of the original, factorized Matrix
,
whereas previously classes Schur
, sparseLU
,
sparseQR
, dCHMsimpl
, and dCHMsuper
did
not.
Users can get the value of the new Dimnames
slot with
dimnames(.)
and set it with dimnames(.) <- value
.
Classes p?BunchKaufman
and p?Cholesky
no
longer extend dtrMatrix
or dtpMatrix
and in turn
no longer extend Matrix
. They retain slots Dim
,
Dimnames
, uplo
, and x
, but not diag
.
This change implies that virtual classes Matrix
and
MatrixFactorization
no longer intersect.
Classes p?Cholesky
gain a perm
slot with
prototype integer(0L)
to support representation of
pivoted factorizations, as typically computed by LAPACK routine
dpstrf
. perm
of length 0 is valid and equivalent
to the identity permutation.
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.
Methods for subscripting Matrix
now use the more
systematic code in ‘R/subscript.R’ and
‘src/subscript.c’, becoming more efficient for all
lsparseMatrix
(no longer coercing to dsparseMatrix
and back),
sparse symmetricMatrix
(no longer coercing to generalMatrix
and back
when i
in x[i, i]
is monotone),
unpackedMatrix
(no longer coercing to matrix
and back), and
RsparseMatrix
(no longer coercing to TsparseMatrix
, then to
CsparseMatrix
, then back to TsparseMatrix
[!]).
x[i, j, drop = FALSE]
preserves the class of x
in more cases where x
is a triangularMatrix
,
diagonalMatrix
, or pMatrix
, doing more complete
checks on i
and j
.
Notably, for x
inheriting from RsparseMatrix
,
the result is now always an RsparseMatrix
, rather than
always a TsparseMatrix
.
NULL
subscripts, as in x[NULL]
,
x[NULL, j]
, and x[i, NULL]
, are now supported
for x
inheriting from Matrix
. They are handled
as integer(0)
, consistent with base.
New nonvirtual class pcorMatrix
extending
dppMatrix
. It is the counterpart of corMatrix
using packed storage, supporting more efficient storage of
dense correlation matrices. Now pack(<corMatrix>)
gives a pcorMatrix
preserving the sd
slot,
rather than a dppMatrix
without an sd
slot.
New virtual classes BunchKaufmanFactorization
,
SchurFactorization
, and QR
, extended by existing
nonvirtual classes p?BunchKaufman
, Schur
, and
sparseQR
, respectively. These are parallel to the
existing virtual classes CholeskyFactorization
and
LU
. Packages defining new factorization classes may
extend these.
Virtual class CHMfactor
and its subclasses
gain formal validity methods.
The validity method for class sparseQR
now
checks that the V
slot is lower trapezoidal and that
the R
slot has non-negative diagonal elements.
New generic functions expand1
and expand2
,
intended to eventually replace expand
and certain 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.
Generic function Cholesky
gains methods for
denseMatrix
returning an object of class p?Cholesky
.
The method for subclass dsyMatrix
admits an argument
perm
indicating if the pivoted factorization should be
computed. The corresponding chol
method gains an argument
pivot
indicating the same. By default, Cholesky
pivots and chol
does not.
Many subclasses of MatrixFactorization
can now be
coerced to “nearby” subclasses of Matrix
.
The resulting Matrix
reflects the internal representation
of the factorization and not necessarily a particular matrix
factor. The new coercions are:
as(<denseLU>, "dgeMatrix")
,
as(<BunchKaufman>, "dtrMatrix")
,
as(<pBunchKaufman>, "dtpMatrix")
,
as(<Cholesky>, "dtrMatrix")
,
as(<pCholesky>, "dtpMatrix")
,
as(<CHMsimpl>, "dtCMatrix")
, and
as(<CHMsuper>, "dgCMatrix")
.
See help("denseLU-class")
(and similar) for details.
determinant(x, ...)
and solve(a, b, ...)
now work for x
and a
inheriting from
MatrixFactorization
, behaving as if x
and a
were replaced by the factorized Matrix
. The exception is
x
inheriting from CHMfactor
, where for backwards
compatibility the default behaviour is still to compute the
determinant of the Cholesky factor. This exception should be
considered temporary, hence defensive code will call
determinant
with (new) optional argument sqrt
set to
TRUE
or FALSE
explicitly, to not rely on the current
default value. See help("CHMfactor-class")
for details.
Generic function diag
gains methods for
p?Cholesky
and CHMfactor
. The result
is a numeric vector containing the diagonal entries
of the diagonal matrix D
, as defined in
help("Cholesky-class")
and help("CHMfactor-class")
.
The lu
and qr
methods for class
dgCMatrix
now admit an order
argument with
value in 0:3
, allowing the expert user to choose
among all ordering methods made available by the CSparse
library.
solve(<dgCMatrix>, b, sparse = TRUE)
is now
handled entirely in C code via cs_spsolve
from the
CSparse library.
New utilities invertPerm
, signPerm
,
isPerm
, and asPerm
for computing the inverse
and sign of a permutation vector, testing if an integer vector
is a permutation vector, and coercing a transposition vector
to a permutation vector. invertPerm
is a more general
version of the already exported function invPerm
,
which is retained as a wrapper around invertPerm
for
backwards compatibility.
The qr.R
method for class sparseQR
gains a backPermute
argument with default FALSE
,
for compatibility with base. Function qrR
,
which existed primarily to provide a back-permuting option,
is retained for backwards compatibility.
x[integer(0), ]
and x[, integer(0)]
now
give a generalMatrix
result when x
is a 0-by-0
diagonalMatrix
, for consistency with all other cases
of x[seq_len(n), ]
and x[, seq_len(n)]
, where
x
is an n
-by-n
triangular, symmetric,
or diagonal matrix.
For x
inheriting from RsparseMatrix
,
subassignment of the form x[i, ] <- value
is now
correctly distinguished from x[i] <- value
.
rownames(x[integer(0), , drop = FALSE])
and
colnames(x[, integer(0), drop = FALSE])
are now always
NULL
and never character(0)
, consistent with
the implementation in base.
Subscript operations on Matrix
now correctly
error whenever the formal argument ... is matched, as
in x[i, j, drop]
, where x[i, j, drop = drop]
is almost always intended.
x[i, ]
now correctly drops dimensions when
x
is a 1-by-n
Matrix
and i
is
TRUE
.
Methods for solve
now obey the following rules
much more strictly:
solve(a=<Matrix>, b=<vector>)
must return a vector.
solve(a=<denseMatrix>, b=<Matrix>)
must return
a denseMatrix
.
solve(a=<sparseMatrix>, b=<Matrix>, sparse=FALSE)
must return a denseMatrix
.
solve(a=<sparseMatrix>, b=<Matrix>, sparse=TRUE)
must return a sparseMatrix
.
resolving some longstanding incompatibilities with base.
Note that methods for sparse a
and missing or sparse
b
have default sparse = TRUE
, while methods
for sparse a
and dense b
have default
sparse = FALSE
.
solve(<symmetricMatrix>)
now always gives a
symmetricMatrix
result. solve(<dpoMatrix>)
and solve(<dppMatrix>)
preserve formal positive
definiteness, giving a dpoMatrix
and dppMatrix
,
respectively.
The prototype of the Dim
slot of virtual class
MatrixFactorization
is now integer(2L)
.
Previously it was integer(0L)
, with the result that
validObject(new("<nonvirtual subclass>"))
was always
an error.
The prototype of the L
slot of class
sparseLU
is now formally lower triangular, so that
validObject(new("sparseLU"))
is not an error.
The prototypes of the Q
and T
slots
of class Schur
are now 0-by-0 dgeMatrix
,
so that validObject(new("Schur"))
is not an error.
BunchKaufman(<matrix>)
now works when argument
uplo
(documented to be optional) is missing.
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.
Coercions to corMatrix
now set the diagonal
elements of the result to 1, consistent with cov2cor
.
dimnames(x) <- value
now validates x@Dim
before value
to avoid undefined behaviour in C-level
check.
invPerm(p)
no longer segfaults for p
that are not valid permutation vectors. (invPerm(NA)
was enough to trigger a segfault.)
chol2inv(x)
now ignores the lower triangular part
of x
not inheriting from triangularMatrix
.
chol2inv(x)
now computes crossprod(solve(x))
instead of tcrossprod(solve(x))
for all formally lower
triangular x
. Previously, crossprod
was used only
for dense x
.
rcond(x, norm)
throws a nicer error for x
of length 0.
Error messages due to invalid norm
in
rcond(x, norm)
now refer to the argument as norm
rather than type
.
rcond(x, norm)
now validates norm
also
for x
of class d(sy|sp|po|pp)Matrix
, even if
for such x
all valid norm
give the same result.
which(<[RT]sparseMatrix>, ...)
now gives indices
in column-major order in all cases, to be consistent with
help("which")
.
Factorizations inheriting from virtual class LU
are now cached under the name denseLU
or sparseLU
,
depending on the nonvirtual class, rather than always under
the name LU
. Note that user code should not rely
on the details of the cache and should instead rely on functions
such as lu
to retrieve cached factorizations.
Errors signaled by as(<dsyMatrix>, "dpoMatrix")
and as(<dspMatrix>, "dppMatrix")
now clarify that the
coercions do not attempt to test for positive semidefiniteness
when the matrix is not positive definite.
Help pages for matrix factorization classes and methods have been broadly expanded and updated to use consistent notation.
C code interfacing the CSparse library now checks in more
places for failed allocations inside of cs_*()
.
The length of the Matrix namespace has been reduced by ~15%. More than 100 unused symbols have been removed.
The following dependencies, needed only for a small number
of Rd
cross references, have been removed:
MatrixModels, expm, igraph, maptools,
sp, spdep. Links to CRAN and Bioconductor in
‘.Rd’ files are preserved throughout.
sfsmisc has been moved from Enhances
to
Suggests
, as Matrix does not formally enhance it
by providing methods, etc.
grDevices and datasets have been added
to Imports
and Suggests
, respectively,
as ‘NAMESPACE’ does import from grDevices
and vignettes do load data (albeit unconditionally)
from datasets.
Example, test, and vignette code no longer fails when
R_DEFAULT_PACKAGES is set to NULL
, thanks to
additional “invisible” library
calls in the
problematic source files.
Examples now use requireNamespace
instead of
require
, preserving the user search path in more cases.
Updates to ‘po/*.{po,pot}’ and ‘inst/po/*’ for translators.
Use #ifdef PR18534fixed
to adapt to R's Lapack
header fix for PR#18534.
The following low level coercion utilities, which were
previously exported but always “hidden” and undocumented,
are now deprecated:
..2dge
, .C2nC
, .T2Cmat
, .asmatrix
,
.dense2sy
, .diag2mat
, .diag2sT
,
.diag2tT
, .dsy2dsp
, .dsy2mat
, .dxC2mat
,
.m2dgC
, .m2lgC
, .m2ngC
, .m2ngCn
,
.m2ngTn
, .n2dgT
, .nC2d
, .nC2l
.
The deprecations follow efforts to define more general and more
systematic (but still fast) coercion utilities, to allow expert
users to bypass S4 dispatch in more cases. The subset of these
currently exported is documented under help("fastMisc")
.
Deprecation warnings will suggest an appropriate replacement,
mostly from that list.
It is not always the case that the replacement can be
“dropped in”, hence users should consult the relevant
documentation when changing their code.
Warnings signaled by coercion methods deprecated
in Matrix 1.5-0 now correctly inherit from class
deprecatedWarning
.
Defining sequence.default
for R < 4.0.0
,
so that kronecker(<CsparseMatrix>, <CsparseMatrix>)
,
kronecker(<CsparseMatrix>, <diagonalMatrix>)
, and
<diagonalMatrix> %*% <denseMatrix>
continue to work
there.
C-level utilities Matrix_memset()
and
Matrix_memcpy()
, both new, are now used in many places
instead of API macros Memzero()
and Memcpy()
which never check for overflow. C-level macro AZERO()
is no longer defined.
C-level macro Calloc_or_Alloca_TO()
now
zero-initializes also in the alloca
-using case.
Replace deprecated Rdefines.h
with
Rinternals.h
and move inclusion outside of
extern "C"
wrapper in API header
‘inst/include/Matrix.h’.
Replace sprintf
with snprintf
globally
to avoid potential buffer overflows.
dimScale(x)
with argument d1
missing is no
longer an error. (The default value had diag(x, FALSE)
instead of diag(x, names = FALSE)
.)
(dim|row|col)Scale(x)
is no longer an error for
traditional matrices x
without a dimnames
attribute.
Our cov2cor()
methods now again preserve (symmetrized!)
dimnames
, fixing Matrix bug #6783 reported by Ben Bolker.
colSums()
and friends now always give a named
result when the marginal Dimnames
are non-NULL
.
(Names were “forgotten” for diagonalMatrix
and
indMatrix
arguments.)
colSums()
and friends now respect na.rm
when
handling diagonalMatrix
with NA
diagonal entries.
expand(<denseLU>)
now “copies-on-modify”,
no longer duplicating the m*n
-length x
slot in
the m == n
case, when it can be used directly.
lu(<m-by-0>)
, lu(<0-by-n>)
, and
BunchKaufman(<0-by-0>)
now give sensible (0-extent)
results, rather than a LAPACK error, for denseMatrix
.
Diagonal()
gets a new optional names
argument.
diag(x) <- value
is now done in C also for
[CRT]sparseMatrix
.
.diagU2N()
gets fast counterpart .diagN2U()
.
colSums()
and friends are now implemented more
efficiently for denseMatrix
and [CRT]sparseMatrix
.
Notably, methods for triangular and symmetric matrices no longer
go via generalMatrix
, and methods for
[CRT]sparseMatrix
now handle nonzero pattern and logical
matrices directly (no longer coercing to double, a constraint
of the earlier implementation using CHOLMOD).
determinant(<ds[yp]Matrix>)
is now computed via
the Bunch-Kaufman factorization. Factorizations are cached in
the factors
slot for future reuse.
Package methods has been 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 some list not containing methods).
‘Simple.R’ test for sparse "POSIXlt"
example
adapted to latest R-devel always having "zone"
which is
character.
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.
C-level functions now PROTECT()
the result of
R_do_slot()
, getAttrib()
, mkString()
, etc.
in many more (but not yet all) places, resolving many new
and some old rchk
warnings.
lu(x)@L@uplo
is now "L"
, not "U"
,
for 0-by-0 and 1-by-1 dgCMatrix
x
.
The validity methods for classes l[ts]CMatrix
now correctly test for structurally nonzero entries on the
wrong side of the diagonal, and fail in that case. This test
was previously only performed for d[ts]Matrix
.
The validity and initialization methods for virtual class
sparseVector
are more diligent, i.e., catching more edge
cases such as NA
in the length
or i
slot.
The validity method for corMatrix
now throws a better
error when the sd
slot is of type "integer"
rather
than "double"
.
.sparseDiagonal()
now agrees with Diagonal()
when called with no arguments, returning a 0-by-0 (rather than
1-by-1) diagonal Matrix
.
sparseMatrix(i, j)
with 0-length i
and
j
now returns a 0-by-0 matrix rather than throwing a
perplexing error.
sparseMatrix(dims = <list>)
and
sparseMatrix(x = <dMatrix>)
now produce errors.
diag(x) <- value
now coerces diagonalMatrix
x
if typeof(value)
is “higher” than
typeof(x@x)
in the usual hierarchy, for consistency with
methods for denseMatrix
and with base::`diag<-`
.
Methods for kronecker()
no longer ignore the
make.dimnames
argument.
Printing a sparseMatrix
with NA
row or column
names is no longer an error.
Products of two pMatrix
objects x
and y
are now computed correctly. Previously, y %*% x
was
returned instead of x %*% y
!
Products x %*% y
with x
a
diagonalMatrix
or indMatrix
and y
a
traditional matrix or vector, or with x
a traditional
matrix or vector and y
a diagonalMatrix
or pMatrix
, now treat the unclassed argument as a
.geMatrix
and return a .geMatrix
, for greater
consistency with other products involving one Matrix
and one non-Matrix
.
Similarly, kronecker(x, y)
with one of x
and
y
a Matrix
and the other a traditional matrix or
vector now treats the unclassed argument as a .geMatrix
.
dimnames(solve(x))
is now rev(dimnames(x))
for denseMatrix
x
, consistent with the handling
of dimnames
by solve.default
. Methods for
sparseMatrix
x
have not been addressed (yet).
is.nan(x)
is now implemented for all x
inheriting from virtual class Matrix
or sparseVector
.
New C-level validity methods for n[ts][CRT]Matrix
,
p?Cholesky
, p?BunchKaufman
, Schur
,
denseLU
, sparseLU
, and sparseQR
.
Notably, in the MatrixFactorization
cases, the following
properties are now checked: the dimensions of each factor,
the orientation of each triangular (or trapezoidal) factor, and
the validity of each permutation vector.
Diagonal(n=, x=)
now recycles x
of any
positive length to length n
. Previously, recycling was
supported only for x
of length 1.
Products involving diagonalMatrix
or indMatrix
have been broadly improved as follows:
dimnames(A %*% B)
is now always
c(dimnames(A)[1], dimnames(B)[2])
.
t?crossprod()
methods involving indMatrix
or its subclass pMatrix
gain a boolArith
argument.
Numeric and boolean products are always returned as
dMatrix
and nMatrix
, respectively, except in
a few special cases where the product can be represented
as an indMatrix
. (Previously, coercions were skipped
when one of the operands was unit diagonal.)
Products of diagonalMatrix
with dense
triangularMatrix
now correctly give a
triangularMatrix
result (and without unpacking).
Products of diagonalMatrix
with
[RT]sparseMatrix
now preserve storage, no longer
coercing to CsparseMatrix
.
crossprod(x, y)
no longer requires the product of
ncol(x)
and ncol(y)
to be less than 2^31
when both x
and y
are indMatrix
. (The
new implementation now always gives a dgTMatrix
result,
whereas previously the result would typically but not always
be a dgCMatrix
.)
kronecker(<Matrix>, <Matrix>)
now gives the correct
“shape” (general, [unit] triangular, symmetric, diagonal)
in all cases where it can be known without checking.
kronecker(<[CR]sparseMatrix>, <Matrix>)
now retains
the storage of the first argument, no longer coercing to
TsparseMatrix
.
New exported functions dimScale
, rowScale
, and
colScale
, for scaling rows and columns of a [mM]atrix
without losing dimnames
and where appropriate without
losing symmetry.
ASAN-detected bugs fixed in C-level functions
Tsparse_as_CRsparse()
(triggered by .T2C(<0-by-0>)
)
and pMatrix_validate()
(triggered by as(<length-10000 integer>, "pMatrix")
).
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 lessis to be silent.
1
is to signal a warning with each deprecated coercion.
2
or greateris 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.
Symmetrization of <Matrix>@Dimnames
and
dimnames(<matrix>)
now goes through C utility symmDN()
in most places, resolving some earlier inconsistencies.
Many more validity methods now correctly operate under the assumption that methods for superclasses have already been called, eliminating many redundant checks.
Validation of <Matrix>@Dim
now looks at type
before length, avoiding a misleading error message.
Validation of <Matrix>@Dimnames
now avoids
isNewList
, which had allowed an error message suggesting
that NULL
is a list.
Setting a factor on a compMatrix
is now to install
the factor itself, not a copy, for efficiency and consistency
with the semantics of <compMatrix>@factors[[name]] <- value
.
Long vector support in methods for packing and unpacking
denseMatrix
, and others.
diag<-
incorrectly preserved the class of dense matrices,
so that, e.g., `diag<-`(x=<dpoMatrix>, value=-1)
was still a
dpoMatrix
. Now the result is always one of the more general
.(ge|tr|sy|tp|sp)Matrix
.
t(<corMatrix>)
no longer clears the sd
slot.
t(<p?BunchKaufman>)
now returns one of the more general
dt[rp]Matrix
, rather than preserving class and clearing
the perm
slot.
t(<symmetricMatrix>)
no longer reverses the
Dimnames
slot. Symmetrization of dn <- x@Dimnames
and t(x)@Dimnames
had given different results when
dn[[1]]
and dn[[2]]
were non-NULL
and
asymmetric.
isTriangular(x, upper)
had incorrectly returned
FALSE
for x
of class triangularMatrix
when upper = TRUE
and x@uplo = "L"
or when
upper = FALSE
and x@uplo = "U"
.
isTriangular
is now equivalent to isDiagonal
in those cases.
isSymmetric()
was equivalent to isDiagonal()
for triangular matrices, not allowing numerical fuzz via an
argument tol
. A tol
argument is now implemented
for all subclasses of dMatrix
except for those inheriting
from symmetricMatrix
or diagonalMatrix
.
Methods for isSymmetric
now also look at
Dimnames
and names(Dimnames)
, following
isSymmetric.matrix
from base. See also
New Features.
band(x, -k, k)
for sparse x
used
isSymmetric(x)
(which tolerates numerical fuzz) to test
for symmetry, resulting in loss of information in some cases.
Now it tests that x
inherits from symmetricMatrix
,
and so returns symmetricMatrix
in fewer cases.
triu(x, k)
and tril(x, k)
incorrectly
required k <= m
(instead of k <= n
),
for m
-by-n
sparse x
. They now accept
all k
from -m
to n
, with fewer errors
in the m < n
case.
crossprod(<Rsparse>, <Tsparse>)
and similar now work
again (optional boolArith
was not passed on), fixing Matrix
bug #6766 by David Cortes.
Ditto for tcrossprod()
, where the old result was even wrong
when it had “worked”, before Matrix 1.2-0.
as(<matrix>, "nMatrix")
can now be sparse or
dense, going via Matrix()
, for greater consistency with
coercions to dMatrix
and lMatrix
.
(Previously, the result was always an ngTMatrix
.)
forceSymmetric(<[RT]sparseMatrix>)
are now more
efficient, returning symmetric [RT]sparseMatrix
without
intermediate coercions to CsparseMatrix
.
tcrossprod(a, b)
for unit triangular sparse matrices
now works correctly.
!<ltrMatrix>
is no longer an error in the 0-by-0
unit diagonal case.
Coercions among [CRT]sparseMatrix
preserve the
factors
slot in more cases.
Coercions of overallocated l.TMatrix
to
denseMatrix
or CsparseMatrix
now give TRUE
instead of NA
in the NA || TRUE
case, following
conventional logic.
Methods for unpacking and indexing packedMatrix
and
for coercing from [CRT]sparseMatrix
to denseMatrix
now check more consistently for overflow of R_XLEN_T_MAX
.
solve(<ddenseMatrix>, <ANY>)
is removed from
the method list. It had allowed infinite recursion, e.g.,
with solve(new("dgeMatrix"), NULL)
.
is.na(<ndenseMatrix>)
gave TRUE
where
the x
slot had NA
. Now the result is always
a zero matrix.
is.na(<.t[rp]Matrix>)
and
is.infinite(<.t[rp]Matrix>)
ignored the diag
slot,
behaving always as though diag == "N"
. They now give
FALSE
on the diagonal in the diag != "N"
case.
Now only “nontrivial” matrix elements determine
whether is.na(<denseMatrix>)
is an ndenseMatrix
or an nsparseMatrix
.
is.na(<ddenseMatrix>)
coerced to lMatrix
.
This unnecessary step is avoided now, saving a potentially
nontrivial allocation.
solve(<ddenseMatrix>, b)
coerced the first argument
to dgeMatrix
when b
was not a ddenseMatrix
or traditional matrix
. This unnecessary step is avoided now,
so that specialized methods for d(tr|sy|po|tp|sp|pp)Matrix
are used where possible (including for b
inheriting from
[ln]denseMatrix
, sparseMatrix
, or numLike
).
`dim<-`(x, -x@Dim)
is now an error, no longer
yielding an invalid Matrix
object.
`dim<-`(x, x@Dim)
is now faster, returning x
without allocation in all cases.
`dim<-`(x, value)
gives a better error when
value
contains NA
or elements exceeding
INT_MAX
.
`dim<-`(<RsparseMatrix>, value)
is now an
RsparseMatrix
, rather than a TsparseMatrix
.
For consistency with other methods,
symmpart(<diagonalMatrix>)
now always inherits from
both dMatrix
and symmetricMatrix
, and
skewpart(<diagonalMatrix>)
now always has symmetric
Dimnames
.
Zeros on the diagonal of skewpart(<[CRT]sparseMatrix>)
are now structural.
as(<ndenseMatrix>, "(vector|matrix|[dl]Matrix)")
and nnzero(<ndenseMatrix>)
now correctly treat NA
in the x
slot as TRUE
.
as(<[nl].TMatrix>, "dMatrix")
now correctly handles
the overallocated case: data for each unique [i,j]
pair are aggregated logically (x1 || ... || xn
) rather than
arithmetically (x1 + ... + xn
), so that elements of the
result are restricted to the set c(0, 1, NA)
.
This bug had also affected the result of sum(<[nl].TMatrix>)
.
dimnames(as(x, "matrix"))
is now NULL
for all x
inheriting from Matrix
,
when x@Dimnames
is the trivial list(NULL, NULL)
.
.bdiag(<named list>)
no longer propagates names
to the Dim
slot of the result.
as(<named vector>, "denseMatrix")
now correctly
propagates names
to the result.
as(<d.[CR]Matrix>, "lMatrix")
no longer drops
non-structural zeros, for greater consistency with analogous
coercions.
Matrix(x, doDiag)
now behaves as documented
for diagonal matrices x
with asymmetric dimnames
,
returning a diagonalMatrix
when doDiag = TRUE
,
rather than a triangularMatrix
.
Matrix(<n-dimensional table>) now works for n != 2
.
Matrix(<sparseVector>)
now works for vector lengths
other than 1, no longer giving an error about length mismatch
when neither of nrow
and ncol
are supplied.
Matrix(<diagonalMatrix>, doDiag = FALSE)
is now a symmetricMatrix
, not a diagonalMatrix
,
matching the documentation of doDiag
.
Matrix(<.geMatrix>, sparse = TRUE, forceCheck)
and Matrix(<.g[CRT]Matrix>, sparse = FALSE, forceCheck)
now respect forceCheck = FALSE
by always returning
generalMatrix
, i.e., not testing for symmetric
or triangular structure.
Matrix(0, nrow, )
, Matrix(0, , ncol)
now
throw (correct) errors for nrow
, ncol
in the
interval [0,1)
, consistent with base::matrix()
.
sparseDefault(<sparseMatrix>)
now counts zeros
without coercing to matrix
,
making Matrix(<sparseMatrix>, sparse = NULL)
much more
efficient.
Methods for group generic Math
no longer
preserve x@diag == "U"
or lose x@Dimnames
when f(0) == 0
and f(1) != 1
.
(The former happened for triangularMatrix
x
and the latter for diagonalMatrix
x
.)
image(Z)
for a completely “empty” (all 0)
sparseMatrix
works again (?!).
x[i, ] <- value
and y[, j] <- value
is now an error in more cases
for m
-by-0 CsparseMatrix
x
and 0-by-n
CsparseMatrix
y
.
In these cases, subassignment gave a (formally) invalid result.
chol(<ds[yp]Matrix>)
now calls the underlying
C-level routine exactly once. Previously, it was called
an extra time in order to test for positive definiteness,
with the result thrown away (!). Hence these methods should
become approximately two times faster.
dimnames(chol(x))
is identical to dimnames(x)
in all cases, now even when chol(x)
is constructed from a
cached MatrixFactorization
, for greater consistency with
base::chol.default()
.
chol(<generalMatrix>)
no longer looks at
Dimnames
when testing for symmetry.
lu(<dtCMatrix>)
no longer returns an invalid
sparseLU
object in the lower triangular case.
lu(x)
had sometimes incorrectly cached its
return value as element "lu"
(rather than "LU"
)
of x@factors
. Now it is always "LU"
.
"Compare"
operators, e.g., a > b
, x != y
,
now work correctly in more dense unitriangular and sparse 0-extent
cases.
!<nMatrix>
is now always an nMatrix
, never
an lMatrix
.
!<ndenseMatrix>
and which(<ndenseMatrix>)
now correctly handle NA
as TRUE
.
anyNA(<denseMatrix>)
had incorrectly returned
anyNA(.@x)
in many cases, giving false positives
for some .(tr|sy)Matrix
and ndenseMatrix
.
Now methods respect the “rules” of these classes.
The boolean arithmetic product A %&% B
and e.g.,
crossprod(A, B, boolArith=TRUE)
now should behave as if
drop0(A)
and drop0(B)
were used, i.e., for formally
sparse matrices, the boolean product results should be stable with
respect to non-structural vs structural zeros.
t(<symmetricMatrix>)
now retains the factors
slot, avoiding recomputation.
qr(<large sparse>)
no longer segfaults in some cases,
but now warns about “Out of memory” and stops, fixing Matrix
bug #6610 reported by Benjamin Tyner.
Fixed <sparse> %*% <dense>
possible memory corruption,
visible via valgrind, fixing Matrix bug #6726 reported by David Cortes.
Fixed the (quite long standing) Matrix bug #6777,
reported by Manuel Koller: tcrossprod(<matrix>, <[dln]sCMatrix>)
has been wrong in some cases.
KhatriRao()
gets new sparseY = TRUE
option and
also works for more Matrix
classes.
Virtual class packedMatrix
gains methods for
pack
, unpack
, isSymmetric
,
isTriangular
, and isDiagonal
implemented in C,
replacing those defined for many subclasses individually.
New virtual class unpackedMatrix
containing
denseMatrix
_without_ packedMatrix
, with methods
for pack
, unpack
, isSymmetric
,
isTriangular
, isDiagonal
, t
, diag
,
and diag<-
implemented in C, replacing those defined for
many subclasses individually.
isTriangular
and isDiagonal
are now
implemented in C also for [CRT]sparseMatrix
and standard
matrix
. isSymmetric
is now implemented in C
for all denseMatrix
and all [CRT]sparseMatrix
,
though these C routines are currently only called when testing
for exact symmetry (always for [ln]Matrix
,
only when tol = 0
for dMatrix
).
Methods for isSymmetric
gain an argument
checkDN = TRUE
indicating whether symmetry of
Dimnames
should be checked. For backwards compatibility
and consistency with isSymmetric.matrix
from base,
the actual condition is checkDN && check.attributes
.
isTriangular(x, upper)
now has a kind
attribute if and only if x
is triangular and
upper
is NA
.
diag(<unpackedMatrix>) <- value
now behaves like
diag(<packedMatrix>) <- value
, supporting coercions
depending on typeof(value)
, consistent with diag<-
from base.
pack
and unpack
are now identity functions
for packedMatrix
and unpackedMatrix
arguments,
respectively (previously an error). pack(<.geMatrix>)
(previously an error) now behaves as pack(<matrix>)
,
i.e., by checking for symmetry or triangularity before packing.
unpack(<matrix>)
now works and is equivalent to
as(<matrix>, "unpackedMatrix")
, with result inheriting
from .(ge|tr|sy)Matrix
, as appropriate.
Many more validity methods implemented in C, for efficiency,
including methods for Matrix
, compMatrix
,
diagonalMatrix
, indMatrix
, pMatrix
,
corMatrix
, [liz]Matrix
, and ndenseMatrix
.
The validity method of dppMatrix
now follows
the validity method of dpoMatrix
, requiring non-negative
diagonal elements.
Validation of <Matrix>@Dimnames[[i]]
now tolerates
vector types other than character, which are coerced to character
in C via the new R_DimNames_fixup()
, for greater
consistency with base matrix()
.
band(x, k1, k2)
is optimized further for both
dense and sparse x
, returning triangularMatrix
,
symmetricMatrix
, and packedMatrix
in more cases.
band()
is now implemented also for
diagonalMatrix
(only tri[ul]()
worked before).
Coercions .ge<->.g[CRT]
, .t[rp]<->.t[CRT]
,
.s[yp]<->.s[CRT]
, and ..[CRT]<->matrix
are now
fully implemented and optimized, with minimal intermediate
allocations. These (and others) no longer rely on CHOLMOD,
which had handled integer types as double and required
preprocessing in many cases (with diagU2N()
, etc.).
Fixes in group methods (e.g., >
, &
, |
),
notably for matrices inheriting from class symmetricMatrix
,
triangularMatrix
, lMatrix
, or nMatrix
.
as.vector
, as.numeric
, and as.logical
are now implemented for all Matrix
.
Subassignment to indMatrix
is no longer prohibited,
now going via TsparseMatrix
.
indMatrix
gains methods for isTriangular
,
isDiagonal
, diag
, diag<-
, band
,
tri[ul]
, and forceSymmetric
. It also gains
coercions to more virtual classes (notably denseMatrix
)
and a coercion to pMatrix
.
solve(<ddenseMatrix>, <numLike>)
now works in all
cases.
determinant(<ds[yp]Matrix>)
is now much faster
in the positive definite case, no longer going via dgeMatrix
.
diag(<[CRT]sparseMatrix>)
is now done in C
and is highly optimized in the .[ts][CR]Matrix
case.
symmpart
and skewpart
are now done in C
for all denseMatrix
and all [CRT]sparseMatrix
.
Both now more faithfully preserve the “storage” of
their argument. (Previously, symmpart(<packedMatrix>)
was an unpackedMatrix
,
and (symm|skew)part(<[RT]sparseMatrix>)
was a CsparseMatrix
.)
as(<vector|matrix>, "([dln]?dense|[dlnCRT]?sparse)Matrix")
are now fully and more consistently implemented. In the vector case,
the result is now always a length
-by-1 generalMatrix
.
In the matrix case, structure is now always examined, hence the result
is a symmetricMatrix
or triangularMatrix
in more cases.
Matrix(<classed matrix>)
now works for classes
other than table
.
lu(<dt[rpCRT]Matrix>)
and lu(<ddiMatrix>)
now behave more consistently. In the diagonal, upper triangular,
and unit lower triangular cases, the result is obtained
“directly”, i.e., without pivoting. In the non-unit
lower triangular case, it is obtained with pivoting.
(Previously, pivoting was never done for dtCMatrix
and always done for dt[rpRT]Matrix
and ddiMatrix
.)
lu(x)
now caches its return value also for all
ds.Matrix
x
(by default).
readMM()
now warns if the number of entries found
is less than number reported in the header.
x[i]
now works for nMatrix
i
,
just as for lMatrix
i
. This supports constructions
such as x[is.na(x)]
, where the logical operation
produces an nMatrix
because it is never NA
.
AZERO()
and friends gain an argument specifying
a zero constant (0 for int
arrays, 0.0 for double
arrays).
C-level utilities (R_)?[gs]et_factors()
have been
renamed (R_)?[gs]et_factor()
, as they only ever get and
set one factor.
The signature of set_factor()
has been changed to
match other set*()
functions:
to (object,name,value)
from (object,value,name)
.
For clarity, set_factor()
now returns void
and is used like other set*()
functions (i.e., for its
side effect). The R interface is unchanged: R_set_factor()
continues to return the value being set.
C-level utilities
make_[di]_matrix_(triangular|symmetric)()
,
packed_to_full_(double|int)()
,
full_to_packed_(double|int)()
, and
install_diagonal(_int)?()
are replaced by safer, more consistently named ones.
Previous versions allowed integer overflow.
C-level utilities dup_mMatrix_as_d?geMatrix()
are
replaced by the more general dense_as_general()
, which
takes arguments controlling memory allocation and the
“kind” of the .geMatrix
result.
New C-level utility DimNames_is_symmetric()
with R interface isSymmetricDN()
, which should be
used consistently to test for symmetry of [dD]imnames
.
Note that these are intended to behave consistently with
symmetricMatrix_validate()
,
by allowing, e.g., list(NULL, nms)
,
but not, e.g., list(A = NULL, B = nms)
.
Coercions to triangularMatrix
and
symmetricMatrix
are now almost all inherited from
Matrix
, whose methods simply call tri[ul]()
and forceSymmetric()
if isTriangular()
and
isSymmetric()
, respectively, return TRUE
.
Many of the exported .*2*
utilities have been
redefined as aliases or wrappers of new, more general functions
(see below). These not-yet-deprecated functions have been
centralized in ‘R/denseMatrix.R’ and ‘R/sparseMatrix.R’.
New C-level utilities
R_(dense|sparse)_as_kind()
for coercion from one “kind” to another;
R_(dense|sparse)_as_general()
for coercion from triangular and symmetric to general;
R_(dense|sparse)_band()
for coercion to triangular (and other banded);
R_(unpacked*|packed*|sparse)_force_symmetric()
for coercion to symmetric;
R_(dense|sparse)_as_(sparse|dense)()
for coercion between dense and sparse of the same “kind”
and “structure”;
R_diagonal_as_sparse()
for coercion from diagonalMatrix
to any
[CRT]sparseMatrix
;
R_(dense|sparse|geMatrix)_as_(matrix|vector)()
for coercion to base matrix and vector; and
tCRsparse_as_RCsparse()
for the idioms
as(t(<[CR]sparseMatrix>), "[RC]sparseMatrix")
.
These all have not-yet-exported R wrappers.
indTri()
and indDiag()
now in C,
with a new argument packed
for efficiently indexing
packedMatrix
. indDiag()
now behaves sensibly
in the n = 0
case.
.M.kind()
, .M.shape()
, and (new)
.M.repr()
are now done in C via R_check_class_etc()
,
requiring a class definition only in “rare” cases.
diag(x)
methods now mostly also keep names
from
dimnames(x)
by default and obey names=*
more generally.
New virtual class packedMatrix
containing packed (dense)
symmetric and triangular matrices. Methods for subscripting,
including diag()
, notably keeping names by default and for
t()
which are memory efficient, i.e., do not work via
unpacking, thanks to Mikael Jagan.
New dmperm()
implementing a Dulmage-Mendelsohn
decomposition, thanks to the persistency of Mauricio Vargas (@uc.cl).
Export more low-level conversion utilities:
.n2dgT
, .m2ngCn
, .m2ngTn
.
Provide some matrix multiplication methods for "RsparseMatrix"
.
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
.
PROTECT()
3 more; as from ‘rchk’ for Matrix 1.4-0.
Slightly better patch notably for Windows, for ‘src/SuiteSparse_config/SuiteSparse_config.h’
Fix to continue working for R 3.5.0 and newer, providing
tryInvokeRestart()
for older versions of R, thanking
Michael Chirico for the heads up.
Modified AZERO()
to work with R_xlen_t
and new
AZEROs()
for size_t
; other tweaks to evade
-Wconversion
warnings.
Update many ‘src/*.c’ preventing integer overflow in “pointer” and index computations for large (dense) matrices; prompted by Dario Strbenac's post to R-devel.
sparse.model.matrix(.., contrasts.arg = <.. ddiMatrix ..>)
now works correctly, fixing R-forge Matrix bug #6673 by Davor Josipovic.
sparse.model.matrix(..)
now also works in cases the
contrast matrix has become a "denseMatrix"
; e.g., in a case
using poly(.)
in the formula; now works correctly, fixing
R-forge Matrix bug #6657 and useful suggestions by Nick Hanewinckel.
Fixed the internal attr.all_Mat()
auxiliary for
all.equal()
, notably for the case when exactly one of the
matrices is a base matrix
.
Fixed long-standing bug in the rbind2()
method for
logical dense matrices, specifically "lgeMatrix"
, thanks to
the notice by Aaron Lun.
fix leak in C-level Csparse_to_dense()
thanks to Bill
Dunlap in R's PR#18204 and install_lu()
called from solve(<dgCMatrix>)
in PR#18206.
fix leak in crossprod(<dsTMatrix>), thanks to report and patch in PR#18205 by Bill Dunlap.
band(M, k1, k2)
now also works when k1 * k2
is
larger than 2^31-1, the maximal integer, fixing R-forge Matrix bug
#6743 by Ariel Paulson. Further, it works when M
is a sparse
"symmetricMatrix"
but the band is not symmetric, k1 != -k2
.
fix leak in C-level code for cbind(m1,m2)
or
rbind(*)
when m1
is "n.Csparse"
and m2
is
not, thanks to Bill Dunlap's diagnosis and patch in R's PR#18210.
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 bug #6745.
inverting or solving dsCMatrix
no longer catches C level
warnings too early which would not free, but rather leak memory;
thanks to Bill Dunlap's analysis and patch in R's PR#18214.
Additionally, such warnings and error are message()
d when
getOption("Matrix.verbose")
is >= 1
.
‘test-tools-1.R’: Sys.memGB()
can no longer use
memory.limit()
on Windows; no returns NA.value = 2.10201
in such cases.
ss <- <sparseVector>[i]
gave an invalid sparseVector
ss
as ss@i
was not necessarily sorted; thanks to a
report by Quran Wu.
as(<dsyMatrix>, "generalMatrix")
and similar, sometimes
did not use (C-level) symmetric_Dimnames()
etc; report
(to R's PR#18250 by Mikael Jagan); fixed all on C level. As a
consequence, you will now see more preserved dimnames after
matrix transformations or operations which involved symmetric matrices.
as(<ddiMatrix>, "matrix")
no longer loses dimnames,
thanks to Mikael Jagan's report as Matrix bug #6751.
No longer include ‘Rdefines.h’ as it is somewhat deprecated.
Update matrix(<data>, n,m)
in ‘tests/*’ to work with
R-devel CMD check --as-cran
cBind()
and rBind()
are now defunct:
simply use cbind()
and rbind()
instead.
For now revert to R (>= 3.5.0)
dependency to accomodate
users on older R installations.
Fixed a thinko (in 1.3-2): Now direct coercion from
"ddiMatrix"
to "dgCMatrix"
, and hence, e.g.,
as(Matrix(1, sparse=TRUE), "dgCMatrix") now works.
Fixed error message in <dtrMatrix> multiplication.
Fixed long-standing bug in R[,j] <- v
when R
is "Rsparse*",
R-forge Matrix bug #6709 by David Cortes.
‘./include/cholmod.h’ and ‘./include/Matrix_stubs.h’ needed updating from SparseSuite update; R-forge Matrix bug #6714 by Kasper Kristensen (TMB pkg).
as.matrix()
and as.array()
now work for
"sparseVector"
s as expected; see Matrix bug #6708.
M[,]
(and similar) now work as in base R;
R-forge Matrix bug #6720 by David Cortes.
-S
now works also when S
has no 'factors' slot.
It signalled an error, e.g., for sparse triangular matrices S
;
R-forge Matrix bug #6656, reported by Chun Fung (Jackson) Kwok.
M*2
and similar no longer keep cached factorizations (in
'factors' slot), but drop them via internal new .empty.factors()
.
R-forge Matrix bug #6606, reported by Tomas Lumley.
removed the nowhere used (and unexported but still active)
class union "Mnumeric"
which actually trickled into many base
classes properties. Notably would it break validity of factor
with a proposed change in validity checking, as factors were also
"Mnumeric"
but did not fulfill its validity method.
Similarly removed (disabled) unused class union "numericVector"
.
removed a few duplicated .alias{.}
from ‘man/*.Rd’.
translation updates (of outlines only); finally added Italian (by Daniele Medri) to svn; updated French (by Philippe Grosjean), forgotten (R part of) Korean. New Lithuanian translations by Gabriele Stupuriene & Rimantas Zakauskas.
In internal diagOdiag()
method, no longer use
matrix(x, n,n)
when x
is longer than n*n.
Update tests/*.R to future matrix(x, n,k)
warning in more
mismatch cases.
Eliminating the need for ‘ftp://*’, add the very small
jgl009
MatrixMarket example to our ‘external/’ files.
rankMatrix()
tweaks for the singular values based methods,
notably method = "maybeGrad"
.
as(new("dtCMatrix", diag="U"), "matrix")
now works, as
C-level diagU2N()
now also works for 0-dimensional triangular
matrices; this also fixes a subsetting (“indexing”) bug of
such 0-dimensional matrices, thanks to a report by Aaron Lun.
logical subsetting of 0-dim. (diagonal/triangular) matrices fixes.
The new FCONE
macros added for newer Fortran/C compiler
combinations are now defined back compatibly with R >= 3.6.0.
chol(<diagonal dt[CRT]Matrix>)
now works.
‘rchk’: fix potentially unPROTECT
ed vars in
‘src/dsyMatrix.c’
rankMatrix(<dense>, method="qr.R")
no longer assumes
non-negative diagonal entries of the R
matrix.
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 NA
s.
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"
).
Subassignment to "diagonalMatrix"
now returns
sparse "triangularMatrix"
more often; also (sparse)
"symmetricMatrix"
.
nearPD()
gets new option: If base.matrix = TRUE
,
the resulting mat
component is a base matrix
, as
often used desired when nearPD()
is used outside the
Matrix package context.
Factored out new qr2rankMatrix()
utility from
rankMatrix()
.
New BunchKaufman(<matrix>)
method.
Added wrld_1deg
sparse matrix example to
distributed version of Matrix (no longer excluding it
via ‘.Rbuildignore’).
New (simple) mat2triplet()
function to be used instead
of summary(<sparseMatrix>)
in code.
Internal .diag2tT()
gains new option drop0 = TRUE
and hence now by default drops zero diagonal entries. Consequently,
e.g., as(<diagonalMatrix>, "CsparseMatrix")
now drops such
zeros, too.
Updated the crucial underlying C libraries from SuiteSparse,
from 4.2.1 to 5.7.1 (from 2020-02-20), visible in .SuiteSparse_version()
.
sparseMatrix()
gets new argument repr = "C"
,
superseding the (now deprecated) giveCsparse = TRUE
. Allows
to return "RsparseMatrix"
matrices.
Similarly, rsparsematrix()
, fac2sparse()
and fac2Sparse()
get the new repr
argument and their giveCsparse
is
deprecated, sometimes only informally for now.
sparse.model.matrix()
gets option sep = ""
, with,
e.g., sep = ":"
allowing to get easier column names; from
R-forge Matrix (non-)bug #6581, by Vitalie Spinu.
rankMatrix(<sparse>, method="qr")
now returns NA
(or NaN
) instead of signalling an error in the case the sparse
Q R
decomposition gave NA
s in diag(R)
.
Coercion (as(., .)
) from e.g., "lsyMatrix"
to
"CsparseMatrix"
silently made asymmetric dimnames symmetric,
as did the internal forceCspSymmetric(*, dimNames)
which may be called from forceSymmetric()
.
Adapt code to new Fortran requirements of passing length of character arguments, thanks to Brian Ripley.
(R-forge Matrix bug #6659, reported by Georg Kindermann):
<sparseVector>[i] <- val
bug fixed.
(R-forge Matrix bug #6666, reported by Ezra Tucker):
which(<ldiMatrix>, array.ind=TRUE)
thinko fixed.
For R-devel Dec 4, 2020: adapt all.equal() check of sparse matrix images (which contain panel functions with environments ..).
tried fixing warning 'cholmod_factorize_p' accessing 16 bytes in a region of size 8 [-Wstringop-overflow=] in ‘src/dsCMatrix.c’ (in two places); seen by pre-release-gcc11 compilation.
Fix last(?) PROTECT()
warning found by rchk
in
‘src/dense.c’'s ddense_skewpart()
.
as(m, "dgTMatrix")
does not lose dimnames
anymore
when m
is a (traditional) matrix
.
M[logical(0), ]
now has dimension 0 x k
for sparse
M
as for base matrices.
log(M, base)
(the 2-argument version of log()
)
wrongly gave the result for base = exp(1)
, i.e., the 1-argument default.
‘test-tools-Matrix.R’: Qidentical()
no longer assumes
class(<matrix>)
to be of length 1.
‘test-tools-1.R’: provide bug-fixed canCoerce()
in
old R versions.
(none)
Fix new PROTECT()
warnings (bugs?) found by rchk
.
Provide isFALSE()
for R < 3.5.0 as now need it for
sparseMatrix printing.
regression tests depending on sample()
now are future
proof reproducible, via RNGversion(.)
.
give information about #{rows} and #{columns} that are
suppressed in print()ing if the matrix is larger than max.print
.
data(<Matrix-data>)
no longer attaches Matrix to
the search path.
"Ops"
group methods, i.e., "Arith", "Compare" & "Logic",
now should all work with 0-extent matrices as well, thanks to bug
reports by Aaron Lun, University of Cambridge.
when printing and formatting sparse matrices, see formatSpMatrix()
,
the maxp
option, e.g., from getOption("max.print")
, is
“rounded up” to 100, as very small values are very rarely appropriate.
image()
gets new optional argument border.color
.
image(Matrix(0, n,m))
now works.
German translation updates.
one more PROTECT()
.
Faster as(<matrix>, "sparseMatrix")
and coercion
"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.
cbind(NULL,<Matrix>)
no longer return NULL
;
analogously for rbind()
, rbind2()
, cbind2()
,
fixing very long standing typo in the corresponsing cbind2()
and rbind2()
methods.
The deprecation warning (once per session) for
cBind()
and rBind()
finally works (fixing a simple thinko).
cbind()
and rbind()
for largish sparse
matrices no longer gives an error because of integer overflow
(in the default case where sparse
is not been specified
hence is chosen by a nnzero()
based heuristic).
.symDiagonal(5, 5:1)
and .trDiagonal(x = 4:1)
now work as expected.
Sp[i]
now is much more efficient for large sparse
matrices Sp
, notably when the result is short.
<sparseVector>[ <negative integer> ]
now also gives
the correct answer when the result is “empty”, i.e., all
zero or false.
large "dspMatrix"
and "dtpMatrix"
objects can
now be constructed via new(*, Dim = *, x = *)
also when
length(x)
is larger than 2^31 (as the C internal
validation method no longer suffers from integer overflow).
More ‘PROTECT()’ing to be “rather safe than sorry” thanks to Tomas Kalibera's check tools.
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.
(R-forge Matrix bug #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.
using Authors@R
in ‘../DESCRIPTION’ to list all
contributors.
solve(-m)
no longer should use a cached Cholesky
factorization (of m
).
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)
rankMatrix(<matrix of all 0>)
now gives zero for all
methods, as it should be.
no longer calling length(NULL) <- <positive>
which
has been deprecated in R-devel since July.
qr.coef(<sparseQR>, y)
now finally has correct (row)
names (from pivot back permutation).
.trDiagonal()
utility is now exported.
quite a collection of new PROTECT(.)
's thanks to
Tomas Kalibera's ‘rprotect’ analysis.
"Ops"
between "table", "xtabs", and our matrices now work.
as(matrix(diag(3), 3, dimnames=rep(list(c("A","b","c")),2)),
"diagonalMatrix")@x
is no longer named.
norm(x, "2")
now works as well (and equivalently to base::norm
).
sparseVector()
now also works without x
argument.
c.sparseVector()
method for c()
of
sparseVectors (and available as regular function on purpose).
as(Diagonal(3), "denseMatrix")
no longer returns a
non-dense "ddiMatrix"
.
S[sel,] <- value
and similar no longer segfault, but
give a "not (yet?) supported"
error
for sparse matrices S
and logical sel
when
sel
contains NA
s.
The same error (instead of a low-level one) is signalled for
indexing (with NA-containing logical sel
), i.e.,
S[sel,]
.
which(x, arr.ind=TRUE, *)
(when x
is a
"lMatrix"
or "nMatrix"
) now works the same as
base::which
, obeying an optional useNames
argument
which defaults to TRUE
. Previously, the resulting
two-column matrix typically had empty dimnames
.
0-length matrix "Ops"
(binary operations) are now
compatible to R-devel (to be R 3.4.0).
C-API: SuiteSparse_long
is now defined as
int64_t
on all platforms, and we now include (C99) ‘inttypes.h’
x[.] <- value
now also works for
"sparseVector"
's, both as x
and as value
.
x[FALSE] <- value
now also works for "sparseVector"
's.
rep(x, *)
now works for "sparseVector"
s and
sparse and dense "Matrix"
-classed matrices x
.
solve(<sparse_LU>)
no gives an error in some cases of
singular matrices, where before the C code accessed illegal memory locations.
in C code, protect _POSIX_C_SOURCE by #ifdef __GLIBC__
cBind()
and rBind()
have been almost silently
deprecated in R >= 3.2.0
and now give a warning,
“once per session” only.
bandSparse(*, k=k, *)
now returns matrices inheriting from
"triangularMatrix"
when obvious from the diagonal indices k
.
KhatriRao(X,Y)
now also works when X
or
Y
is completely zero.
The 0-dim. Matrix multiplication fix in 1.2-5 did trigger wrong warnings in other diagonal matrix multiplications.
isSymmetric(m)
now also works for "indMatrix"
m
.
isSymmetric(m)
is faster for large dense asymmetric matrices.
Matrix multiplications (A %*% B
) now work correctly
when one of the matrices is diagonal and the other has a zero dimension.
sparseMatrix()
gets new argument triangular
and a smarter default for dims
when symmetric
or
triangular
is true.
as(<sparse>, "denseMatrix")
now works in more cases
when prod(dim(.))
is larger than 2^{31} - 1
.
Hence, e.g., !S
now works for much larger sparse matrices
S
.
creating very large dense matrices, e.g., by
as(<sparseM.>, "matrix")
would segfault (in case it could
allocate enough storage).
MatrixClass()
is exported now.
More exports of semi-internal functions (for speed, named
".<foo>"
, i.e., inofficial API), such as .solve.dgC.lu()
.
more Korean translations
Packages linking to Matrix (LinkingTo:
in ‘DESCRIPTION’) now find
‘alloca’ properly defined in ‘Matrix.h’ even for non-GNU
compilation environments such as on Solaris or AIX.
extended "n?CMatrix" classes (e.g., from setClass(.,
contains="ngCMatrix")
) now can be coerced via as(.)
to
"d.CMatrix"
.
The printing of largish sparse matrices is improved, notably
in the case where columns are suppressed, via new fitWidth =
TRUE
option in printSpMatrix2()
.
cbind2()
and rbind2()
no longer fail to
determine sparse
when it is unspecified and hence
NA
, fixing R-forge bug #6259.
Explicitly import from “base” packages such as "stats"
.
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 R-forge bug #6018.
"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
.
For symmetricMatrix
objects which have symmetrical
dimnames by definition, it is allowed to only set one half of the
dimnames
to save storage, e.g., list(NULL, nms)
is
semantically equivalent to list(nms, nms)
.
as.vector(<sparseVector>)
etc, now work, too.
lu(<sparseMatrix>)
now keeps dimnames
.
better ‘NEWS.Rd’ (which pleases Kurt and tidy
;-)
S[] <- T
and S[] <- spV
now work (in more cases)
for sparse matrices S, T and sparseVector spV
.
Huge dense matrix multiplication did lead to segfaults, see R-help, “does segfault mean (always) a bug?”, May 5, 2015. Fixed by using C's Alloca() only in smallish cases.
Optional arguments in image()
, e.g., main=
<..>)
now also work for lgCMatrix
, nMatrix
etc;
thanks to a 4.5 years old report by Mstislav Elagin.
dimnames(A) <- val
now resets the factors
slot
to empty, as the factorizations now keep dimnames more often.
crossprod(<matrix>, Diagonal(<n>))
works again (and
these are tested more systematically).
Matrix products (%*%
, crossprod
, and
tcrossprod
) for "dtrMatrix"
are correct in all
cases, including keeping dimnames.
Matrix(d)
(and other coercions to "Matrix"
)
now correctly keeps dimnames
also when d
is a
traditional diagonal "matrix"
.
New %&%
for “boolean arithmetic” matrix product.
New argument boolArith = NA
in crossprod()
and
tcrossprod()
. boolArith = TRUE
now forces boolean
arithmetic, where boolArith = FALSE
forces numeric one.
Several of these products are more efficient thanks to new C
functionality based on our new chm_transpose_dense()
, and
others based on geMatrix_crossprod
,
geMatrix_matrix_mm
, etc.
Most dense matrix products, also for non-dgeMatrix
,
including "l..Matrix"
and "n..Matrix"
ones are now
directly handled by new .Call()
s.
"dMatrix"
(numeric) and "lMatrix"
(logical)
matrices can now be coerced to "nMatrix"
(non-zero pattern
or “boolean”) even when they contain NA
s, which then
become TRUE
s.
More thorough checking of cbind2()
and
rbind2()
methods, notably as they are called from cbind()
and rbind()
from R version 3.2.0 on.
rbind2(<dense>, <dense>)
is faster, being based on new C code.
symmetric Matrices (i.e., inheriting from
"symmetricMatrix"
) are allowed to have dimnames
of
the form list(NULL, <names>)
and now print correctly
and get correctly coerced to general matrices.
indMatrix
object (“index matrices”) no longer
need to be “skinny”.
rsparseMatrix()
now accepts rand.x = NULL
and
then creates a random pattern matrix
("nsparseMatrix"
).
anyDuplicatedT()
and uniqTsparse()
low level
utilities are exported now.
Partial Korean translations of messages.
For R \ge 3.2.0
, cBind()
and rBind()
are deprecated, as they are no longer needed since cbind()
and rbind()
do work automatically.
Fix some rbind2()
methods.
t()
now transposes the dimnames even for symmetric
matrices.
diag(M) <- val
did not always recycle val
to
full length, e.g., when M
was a "dtrMatrix"
.
crossprod(<indMatrix>)
was wrong in cases where the
matrix had all-zero columns.
Matrix products (%*%
, crossprod
, and
tcrossprod
) with one sparse and one dense argument now
return numeric (a "dMatrix"
) when they should, i.e.,
unless the new setting boolArith = TRUE
is applied.
More use of anyNA()
(for speedup).
Matrix products (%*%
, crossprod
,
tcrossprod
) now behave compatibly to R 3.2.0, i.e., more
lenient in matching dimensions for matrix - vector products.
isTriangular()
gets new optional argument upper = NA
.
crossprod()
and tcrossprod()
fixes for
several <diagonal> o <sparse> combinations.
rowMeans(<dgeMatrix>, na.rm=TRUE)
was wrong sometimes.
fix and speedup of coercions (as(., .)
) from and to
symmetric or triangular matrices.
invPerm()
coercion to integer
dimnames( solve(.,.) )
fix [r3036]
tril()
and triu()
now return correct uplo
.
names(dimnames(.))
now preserved, e.g. in
symmpart()
or subsetting (A[i,j]
).
new rsparsematrix()
for random sparse Matrices.
improved warnings, notably for unused arguments previously
swallowed into ...
.
crossprod(<vec>, <dsyMatrix>)
fixed.
crossprod()
and kronecker()
fixes for some
<indMatrix> cases.
%*%
and crossprod()
now also work with
sparseVector
s.
speedup of crossprod(v, <sparseM>)
, thanks to nudge
by Niels Richard Hansen.
new help page for all such matrix products (‘../man/matrix-products.Rd’).
image()
now gets correct ylim
again.
More consistent matrix products.
correct adaption to R 3.1.0
using tolerance
(and not ‘tol’) in all.equal()
export fast power-user coercion utilities
.dsy2mat()
, .dxC2mat()
, .T2Cmat()
, ..2dge()
.
matrix products now (mostly) work with sparseVector
s;
and correctly in some more cases.
Testing code's assertWarning()
adapted for R \le 3.0.1
.
Depends: R >= 2.15.2
eases checking.
image(.., xlim, ylim)
: nicer defaults
for the axis limits, and ylim
is sorted decreasingly; not
strictly back-compatible but should never harm.
rankMatrix(*, method="qr")
now using tol
T2graph()
and graph2T()
export old functionality explicitly.
Tweaks in conversions between "graph"
and
"sparseMatrix"
objects. Notably, as(<graph>,
<Matrix>)
now more often returns a (0/1 pattern) "n..Matrix".
sparseMatrix()
: new use.last.ij
argument.
KhatriRao()
: fix rownames (X <-> Y)
qr.coef()
, qr.fitted
, and qr.resid
now
also work with sparse RHS y
.
sparse matrix “sub assignments”, e.g., M[ii] <- v
,
speedup and fixes.
bug fixes also in M[negative indices] <- value
and
<sparseMatrix>[cbind(i,j)]
.
fac2sparse
and fac2Sparse
now exported, with a
new giveCsparse
option.
Update to latest SuiteSparse
C library by Tim Davis,
U. Florida.
ensuing “C API changes”
new .SuiteSparse_version()
function
Many ‘Imports:’ instead of ‘Depends:’.
fixed long lasting undetected solve(<dsCMatrix>, *)
bug.
Our all.equal()
methods no longer sometimes return
c("TRUE", "....difference..")
.
rankMatrix(<matrix>)
: fix the internal x.dense
definition.
Revert some wrong changes to solve(<sparse>, *)
from
1.0-13 (“stop gap fix” for R 3.0.2).
New (efficient) KhatriRao()
function by Michael Cysouw
New "indMatrix"
class of “index matrices”, a
generalization of "pMatrix"
, the permutation matrices, many
methods generalized from pMatrix to indMatrix. All (initial)
functionality contributed by Fabian Scheibl, Univ. Munich.
Export and document isDiagonal()
and
isTriangular()
as they are useful outside of Matrix.
rankMatrix(M, method="qr")
no longer needs
sval
which makes it considerably more useful for large
sparse M
.
Start providing anyNA
methods for R >= 3.1.0
.
solve(<sparse> a, <sparse> b)
: if a
is
symmetric, now compute sparse result.
nearPD()
gets new option conv.norm.type = "I"
.
determinant(<dpoMatrix>)
now uses chol()
, and
hence also an existing (‘cached’) Cholesky factor.
3 new C -> R
utilities (including hidden R function
.set.factors()
for caching also from R, not just in C).
M[] <- v
for unitriangular M
now correct.
lu(.)
no longer sometimes returns unsorted columns.
.
.
.
as(<csr>, "dgCMatrix")
(from package SparseM)
now works again.
.
.sparseDiagonal()
: new unitri
argument, and
more flexibility;
new solve(<dsCMatrix>, <missing>)
via efficient C code.
.
new sparseVector()
constructor function.
is.finite()
is.infinite()
now work for our
matrices and "*sparseVector" objects.
diag(.) <- V
now preserves symmetricity,
triangularity and even uni-triangularity sometimes.
Quite a few fixes for Ops
(arithmetic, logic, etc)
group methods.
Ditto for diagonalMatrix
methods.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
During Doug Bates' sabbatical in Zurich, Martin Maechler becomes co-author of the Matrix package.
Beginning of class reorganization with a more systematic naming scheme.
More (correct) coercions as(<from>, <to>)
.
lme4 / lmer specific R code moved out to lme4 package.
.
Doug Bates (only)
Sparse matrices, classes and methods, partly via
Interface to LDL, TAUCS, Metis and UMFPACK C libraries
.............................................
The first CRAN release of the Matrix package, titled “A Matrix library for R” authored by Douglas Bates (maintainer, principal author) and Saikat DebRoy.
Matrix()
constructor for R objects of class Matrix
.
Matrix.class()
returning informal subclasses such as
"Hermitian"
, "LowerTriangular"
is.Orthonormal()
, is.Hermitian()
,
is.UpperTriangular()
functions.
SVD()
, lu()
, and schur()
decomposition
generics with "Matrix"
methods.
rcond()
, norm()
, det()
;
expand()
and facmul()
.
C++ interface to LAPACK