Question

我试图延迟矩阵：

> B = matrix( c(2, 4, 3, 1, 5, 7),  nrow=3, ncol=2)
> B
     [,1] [,2]
[1,]    2    1
[2,]    4    5
[3,]    3    7
> lag(B)
     [,1] [,2]
[1,]    2    1
[2,]    4    5
[3,]    3    7

为什么lag(B)不给：

> lag(B)
     [,1] [,2]
[1,]    0    0
[2,]    2    1
[3,]    4    5

Answer 1

这是因为滞后会移动对象的次，而不是数据值。它真正用于时间序列对象。

在普通矩阵lag上使用B时，会调用lag.default方法。由于没有时间与普通矩阵相关联，因此假定时间为1, 2, ..., NROW(B)：

> time(B)
[1] 1 2 3
attr(,"tsp")
[1] 1 3 1

并将时间移动一，以便它们现在从0开始：

> time(lag(B))
[1] 0 1 2
attr(,"tsp")
[1] 0 2 1

如果要组合具有时间的对象，请使用时间序列类。（第一列是下面显示的时间。）

> library(zoo)
>
> # zooreg - regular series or almost so
> B.zr <- zooreg(B)
> merge(B.zr, lag(B.zr))
  B.zr.1 B.zr.2 lag(B.zr).1 lag(B.zr).2
0     NA     NA           2           1
1      2      1           4           5
2      4      5           3           7
3      3      7          NA          NA

> # zoo - irregular series
> B.z <- zoo(B)
> merge(B.z, lag(B.z))
  B.z.1 B.z.2 lag(B.z).1 lag(B.z).2
1     2     1          4          5
2     4     5          3          7
3     3     7         NA         NA

注意lag.zooreg之间的差异，它可以超出产生0时间的原始时间范围和lag.zoo之间的差异，因为后者没有规律性假设。

我们也可以使用假设有规律性的ts类，因此可以产生0时间，但没有merge.ts使得它在这里不太有用。

Answer 2

我从未理解lag函数，而是使用Lag包中的quantmod：

> # library(quantmod)
> apply(B, 2, Lag)
     [,1] [,2]
[1,]   NA   NA
[2,]    2    1
[3,]    4    5

如果您希望（或需要）延迟没有ts属性的矩阵，可以使用quantmod包中的apply和Lag，但如果您不想安装只包含一个函数的包，然后你可以编写自己的函数，一个想法是这样的：

lag.matrix <- function(x, k=1){
  N <- ncol(B)
  l <- matrix(embed(x,k+1)[, -c(1:(k*N))], ncol=N)
  NAs <- matrix(rep(NA, k*N), ncol=N)
  rbind(NAs, l)
}
> lag.matrix(B, k=1)
     [,1] [,2]
[1,]   NA   NA
[2,]    2    1
[3,]    4    5
> lag.matrix(B, k=2)
     [,1] [,2]
[1,]   NA   NA
[2,]   NA   NA
[3,]    2    1

另一个解决方案可能是由@GSee发布的评论，它可以根据您的意愿使用lag。

> lag(xts(B, .POSIXct(0)+0:(nrow(B)-1)))
                    [,1] [,2]
1970-01-01 01:00:00   NA   NA
1970-01-01 01:00:01    2    1
1970-01-01 01:00:02    4    5

Answer 3

l <- matrix(0,nrow(B),nrow(B))
l[-1,-nrow(B)] <- diag(nrow(B)-1)
l
##     [,1] [,2] [,3]
## [1,]    0    0    0
## [2,]    1    0    0
## [3,]    0    1    0

l %*% B
##      [,1] [,2]
## [1,]    0    0
## [2,]    2    1
## [3,]    4    5

Answer 4

延迟R中矩阵的最简单方法是使用`embed（）＆＃39;功能。这是一个快速重现的例子：

> # Create a 5x2 matrix
> m <- replicate(2, 1:5)
> m
     [,1] [,2]
[1,]    1    1
[2,]    2    2
[3,]    3    3
[4,]    4    4
[5,]    5    5
> 
> # Use the 'embed()' function to lag the matrix
> lag_m <- embed(m, 3)
> lag_m
     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    3    3    2    2    1    1
[2,]    4    4    3    3    2    2
[3,]    5    5    4    4    3    3

关于embed（）函数及其输出的一些重要的话。

该功能使用如下：embed（matrix，lag + 1）

函数的第一个参数是我们想要滞后的矩阵。第二个论点;然而，是我们想要的滞后数量加上1＆＃34;。因此，embed（matrix，3）意味着我们希望将矩阵滞后2个时间段。

函数的输出是滞后矩阵，如下所示：

。前两列代表原始m矩阵，但行数根据滞后数量调整（最初5行减去2段滞后）

。第二组列（第3列和第4列）是滞后1个时间段的m矩阵

。第三组列（第5列和第6列）是滞后2个时间段的m矩阵。

为什么r中的滞后不适用于矩阵？

4 个答案: