Идиоматический способ объединить несколько списков одинаковой длины в F #?

У меня есть несколько списков, каждый из которых содержит 9 чисел с плавающей запятой. По сути, мне нужно создать один новый список, который берет первый элемент из каждого из моих списков и складывает их вместе как мой первый элемент, затем добавляет второй элемент из каждого списка как мой второй элемент и т. Д.

Так эффективно, если мои данные выглядят примерно так:

List1 = [a1; b1; c1; d1; e1; f1; g1; h1; i1]
List2 = [a2; b2; c2; d2; e2; f2; g2; h2; i2]
...
Listn = [an; bn; cn; dn; en; fn; gn; hn; in]

Затем мне нужно создать новый список Listx, чтобы

Listx = [a1 + a2 + ... + an; b1 + b2 + ... + bn; ... ]

Количество списков, которые я буду объединять, будет варьироваться (иногда у меня может быть только один список из 9 номеров, а иногда более 100 списков, всегда длиной 9 элементов), поэтому мне было интересно, есть ли у кого-нибудь совет по хорошему идиоматическому способу делать это?

Я просмотрел этот вопрос и этот, но оба появляются чтобы отстаивать промежуточный шаг - сначала индексировать мои элементы, а затем использовать groupby. Меня это беспокоит, потому что а) у меня такое чувство, что для моего конкретного случая может быть более элегантное решение и б) производительность может быть проблемой позже - я не хочу преждевременно оптимизировать, но я также не хочу стрелять в себя в ногу.


list f# functional-programming idioms
person Terence Lewis    schedule 01.02.2012    source источник
comment
производительность может быть проблемой позже - я не хочу преждевременно оптимизировать, но я также не хочу стрелять себе в ногу. Я согласен с этим мнением, но стоит отметить, что если вы правильно инкапсулировать функциональность, а затем изменить реализацию, если производительность является проблемой, должно быть безболезненным и не влиять на остальную часть вашего кода.   -  person ildjarn    schedule 02.02.2012

Ответы (4)


arrow_upward
7
arrow_downward

Вот решение, которое работает со списком списков одинаковой длины:

let mapN f = function
   | []  -> []
   | xss -> List.reduce (List.map2 f) xss

let inline merge xss = mapN (+) xss

// Usage
let yss = List.init 1000 (fun i -> [i+1..i+9])
let ys = merge yss
person pad    schedule 01.02.2012
comment
Вам нужно отметить sumAll inline для работы с float и другими числовыми типами. - person Daniel; 02.02.2012

arrow_upward
2
arrow_downward

Я бы пошел через что-то попроще, например, матрицу:

let merge xss =
  let m = matrix xss
  List.map (m.Column >> Seq.sum) [0..m.NumCols-1]
person J D    schedule 02.02.2012

arrow_upward
1
arrow_downward

Вот один из подходов:

let merge lists =
  let rec impl acc lists =
    match List.head lists with
    | [] -> List.rev acc
    | _  -> let acc' = (lists |> List.map List.head |> List.reduce (+))::acc
            let lists' = List.map List.tail lists
            impl acc' lists'
  impl [] lists

Некоторые примечания:

  • List.reduce (+) используется вместо List.sum или List.sumBy, потому что последние работают только для числовых типов, тогда как (+) может работать, например, для string.

  • merge имеет тип int list list -> int list, а не общий из-за тонкостей работы оператора +. Если вам нужно, чтобы это работало только для одного типа, а этот тип не int (например, float), тогда будет достаточно добавления аннотации типа к merge:

    let merge (lists:float list list) =

  • merge можно пометить inline, и тогда он будет работать для любого типа, который поддерживает оператор +, но это приведет к большому раздутию в вашем IL, если существует более одного или двух call-сайтов. Если у вас есть несколько типов, которые должны работать с merge, и все они известны заранее, то хорошим обходным решением здесь является создание merge inline (и, возможно, private), а затем определение различных функций для конкретных типов, которые реализованы в терминах общего merge:

    let inline merge lists =
  let rec impl acc lists =
    match List.head lists with
    | [] -> List.rev acc
    | _  -> let acc' = (lists |> List.map List.head |> List.reduce (+))::acc
            let lists' = List.map List.tail lists
            impl acc' lists'
  impl [] lists

let mergeInts (lists:int list list) = merge lists
let mergeFloats (lists:float list list) = merge lists
let mergeStrings (lists:string list list) = merge lists

    Если затем вы вызываете только merges, зависящие от типа, раздувание IL должно быть незначительным.

  • Наконец, если производительность действительно вызывает беспокойство, используйте массивы, а не списки.
person ildjarn    schedule 01.02.2012

arrow_upward
0
arrow_downward

Вот альтернативный один лайнер со значениями по умолчанию, когда список списков пуст:

let sumVertically length = List.fold (List.map2 (+)) (List.replicate length 0)

//usage
//stolen from pad's answer
let listOfLists = List.init 1000 (fun i -> [i+1..i+9])
sumVertically 9 listOfLists
person bklaric    schedule 12.01.2017