6

我试图滞后一个矩阵：

> 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
4

4 回答 4

3

这是因为滞后改变了对象的时间，而不是数据值。它真的适用于时间序列对象。

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

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

并将时间移动 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降低它的用处。

于 2013-05-20T14:41:25.940 回答
2

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

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

如果您想要（或需要）滞后一个没有ts属性的矩阵，一种方法可能是使用apply和Lag来自 quantmod 包，但如果您不想只为一个功能安装包，那么您可以编写自己的函数，一个想法是像这样：

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
于 2013-05-20T13:35:14.720 回答
1 
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
于 2013-05-20T13:25:57.243 回答
1

在 R 中滞后矩阵的最简单方法是使用“embed()”函数。这是一个快速可重现的示例：

> # 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”的滞后数。因此， embed(matrix, 3) 意味着我们希望将矩阵滞后 2 个时间段。

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

. 前两列表示原始 m 矩阵，但行数根据滞后数进行了调整（最初为 5 行减去 2 个时间段滞后）

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

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

于 2015-02-24T22:05:11.890 回答