R中具有不同间隔的序列：匹配传感器数据答案

【问题标题】：Sequence with different intervals in R: matching sensor dataR中具有不同间隔的序列：匹配传感器数据
【发布时间】：2015-10-07 08:01:00
【问题描述】：

我需要一个以不同间隔重复序列中数字的向量。我基本上需要这个

 c(rep(1:42, each=6), rep(43:64, each = 7),
 rep(65:106, each=6), rep(107:128, each = 7),

....但我需要继续这样做，直到接近 200 万。所以我想要一个看起来像

的向量

[1] 1 1 1 1 1 1 2 2 2 2 2 2 3 3 3 3 3 3 4 4 4 4 4 4 5 5 5 5 5 5 ...
.....
[252] 43 43 43 43 43 43 43 44 44 44 44 44 44 44 
....
[400] 64 64 64 64 64 64 65 65 65 65 65 65...

等等。不仅仅是在 6 和 7 重复之间交替，而是主要是 6 和更少的 7，直到整个向量大约有 170 万行。那么，我可以做一个循环吗？还是申请、复制？我需要向量中的第 400 个条目为 64，第 800 个条目为 128，依此类推，采用均匀间隔的整数。

更新

感谢大家提供的快速聪明的技巧。它奏效了，至少在我处理的最后期限内足够好。我意识到重复 6 xs 和 7 xs 是尝试解决这个问题的一种非常愚蠢的方法，但至少它很快。但是现在我有一些时间，我想在这里获得每个人对我真正的潜在问题的意见/想法。

我有两个要合并的数据集。它们都是传感器数据集，都以秒表时间作为主键。但是一个每 1/400 秒记录一次，另一个每 1/256 秒记录一次。我已经修剪了每个的顶部，以便它们在完全相同的时刻开始。但是..现在呢？我在一组中每秒有 400 条记录，在另一组中每秒有 256 条记录。有没有办法在不丢失数据的情况下合并这些？插值或只是重复 obs 是好的，必要的，我认为，但我宁愿不丢弃任何数据。我阅读了this post here，这与使用 xts 和 zoo 解决与我的问题非常相似的问题有关。但是他们每个都有很好的时代日期/时间。我只有这可怕的几分之一秒！

sample data (A):
       time dist a_lat
1  139.4300   22     0
2  139.4325   22     0
3  139.4350   22     0
4  139.4375   22     0
5  139.4400   22     0
6  139.4425   22     0
7  139.4450   22     0
8  139.4475   22     0
9  139.4500   22     0
10 139.4525   22     0

sample data (B):
      timestamp  hex_acc_x  hex_acc_y hex_acc_z 
1  367065215501 -0.5546875 -0.7539062 0.1406250  
2  367065215505 -0.5468750 -0.7070312 0.2109375  
3  367065215509 -0.4218750 -0.6835938 0.1796875  
4  367065215513 -0.5937500 -0.7421875 0.1562500  
5  367065215517 -0.6757812 -0.7773438 0.2031250  
6  367065215521 -0.5937500 -0.8554688 0.2460938 
7  367065215525 -0.6132812 -0.8476562 0.2109375 
8  367065215529 -0.3945312 -0.8906250 0.2031250 
9  367065215533 -0.3203125 -0.8906250 0.2226562 
10 367065215537 -0.3867188 -0.9531250 0.2578125

（哦，是的，顺便说一句，B 数据集时间戳是纪元格式 * 256，因为生活很艰难。我没有为此转换它，因为数据集 A 没有类似的东西，只有 0.0025 间隔。还有 B 数据传感器保持开启数小时后，A 数据传感器关闭，因此无济于事）

【问题讨论】：

@akrun 是的，它略有不同
@VeerendraGadekar 我没有仔细看，但可能对该解决方案稍作修改就可以在这里
谢谢！是的，如果我能让它工作，我可以制作 2 个向量，然后组合和排序！但我无法让它适用于多个序列。
我猜一个选项是n <- 4; indx <- rep(seq(n), rep(c(42,22), n/2));n1 <- 128; lst <- split(seq(n1), indx);lst[c(TRUE, FALSE)] <- lapply(lst[c(TRUE, FALSE)],function(x) rep(x, each=6));lst[c(FALSE, TRUE)] <- lapply(lst[c(FALSE, TRUE)],function(x) rep(x, each=7));unlist(lst)
当您说“不仅仅是在 6 7 和重复之间交替”时，您如何确定给定数字块 each 重复了多少次？总是 42 然后 22 然后 42 然后 22 ...？

标签： r time-series sequence sensors matching

【解决方案1】：

alt <- data.frame(len=c(42,22),rep=c(6,7));
alt;
##   len rep
## 1  42   6
## 2  22   7
altrep <- function(alt,cyc,len) {
    cyclen <- sum(alt$len*alt$rep);
    if (missing(cyc)) {
        if (missing(len)) {
            cyc <- 1;
            len <- cyc*cyclen;
        } else {
            cyc <- ceiling(len/cyclen);
        };
    } else if (missing(len)) {
        len <- cyc*cyclen;
    };
    if (isTRUE(all.equal(len,0))) return(integer());
    result <- rep(1:(cyc*sum(alt$len)),rep(rep(alt$rep,alt$len),cyc));
    length(result) <- len;
    result;
};
altrep(alt,2);
##   [1]   1   1   1   1   1   1   2   2   2   2   2   2   3   3   3   3   3   3   4   4   4   4   4   4   5   5   5   5   5   5   6   6   6   6   6   6   7   7   7   7   7   7   8   8   8   8   8   8   9   9   9
##  [52]   9   9   9  10  10  10  10  10  10  11  11  11  11  11  11  12  12  12  12  12  12  13  13  13  13  13  13  14  14  14  14  14  14  15  15  15  15  15  15  16  16  16  16  16  16  17  17  17  17  17  17
## [103]  18  18  18  18  18  18  19  19  19  19  19  19  20  20  20  20  20  20  21  21  21  21  21  21  22  22  22  22  22  22  23  23  23  23  23  23  24  24  24  24  24  24  25  25  25  25  25  25  26  26  26
## [154]  26  26  26  27  27  27  27  27  27  28  28  28  28  28  28  29  29  29  29  29  29  30  30  30  30  30  30  31  31  31  31  31  31  32  32  32  32  32  32  33  33  33  33  33  33  34  34  34  34  34  34
## [205]  35  35  35  35  35  35  36  36  36  36  36  36  37  37  37  37  37  37  38  38  38  38  38  38  39  39  39  39  39  39  40  40  40  40  40  40  41  41  41  41  41  41  42  42  42  42  42  42  43  43  43
## [256]  43  43  43  43  44  44  44  44  44  44  44  45  45  45  45  45  45  45  46  46  46  46  46  46  46  47  47  47  47  47  47  47  48  48  48  48  48  48  48  49  49  49  49  49  49  49  50  50  50  50  50
## [307]  50  50  51  51  51  51  51  51  51  52  52  52  52  52  52  52  53  53  53  53  53  53  53  54  54  54  54  54  54  54  55  55  55  55  55  55  55  56  56  56  56  56  56  56  57  57  57  57  57  57  57
## [358]  58  58  58  58  58  58  58  59  59  59  59  59  59  59  60  60  60  60  60  60  60  61  61  61  61  61  61  61  62  62  62  62  62  62  62  63  63  63  63  63  63  63  64  64  64  64  64  64  64  65  65
## [409]  65  65  65  65  66  66  66  66  66  66  67  67  67  67  67  67  68  68  68  68  68  68  69  69  69  69  69  69  70  70  70  70  70  70  71  71  71  71  71  71  72  72  72  72  72  72  73  73  73  73  73
## [460]  73  74  74  74  74  74  74  75  75  75  75  75  75  76  76  76  76  76  76  77  77  77  77  77  77  78  78  78  78  78  78  79  79  79  79  79  79  80  80  80  80  80  80  81  81  81  81  81  81  82  82
## [511]  82  82  82  82  83  83  83  83  83  83  84  84  84  84  84  84  85  85  85  85  85  85  86  86  86  86  86  86  87  87  87  87  87  87  88  88  88  88  88  88  89  89  89  89  89  89  90  90  90  90  90
## [562]  90  91  91  91  91  91  91  92  92  92  92  92  92  93  93  93  93  93  93  94  94  94  94  94  94  95  95  95  95  95  95  96  96  96  96  96  96  97  97  97  97  97  97  98  98  98  98  98  98  99  99
## [613]  99  99  99  99 100 100 100 100 100 100 101 101 101 101 101 101 102 102 102 102 102 102 103 103 103 103 103 103 104 104 104 104 104 104 105 105 105 105 105 105 106 106 106 106 106 106 107 107 107 107 107
## [664] 107 107 108 108 108 108 108 108 108 109 109 109 109 109 109 109 110 110 110 110 110 110 110 111 111 111 111 111 111 111 112 112 112 112 112 112 112 113 113 113 113 113 113 113 114 114 114 114 114 114 114
## [715] 115 115 115 115 115 115 115 116 116 116 116 116 116 116 117 117 117 117 117 117 117 118 118 118 118 118 118 118 119 119 119 119 119 119 119 120 120 120 120 120 120 120 121 121 121 121 121 121 121 122 122
## [766] 122 122 122 122 122 123 123 123 123 123 123 123 124 124 124 124 124 124 124 125 125 125 125 125 125 125 126 126 126 126 126 126 126 127 127 127 127 127 127 127 128 128 128 128 128 128 128
altrep(alt,len=1000);
##   [1]   1   1   1   1   1   1   2   2   2   2   2   2   3   3   3   3   3   3   4   4   4   4   4   4   5   5   5   5   5   5   6   6   6   6   6   6   7   7   7   7   7   7   8   8   8   8   8   8   9   9   9
##  [52]   9   9   9  10  10  10  10  10  10  11  11  11  11  11  11  12  12  12  12  12  12  13  13  13  13  13  13  14  14  14  14  14  14  15  15  15  15  15  15  16  16  16  16  16  16  17  17  17  17  17  17
## [103]  18  18  18  18  18  18  19  19  19  19  19  19  20  20  20  20  20  20  21  21  21  21  21  21  22  22  22  22  22  22  23  23  23  23  23  23  24  24  24  24  24  24  25  25  25  25  25  25  26  26  26
## [154]  26  26  26  27  27  27  27  27  27  28  28  28  28  28  28  29  29  29  29  29  29  30  30  30  30  30  30  31  31  31  31  31  31  32  32  32  32  32  32  33  33  33  33  33  33  34  34  34  34  34  34
## [205]  35  35  35  35  35  35  36  36  36  36  36  36  37  37  37  37  37  37  38  38  38  38  38  38  39  39  39  39  39  39  40  40  40  40  40  40  41  41  41  41  41  41  42  42  42  42  42  42  43  43  43
## [256]  43  43  43  43  44  44  44  44  44  44  44  45  45  45  45  45  45  45  46  46  46  46  46  46  46  47  47  47  47  47  47  47  48  48  48  48  48  48  48  49  49  49  49  49  49  49  50  50  50  50  50
## [307]  50  50  51  51  51  51  51  51  51  52  52  52  52  52  52  52  53  53  53  53  53  53  53  54  54  54  54  54  54  54  55  55  55  55  55  55  55  56  56  56  56  56  56  56  57  57  57  57  57  57  57
## [358]  58  58  58  58  58  58  58  59  59  59  59  59  59  59  60  60  60  60  60  60  60  61  61  61  61  61  61  61  62  62  62  62  62  62  62  63  63  63  63  63  63  63  64  64  64  64  64  64  64  65  65
## [409]  65  65  65  65  66  66  66  66  66  66  67  67  67  67  67  67  68  68  68  68  68  68  69  69  69  69  69  69  70  70  70  70  70  70  71  71  71  71  71  71  72  72  72  72  72  72  73  73  73  73  73
## [460]  73  74  74  74  74  74  74  75  75  75  75  75  75  76  76  76  76  76  76  77  77  77  77  77  77  78  78  78  78  78  78  79  79  79  79  79  79  80  80  80  80  80  80  81  81  81  81  81  81  82  82
## [511]  82  82  82  82  83  83  83  83  83  83  84  84  84  84  84  84  85  85  85  85  85  85  86  86  86  86  86  86  87  87  87  87  87  87  88  88  88  88  88  88  89  89  89  89  89  89  90  90  90  90  90
## [562]  90  91  91  91  91  91  91  92  92  92  92  92  92  93  93  93  93  93  93  94  94  94  94  94  94  95  95  95  95  95  95  96  96  96  96  96  96  97  97  97  97  97  97  98  98  98  98  98  98  99  99
## [613]  99  99  99  99 100 100 100 100 100 100 101 101 101 101 101 101 102 102 102 102 102 102 103 103 103 103 103 103 104 104 104 104 104 104 105 105 105 105 105 105 106 106 106 106 106 106 107 107 107 107 107
## [664] 107 107 108 108 108 108 108 108 108 109 109 109 109 109 109 109 110 110 110 110 110 110 110 111 111 111 111 111 111 111 112 112 112 112 112 112 112 113 113 113 113 113 113 113 114 114 114 114 114 114 114
## [715] 115 115 115 115 115 115 115 116 116 116 116 116 116 116 117 117 117 117 117 117 117 118 118 118 118 118 118 118 119 119 119 119 119 119 119 120 120 120 120 120 120 120 121 121 121 121 121 121 121 122 122
## [766] 122 122 122 122 122 123 123 123 123 123 123 123 124 124 124 124 124 124 124 125 125 125 125 125 125 125 126 126 126 126 126 126 126 127 127 127 127 127 127 127 128 128 128 128 128 128 128 129 129 129 129
## [817] 129 129 130 130 130 130 130 130 131 131 131 131 131 131 132 132 132 132 132 132 133 133 133 133 133 133 134 134 134 134 134 134 135 135 135 135 135 135 136 136 136 136 136 136 137 137 137 137 137 137 138
## [868] 138 138 138 138 138 139 139 139 139 139 139 140 140 140 140 140 140 141 141 141 141 141 141 142 142 142 142 142 142 143 143 143 143 143 143 144 144 144 144 144 144 145 145 145 145 145 145 146 146 146 146
## [919] 146 146 147 147 147 147 147 147 148 148 148 148 148 148 149 149 149 149 149 149 150 150 150 150 150 150 151 151 151 151 151 151 152 152 152 152 152 152 153 153 153 153 153 153 154 154 154 154 154 154 155
## [970] 155 155 155 155 155 156 156 156 156 156 156 157 157 157 157 157 157 158 158 158 158 158 158 159 159 159 159 159 159 160 160

您可以指定len=1.7e6（并省略cyc 参数）以获得正好170 万个元素，或者您可以使用cyc 获得整数个循环。

【讨论】：

【解决方案2】：

或者，如果您愿意，可以使用apply 试试这个

# using this sample data
df <- data.frame(from=c(1,4,7,11), to = c(3,6,10,13),rep=c(6,7,6,7));

> df
#  from to rep
#1    1  3   6
#2    4  6   7
#3    7 10   6
#4   11 13   7

unlist(apply(df, 1, function(x) rep(x['from']:x['to'], each=x['rep'])))    
# [1]  1  1  1  1  1  1  2  2  2  2  2  2  3  3  3  3  3  3  4  4  4  4  4  4  4
#[26]  5  5  5  5  5  5  5  6  6  6  6  6  6  6  7  7  7  7  7  7  8  8  8  8  8
#[51]  8  9  9  9  9  9  9 10 10 10 10 10 10 11 11 11 11 11 11 11 12 12 12 12 12
#[76] 12 12 13 13 13 13 13 13 13

【讨论】：

很好，这解决了我在问题中的问题/评论，因为第三列 rep 可以很容易地被一个函数填充，以捕获 6 比 7 的变化比率

【解决方案3】：

怎么样

len <- 2e6
step <- 400

x <- rep(64 * seq(0, ceiling(len / step) - 1), each = step) + 
        sort(rep(1:64, length.out = step))

x <- x[seq(len)] # to get rid of extra elements

【讨论】：

【解决方案4】：

既然你这么说......我完全不知道你打算如何使用所有 6s 和 7s。 :-)

