小编Mai*_*tor的帖子

我问过这个并得到了答案:

var geom = new THREE.Geometry(); 
var v1 = new THREE.Vector3(0,0,0);
var v2 = new THREE.Vector3(0,500,0);
var v3 = new THREE.Vector3(0,500,500);

geom.vertices.push(new THREE.Vertex(v1));
geom.vertices.push(new THREE.Vertex(v2));
geom.vertices.push(new THREE.Vertex(v3));

var object = new THREE.Mesh( geom, new THREE.MeshNormalMaterial() );
scene.addObject(object);

我希望这可行,但事实并非如此.

在Python上,range(3)将返回[0,1,2].是否存在多维范围的等价物？

range((3,2)) # [(0,0),(0,1),(1,0),(1,1),(2,0),(2,1)]

因此,例如,循环通过基于图块的游戏上的矩形区域的图块可以写为:

for x,y in range((3,2)):

注意我不是要求实现.我想知道这是否是一个公认的模式,如果在Python或它的标准/公共库上有内置函数.

依赖类型通常被宣传为一种方法,使您能够断言程序是否符合规范.因此,例如,要求您编写一个对列表进行排序的代码- 您可以通过将"sort"的概念编码为类型并编写诸如的函数来证明代码是正确的List a -> SortedList a.但是,您如何证明规范SortedList是正确的？难道不是这样,您的规范越复杂,您对该规范作为类型的编码就越不可能吗？

创建node.js应用程序非常简单.

var app = require('express')();
app.get('/',function(req,res){
    res.send("Hello world!");
});

但是假设人们开始沉迷于你的Hello World!应用程序并耗尽你的资源.这个例子如何在实践中扩大规模？我不明白,因为是的,你可以在不同的计算机上打开几个node.js实例 - 但是当有人访问http://your_site.com/时,它直接针对那个特定的机器,那个特定的端口,那个特定的节点进程.又怎样？

我想知道在Haskell或Idris等类型语言中表达智能合约的最佳方式是什么(例如,您可以将其编译为在以太坊网络上运行).我主要担心的是:哪种类型可以捕获合同可以执行的所有操作？

天真的解决方案:EthIO

一个天真的解决方案是将合同定义为EthIO类型的成员.这种类型就像Haskell一样IO,但它不是启用系统调用,而是包括区块链调用,即它可以读取和写入区块链的状态,调用其他合同,获取块数据等等.

-- incrementer.contract

main: EthIO
main = do
   x <- SREAD 0x123456789ABCDEF
   SSTORE (x + 1) 0x123456789ABCDEF

这显然足以执行任何合同,但是:

1. 太强大了.

2. 特别是与以太坊区块链非常相关.

保守解决方案:事件采购模式

根据这个想法,合同将被定义为一系列行动的折叠:

type Contract action state = {
    act  : UserID -> action -> state -> state,
    init : state
}

所以,程序看起来像:

incrementer.contract

main : Contract
main = {
    act _ _ state = state + 1,
    init          = 0
}

也就是说,您可以定义初始状态,操作类型以及用户提交操作时该状态的更改方式.这将允许人们定义任何不涉及发送/接收资金的任意合同.大多数区块链都有某种货币,大多数有用的合约都是以某种方式涉及金钱,所以这种类型的限制性太强了.

不太保守的解决方案:事件+货币

我们可以通过将货币逻辑硬编码到上面的类型中来使上述类型知道货币.因此,我们得到类似的东西:

type Contract action state = {
    act        : UserID -> …

我经常发现自己必须代表一个由非常小的值组成的结构.例如,Foo有4个值a, b, c, d,范围从0 to 3.通常我不在乎,但有时,这些结构是

1. 用于紧密循环;

2. 他们的价值读数十亿次/秒,这是该计划的瓶颈;

3. 整个计划由数十亿美元组成Foo;

在这种情况下,我发现自己无法决定如何Foo有效地表达.我基本上有4种选择:

struct Foo {
    int a;
    int b;
    int c;
    int d;
};

struct Foo {
    char a;
    char b;
    char c;
    char d;
};

struct Foo {
    char abcd;
};

struct FourFoos {
    int abcd_abcd_abcd_abcd;
};

它们分别使用128,32,8,8位Foo,从稀疏到密集.第一个例子可能是最语言的例子,但使用它实际上会增加16倍于程序的大小,这听起来不太合适.而且,大部分内存都会被零填充而根本不被使用,这让我想知道这不是浪费.另一方面,密集地打包它们会带来额外的开销来阅读它们.

在结构中表示小值的计算"最快"方法是什么？

在Haskell中,使用函数编写代数数据类型(ADT)非常容易.这允许我们编写依赖于本机函数进行替换的解释器,即高阶抽象语法(HOAS),其已知非常有效.例如,这是一个使用该技术的简单λ演算解释器:

data Term
  = Hol Term
  | Var Int
  | Lam (Term -> Term)
  | App Term Term

pretty :: Term -> String
pretty = go 0 where
  go lvl term = case term of
    Hol hol     -> go lvl hol 
    Var idx     -> "x" ++ show idx
    Lam bod     -> "?x" ++ show lvl ++ ". " ++ go (lvl+1) (bod (Hol (Var lvl)))
    App fun arg -> "(" ++ go lvl fun ++ " …

用一种命令式语言来思考下面的纯函数:

def foo(x,y):
    x = f(x) if a(x)
    if c(x): 
        x = g(x)
    else:
        x = h(x)
    x = f(x)
    y = f(y) if a(y)
    x = g(x) if b(y)
    return [x,y]

该函数表示必须逐步更新变量的样式.在大多数情况下可以避免这种情况,但有些情况下这种模式是不可避免的 - 例如,为机器人编写烹饪程序,这本身就需要一系列步骤和决定.现在,想象一下我们试图foo在Haskell中代表.

foo x0 y0 =
    let x1 = if a x0 then f x0 else x0 in
    let x2 = if c x1 then g x1 else h x1 in
    let x3 = f x2 in
    let y1 = if a y0 then f …

一般问题

假设您正在编写一个由图形组成的系统,以及可以根据相邻节点的配置激活的图形重写规则.也就是说,您有一个在运行时期间无法预测地增长/收缩的动态图形.如果你天真地使用malloc,新的节点将被分配在内存中的随机位置; 经过足够的时间,你的堆将成为指针spaghetti,给你可怕的缓存效率.是否有任何轻量级的增量技术可以使节点在一起在内存中保持紧密联系？

我尝试了什么

我唯一能想到的是将节点嵌入到笛卡尔空间中,并使用一些物理弹性模拟来排斥/吸引节点.那将有线节点保持在一起,但看起来很傻,我想模拟的开销会比缓存效率加速更大.

坚实的例子

这是我正在尝试实施的系统.这是我试图在C中优化的代码的简短片段.这个 repo是JS中的一个原型,工作实现,具有可怕的缓存效率(以及语言本身).该视频以图形方式显示系统的运行情况.

我正在使用browserify创建一个需要大型库(如jquery和three.js)的文件.编译过程需要几秒钟,可能是因为它重新编译了我所做的每个小改动的所有库.有没有办法加快速度？