标签: aggregate

假设我有一个数据表dt.recipes，其中包含包含各种项目的列表，例如：

recipe_id     ingredients
1             apple, banana, cucumber, water
2             apple, meat, water
3             water

如何创建一个表，计算中存在的唯一项目的数量dt.recipes$ingredients？换句话说，我正在寻找与此类似的结果：

ingredient    count
water         3
apple         2
banana        1
cucumber      1
meat          1

任何指点将不胜感激，提前致谢！

在 C++20 中，聚合不能有用户声明或继承的构造函数（因此您不能将它们声明为删除）。那么有没有办法让结构体仍然是聚合的，但不可复制呢？

我想要实现:

foreach (ScheduleItem s in ScheduleItems)
{
    foreach (IScheduleModule m in s.ScheduleModules)
    {
        yield return m;
    }
}

使用LINQ聚合,我不明白为什么

return ScheduleItems.Aggregate(new Collection<IScheduleModule>(), (x, o) => x.Union(o.ScheduleModules) as Collection<IScheduleModule>);

返回null.

我没有使用嵌套foreach的问题,但我的直觉是使用聚合,我不明白为什么它不会产生相同的结果.

还有其他方法吗？在可读性和性能方面最好的是什么？

这是我昨天学到的问题的延伸apply.weekly.这很好用,但我想在宽zoo对象上做这件事.如果我apply.weekly在宽范围内使用zoo它会对列进行求和,然后执行每周聚合:

> library(xts)
> set.seed(2001)
> zoo.daily <- zoo(data.frame(a=rnorm(20), b=rnorm(20), c=rnorm(20)), order.by=as.Date("2001-05-25") + 0:19)
> apply.weekly(zoo.daily, sum)
2001-05-27 2001-06-03 2001-06-10 2001-06-13 
  1.091999  -3.017688   3.842305   2.045370 
> apply.weekly(zoo.daily[, 1] + zoo.daily[, 2] + zoo.daily[, 3], sum) 
2001-05-27 2001-06-03 2001-06-10 2001-06-13 
  1.091999  -3.017688   3.842305   2.045370 

我尝试了apply运营商系列,但这些似乎剥离了zoo日期索引.我可以在一个for循环中完成它,但它确实非常耗时(远远超过周期性aggregate函数的四倍as.yearmon).这是for循环:

