Lets say I have a List<IEnumerable<double>> containing variable number of infinite sources of double numbers. Lets say they are all wave generator functions and I need to superimpose them into a single wave generator represented by IEnumerable<double> simply by taking the next number out of each and suming them.
I know I can do this through iterator methods, something like this:
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();
}
}
however, it seems rather "pedestrian". Is there a LINQ-ish way to achieve this?
I guess there is no way around this without extending LINQ. So here's what I wrote in the end. I'll try to contact MoreLinq authors to get this included in some way, it can be useful in some pivoting scenarios:
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();
}
}
}
using this I managed to compress my combined generator:
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);
}
// ...
}
Collected from the Internet
Please contact [email protected] to delete if infringement.
Comments