LINQのマージリスト<IEnumerable <T>>をある規則で1つのIEnumerable <T>に変換します

Question

List<IEnumerable<double>>には可変数の無限の倍数の倍数のソースが含まれています。彼らはすべての波ジェネレータ関数であると言いましょう。私はIEnumerable<double>で表される単一の波発生器にそれらを重ねて、それぞれから次の数を取り出して合計する必要があります。

私は反復子メソッドを介してこれを行うことができます知っている、このような何か：

public IEnumerable<double> Generator(List<IEnumerable<double>> wfuncs) 
    { 
     var funcs = from wfunc in wfuncs 
        select wfunc.GetEnumerator(); 

     while(true) 
     { 
      yield return funcs.Sum(s => s.Current); 
      foreach (var i in funcs) i.MoveNext(); 
     } 
    } 

は、しかし、それは「歩行者」というそうです。これを実現するLINQ-ishの方法はありますか？

Answer 1

私はLINQを拡張せずにこれを回避する方法はないと思います。ここに私が最後に書いたものがあります。私はそれはいくつかのピボットのシナリオで役立つことができ、これはいくつかの方法に含まれ得るためにMoreLinqの作者に連絡してみましょう：

public static class EvenMoreLinq 
{ 
    /// <summary> 
    /// Combines mulitiple sequences of elements into a single sequence, 
    /// by first pivoting all n-th elements across sequences 
    /// into a new sequence then applying resultSelector to collapse it 
    /// into a single value and then collecting all those 
    /// results into a final sequence. 
    /// NOTE: The length of the resulting sequence is the length of the 
    ///  shortest source sequence. 
    /// Example (with sum result selector): 
    /// S1 S2 S2 | ResultSeq 
    /// 1 2 3 |   6 
    /// 5 6 7 |   18 
    /// 10 20 30 |   60 
    /// 6 - 7 |   - 
    /// -   - |   
    /// </summary> 
    /// <typeparam name="TSource">Source type</typeparam> 
    /// <typeparam name="TResult">Result type</typeparam> 
    /// <param name="source">A sequence of sequences to be multi-ziped</param> 
    /// <param name="resultSelector">function to compress a projected n-th column across sequences into a single result value</param> 
    /// <returns>A sequence of results returned by resultSelector</returns> 
    public static IEnumerable<TResult> MultiZip<TSource, TResult> 
            this IEnumerable<IEnumerable<TSource>> source, 
            Func<IEnumerable<TSource>, TResult> resultSelector) 
    { 
     if (source == null) throw new ArgumentNullException("source"); 
     if (source.Any(s => s == null)) throw new ArgumentNullException("source", "One or more source elements are null"); 
     if (resultSelector == null) throw new ArgumentNullException("resultSelector"); 

     var iterators = source.Select(s => s.GetEnumerator()).ToArray(); 
     try 
     { 
      while (iterators.All(e => e.MoveNext())) 
       yield return resultSelector(iterators.Select(e => e.Current)); 
     } 
     finally 
     { 
      foreach (var i in iterators) i.Dispose(); 
     } 
    } 
} 

私の組み合わせジェネレータ圧縮し、私はこの管理を使用して：

interface IWaveGenerator 
{ 
    IEnumerable<double> Generator(double timeSlice, double normalizationFactor = 1.0d); 
} 


[Export(typeof(IWaveGenerator))] 
class CombinedWaveGenerator : IWaveGenerator 
{ 
    private List<IWaveGenerator> constituentWaves; 

    public IEnumerable<double> Generator(double timeSlice, double normalizationFactor = 1) 
    { 
     return constituentWaves.Select(wg => wg.Generator(timeSlice)) 
           .MultiZip(t => t.Sum() * normalizationFactor); 
    } 
    // ... 
} 

Answer 2

IEnumerablesでZipメソッドを集計できます。

public IEnumerable<double> Generator(List<IEnumerable<double>> wfuncs) 
    { 
     return wfuncs.Aggregate((func, next) => func.Zip(next, (d, dnext) => d + dnext)); 
    } 

これは基本的に同じZipメソッドを何度も繰り返し適用します。

wfuncs[0].Zip(wfuncs[1], (d, dnext) => d + dnext) 
     .Zip(wfuncs[2], (d, dnext) => d + dnext) 
     .Zip(wfuncs[3], (d, dnext) => d + dnext); 

はそれを試してみてください：：4 IEnumerablesでは、これはに拡大するfiddle

Answer 3

これは、LINQは、おそらく理解するのがより困難になり、そしてあなたに何も買わないだろうな状況です。あなたの最善の策はあなたのサンプルメソッドを修正することです。このようなものはうまくいくはずです：

public IEnumerable<double> Generator(IReadOnlyCollection<IEnumerable<double>> wfuncs) 
{ 
    var enumerators = wfuncs.Select(wfunc => wfunc.GetEnumerator()) 
     .ToList(); 

    while(enumerators.All(e => e.MoveNext())) 
    { 
     yield return enumerators.Sum(s => s.Current); 
    } 
}