小编Mai*_*tor的帖子

在JavaScript中,您可以使用a直接操作图像的像素Uint8ClampedArray.在将该图像渲染到画布之前,您必须:

1. 创建一个ImageData对象.

2. 用它渲染Uint8ClampedArray到一个ImageData对象ImageData.data.set.

3. ImageData用画布将该对象绘制到画布上context.putImageData.

因此,从拥有Uint8ClampedArray图像到实际在屏幕上看到它,它需要不少于3次O(N)复制操作.对于大图像,这可能是非常有害的.一个解决办法是缓存的ImageData对象,并更换指针imageData.data到你的Uint8ClampedArray-但是imageData.data是只读的!有没有办法更有效地做到这一点？

在Haskell中,我有一个容器,如:

data Container a = Container { length :: Int, buffer :: Unboxed.Vector (Int,a) }

这个容器是一棵扁平的树.它的访问器通过向量(!)执行二进制(log(N))搜索,以便找到index存储的正确存储桶.

(!) :: Container a -> Int -> a
container ! index = ... binary search ...

由于连续访问可能位于同一个存储桶中,因此可以通过以下方式进行优化:

if `index` is on the the last accessed bucket, skip the search

棘手的一点是这last accessed bucket部分.在JavaScript中,我只是不明确地修改容器对象上的隐藏变量.

function read(index,object){

    var lastBucket = object.__lastBucket;

    // if the last bucket contains index, no need to search
    if (contains(object, lastBucket, index))
        var bucket = …

结点策略可用于构建图形,例如,使用简单的双边图形作为示例:

data Node = Node Node Node

-- a - b
-- |   |
-- c - d
square = a where
    a = Node b c
    b = Node a d
    c = Node a d
    d = Node b c

这个策略相当优雅,但是如果没有Int标签,我找不到实际使用它的方法.例如,我如何编写一个计算square值上节点数量的函数？

countNodes :: Node -> Int
countNodes = ... ??? ...

main = print $ countNodes square
-- output: 4

自然数可以使用二进制表示形式在对数空间中表示(此处为little-endian):

-- The type of binary numbers; little-endian; O = Zero, I = One
data Bin = O Bin | I Bin | End

然后可以通过调用函数()次数来实现a和添加.这种实现的问题在于它本质上是顺序的.为了添加2个号码,呼叫按顺序链接.(例如使用进位)的其他实现遭受相同的问题.很容易看出,添加不能与该表示并行实现.是否使用代数数据类型表示自然数,它采用对数空间,并且可以并行添加？bsuccessorO(log(N))absucadd

插图代码:

-- The usual fold  
fold :: Bin -> (t -> t) -> (t -> t) -> t -> t
fold (O bin) zero one end = zero (fold bin zero one end)
fold (I bin) zero one end = one (fold bin …

在交互网上有一个已知的 \xce\xbb 微积分项的实现的已知实现。但它过于复杂且效率低下。众所周知，Lamping 的抽象算法能够以最佳方式将 xcexbb 微积分项的一个非常大的子集评估为正规形式。此外，它与交互组合器非常相似，只有一个关键区别：不是两种类型的节点，而是无限系列的不同可能节点。换句话说，Lamping的抽象算法只是交互组合器加上整数标签。

是否可以在交互组合器上有效地模拟这些整数标签（以及抽象算法）？

我需要一个函数split : Word64 -> (Word64, Word64)，可以接受任何 Word64 并将其拆分为两个不同的 Word64，这样我就可以继续以任意顺序拆分子代和孙代，同时避免冲突。也就是说，对于sa, sb种子的任何一对连续分裂（例如sa = fst.split.fst.split$ seed），sa必须与sb>99.99% 的几率不同。

我考虑过使用配对函数，但这会使孩子比父母大，所以，在几次分割之后，会出现整数溢出。我需要的东西基本上以半随机的方式将可能的 Word64 位空间上的任何值发送到其他两个值。另外，我需要它尽可能快速和简单。指令越少越好。这可能是我错过的一个非常愚蠢的计算。

这里可以使用什么？

免责声明：我以前也问过类似的问题，但现在我终于对问题有了更好的理解，并且确切地知道我需要什么。

使用Church编码,可以在不使用内置ADT系统的情况下表示任意代数数据类型.例如,Nat可以表示(例如在Idris中):

-- Original type

data Nat : Type where
    natSucc : Nat -> Nat
    natZero : Nat

-- Lambda encoded representation

Nat : Type
Nat = (Nat : Type) -> (Nat -> Nat) -> Nat -> Nat

natSucc : Nat -> Nat
natSucc pred n succ zero = succ (pred n succ zero)

natZero : Nat
natZero n succ zero = zero

Pair 可以表示为:

-- Original type
data Pair_ : (a : Type) -> (b : Type) -> …

我正在尝试使用 WebGL 绘制单个像素。我正在使用gl_PointSize = 1.0, 和gl_FragColor = vec4(0.0, 0.0, 0.0, 1.0). 我预计单个黑色像素。然而，这就是我的观点的呈现方式：

也就是说，我得到的是覆盖大约 3x3 区域的灰点。我如何获得实际的单个像素？

我一直在寻找一种在 WebGL 纹理上存储浮动的方法。我在互联网上找到了一些解决方案，但那些只处理 [0..1) 范围内的浮点数。我希望能够存储任意浮点数，为此，需要扩展这样的函数以存储指数（例如，在第一个字节上）。不过，我不太明白这些是如何工作的，因此如何做到这一点并不明显。简而言之：

将浮点数打包成 4 个字节的有效算法是什么？

诸如以太坊之类的区块链在其智能合约处理虚拟机上使用基于堆栈寄存器的语言.该模型非常方便,因为它提供了一种简单的机制来测量运行程序所需的工作量:只需为每个基本操作和总和确定成本.

假设使用智能契约的区块链而不是虚拟机,使用了函数式编程语言,如Haskell的核心.是否有任何简单,准确的方法来衡量执行功能程序所需的工作量 - 请记住,节点能够使用任何评估策略,因此这种测量必须是通用的.