How to create a diagonal matrix from a sparse Vector

Suppose x is defined as

x <- as(c(1,1,0,0,1,0), "sparseVector")

I want to create a diagonal matrix where the diagonal elements are given by the entries in x.

I tried Diagonal(x = x), but I get the following error.

Error in Diagonal(x = x) : 'x' has unsupported class "dsparseVector"

I think you are looking for sparseMatrix. e.g.:

library(Matrix)

x <- c(1,1,0,0,1,0)
x <- sparseMatrix(i = seq(x), j = seq(x), x = x)
x
# 6 x 6 sparse Matrix of class "dgCMatrix"
#                 
# [1,] 1 . . . . .
# [2,] . 1 . . . .
# [3,] . . 0 . . .
# [4,] . . . 0 . .
# [5,] . . . . 1 .
# [6,] . . . . . 0

To treat zeros in the original vector as sparse elements:

x <- c(1,1,0,0,1,0)
x <- sparseMatrix(i = which(x!=0), j = which(x!=0), x = x[which(x!=0)], 
  dims = rep(length(x), 2))
x
# 6 x 6 sparse Matrix of class "dgCMatrix"
#                 
# [1,] 1 . . . . .
# [2,] . 1 . . . .
# [3,] . . . . . .
# [4,] . . . . . .
# [5,] . . . . 1 .
# [6,] . . . . . .

You can multiply the Diagonal matrix with your sparse vector:

Diagonal(length(x)) * x
#6 x 6 sparse Matrix of class "dgCMatrix"
#                
#[1,] 1 . . . . .
#[2,] . 1 . . . .
#[3,] . . . . . .
#[4,] . . . . . .
#[5,] . . . . 1 .
#[6,] . . . . . .

It can be constructed from the components of x using sparseMatrix creating an object of dgCMatrix:

sparseMatrix(x@i, x@i, x = x@x, dims = c(x@length, x@length))

giving:

6 x 6 sparse Matrix of class "dgCMatrix"
                
[1,] 1 . . . . .
[2,] . 1 . . . .
[3,] . . . . . .
[4,] . . . . . .
[5,] . . . . 1 .
[6,] . . . . . .

Note

library(Matrix)
x <- as(c(1, 1, 0, 0, 1, 0), "sparseVector")

You want Diagonal(x = as.vector(<sparseVector>)). Having said that, it is reasonable to expect Diagonal(x = <sparseVector>) to do the same thing. Maybe that is a feature request for Matrix 1.6-1 ...

In any case, the result will be an object inheriting from diagonalMatrix and storing zeros on the diagonal explicitly. Yes, that is "suboptimal", but, in exchange, you benefit from highly optimized methods for diagonalMatrix.

If you are only interested in object size, then why not keep the sparseVector representation?

library(Matrix)
set.seed(0)
n <- 1e+06L
x0 <- sample(c(0, 1), size = n, replace = TRUE, prob = c(1000, 1))
x <- as(x0, "sparseVector")
l <- list(x0 = x0, x = x,
          D = Diagonal(x = as.vector(x)),
          C = sparseMatrix(i = x@i, j = x@i, x = x@x, dims = rep.int(x@length, 2L),
                           triangular = TRUE, repr = "C"),
          R = sparseMatrix(i = x@i, j = x@i, x = x@x, dims = rep.int(x@length, 2L),
                           triangular = TRUE, repr = "R"),
          T = sparseMatrix(i = x@i, j = x@i, x = x@x, dims = rep.int(x@length, 2L), 
                           triangular = TRUE, repr = "T"))
cl <- vapply(l, class, "")
os <- vapply(l, object.size, 0)
data.frame(class = cl, bytes = os, ratio = os/min(os))

           class   bytes      ratio
x0       numeric 8000048 651.894394
x  dsparseVector   12272   1.000000
D      ddiMatrix 8001240 651.991525
C      dtCMatrix 4013064 327.009778
R      dtRMatrix 4013064 327.009778
T      dtTMatrix   16816   1.370274

n. <- as.double(n) # avoid integer overflow in rsparsematrix ... FIXME
M <- rsparsematrix(n., n., 1/n.)
with(l, microbenchmark::microbenchmark(D %*% M, C %*% M, R %*% M, T %*% M))

Unit: milliseconds
    expr       min        lq     mean    median       uq      max neval
 D %*% M  6.028189  6.502477  6.89017  6.680889  7.13894 10.35902   100
 C %*% M 20.564288 20.793950 21.03865 20.909795 21.07154 24.19648   100
 R %*% M 21.509297 21.793222 22.63789 22.000969 22.49524 63.59588   100
 T %*% M 22.943067 23.205651 24.18345 23.497592 24.09761 64.76713   100