标签: aggregate

可以说我们有以下代码:

#include <iostream>
#include <string>

struct A
{
  A() {}
  A(const A&) { std::cout << "Copy" << std::endl; }
  A(A&&) { std::cout << "Move" << std::endl; }
  std::string s;
};

struct B
{
  A a;
};

int main()
{
  B{A()};
}

在这里,我认为struct A不是一个聚合,因为它既有非平凡的构造函数,也有std::string我认为不是聚合的成员.这可能意味着它B也不是一个聚合体.

然而,我可以聚合初始化B.此外,这可以在没有调用复制或移动构造函数的情况下完成(例如,在ideone上的C++ 0x GCC 4.5.1 ).

这种行为似乎是一种有用的优化,特别是对于没有廉价移动的大型堆栈类型的组合.

我的问题是:这种聚合初始化何时在C++ 0x下有效？

编辑+跟进问题:

下面的DeadMG回答如下:

这根本不是聚合初始化,它是统一初始化,基本上在这种情况下意味着调用构造函数,并且没有复制或移动可能由RVO和NRVO完成.

请注意,当我更改B为以下内容时:

struct B
{
  A a;
  B(const A& a_) : a(a_) {}
  B(A&& a_) : a(std::move(a_)) {} …

假设您(在Postgres 9.1中)有这样一个表:

date | value 

它有一些空白(我的意思是:并非每个可能的日期在最小(日期)和最大(日期)之间有它的行).

我的问题是如何聚合这些数据,以便分别处理每个一致的组(没有间隙),如下所示:

min_date | max_date | [some aggregate of "value" column] 

有什么想法怎么做？我相信这是可能的窗口功能,但是过了一段时间,试图lag()和lead()我有点卡住了.

例如,如果数据是这样的:

 date          | value  
---------------+-------  
 2011-10-31    | 2  
 2011-11-01    | 8  
 2011-11-02    | 10  
 2012-09-13    | 1  
 2012-09-14    | 4  
 2012-09-15    | 5  
 2012-09-16    | 20  
 2012-10-30    | 10  

输出(sum作为聚合)将是:

   min     |    max     |  sum  
-----------+------------+-------  
2011-10-31 | 2011-11-02 |  20  
2012-09-13 | 2012-09-16 |  30  
2012-10-30 | 2012-10-30 |  10  

在这里尝试aggregate另一个问题时,我遇到了一个相当奇怪的结果.我无法弄清楚为什么,我想知道我在做什么是完全错误的.

假设,我有data.frame这样的:

df <- structure(list(V1 = c(1L, 2L, 1L, 2L, 3L, 1L), 
                     V2 = c(2L, 3L, 2L, 3L, 4L, 2L), 
                     V3 = c(3L, 4L, 3L, 4L, 5L, 3L), 
                     V4 = c(4L, 5L, 4L, 5L, 6L, 4L)), 
                  .Names = c("V1", "V2", "V3", "V4"), 
        row.names = c(NA, -6L), class = "data.frame")
> df
#   V1 V2 V3 V4
# 1  1  2  3  4
# 2  2  3  4  5
# 3  1  2  3  4 …

我有一个具有多个级别的树,其中叶节点可能具有属性"count".我想计算每个子树的总计数,并将这些值缓存在每个子树的根节点中.这可能在Gremlin？

我正在尝试将Repository模式用于我当前的项目,而我目前正在尝试对域进行建模并找到聚合根.

我已经读过"级联删除"规则,该规则指出如果在删除根时删除成员没有意义,那么它不应该是根目录的一部分.

我将以警察事件为例: -

事件(聚合根) - 这可能包含调查人员,每个官员做的笔记.它还可能包含嫌疑人的受访日期列表.是否为此事件获得了闭路电视录像？每次看CCTV的日志和谁？是中央电视台为证据/法庭等制作的副本

似乎IncidentAggregate可能会变得庞大,因为它看起来一切都挂在那个事件上.

我的问题是双重的,聚合根应该管理多少,根源是一个好主意？

这可能不是一个特别好的例子,因为你可能永远不会删除类似警察事件的东西,但我希望它能更好地描述我的问题.

我正在查看aggregateR中函数的帮助页面.我从未使用过这个便利功能,但我有一个过程应该可以帮助我加快速度.但是,我完全无法通过这个例子来理解发生了什么.

一个例子如下:

1> aggregate(state.x77, list(Region = state.region), mean)
         Region Population Income Illiteracy Life Exp Murder HS Grad  Frost   Area
1     Northeast       5495   4570      1.000    71.26  4.722   53.97 132.78  18141
2         South       4208   4012      1.738    69.71 10.581   44.34  64.62  54605
3 North Central       4803   4611      0.700    71.77  5.275   54.52 138.83  62652
4          West       2915   4703      1.023    71.23  7.215   62.00 102.15 134463

这里的输出正是我所期望的.所以我试着了解发生了什么.所以我看看state.x77

1> head(state.x77)
           Population Income Illiteracy Life Exp Murder HS Grad Frost   Area
Alabama          3615   3624        2.1 …

我有一个数据框,我从这样的文件中读取:

name, points, wins, losses, margin
joe, 1, 1, 0, 1
bill, 2, 3, 0, 4
joe, 5, 2, 5, -2
cindy, 10, 2, 3, -2.5

等等

我想在这些数据的所有行中平均列值,是否有一种简单的方法在R中执行此操作？

例如,我想获得所有"Joe's"的平均列值,如下所示

joe, 3, 1.5, 2.5, -.5

当使用df.mean()时,我得到一个结果,其中给出了每列的平均值.现在让我们说我想要第一列的平均值,以及第二列的总和.有没有办法做到这一点？我不想拆卸和重新组装数据帧.

我最初的想法是按照pandas.groupby.agg()的方式做一些事情:

df = pd.DataFrame(np.random.random((10,2)), columns=['A','B'])
df.apply({'A':np.mean, 'B':np.sum}, axis=0)

Traceback (most recent call last):

