我有一个data.tableR:
library(data.table)
set.seed(1)
DT = data.table(
group=sample(letters[1:2],100,replace=TRUE),
year=sample(2010:2012,100,replace=TRUE),
v=runif(100))
按组和年份将这些数据汇总到汇总表中简单而优雅:
table <- DT[,mean(v),by='group, year']
但是,将这些数据聚合到汇总表(包括小计和总计)中会稍微困难一些,而且不那么优雅:
library(plyr)
yearTot <- DT[,list(mean(v),year='Total'),by='group']
groupTot <- DT[,list(mean(v),group='Total'),by='year']
Tot <- DT[,list(mean(v), year='Total', group='Total')]
table <- rbind.fill(table,yearTot,groupTot,Tot)
table$group[table$group==1] <- 'Total'
table$year[table$year==1] <- 'Total'
这会产生:
table[order(table$group, table$year), ]
是否有一种简单的方法可以使用data.table指定小计和总计,例如plyr的margins=TRUE命令？我更喜欢在我的数据集上使用data.table而不是plyr,因为它是我已经拥有的data.table格式的非常大的数据集.
我有两个命名的向量
v1 <- 1:4
v2 <- 3:5
names(v1) <- c("a", "b", "c", "d")
names(v2) <- c("c", "e", "d")
我想通过名称添加它们,即预期的结果是
> v3
a b c d e
1 2 6 9 4
有没有办法以编程方式在R中执行此操作？请注意,名称可能不一定按排序顺序排列,v2如上所述.
使用C++ 17,我们将有可能返回不可移动(包括不可复制)类型,例如std::mutex,通过可以被认为是有保证的返回值优化(RVO):通过简化的值类别保证复制省略:
struct nocopy { nocopy(nocopy&) = delete; nocopy() = default; };
auto getRVO(){
return nocopy();
}
我们还将具有结构化绑定,允许:
tuple<T1,T2,T3> f();
auto [x,y,z] = f();
template<typename T1,typename T2,typename T3>
struct many {
T1 a;
T2 b;
T3 c;
};
// (Original questions missed 'many' on the next line. Thanks, T.C.)
auto f(){ return many{string(),5.7, false} };
auto [x,y,z] = f();
但这些功能是否可以实现这样的功能呢？
auto get_ensured_rvo_str(){
return std::pair(std::string(),nocopy());
}
auto get_class_and_mutex(){
return many{SomeClass(),std::mutex(),std::string()}; …我继承了以下数据库设计.表是:
customers
---------
customerid
customernumber
invoices
--------
invoiceid
amount
invoicepayments
---------------
invoicepaymentid
invoiceid
paymentid
payments
--------
paymentid
customerid
amount
我的查询需要返回给定客户编号的invoiceid,发票金额(在发票表中)和应付金额(发票金额减去对发票的任何付款).客户可能有多张发票.
当对发票进行多次付款时,以下查询为我提供了重复记录:
SELECT i.invoiceid, i.amount, i.amount - p.amount AS amountdue
FROM invoices i
LEFT JOIN invoicepayments ip ON i.invoiceid = ip.invoiceid
LEFT JOIN payments p ON ip.paymentid = p.paymentid
LEFT JOIN customers c ON p.customerid = c.customerid
WHERE c.customernumber = '100'
我怎么解决这个问题？
我希望我能以正确的方式提出这个问题.我正在学习Elastic MapReduce的方法,并且我看到了许多对"Aggregate"减速器的引用,它可以与"Streaming"作业流程一起使用.
在亚马逊的"Amazon Elastic MapReduce简介"PDF中,它声明"Amazon Elastic MapReduce有一个名为aggregrate的默认缩减器"
我想知道的是:还有其他默认减速机可用吗？
我知道我可以编写自己的减速机,但我不想写完已经存在的东西并"重新发明轮子",因为我确信我的轮子不会像原来那样好.
我试图按资产类别计算资产加权回报.对于我的生活,我无法弄清楚如何使用aggregate命令来做到这一点.
我的数据框看起来像这样
dat <- data.frame(company, fundname, assetclass, return, assets)
我正在尝试做一些事情(不要复制这个,这是错的):
aggregate(dat, list(dat$assetclass), weighted.mean, w=(dat$return, dat$assets))
var nums = new[]{ 1, 2, 3, 4, 5, 6, 7};
var pairs = /* some linq magic here*/ ;
=> pairs = {{1,2},{3,4},{5,6},{7,0}}
元素pairs应该是两元素列表,或者是一些具有两个字段的匿名类的实例,例如new {First = 1, Second = 2}.
我需要在ddply或者聚合中使用group by,如果这更容易的话.我不确定如何做到这一点,因为我需要使用cumsum作为我的聚合函数.这就是我的数据:
level1 level2 hour product
A tea 0 7
A tea 1 2
A tea 2 9
A coffee 17 7
A coffee 18 2
A coffee 20 4
B coffee 0 2
B coffee 1 3
B coffee 2 4
B tea 21 3
B tea 22 1
预期产量:
A tea 0 7
A tea 1 9
A tea 2 18
A coffee 17 7
A coffee 18 9
A coffee 20 13
B coffee 0 2
B …我们有一个简单的结构,它只是一个列表列表,就像这样......
var fooInfo = new List<List<Foo>>();
我想知道是否有一种简单的方法可以使用linq从内部列表中返回所有项目的总和.例如,如果我们有这个......
fooInfo.add(new List<Foo>()); // First list within the outer list
fooInfo.add(new List<Foo>()); // Second list within the outer list
fooInfo.add(new List<Foo>()); // Third list within the outer list
// Add two items to the first inner list
fooInfo[0].add(new Foo());
fooInfo[0].add(new Foo());
// Add one item to the second inner list
fooInfo[1].add(new Foo());
// Add four items to the third inner list
fooInfo[2].add(new Foo());
fooInfo[2].add(new Foo());
fooInfo[2].add(new Foo());
fooInfo[2].add(new Foo());
...我们将有三个列表分别包含两个,一个和四个项目,这意味着总共'Foo'对象是七个.这是我希望通过linq检索的数字,而不是必须编写我们自己的循环代码并手动计算它们.
例如
var totalFoos = …鉴于此代码示例,有关传递给临时字符串的生命周期的规则是什么S.
struct S
{
// [1] S(const std::string& str) : str_{str} {}
// [2] S(S&& other) : str_{std::move(other).str} {}
const std::string& str_;
};
S a{"foo"}; // direct-initialization
auto b = S{"bar"}; // copy-initialization with rvalue
std::string foobar{"foobar"};
auto c = S{foobar}; // copy-initialization with lvalue
const std::string& baz = "baz";
auto d = S{baz}; // copy-initialization with lvalue-ref to temporary
根据标准:
N4140 12.2 p5.1(在N4296中删除)
绑定到构造函数的ctor-initializer(12.6.2)中的引用成员的临时绑定将持续存在,直到构造函数退出.
N4296 12.6.2 p8
绑定到mem-initializer中的引用成员的临时表达式是错误的.
因此,拥有用户定义的构造函数[1]绝对不是我们想要的.它甚至应该在最新的C++ 14中形成不良(或者是它？)gcc和clang都没有警告它.
它是否随直接聚合初始化而改变？在这种情况下,我看起来,临时寿命延长了.
现在关于复制初始化,默认移动构造函数和引用成员状态[2] …