week.ends <- index(zoo.daily[endpoints(zoo.daily, "weeks")[-1], ])
num.weeks <- nweeks(zoo.daily)
num.stocks <- ncol(zoo.daily)
zoo.weeks <- zoo(matrix(NA, …

我是linq的新手,我需要帮助.我有一个带有金额字段的交易表,我希望将金额字段拆分为借方和贷方.与以下sql查询等效的linq是什么:选择sum(Amount <0？Amount:0)作为Debit,sum(Amount> 0？0:Amount)作为来自Account = strAccount的交易的Credit.

我在R写第一个程序,作为一个新手,我有一些麻烦,希望你能帮助我.

我有一个像这样的数据框:

> v1<-c(1,1,2,3,3,3,4)
> v2<-c(13,5,15,1,2,7,4)
> v3<-c(0,3,6,13,8,23,5)
> v4<-c(26,25,11,2,8,1,0)
> datos<-data.frame(v1,v2,v3,v4)
> names(datos)<-c("Position","a1","a2","a3")

> datos
  posicion a1 a2 a3
1        1 13  0 26
2        1  5  3 25
3        2 15  6 11
4        3  1 13  2
5        3  2  8  8
6        3  7 23  1
7        4  4  5  0

我需要的是总结的数据a1,a2以及a3(在我的实际情况,从a1到a51由分组)Position.我正在尝试这个功能,aggregate()但它只适用于手段,而不是总和,我不知道为什么.

提前致谢

如果您的唯一列ID是字符,您如何使用聚合？

aggregate(data, list(data$colID), sum)
Error in Summary.factor(c(1L, 1L), na.rm = FALSE) : 
  sum not meaningful for factors

改为角色..

data$colID<-as.character(data$colID)

aggregate(data, list(data$colID), sum)
Error in FUN(X[[1L]], ...) : invalid 'type' (character) of argument

ddply I get a similar error.  
Error in FUN(X[[1L]], ...) : 
  only defined on a data frame with all numeric variables

我只想通过colID聚合,我不想总结它.我想要所有其他列总和.

dput(data)
structure(list(colID = structure(c(1L, 1L, 1L, 2L, 2L), .Label = c("a", 
"b"), class = "factor"), col1 = c(1, 0, 0, 0, 2), col2 = c(0, 
1, …

我正在为一家电信公司开发一个大型系统.我是DDD的新手,很难将不同的部分连接在一起.我们当前的系统是使用NHibernate构建的.它目前有超过600个表,所有数据访问都是使用NHibernate完成的,但对于新系统,我们将使用EF.以下是每个功能区域中的几个功能区域和数据库表的示例.

客户
-----> CustomerDemographics
-----> CustomerPayments
-----> CustomerTransactions

RoutingEngine
-----> InboundRoutes
-----> OutboundRoutes

ProvisioningEngine
-----> InboundSwithces
-----> OutboundSwitches
-----> RouterConfigs
-----> GatewayConfigs

BillingEngine
-----> InboundTraffic
-----> OutboundTraffic

由于系统必须是可单元测试的,因此我开始使用存储库模式抽象实际实体.一种方法是为每个数据库表创建一个存储库对象.当然,所有这些存储库类都可以从通用存储库接口派生.然而,这将在代码库维护方面增加相当多的开销.在DDD中,我读到了聚合的这个概念,但我不确定它应该如何在EF的上下文中特别应用.Aggregate对象应该是这些存储库的容器还是更多的相关上下文的容器(意味着有界DbContexts的内容)？

我根据几年小时数据的数据框(球)进行昼夜风速循环.我想按季节绘制它们,所以我将我需要的日期分类并按照以下方式加入它们:

b8 = subset(ball, as.Date(date)>="2008-09-01 00:00:00, GMT" & as.Date(date)<= "2008-11-30 23:00:00, GMT"  )
b9  = subset(ball, as.Date(date)>="2009-09-01 00:00:00, GMT" & as.Date(date)<= "2009-11-30 23:00:00, GMT"  )
b10 = subset(ball,  as.Date(date)>="2010-09-01 00:00:00, GMT" & as.Date(date)<= "2010-11-30 23:00:00, GMT")
ballspr = rbind(b8,b9,b10)

然后我用这个得到一个昼夜循环:

sprwsdiurnal <- aggregate(ballspr["ws"], format(ballspr["date"],"%H"),summary, na.rm=T)

对于四个季节中的三个季节,这使得具有这种结构的对象:

   date                                               ws
1    00  0.200, 1.000, 1.600, 2.021, 2.500, 8.000, 5.000
2    01  0.100, 1.000, 1.600, 1.988, 2.500, 8.600, 1.000
3    02  0.100, 1.000, 1.700, 1.982, 2.600, 8.900, 1.000

......到24小时......

23   22  0.100, 1.200, …

我有一个关于微博的数据集(600 Mb与5038720观察),我试图找出一个用户在一小时内发布了多少推文(具有相同中间数的推文).以下是数据集的外观:

head(mydata)

       uid              mid    year month date hour min sec
1738914174 3342412291119279 2011     8    3   21   4  12
1738914174 3342413045470746 2011     8    3   21   7  12
1738914174 3342823219232783 2011     8    5    0  17   5
1738914174 3343095924467484 2011     8    5   18  20  43
1738914174 3343131303394795 2011     8    5   20  41  18
1738914174 3343386263030889 2011     8    6   13  34  25

这是我的代码:

count <- function(x) {
length(unique(na.omit(x)))
}
attach(mydata)
hourPost <- aggregate(mid, by=list(uid, hour), FUN=count)

它在那里挂了大约半个小时,我发现所有真正的内存(24 Gb)都被使用了,它开始使用虚拟内存.知道为什么这个小任务消耗了这么多时间和记忆,我该如何改进呢？提前致谢!