在 f# 中创建路径列表

Question

（这可能是经典，但我想知道如何最好地表达它）

我从左边开始，在某个日期。 对于某些资产，我可以计算从开始日期到某个未来日期的回报。 从那个未来的日期开始，我可以递归地在时间上进一步移动。

我想生成尽可能向右的所有路径，但在某个目标日期之前停止。

这是我的代码。 'a 是一种资产，并且 (DateTime*DateTime) 是我对所述底层证券有报价的 2 倍。

  member this.getPaths dtstart dtend : Set<('a*(DateTime*DateTime)) list>=
     let rec getPaths dtstart dtend (pastpath:List<'a*(DateTime*DateTime)>) : seq<('a*(DateTime*DateTime)) list>=
        let udls = this.getUnderlyingsQuotingAt dtstart
        let onestep = seq { for udl in udls do
                                let qt = this.QuoteNextAfterSrict udl dtstart 
                                if qt.IsNone || (qt.Value |> fst > dtend) then
                                   yield pastpath |> List.rev  
                                else
                                   let nextdate = qt.Value |> fst 
                                   yield! (getPaths nextdate dtend  ((udl, (dtstart, nextdate))::pastpath) )  } 
        onestep
     getPaths dtstart dtend  List.empty |> Set.ofSeq 

由于我使用了yield!，最后我会为每次失败收集一条新路径。 所以，最后我必须对我的序列进行重复数据删除。 我的问题是：有没有更好的方法来找到完整的路径，而无需重复数据删除？

我可以进行第二次传递或添加一个 List 参数，但是是否有一些“纯粹”的方法可以一次性做到这一点？

更新

我认为我在许多无用的内部循环中弄错了整个方法。 可能矢量化下一个可用的报价会很有用。我会在重构后更新代码。

更新 2

第一次重写是以下内容，将 yield |> List.rev 上移一级，允许减少不必要的探索。

  member this.getPaths dtstart dtend : Set<('a*(DateTime*DateTime)) list>=
     let count = ref  0

     printfn "computing path from %A to %A " dtstart dtend
     let rec getPaths dtstart dtend (pastpath:List<'a*(DateTime*DateTime)>)  : seq<('a*(DateTime*DateTime)) list>=
        let udls      = this.getUnderlyingsQuotingAt dtstart
        let udlquotes = udls |> Seq.map   (fun udl -> (udl , this.QuoteNextAfterSrict udl dtstart))
                                              |> Seq.filter (fun   (_, q) -> q.IsSome)
                                              |> Seq.map    (fun   (udl, q) -> (udl, q.Value))
                                              |> Seq.filter (fun   (_, q) -> fst q <= dtend  )

        let onestep = seq { if udlquotes.IsEmpty then
                                yield pastpath  |> List.rev  
                            else
                                for (udl, q) in udlquotes  do
                                      let nextdate =  (fst q)
                                      count := !count + 1
                                      if !count%1000 = 0 then printfn "!count  %A , path : %A " !count pastpath
                                      yield! (getPaths nextdate dtend  ((udl, (dtstart,  nextdate))::pastpath)   )
                       }
        onestep
     getPaths dtstart dtend  List.empty |> Set.ofSeq 

Answer 1

我不太了解您的算法，但我认为总体结构看起来不错。 “重复数据删除”是什么意思？如果您指的是在递归处理结束时使用的 List.rev 调用，那么这是很常见的模式（我认为没有更好的方法来做到这一点）。

关于 F# 编码风格，在分析 qt 值时无法轻松使用模式匹配，这有点令人失望（因为无法使用内置模式对条件进行编码）。但是，您可以定义一个在输入大于参数时匹配的辅助参数化活动模式：

let inline (|MoreThan|_|) limit input = 
  if input > limit then Some input else None

使用该模式，您可以使 seq 的正文更具可读性：

let rec getPaths dtstart dtend pastpath = seq {
  let udls = this.getUnderlyingsQuotingAt dtstart 
  for udl in udls do 
    match this.QuoteNextAfterSrict udl dtstart with
    | None 
    | Some (MoreThan dtend _, _) ->
        yield pastpath |> List.rev   
    | Some (nextdate, _) ->
        let newpath = (udl, (dtstart, nextdate))::pastpath
        yield! getPaths nextdate dtend newpath }