无论如何，我建议标准化时间，添加“样本”列，然后合并它们。也许拥有“样本”列可能会方便您以后的处理。

您的数据：

df400 <- structure(list(time = c(139.43, 139.4325, 139.435, 139.4375, 139.44, 139.4425,
                                 139.445, 139.4475, 139.45, 139.4525),
                        dist = c(22L, 22L, 22L, 22L, 22L, 22L, 22L, 22L, 22L, 22L),
                        a_lat = c(0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L)),
                   .Names = c("time", "dist", "a_lat"),
                   class = "data.frame", row.names = c(NA, -10L))

df256 <- structure(list(timestamp = c(367065215501, 367065215505, 367065215509, 367065215513,
                                      367065215517, 367065215521, 367065215525, 367065215529, 
                                      367065215533, 367065215537),
                        hex_acc_x = c(-0.5546875, -0.546875, -0.421875, -0.59375, -0.6757812,
                                      -0.59375, -0.6132812, -0.3945312, -0.3203125, -0.3867188),
                        hex_acc_y = c(-0.7539062, -0.7070312, -0.6835938, -0.7421875,
                                      -0.7773438, -0.8554688, -0.8476562, -0.890625,
                                      -0.890625, -0.953125),
                        hex_acc_z = c(0.140625, 0.2109375, 0.1796875, 0.15625, 0.203125,
                                      0.2460938, 0.2109375, 0.203125, 0.2226562, 0.2578125)),
                   .Names = c("timestamp", "hex_acc_x", "hex_acc_y", "hex_acc_z"),
                   class = "data.frame", row.names = c(NA, -10L))

