#### Containing all cbind2() and rbind2() methods for all our Matrices
###-- General -----------------------------------------------------------
###-- Dense, incl Diagonal ----------------------------------------------
###-- Sparse ------------------------------------------------------------
for(f in c("cbind2", "rbind2")) {
setMethod(f, signature(x = "sparseMatrix", y = "matrix"),
function(x, y) callGeneric(x, as_Csparse2(y)))
setMethod(f, signature(x = "matrix", y = "sparseMatrix"),
function(x, y) callGeneric(as_Csparse2(x), y))
}
## originally from ./Matrix.R : -------------------------------
## The trivial methods :
setMethod("cbind2", signature(x = "Matrix", y = "NULL"),
function(x, y) x)
setMethod("cbind2", signature(x = "Matrix", y = "missing"),
function(x, y) x)
setMethod("cbind2", signature(x = "NULL", y="Matrix"),
function(x, y) x)
## using "atomicVector" not just "numeric"
setMethod("cbind2", signature(x = "Matrix", y = "atomicVector"),
function(x, y) callGeneric(x, matrix(y, nrow = nrow(x))))
setMethod("cbind2", signature(x = "atomicVector", y = "Matrix"),
function(x, y) callGeneric(matrix(x, nrow = nrow(y)), y))
setMethod("cbind2", signature(x = "ANY", y = "Matrix"),
function(x, y) .bail.out.2(.Generic, class(x), class(y)))
setMethod("cbind2", signature(x = "Matrix", y = "ANY"),
function(x, y) .bail.out.2(.Generic, class(x), class(y)))
setMethod("rbind2", signature(x = "Matrix", y = "NULL"),
function(x, y) x)
setMethod("rbind2", signature(x = "Matrix", y = "missing"),
function(x, y) x)
setMethod("rbind2", signature(x = "NULL", y="Matrix"),
function(x, y) x)
setMethod("rbind2", signature(x = "Matrix", y = "atomicVector"),
function(x, y) callGeneric(x, matrix(y, ncol = ncol(x))))
setMethod("rbind2", signature(x = "atomicVector", y = "Matrix"),
function(x, y) callGeneric(matrix(x, ncol = ncol(y)), y))
setMethod("rbind2", signature(x = "ANY", y = "Matrix"),
function(x, y) .bail.out.2(.Generic, class(x), class(y)))
setMethod("rbind2", signature(x = "Matrix", y = "ANY"),
function(x, y) .bail.out.2(.Generic, class(x), class(y)))
## Makes sure one gets x decent error message for the unimplemented cases:
setMethod("cbind2", signature(x = "Matrix", y = "Matrix"),
function(x, y) {
rowCheck(x,y)
stop(gettextf("cbind2() method for (%s,%s) not-yet defined",
class(x), class(y)))
})
## Use a working fall back {particularly useful for sparse}:
## FIXME: implement rbind2 via "cholmod" for C* and Tsparse ones
setMethod("rbind2", signature(x = "Matrix", y = "Matrix"),
function(x, y) {
colCheck(x,y)
t(cbind2(t(x), t(y)))
})
## originally from ./denseMatrix.R : -------------------------------
### cbind2
setMethod("cbind2", signature(x = "denseMatrix", y = "numeric"),
function(x, y) {
d <- dim(x); nr <- d[1]; nc <- d[2]
y <- rep(y, length.out = nr) # 'silent procrustes'
## beware of (packed) triangular, symmetric, ...
x <- as(x, geClass(x))
x@x <- c(x@x, as.double(y))
x@Dim[2] <- nc + 1L
if(is.character(dn <- x@Dimnames[[2]]))
x@Dimnames[[2]] <- c(dn, "")
x
})
## the same, (x,y) <-> (y,x):
setMethod("cbind2", signature(x = "numeric", y = "denseMatrix"),
function(x, y) {
d <- dim(y); nr <- d[1]; nc <- d[2]
x <- rep(x, length.out = nr)
y <- as(y, geClass(y))
y@x <- c(as.double(x), y@x)
y@Dim[2] <- nc + 1L
if(is.character(dn <- y@Dimnames[[2]]))
y@Dimnames[[2]] <- c("", dn)
y
})
setMethod("cbind2", signature(x = "denseMatrix", y = "matrix"),
function(x, y) callGeneric(x, as_geSimpl(y)))
setMethod("cbind2", signature(x = "matrix", y = "denseMatrix"),
function(x, y) callGeneric(as_geSimpl(x), y))
setMethod("cbind2", signature(x = "denseMatrix", y = "denseMatrix"),
function(x, y) {
nr <- rowCheck(x,y)
ncx <- x@Dim[2]
ncy <- y@Dim[2]
## beware of (packed) triangular, symmetric, ...
hasDN <- !is.null(dnx <- dimnames(x)) |
!is.null(dny <- dimnames(y))
x <- as(x, geClass(x))
y <- as(y, geClass(y))
x@x <- c(x@x, y@x)
x@Dim[2] <- ncx + ncy
if(hasDN) {
## R and S+ are different in which names they take
## if they differ -- but there's no warning in any case
rn <- if(!is.null(dnx[[1]])) dnx[[1]] else dny[[1]]
cx <- dnx[[2]] ; cy <- dny[[2]]
cn <- if(is.null(cx) && is.null(cy)) NULL
else c(if(!is.null(cx)) cx else rep.int("", ncx),
if(!is.null(cy)) cy else rep.int("", ncy))
x@Dimnames <- list(rn, cn)
}
x
})
### rbind2 -- analogous to cbind2 --- more to do for @x though:
setMethod("rbind2", signature(x = "denseMatrix", y = "numeric"),
function(x, y) {
if(is.character(dn <- x@Dimnames[[1]])) dn <- c(dn, "")
y <- rbind2(as(x,"matrix"), y)
new(paste(.M.kind(y), "geMatrix", sep=''), x = c(y),
Dim = x@Dim + 1:0, Dimnames = list(dn, x@Dimnames[[2]]))
})
## the same, (x,y) <-> (y,x):
setMethod("rbind2", signature(x = "numeric", y = "denseMatrix"),
function(x, y) {
if(is.character(dn <- y@Dimnames[[1]])) dn <- c("", dn)
x <- rbind2(x, as(y,"matrix"))
new(paste(.M.kind(x), "geMatrix", sep=''), x = c(x),
Dim = y@Dim + 1:0, Dimnames = list(dn, y@Dimnames[[2]]))
})
setMethod("rbind2", signature(x = "denseMatrix", y = "matrix"),
function(x, y) callGeneric(x, as_geSimpl(y)))
setMethod("rbind2", signature(x = "matrix", y = "denseMatrix"),
function(x, y) callGeneric(as_geSimpl(x), y))
setMethod("rbind2", signature(x = "denseMatrix", y = "denseMatrix"),
function(x, y) {
nc <- colCheck(x,y)
nrx <- x@Dim[1]
nry <- y@Dim[1]
dn <-
if(!is.null(dnx <- dimnames(x)) |
!is.null(dny <- dimnames(y))) {
## R and S+ are different in which names they take
## if they differ -- but there's no warning in any case
list(if(is.null(rx <- dnx[[1]]) && is.null(ry <- dny[[1]]))
NULL else
c(if(!is.null(rx)) rx else rep.int("", nrx),
if(!is.null(ry)) ry else rep.int("", nry)),
if(!is.null(dnx[[2]])) dnx[[2]] else dny[[2]])
} else list(NULL, NULL)
## beware of (packed) triangular, symmetric, -> "cheap" (FIXME):
x <- rbind2(as(x,"matrix"), as(y,"matrix"))
new(paste(.M.kind(x), "geMatrix", sep=''), x = c(x),
Dim = c(nrx + nry, nc), Dimnames = dn)
})
## originally from ./diagMatrix.R : --------------------------------------
## For diagonalMatrix: preserve sparseness {not always optimal, but "the law"}
## hack to suppress the obnoxious dispatch ambiguity warnings:
diag2Sp <- function(x) suppressWarnings(as(x, "CsparseMatrix"))
setMethod("cbind2", signature(x = "diagonalMatrix", y = "sparseMatrix"),
function(x,y) cbind2(diag2Sp(x), as_Csparse2(y)))
setMethod("cbind2", signature(x = "sparseMatrix", y = "diagonalMatrix"),
function(x,y) cbind2(as_Csparse2(x), diag2Sp(y)))
setMethod("rbind2", signature(x = "diagonalMatrix", y = "sparseMatrix"),
function(x,y) rbind2(diag2Sp(x), as_Csparse2(y)))
setMethod("rbind2", signature(x = "sparseMatrix", y = "diagonalMatrix"),
function(x,y) rbind2(as_Csparse2(x), diag2Sp(y)))
## in order to evade method dispatch ambiguity, but still remain "general"
## we use this hack instead of signature x = "diagonalMatrix"
for(cls in names(getClass("diagonalMatrix")@subclasses)) {
setMethod("cbind2", signature(x = cls, y = "matrix"),
function(x,y) cbind2(diag2Sp(x), as_Csparse2(y)))
setMethod("cbind2", signature(x = "matrix", y = cls),
function(x,y) cbind2(as_Csparse2(x), diag2Sp(y)))
setMethod("rbind2", signature(x = cls, y = "matrix"),
function(x,y) rbind2(diag2Sp(x), as_Csparse2(y)))
setMethod("rbind2", signature(x = "matrix", y = cls),
function(x,y) rbind2(as_Csparse2(x), diag2Sp(y)))
## These are already defined for "Matrix"
## -- repeated here for method dispatch disambiguation {"design-FIXME" ?}
setMethod("cbind2", signature(x = cls, y = "atomicVector"),
function(x, y) callGeneric(x, matrix(y, nrow = nrow(x))))
setMethod("cbind2", signature(x = "atomicVector", y = cls),
function(x, y) callGeneric(matrix(x, nrow = nrow(y)), y))
setMethod("rbind2", signature(x = cls, y = "atomicVector"),
function(x, y) callGeneric(x, matrix(y, ncol = ncol(x))))
setMethod("rbind2", signature(x = "atomicVector", y = cls),
function(x, y) callGeneric(matrix(x, ncol = ncol(y)), y))
}
## originally from ./dsparseMatrix.R : --------------------------------
setMethod("cbind2", signature(x = "sparseMatrix", y = "sparseMatrix"),
function(x, y) {
nr <- rowCheck(x,y)
## beware of (packed) triangular, symmetric, ...
hasDN <- !all(lapply(c(dnx <- dimnames(x),
dny <- dimnames(y)), is.null))
ans <- .Call(Csparse_horzcat,
as_Csparse2(x), as_Csparse2(y))
if(hasDN) {
## R and S+ are different in which names they take
## if they differ -- but there's no warning in any case
rn <- if(!is.null(dnx[[1]])) dnx[[1]] else dny[[1]]
cx <- dnx[[2]] ; cy <- dny[[2]]
cn <- if(is.null(cx) && is.null(cy)) NULL
else c(if(!is.null(cx)) cx else rep.int("", ncol(x)),
if(!is.null(cy)) cy else rep.int("", ncol(y)))
ans@Dimnames <- list(rn, cn)
}
ans
})
setMethod("rbind2", signature(x = "sparseMatrix", y = "sparseMatrix"),
function(x, y) {
nr <- colCheck(x,y)
## beware of (packed) triangular, symmetric, ...
hasDN <- !all(lapply(c(dnx <- dimnames(x),
dny <- dimnames(y)), is.null))
ans <- .Call(Csparse_vertcat,
as_Csparse2(x), as_Csparse2(y))
if(hasDN) {
## R and S+ are different in which names they take
## if they differ -- but there's no warning in any case
cn <- if(!is.null(dnx[[2]])) dnx[[2]] else dny[[2]]
rx <- dnx[[1]] ; ry <- dny[[1]]
rn <- if(is.null(rx) && is.null(ry)) NULL
else c(if(!is.null(rx)) rx else rep.int("", nrow(x)),
if(!is.null(ry)) ry else rep.int("", nrow(y)))
ans@Dimnames <- list(rn, cn)
}
ans
})
if(FALSE) {
## FIXME
##------------- maybe a bit faster --- but too much to maintain
## would have to be done for "rbind2" as well ...
setMethod("cbind2", signature(x = "sparseMatrix", y = "numeric"),
function(x, y) {
d <- dim(x); nr <- d[1]; nc <- d[2]; cl <- class(x)
x <- as_Csparse2(x)
if(nr > 0) {
y <- rep(y, length.out = nr) # 'silent procrustes'
n0y <- y != 0
n.e <- length(x@i)
x@i <- c(x@i, (0:(nr-1))[n0y])
x@p <- c(x@p, n.e + sum(n0y))
x@x <- c(x@x, y[n0y])
} else { ## nr == 0
}
x@Dim[2] <- nc + 1L
if(is.character(dn <- x@Dimnames[[2]]))
x@Dimnames[[2]] <- c(dn, "")
x
})
## the same, (x,y) <-> (y,x):
setMethod("cbind2", signature(x = "numeric", y = "sparseMatrix"),
function(x, y) {
d <- dim(y); nr <- d[1]; nc <- d[2]; cl <- class(y)
y <- as_Csparse2(y)
if(nr > 0) {
x <- rep(x, length.out = nr) # 'silent procrustes'
n0x <- x != 0
y@i <- c((0:(nr-1))[n0x], y@i)
y@p <- c(0:0, sum(n0x) + y@p)
y@x <- c(x[n0x], y@x)
} else { ## nr == 0
}
y@Dim[2] <- nc + 1L
if(is.character(dn <- y@Dimnames[[2]]))
y@Dimnames[[2]] <- c(dn, "")
y
})
}## -- no longer