小编Mus*_*ful的帖子

给定(预先存在的)具有各种类型列的数据框,将所有字符列转换为因子的最简单方法是什么,而不影响其他类型的任何列？

这是一个例子data.frame:

df <- data.frame(A = factor(LETTERS[1:5]),
                 B = 1:5, C = as.logical(c(1, 1, 0, 0, 1)),
                 D = letters[1:5],
                 E = paste(LETTERS[1:5], letters[1:5]),
                 stringsAsFactors = FALSE)
df
#   A B     C D   E
# 1 A 1  TRUE a A a
# 2 B 2  TRUE b B b
# 3 C 3 FALSE c C c
# 4 D 4 FALSE d D d
# 5 E 5  TRUE e E e
str(df)
# 'data.frame':  5 …

我希望stringstream有一个构造函数窃取其初始内容string&&.STL中通常不存在这样的种间"移动构造函数"吗？如果没有,为什么不呢？

特定

struct Range{
    Range(double from, double to) : from(from), to(to) {}
    double from;
    double to;
};

struct Box{
    Box(Range x, Range y) : x(x), y(y) {}
    Range x;
    Range y;
};

假设我们跑了Box box(Range(0.0,1.0),Range(0.0,2.0)).

启用优化的现代编译器是否可以避免Range在此构造期间完全复制对象？(即构建Range内部的对象box以开始？)

背景

我将以下接口作为API的一部分公开:

public interface Pasture {
    /**
     * @param t         The time of the visit (as measured from optimization starting point).
     * @param tLast     The time of the preceding visit (as measured from optimization starting point).
     * @return          The expected reward that will be reaped by visiting under the given conditions.
     */
    double yield(long t, long tLast);    
}

客户端将"牧场"模型作为实现此接口的对象传递给我.每个物体代表一个牧场.

在API方面,我会在不同时间跟踪对这些对象的"访问",然后pasture.yield(time, lastVisitTime)在我需要知道牧场在平均时间内产生了多少时调用.

问题出现了,这个接口可以在客户端实现为lambda表达式,显然每个lambda表达式实例化都不一定会创建一个带有新标识的新对象,这是我依赖的,以便跟踪哪些牧场在什么时候被访问过.

题

有没有办法阻止接口实现为lambda表达式,而强制客户端将其实现为匿名类.当然,为它添加一个虚拟方法可以解决问题,但在我看来,这将是任意和不整洁的.还有另外一种方法吗？

给定a FileTime fileTime,如何以自定义方式格式化为字符串？

String s = fileTime.toString() 仅以ISO格式提供.

String s = DateTimeFormatter.ofPattern("uuuu-MMM-dd HH:mm:ss")
                              .format(fileTime.toInstant());

投 UnsupportedTemporalTypeException: Unsupported field: Year

做一个unique_ptr实例(没有定制删除)具有相同的内存占用为原料指针或不仅仅是该指针的实例存储更多？

作为Eigen的新手，我要努力应对一些问题。

使用矩阵乘法，Eigen默认情况下会创建一个临时文件以避免混叠问题：

matA = matA * matA; // works fine (Eigen creates a temporary before assigning)

如果可以安全地假定没有混叠，则可以使用.noalias()进行优化：

matB = matA * matA; // sub-optimal (due to unnecessary temporary)
matB.noalias() = matA * matA; // more efficient

因此，Eigen在默认情况下会避免做出不安全的假设，除非明确告诉您可以假设没有混叠是安全的。到目前为止，一切都很好。

但是，对于许多其他表达式，例如a = a.transpose()Eigen，默认情况下会做出不安全的假设（没有混叠问题），并且需要显式干预以避免该不安全的假设：

a = a.transpose().eval(); // or alternatively: a.transposeInPlace()

因此，如果我们关注效率，则仅当存在潜在的混叠时才注意不够，而在没有潜在的混叠时则不足以注意。我们必须要小心，既当有潜在的混淆，并且在没有潜在的混淆，并决定一个特殊的干预措施是有保证的基础上，表达是否涉及矩阵乘法与否。在Eigen中，对于Eigen界面中的这种“默认期望混合”是否有一些设计依据？

我所咨询的几乎所有C/C++运算符优先级表都列出了三元条件运算符具有比赋值运算符更高的优先级.但是,有一些表,例如维基百科上的表和operator-precedence.com上的表,它们将它们放在相同的优先级上.哪个更高或更高？

我经常发现自己这样做:

list.stream().min(new Comparator<>() {

    @Override
    public int compare(E a, E b) {
        return Double.compare(f(a),f(b));
    }
})

哪里f是计算密集型功能.这需要两倍于f实际需要的评估.我更喜欢

list.stream().mapToDouble(f).min()

但后来我不知道如何获得这个最小值对应的原始元素.

围绕这个的一个丑陋的方法是

class WithF<E>{
    private final E e;
    private final double fe;
    WithF(E e, double fe){
        this.e = e;
        this.fe = fe;
    }
    public E getE(){
        return e;
    }
    public double getFE(){
        return fe;
    }
}

然后

list.stream().map(e -> new WithF<>(e,f(e))).min(Comparator.comparingDouble(WithF::getFE))

使用流API是否有更好的,惯用的方法？

沿着维度3对3D数组求和(从而产生矩阵)的规范方法是什么？

我知道我可以apply(A,c(1,2),sum)但是(错误地或正确地)我从某个地方得到的印象是使用apply并不比使用for循环更好.

我可能是aperm数组,colSum然后aperm再次取消它,但那不是很可读.

有没有更好的办法？