小编men*_*ics的帖子

在Haskell中是否有任何良好的空间索引实现,如R-tree,kd-tree等...

我正在运行以下Scala代码.它编译10,000个立方体的单个显示列表.然后它在显示循环中显示它们,动画师尽可能快地运行.但FPS只有20左右.我原以为使用显示列表可以很快处理这个问题.我有一种情况需要能够显示10k-100k的物体.有没有更好的方法呢？在显示循环中,几乎所有它都是调用gluLookAt和glCallList(它是最后一个方法).

我正在使用jogamp.org的JOGL 2.0-rc5,它说它支持"OpenGL 1.3 - 3.0,3.1 - 3.3,≥4.0,ES 1.x和ES 2.x +几乎所有供应商扩展"

class LotsOfCubes extends GLEventListener {
  def show() = {
    val glp = GLProfile.getDefault();
    val caps = new GLCapabilities(glp);
    val canvas = new GLCanvas(caps);
    canvas.addGLEventListener(this);

    val frame = new JFrame("AWT Window Test");
    frame.setSize(300, 300);
    frame.add(canvas);
    frame.setVisible(true);
  }

  override def init(drawable: GLAutoDrawable) {
    val gl = drawable.getGL().getGL2()
    gl.glEnable(GL.GL_DEPTH_TEST)

    gl.glNewList(21, GL2.GL_COMPILE)
    var i = -10.0f
    var j = -10.0f
    while (i < 10.0f) {
      while (j < 10.0f) {
        drawItem(gl, i, j, …

我搜索并找到了有关此主题的一些信息,但答案要么令人困惑,要么不适用.

我有这样的事情:

class Thing (val name:String, val refs:IndexedSeq[Ref])
class Ref (val name:String, val thing:Thing)

现在,我想说,加载一个文件,解析它并从中填充这个数据结构.它是不可变的和循环的,怎么会这样做？

另外,假设我确实填充了这个数据结构,现在我想修改它,比如更改rootThing.refs(3).name,怎么可能这样做呢？

感谢此处发布的想法.在这一点上,我在想如果一个人真的想要这样的东西的持久性数据结构,那就跳出框框思考并考虑客户端代码需要问什么问题.因此,不要考虑对象和字段,而应考虑查询,索引等.首先,我在想: 是否存在双向多图持久数据结构？

有没有办法指定一个actor可以接受什么类型的消息,如果有什么东西试图发送一些其他类型的话,会给出编译错误？

我想在Windows上部署需要访问GHC API的应用程序.使用Wiki中的第一个简单示例:

http://www.haskell.org/haskellwiki/GHC/As_a_library

导致以下错误(在具有haskell平台的一台机器上编译并在另一个干净的Windows安装上执行):test.exe:在C:\ haskell\lib\package.conf.d中找不到包数据库

我想将我的应用程序部署为一个简单的zip文件,而不是要求用户安装任何东西.是否有一种简单的方法可以在该zip文件中包含所需的GHC内容,以便它可以工作？

是否有Scala SWT包装器/ API具有最多的功能并且最准备好使用？我看到一对看似非正式的包装纸,但无法判断它们是否得到了维护.另外,我在多个地方看到一两个,我不确定它们的规范位置.

有些语言支持足够强大的类型系统,他们可以在编译时证明代码不能解决其边界之外的数组.我的问题是,如果我们要将这样的语言编译到JVM,是否有某种方法可以利用它来提高性能并删除每次访问阵列时发生的数组边界检查？

1)我知道最近的JDK支持一些数组绑定检查消除,但由于我在编译时知道某些调用是安全的,我可以更安全地删除.

2)有些人可能会认为这不会对性能产生太大影响,但肯定会有所影响,尤其是在阵列/计算等重大应用中,例如科学计算.

关于铸造的同样问题.我知道某些东西是某种类型,但Java并不是因为它的有限类型系统.有没有办法告诉JVM"信任我"并跳过任何检查？

我意识到可能没有办法这样做,因为JVM通常是分布式的,用这个功能修改JVM是否合理？这件事已经完成了吗？

这是为JVM编译更强大的类型语言的挫折之一,它仍然受到Java限制的阻碍.

我是Scala的新手...这是代码:

  def ack2(m: BigInt, n: BigInt): BigInt = {
      val z = BigInt(0)
      (m,n) match {
          case (z,_) => n+1
          case (_,z) => ack2(m-1,1) // Compiler says unreachable code on the paren of ack2(
          case _ => ack2(m-1, ack2(m, n-1)) // Compiler says unreachable code on the paren of ack2(
      }
  }

我试图理解......为什么会出现这个错误？

注意:我正在使用Scala Eclipse Plugin 2.8.0.r21376-b20100408034031 ch.epfl.lamp.sdt.feature.group

我在使用ghc版本7.0.3.20110330的Ubuntu 11.10上运行nvidia显示驱动程序的"当前版本更新".您可以通过运行来重现:

curl http://ix.io/1t6 > Stroke.hs; ghc --make Stroke.hs; ./Stroke
...
Stroke: user error (unknown GLU entry gluOrtho2D)

但我可以运行opengl,它运行正常.我尝试了glxgears,它运行良好,我运行了一个opengl基准测试,它运行良好.

haskell opengl libs版本的运行结果:

for p in OpenGL OpenGLRaw GLURaw; do ghc-pkg latest $p; done

OpenGL-2.4.0.1
OpenGLRaw-1.1.0.1
GLURaw-1.1.0.0

假设:

1. 只有一个特定的线程可以设置某个引用字段(不是long或double,因此写入它是原子的)
2. 有任意数量的线程可能会读取同一个字段
3. 稍微陈旧的读取是可以接受的(最多几秒钟)

在这种情况下,您需要volatile或AtomicReference或类似的东西吗？

本文指出:

如果严格遵守单一编写原则,则不需要内存屏障.

这似乎表明,在我描述的情况下,你真的不需要做任何特别的事情.

所以,这是一个测试我跑了好奇的结果:

import org.junit.Test;

public class ThreadTest {
    int onlyWrittenByMain = 0;
    int onlyWrittenByThread = 0;

    @Test
    public void testThread() throws InterruptedException {
        Thread newThread = new Thread(new Runnable() {
            @Override
            public void run() {
                do {
                    onlyWrittenByThread++;
                } while (onlyWrittenByMain < 10 || onlyWrittenByThread < 10);
                System.out.println("thread done");
            }
        });
        newThread.start();

        do {
            onlyWrittenByMain++;
            // Thread.yield();
            // System.out.println("test");
            // new Random().nextInt();
        } while (onlyWrittenByThread < 10);
        System.out.println("main done");
    }
}

有时运行它会输出"thread …