使用函数式编程 (F#) 将位置列表转换为 2D 位置数组

Question

您如何使以下代码以相同的速度运行？一般来说，作为输入，我有一个包含位置坐标和其他内容的对象列表，我需要创建一个包含这些对象的二维数组。

let m = Matrix.Generic.create 6 6 []
let pos = [(1.3,4.3); (5.6,5.4); (1.5,4.8)]  
pos |> List.iter (fun (pz,py) ->
  let z, y = int pz, int py
  m.[z,y] <- (pz,py) :: m.[z,y]
)

大概可以这样实现：

let pos = [(1.3,4.3); (5.6,5.4); (1.5,4.8)]
Matrix.generic.init 6 6 (fun z y ->
  pos |> List.fold (fun state (pz,py) ->
    let iz, iy = int pz, int py
    if iz = z && iy = y then (pz,py) :: state else state
  ) []
)

但我想它会慢得多，因为它循环遍历整个矩阵乘以列表而不是前一个列表迭代......

PS：代码可能有误，因为我在这台电脑上没有 F# 来检查它。

Answer 1

你可以这样做：

[1.3, 4.3; 5.6, 5.4; 1.5, 4.8]
|> Seq.groupBy (fun (pz, py) -> int pz, int py)
|> Seq.map (fun ((pz, py), ps) -> pz, py, ps)
|> Matrix.Generic.initSparse 6 6

但在你的问题中你说：

您如何使以下代码以相同的速度运行？

在后来的评论中你说：

好吧，我尽量避免可变性，以便将来代码易于并行化

恐怕这是希望战胜现实的胜利。函数式代码通常具有较差的绝对性能，并且在并行化时扩展性很差。鉴于此代码正在执行大量分配，您根本不可能从并行性中看到任何性能提升。

Answer 2

这取决于“功能性”的定义。我会说“功能”函数意味着它总是为相同的参数返回相同的结果，并且它不会修改任何全局状态（或参数的值，如果它们是可变的）。我认为这是对 F# 的合理定义，但这也意味着在本地使用突变不会“功能失调”。

在我看来，下面的函数是“函数式的”，因为它创建并返回一个新矩阵而不是修改现有的矩阵，但当然，函数的实现使用突变。

let performStep m =
  let res = Matrix.Generic.create 6 6 [] 
  let pos = [(1.3,4.3); (5.6,5.4); (1.5,4.8)]   
  for pz, py in pos do
    let z, y = int pz, int py 
    res.[z,y] <- (pz,py) :: m.[z,y] 
  res

无突变版本： 现在，如果您想让实现完全正常运行，那么我将首先创建一个矩阵，该矩阵在您想要将新列表元素添加到矩阵元素的位置包含 Some(pz, py)，在所有其他位置包含 None地方。我想这可以通过初始化一个稀疏矩阵来完成。像这样的：

let sp = pos |> List.map (fun (pz, py) -> int pz, int py, (pz, py)) 
let elementsToAdd = Matrix.Generic.initSparse 6 6 sp

那么你应该能够将原始矩阵m 与新创建的elementsToAdd 结合起来。这当然可以使用init 来完成（但是，使用map2 之类的东西可能会更好）：

let res = Matrix.init 6 6 (fun i j -> 
  match elementsToAdd.[i, j], m.[i, j] with
  | Some(n), res -> n::res
  | _, res -> res )

F# 库函数中仍然很可能隐藏了一些突变（例如init 和initSparse），但至少它显示了一种使用更原始操作来实现操作的方法。

编辑：这仅在您需要向每个矩阵单元添加最多单个元素时才有效。如果你想添加多个元素，你必须先将它们分组（例如使用Seq.groupBy）

Answer 3

为什么要在功能上做到这一点？ Matrix 类型被设计为可以变异，所以你现在的做法对我来说看起来不错。

如果你真的想在功能上做到这一点，我会这样做：

let pos = [(1.3,4.3); (5.6,5.4); (1.5,4.8)]  
let addValue m k v = 
  if Map.containsKey k m then
    Map.add k (v::m.[k]) m
  else
    Map.add k [v] m
let map = 
  pos 
  |> List.map (fun (x,y) -> (int x, int y),(x,y)) 
  |> List.fold (fun m (p,q) -> addValue m p q) Map.empty
let m = Matrix.Generic.init 6 6 (fun x y -> if (Map.containsKey (x,y) map) then map.[x,y] else [])

这会遍历列表一次，创建一个从索引到点列表的不可变映射。然后，我们初始化矩阵中的每个条目，对每个条目进行一次映射查找。这应该花费总时间O(M + N log N)，其中M 和N 分别是矩阵和列表中的条目数。我相信您使用突变的原始解决方案需要O(M+N) 时间，而您修改后的解决方案需要O(M*N) 时间。