  File "<ipython-input-81-265d3e797682>", line 1, in <module>
    df.apply({'A':np.mean, 'B':np.sum}, axis=0)

  File "C:\Users\Patrick\Anaconda\lib\site-packages\pandas\core\frame.py", line 3471, in apply
    return self._apply_standard(f, axis, reduce=reduce)

  File "C:\Users\Patrick\Anaconda\lib\site-packages\pandas\core\frame.py", line 3560, in _apply_standard
    results[i] = func(v)

TypeError: ("'dict' object is not callable", u'occurred at index A')

但显然这不起作用.看起来传递一个字典会是一种直观的方式,但还有另一种方式(再次没有拆解和重新组装DataFrame)吗？

在使用自定义函数循环数据框中的组时遇到一些麻烦.

以下是一些示例数据:

set.seed(42)
tm <- as.numeric(c("1", "2", "3", "3", "2", "1", "2", "3", "1", "1"))
d <- as.numeric(sample(0:2, size = 10, replace = TRUE))
t <- as.numeric(sample(0:2, size = 10, replace = TRUE))
h <- as.numeric(sample(0:2, size = 10, replace = TRUE))

df <- as.data.frame(cbind(tm, d, t, h))
df$p <- rowSums(df[2:4])

我创建了一个自定义函数来计算值w:

calc <- function(x) {
  data <- x
  w <- (1.27*sum(data$d) + 1.62*sum(data$t) + 2.10*sum(data$h)) / sum(data$p)
  w
  }

当我在整个数据集上运行该函数时,我得到以下答案:

calc(df)
[1]1.664474

理想情况下,我想返回按tm分组的结果,例如:

tm     w
1    result of calc …

我试图在我的数据中找到在多个方面相同的条目.我目前使用嵌套聚合的复杂查询来执行此操作:

{
  "size": 0, 
  "aggs": { 
    "duplicateFIELD1": { 
      "terms": { 
        "field": "FIELD1", 
        "min_doc_count": 2 },
      "aggs": { 
        "duplicateFIELD2": { 
          "terms": { 
            "field": "FIELD2", 
            "min_doc_count": 2 },
          "aggs": {
            "duplicateFIELD3": {
              "terms": {
                "field": "FIELD3",
                "min_doc_count": 2 },
              "aggs": {
                "duplicateFIELD4": {
                  "terms": {
                    "field": "FIELD4",
                    "min_doc_count": 2 },
                  "aggs": {
                    "duplicate_documents": { 
                      "top_hits": {} } } } } } } } } } } }

这在某种程度上起作用,因为当没有找到重复项时,我得到的结果如下所示:

{
  "took" : 5,
  "timed_out" : false,
  "_shards" : {
    "total" : …