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

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

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

有没有更好的办法？

有没有一种简单快速的方法来获得R中整数向量中出现的每个整数的频率？

以下是我到目前为止的尝试:

x <- floor(runif(1000000)*1000)

print('*** using TABLE:')
system.time(as.data.frame(table(x)))

print('*** using HIST:')
system.time(hist(x,breaks=min(x):(max(x)+1),plot=FALSE,right=FALSE))

print('*** using SORT')
system.time({cdf<-cbind(sort(x),seq_along(x)); cdf<-cdf[!duplicated(cdf[,1]),2]; c(cdf[-1],length(x)+1)-cdf})

print('*** using ECDF')
system.time({i<-min(x):max(x); cdf<-ecdf(x)(i)*length(x); cdf-c(0,cdf[-length(i)])})

print('*** counting in loop')
system.time({h<-rep(0,max(x)+1);for(i in seq_along(x)){h[x[i]]<-h[x[i]]+1}; h})

#print('*** vectorized summation') #This uses too much memory if x is large
#system.time(colSums(matrix(rbind(min(x):max(x))[rep(1,length(x)),]==x,ncol=max(x)-min(x)+1)))

#Note: There are some fail cases in some of the above methods that need patching if, for example, there is a chance that some integer bins are unoccupied

以下是结果:

[1] "*** using …

让 C被一个类中定义(部分地)由

private static class C {
    private final int x;
    // lots more fields be here

    public C(int x, /* lots more arguments here */) {
        this.x = x;
        // lots more fields initialized here
    }

    public int getX(){
        return x;
    }
}

让cs是一个List<C>实现RandomAccess,并分类对C.getX().

什么是标准的方法来执行的二进制搜索cs的x1上C.getX()？(换句话说,假装每个元素c都被替换c.getX(),然后我们x1在这些整数中搜索.)

Collections.binarySearch(
    cs,
    new C(x1,/* dummy arguments */),
    (a,b) -> Integer.compare(a.getX(),b.getX())
);

它的缺点是它需要构造一个新的C …

new File(url).lastModified()返回long等于自纪元以来的毫秒数（基于 GMT）。

将其转换为String代表系统本地日期/时间的简单方法是什么？

如果你真的需要看到我在这里的尝试，那就是，但这是一团糟，而且无论如何都是错误的：

LocalDateTime.ofEpochSecond(new File(url).lastModified()/1000,0,ZoneOffset.UTC).atZone(ZoneId.of("UTC")).format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG))

除此之外，LocalDateTime我只是不知道时间 API 是如何工作的。

以下应用：

public class Temp extends Application {

    @Override
    public void start(Stage primaryStage) {
        StackPane root = new StackPane();

        Rectangle rect = new Rectangle(10.0,10.0);
        rect.setStyle("-fx-fill: red; -fx-border-style: solid; -fx-border-width: 5; -fx-border-color: black;");
        root.getChildren().add(rect);

        Scene scene = new Scene(root, 100, 100);

        primaryStage.setScene(scene);
        primaryStage.show();
    }

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        launch(args);
    }
}

产生以下窗口：

为什么我的矩形没有粗黑色边框？

我希望就如何处理我即将进行的设计提出一些高级建议.

解决我的问题的直接方法将导致数以百万计的指针.在64位系统上,这些可能是64位指针.但就我的应用程序而言,我认为我不需要超过32位的地址空间.我仍然希望系统能够利用64位处理器算法(假设这是我在64位系统上运行得到的).

进一步背景

我正在实现一个树状数据结构,其中每个"节点"包含一个8字节的有效负载,但也需要指向四个相邻节点(父节点,左子节点,中间子节点,右子节点)的指针.在使用64位指针的64位系统上,这相当于32字节,仅用于将8字节有效负载链接到树中 - "链接开销"为400%.

数据结构将包含数百万个这样的节点,但我的应用程序除此之外不需要太多内存,因此所有这些64位指针看起来都很浪费.该怎么办？有没有办法在64位系统上使用32位指针？

我考虑过了

1. 将有效载荷存储在数组中,使得索引暗示(并暗示)"树地址",并且可以使用该索引上的简单算术计算给定索引的邻居.不幸的是,这需要我根据树的最大深度调整数组的大小,这是我事先不知道的,并且由于较低级别中的空节点元素,它可能会产生更大的内存开销,因为不是树的所有分支走到同样的深度.

2. 将节点存储在一个足够大的数组中以保存所有节点,然后使用索引而不是指针链接邻居.AFAIK这里的主要缺点是每个节点都需要数组的基地址才能找到它的邻居.所以他们要么需要存储它(一百万次),要么需要传递每个函数调用.我不喜欢这个.

3. 假设所有这些指针中最重要的32位为零,如果不是则抛出异常,并且仅存储最低有效32位.因此可以根据需要重建所需的指针.该系统可能使用超过4GB,但该过程永远不会.我只是假设指针偏离了进程基地址,并且不知道这对于通用平台(Windows,Linux,OSX)有多安全(如果有的话).

4. 存储64位和64位指针之间的差异this,假设这个差异将在int32_t(并且如果不是)的范围内.然后任何节点都可以通过添加该偏移来找到它的邻居this.

有什么建议？关于最后一个想法(我目前认为这是我最好的候选人),我可以假设在一个使用少于2GB的进程中,动态分配的对象将彼此相差2 GB以内吗？或者根本不是吗？

特定

struct Range{
    Range(double from, double to) : from(from), to(to) {}
    double from;
    double to;
    // if it matters to the compiler, we can add more fields here to make copying expensive
};

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通过在内部构建它们box来完全避免复制对象.

有没有编译器真的这样做？

我自己的尝试没有成功.

考虑以下循环:

while((expressionA) & (expressionB)){
    // do something
}

while((expressionA) && (expressionB)){
    // do something
}

其中expressionA和expressionB是类型的表达bool和expressionB不具有副作用.在这些条件下,这两种情况都是为-如果换算后(右？).

一个(假设的)编译器天真地从源代码中获取其提示将在&&版本中放置一个分支,我们最终将支付分支预测失败.

使用现代编译器(例如当前的GCC),是否有任何条件可以使&版本在版本上获得显着的性能提升&&？

我的猜测是否定的,因为:

• 如果expressionB足够便宜,编译器将识别这一点并避免创建短路分支.
• 如果expressionB足够昂贵,编译器将创建短路,因为:
  • 如果概率expressionA不接近1.0,我们可以从短路中获得可观的平均性能增益.
  • 如果概率expressionA接近1.0,我们将不会支付太多,因为分支预测将趋于成功.

如何在 R 中计算两个排列之间的 Kendall tau 距离（又名冒泡排序距离）而不加载额外的库？

给定一个向量u元素和矢量i指数到载体x,我们如何可以插入的元素u到x对应于指数的元素后i,无需重复？

例如

x <- c('a','b','c','d','e')
u <- c('X','X')
i <- c(2,3)
# now we want to get c('a','b','X','c','X','d','e')

我想一步完成这个(即避免循环),因为每个步骤都需要创建一个新的向量,实际上这些是长向量.

我希望有一些索引魔法.