如何在F#中实现符合规格的曼德博集合异步计算函数mandelbrotAsync

基础规则与约束 #

• 已知复数类型定义：type Complex = double * double，即两个连续存储的double值分别对应复数的实部、虚部。
• 曼德博集合单元素判定逻辑：对输入复数c，从z=0初始值开始执行n次迭代，迭代公式为z = z² + c；若迭代全程满足模长平方不超过4（即无逃逸），则对应位置判定结果为true，否则为false。
• 实现强制要求：
  • 通过divide函数将输入复数数组cs的全索引范围划分为m个连续、无重叠、全覆盖的区块，每个区块对应起止索引(s,e)。
  • 所有区块的计算依托F#的Async机制并行执行，不采用串行计算模式。
  • 区块计算启动时，必须将区块起始索引s作为参数传入start函数执行。
  • 区块计算完成时，必须将区块结束索引e作为参数传入finish函数执行。
  • 最终返回的布尔数组长度与cs完全一致，索引位置与判定结果一一对应。

核心辅助函数实现 #

1. 范围划分函数divide #

按照数组总长度、目标划分块数，生成连续的(s,e)区间序列，保证区间无重叠、无遗漏覆盖全范围：

let divide total m =
    if m <= 0 then invalidArg (nameof m) "划分块数必须为正整数"
    let baseSize = total / m
    let remainder = total % m
    seq {
        let mutable pos = 0
        for blockIdx in 0 .. m - 1 do
            // 前remainder个块多分配1个元素，保证划分均匀
            let currentBlockSize = baseSize + (if blockIdx < remainder then 1 else 0)
            let s = pos
            let e = pos + currentBlockSize
            yield (s, e)
            pos <- e
    }

2. 单复数曼德博判定函数 #

按照迭代规则计算单个复数是否属于曼德博集合：

let private checkMandelbrot (iterCount: int) (c: Complex) =
    let cr, ci = c
    let mutable zr, zi = 0.0, 0.0
    let mutable escaped = false
    let mutable curIter = 0
    while curIter < iterCount && not escaped do
        let zrSq = zr * zr
        let ziSq = zi * zi
        escaped <- zrSq + ziSq > 4.0
        if not escaped then
            // 计算下一次迭代值 z = z² + c
            let nextZr = zrSq - ziSq + cr
            let nextZi = 2.0 * zr * zi + ci
            zr <- nextZr
            zi <- nextZi
            curIter <- curIter + 1
    not escaped

mandelbrotAsync 完整实现 #

let mandelbrotAsync m n start finish cs =
    async {
        let totalLen = cs.Length
        // 提前初始化与输入数组同长度的结果数组
        let result = Array.zeroCreate<bool> totalLen
        // 将全索引范围划分为m个连续区块
        let ranges = divide totalLen m
        // 为每个区块构建独立的异步计算单元
        let blockTasks =
            ranges
            |> Seq.map (fun (s, e) ->
                async {
                    // 区块启动时，传入起始索引s执行start
                    start s
                    // 计算当前区块覆盖范围内的所有元素判定结果
                    for i in s .. e - 1 do
                        result.[i] <- checkMandelbrot n cs.[i]
                    // 区块计算完成时，传入结束索引e执行finish
                    finish e
                })
        // 并行执行所有区块的异步计算任务
        do! blockTasks |> Async.Parallel |> Async.Ignore
        // 全部任务执行完成后返回结果数组
        return result
    }

内容的提问来源于stack exchange，提问作者Keneth