标准化您的时间框架：

colnames(df256)[1] <- 'time'
df400$time <- df400$time - df400$time[1]
df256$time <- (df256$time - df256$time[1]) / 256

分配一个标签以便于参考（不是NAs 不够清晰）：

df400 <- cbind(sample='A', df400, stringsAsFactors=FALSE)
df256 <- cbind(sample='B', df256, stringsAsFactors=FALSE)

现在进行合并和排序：

dat <- merge(df400, df256, by=c('sample', 'time'), all.x=TRUE, all.y=TRUE)
dat <- dat[order(dat$time),]
dat
##    sample     time dist a_lat  hex_acc_x  hex_acc_y hex_acc_z
## 1       A 0.000000   22     0         NA         NA        NA
## 11      B 0.000000   NA    NA -0.5546875 -0.7539062 0.1406250
## 2       A 0.002500   22     0         NA         NA        NA
## 3       A 0.005000   22     0         NA         NA        NA
## 4       A 0.007500   22     0         NA         NA        NA
## 5       A 0.010000   22     0         NA         NA        NA
## 6       A 0.012500   22     0         NA         NA        NA
## 7       A 0.015000   22     0         NA         NA        NA
## 12      B 0.015625   NA    NA -0.5468750 -0.7070312 0.2109375
## 8       A 0.017500   22     0         NA         NA        NA
## 9       A 0.020000   22     0         NA         NA        NA
## 10      A 0.022500   22     0         NA         NA        NA
## 13      B 0.031250   NA    NA -0.4218750 -0.6835938 0.1796875
## 14      B 0.046875   NA    NA -0.5937500 -0.7421875 0.1562500
## 15      B 0.062500   NA    NA -0.6757812 -0.7773438 0.2031250
## 16      B 0.078125   NA    NA -0.5937500 -0.8554688 0.2460938
## 17      B 0.093750   NA    NA -0.6132812 -0.8476562 0.2109375
## 18      B 0.109375   NA    NA -0.3945312 -0.8906250 0.2031250
## 19      B 0.125000   NA    NA -0.3203125 -0.8906250 0.2226562
## 20      B 0.140625   NA    NA -0.3867188 -0.9531250 0.2578125

我猜你的数据只是一个小代表。如果我猜得不好（A 的整数是秒，B 的整数是 1/400 秒），那么只是缩放不同。无论哪种方式，通过将第一个值重置为零然后合并/排序，它们很容易合并和排序。

【讨论】：

啊，这很有趣。是的，您猜对了秒整数。我打算用这个，肯定可以的。
这很有趣......我从来没有遇到过epoch*256（或者处理过那么大的整数），所以看到 R 以非直觉方式处理它们是很有启发性的。（这是我了解更多关于R的“东西”的方式。:-)
关于原计划，这些实际上是 2 个单独的类似问题，应该指定。那是针对间隔为 1/64 秒的类似问题（我知道，这仍然不是一个好计划。这是同事的建议）。我只有一堆不同格式的这些集合。这适用于所有人！ =）真的，非常感谢。这是我在这里的第一篇文章，我一定会回来的，希望能变得更好，并帮助其他人做一些更简单的事情
那么欢迎来到 SO！当问题得到解决时，请花时间将其中一个答案标记为“已接受”（无论我是否，我的目标不是自私的）。这是一种礼貌，也是一种“结束问题/讨论”的方式。