小编dev*_*ium的帖子

我想知道使用这个中值函数的原因是什么,而不仅仅是计算min + (max - min) / 2:

// used by the random number generator
private static final double  M_E12 = 162754.79141900392083592475;

/**
 * Return an estimate of median of n values distributed in [min,max)
 * @param min the minimum value 
 * @param max the maximum value
 * @param n 
 * @return an estimate of median of n values distributed in [min,max)
 **/
private static double median(double min, double max, int n) 
{
    // get random value in [0.0, …

当比较两种不同的算法实现(因此,不关心它们的绝对性能,但仅仅是相对性能)时,我最好强迫Java只运行解释代码吗？

也就是说,-Xint旗帜上的我会好些吗？

我正在阅读斯坦利的论文，但无法弄清楚NEAT中到底有多少不相交和多余的基因。我知道它们似乎与某种特定的方式相关，因为它们都包含与父母双方都不相关的创新数字。但是，它们有什么区别呢？

谁能阐明这个问题？

我试图遵循这个教程:

http://andrewclement.blogspot.pt/2009/02/load-time-weaving-basics.html

但我偶然发现了几个问题:

首先,我的系统没有设置javac和ajcPATH变量,因此我将bin/JDK7 的目录添加到PATH变量以及AspectJ的bin/目录中.

但是在运行时ajc WhereDoesTheTimeGo.java Simple.java我收到以下错误:

[warning] couldn't find aspectjrt.jar on classpath, checked: C:\Program Files\Ja
va\jre7\lib\resources.jar;C:\Program Files\Java\jre7\lib\rt.jar;C:\Program Files
\Java\jre7\lib\sunrsasign.jar;C:\Program Files\Java\jre7\lib\jsse.jar;C:\Program
 Files\Java\jre7\lib\jce.jar;C:\Program Files\Java\jre7\lib\charsets.jar;C:\Prog
ram Files\Java\jre7\lib\jfr.jar;C:\Program Files\Java\jre7\classes;C:\Program Fi
les\Java\jre7\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jre7\lib\ext\dn
sns.jar;C:\Program Files\Java\jre7\lib\ext\jaccess.jar;C:\Program Files\Java\jre
7\lib\ext\localedata.jar;C:\Program Files\Java\jre7\lib\ext\sunec.jar;C:\Program
 Files\Java\jre7\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jre7\lib\ext\
sunmscapi.jar;C:\Program Files\Java\jre7\lib\ext\zipfs.jar;C:\Program Files\Java
\jre7\lib\tools.jar

[error] classpath error: unable to find org.aspectj.lang.JoinPoint (check that a
spectjrt.jar is in your classpath)

所以我手动将引用的文件添加到类路径:

ajc -cp ajc -cp C:\aspectj1.7\lib\aspectjrt.jar Simple.java WhereDoesTheTimeGo.java

然后执行显然没问题,同时创建了两个.class文件.但是之后...:

ajtests>java Simple
Exception in thread …

我需要将任意整数（即bigint）转换为其数字，以便我可以通过索引访问它们。

不过，我发现自己在该算法的两种可能实现之间徘徊：

open System

let toDigits (x:bigint) =
    x.ToString() 
    |> Seq.map (fun c -> (int c) - (int '0'))
    |> Seq.toArray

let toDigits' (x:bigint) =
    seq {
        let x' = ref x
        while !x' <> 0I do
            yield (int (!x' % 10I))
            x' := !x' / 10I
    } |> Seq.toArray |> Seq.rev

我嘀咕哪一个最快？为了帮助我回答这个问题，我设计了一个简单的profile方法

let profile f times = 
    let x = ref 0
    while !x < times do
        incr x
        f (bigint !x) |> ignore

与 …

我在这个看似简单的问题上遇到了麻烦:

let xs = Array2D.init 3 3 (fun j i -> j*3 + i)
printfn "%O" (xs.GetType()) // prints System.Int32[,]

for v in xs do
    printfn "%d" v // <- this gives a compiler error. why should it?

问题似乎是F#认为v属于类型obj,这有点奇怪.

这是一个编译器错误还是我错过了一些非常明显的东西？

谢谢

我在大型系统中工作时看到的一个常见模式（问题）是类名冲突。特别是在处理不同的有界上下文时，我们可以在不同的包中找到多个具有相同名称的类。

我已经看到在 Scala 中可以在本地重命名类的名称，但我想知道是否可以重命名来自给定包的所有导入类的名称。我正在寻找类似于

import data.{*-> Data*} // all classes on data.* will appear with a Data prefix
import domain.{*->Domain*} // all classes on domain.P will appear with a Domain prefix

谢谢

我实现了一个我选择调用的函数divideAt:

module List =
    let divideAt predicate list =
        let rec divideAt' acc = function
            | [] -> (List.rev acc, [])
            | h::_ as ls when predicate h -> (List.rev acc, ls)
            | h::t -> divideAt' (h::acc) t
        divideAt' [] list

这个想法相对简单:有时你想给定一个列表中的元素,将它之前的所有元素分成左边的列表,然后将所有元素分成另一个元素.

我查看了List的所有功能,但是找不到任何可以让我以高效的方式执行此操作的功能.还是有吗？完全依赖于高阶函数的等效但速度较慢的实现可以通过这种方式实现,例如:

let divideAt predicate list =
    match List.tryFindIndex predicate list with
    | None -> (list, [])
    | Some(index) -> (List.take index list, List.skip index list)

是否有一些东西可以让我更简洁地实现这一点而不必依赖"低级"递归算法而不会像使用这个HOF实现时那样产生性能损失？

谢谢

当我们处于用户模式并且发生页面错误时，我有些困惑。

IIRC，当TLB尝试将我的（用户空间）虚拟地址映射到物理地址时将发生页面错误，并且它将失败。

然后，它将生成将由OS同步处理的异常。但是现在的问题是：此异常处理程序代码的地址及其相关数据很可能也不会在TLB中！

这是递归的还是此内存地址的内核范围受不同规则的约束（例如，虚拟/物理内存之间的自动映射，以避免需要使用TLB？）

谢谢！

工作中有一个与超线程至强机器相关的讨论。我对超线程如何工作的（肤浅的）理解是 CPU 在物理上多路复用来自两个“线程”的指令。也就是说，执行单元是共享的，但是有两个不同的架构集（寄存器集、指令队列，甚至可能是分支预测器等）——每个线程一个。执行单元及其缓冲区/队列总是准备好接收新的指令/数据，从这个角度来看，禁用一个线程而不是保留两个线程没有任何优势。

我的同事暗示通过关闭超线程我们可以实现加速，因为运行单线程的 CPU 不再需要“查看”另一个线程是否也有一些工作要做。我的理解是，所有这些电路都已经硬连线以多路复用来自两个线程的传入数据/指令，并且禁用超线程只会关闭其中一个线程，不允许它接收任何指令/数据，但实际上没有其他不同。这是超线程如何工作的一个很好的心理模型吗？

我确实理解有很多因素在起作用，例如内存工作集、共享缓存的问题等，可能会影响 2 线程超线程 CPU 与禁用超线程的同一 CPU 相比的表现，但是我的问题更多地是针对禁用超线程是否以某种方式使整个数据/指令流通过管道更快？例如，在尝试填充后端前端的缓冲区时是否会出现争用问题？

我同事的解释也以某种方式包括管理程序，但我看不到两者之间的关系？它们似乎是正交的概念。

谢谢！