web-dev-qa-db-ja.com

LINQを使用してC＃の数値の配列の累積合計を見つける

ダブルスを含むcsv文字列（例： "0.3,0.4,0.3"）があり、これらの数値の累積合計を含むダブル配列（例：[0.3,0.7,1.0]）を出力できるようにしたい。

これまでのところ、私は持っています

double[] probabilities = textBox_f.Text.Split(new char[]{','}).Select(s => double.Parse(s)).ToArray();

これは、数値を配列として提供しますが、数値の累積合計は提供しません。

この式を継続して必要なものを取得する方法はありますか、または反復を使用して、既に持っている配列から新しい配列を作成する必要がありますか？

c#arrayslinqcumulative-sum
19
simonalexander2005
var input=new double[]{ ... }
double sum=0;

var output=input
    .Select(w=>sum+=w);
0
Blindy

一般化する時があり、実際に提起された問題を解決する時があります。これは後者の時間の1つです。 doubleのシーケンスを部分和のシーケンスに変換するメソッドを作成する場合は、次のようにします。

public static IEnumerable<double> CumulativeSum(this IEnumerable<double> sequence)
{
    double sum = 0;
    foreach(var item in sequence)
    {
        sum += item;
        yield return sum;
    }        
}

簡単。集計や複雑なクエリなどをいじる必要はありません。理解しやすく、デバッグしやすく、使いやすい：

textBox_f.Text
    .Split(new char[]{','})
    .Select(s => double.Parse(s))
    .CumulativeSum()
    .ToArray();

ここで、それがユーザー入力の場合、double.Parseが例外をスローする可能性があることに注意してください。次のようなことをする方が良いかもしれません：

public static double? MyParseDouble(this string s)
{
    double d;
    if (double.TryParse(s, out d))
        return d;
    return null;
}

public static IEnumerable<double?> CumulativeSum(this IEnumerable<double?> sequence)
{
    double? sum = 0;
    foreach(var item in sequence)
    {
        sum += item;
        yield return sum;
    }        
}
...
textBox_f.Text
    .Split(new char[]{','})
    .Select(s => s.MyParseDouble())
    .CumulativeSum()
    .ToArray();

また、ユーザーが入力ミスをしても例外は発生しません。 nullを取得します。

46
Eric Lippert

しばらく前に同様の要件がありました。基本的には集計を行う必要がありましたが、各中間値も選択する必要がありました。そこで、次のように使用できるSelectAggregateという名前の拡張メソッドを作成しました（おそらく最も適切な名前ではありませんが、それ以上のものは見つかりませんでした）。

double[] numbers = new [] { 0.3, 0.4, 0.3 };
double[] cumulativeSums = numbers.SelectAggregate(0.0, (acc, x) => acc + x).ToArray();

コードは次のとおりです。

    public static IEnumerable<TAccumulate> SelectAggregate<TSource, TAccumulate>(
        this IEnumerable<TSource> source,
        TAccumulate seed,
        Func<TAccumulate, TSource, TAccumulate> func)
    {
        source.CheckArgumentNull("source");
        func.CheckArgumentNull("func");
        return source.SelectAggregateIterator(seed, func);
    }

    private static IEnumerable<TAccumulate> SelectAggregateIterator<TSource, TAccumulate>(
        this IEnumerable<TSource> source,
        TAccumulate seed,
        Func<TAccumulate, TSource, TAccumulate> func)
    {
        TAccumulate previous = seed;
        foreach (var item in source)
        {
            TAccumulate result = func(previous, item);
            previous = result;
            yield return result;
        }
    }
19
Thomas Levesque

Aggregate演算子を使用し、List<double>を集計アキュムレータとして使用します。そうすれば、それ自体が一連の合計である射影を生成できます。

開始するための例を次に示します。

double[] runningTotal = textBox_f.Text
            .Split(new char[]{','})
            .Select(s => double.Parse(s))
            .Aggregate((IEnumerable<double>)new List<double>(), 
                       (a,i) => a.Concat(new[]{a.LastOrDefault() + i}))
            .ToArray();
5
LBushkin

まず第一に、それがLinqにとって良い仕事だとは思いません。昔ながらのforeachの方がうまくいくでしょう。しかし、パズルとしては問題ありません。

最初のアイデアはサブクエリを使用することでしたが、O（n ^ 2）であるため、私はそれが好きではありません。これが私の線形ソリューションです：

        double[] probabilities = new double[] { 0.3, 0.4, 0.3};
        probabilities
            .Aggregate(
                new {sum=Enumerable.Empty<double>(), last = 0.0d},
                (a, c) => new {
                    sum = a.sum.Concat(Enumerable.Repeat(a.last+c,1)),
                    last = a.last + c
                },
                a => a.sum
            );
2
Andrey

なぜLINQである必要があるのですか？

var cumulative = new double[probabilities.Length];
for (int i = 0; i < probabilities.Length; i++)
    cumulative[i] = probabilities[i] + (i == 0 ? 0 : cumulative[i-1]);
2
Timwi

rXを使用：

var input=new double[]{ ... }
var output = new List<double>();
input.ToObservable().Scan((e, f) => f + e).Subscribe(output.Add);
1
Bruno Garnier

これは、ジェネレーターを使用して一般化するのは実際には非常に簡単です。これは、AccumulateとSelectの組み合わせのように機能するAggregateと呼ばれる新しい拡張メソッドです。シーケンス内の各要素とこれまでの累積値に二項関数を適用することにより、新しいシーケンスを返します。

 public static class EnumerableHelpers 
 {
    public static IEnumerable<U> Accumulate<T, U>(this IEnumerable<T> self, U init, Func<U, T, U> f) 
    {
        foreach (var x in self)
            yield return init = f(init, x);
    }

    public static IEnumerable<T> Accumulate<T>(this IEnumerable<T> self, Func<T, T, T> f)
    {
        return self.Accumulate(default(T), f);
    }

    public static IEnumerable<double> PartialSums(this IEnumerable<double> self)
    {
        return self.Accumulate((x, y) => x + y);
    }

    public static IEnumerable<int> PartialSums(this IEnumerable<int> self)
    {
        return self.Accumulate((x, y) => x + y);
    }
 }
1
cdiggins

List<double>の累積合計：

var nums = new List<double>() { 0.3, 0.0, 0.4, 1.1 };
var cumsum = nums.Aggregate(new List<double> (), 
              (list, next) => { list.Add(list.LastOrDefault() + next); return list; });
0
Alamakanambra

これがa LINQを使用して行う方法です。

double[] doubles = { 1.7, 2.3, 1.9, 4.1, 2.9 };
var doublesSummed = new List<double>();

Enumerable.Aggregate(doubles, (runningSum, nextFactor) => {
    double currentSum = runningSum + nextFactor;
    doublesSummed.Add(currentSum);
    return currentSum;
});

doublesSummed.Dump();

LINQPadの場合：

  • 4
  • 5.9
  • 10
  • 12.9
0
kamranicus