C# IReadOnlyList.Sum方法代码示例

      private void ReassembleChunksAndDispatch(IReadOnlyList<MultiPartChunkDto> chunks) {
//         Console.WriteLine(chunks.First().MultiPartMessageId.ToString("n").Substring(0, 6) + " Got to reassemble!");
         RemoveAssemblerFromCache(chunks.First().MultiPartMessageId);

         var payloadLength = chunks.Sum(c => c.BodyLength);
         var payloadBytes = new byte[payloadLength];
         for (int i = 0, offset = 0; i < chunks.Count; i++) {
            var chunk = chunks[i];
            Buffer.BlockCopy(chunk.Body, 0, payloadBytes, offset, chunk.BodyLength);
            offset += chunk.BodyLength;
         }

         var e = inboundDataEventPool.TakeObject();
         e.Data = payloadBytes;
         e.DataOffset = 0;
         e.DataLength = payloadLength;

//         Console.WriteLine(chunks.First().MultiPartMessageId.ToString("n").Substring(0, 6) + " Dispatching to HIDE!");
         dispatcher.HandleInboundDataEvent(
            e,
            _ => {
               e.Data = null;
               inboundDataEventPool.ReturnObject(e);
            });
      }

        private float[] ConcatenateChunksOfSamples(IReadOnlyList<float[]> chunks)
        {
            if (chunks.Count == 1)
            {
                return chunks[0];
            }

            float[] samples = new float[chunks.Sum(a => a.Length)];
            int startAt = 0;
            foreach (float[] chunk in chunks)
            {
                Buffer.BlockCopy(chunk, 0, samples, startAt * sizeof(float), chunk.Length * sizeof(float));
                startAt += chunk.Length;
            }

            return samples;
        }

        private float[] ConcatenateChunksOfSamples(IReadOnlyList<float[]> chunks)
        {
            if (chunks.Count == 1)
            {
                return chunks[0];
            }

            float[] samples = new float[chunks.Sum(a => a.Length)];
            int index = 0;
            foreach (float[] chunk in chunks)
            {
                Array.Copy(chunk, 0, samples, index, chunk.Length);
                index += chunk.Length;
            }

            return samples;
        }

        private static Point2[] CopyData(IReadOnlyList<Vector2> outer, IReadOnlyList<IReadOnlyList<Vector2>> holes)
        {
            var points = new Point2[outer.Count + holes.Sum(h => h.Count)];
            var index = 0;

            //Copy points backwards (because CGAL wants them counter-clowise, but we supply them clockwise)
            for (var i = outer.Count - 1; i >= 0; i--)
                points[index++] = new Point2(outer[i].X, outer[i].Y);

            //Points are copied forward here, because holes are supplied to us clockwise wound and CGAL wants them clockwise
            foreach (var hole in holes)
            {
                for (var j = 0; j < hole.Count; j++)
                    points[index++] = new Point2(hole[j].X, hole[j].Y);
            }
            return points;
        }

        /// <summary>
        /// Calculates incremental and decremental running variance.
        /// </summary>
        /// <param name="samples">Sample data.</param>
        /// <param name="onCalculated">
        /// Action callback which fires on each element addition-removal. 
        /// <para>Parameters are: (index, incremental (average, incremental variance, decremental average, decremental variance).</para>
        /// </param>
        /// <param name="weights">Sample weights.</param>
        /// <param name="returnSSE">True to return unnormalized variance (SSE). False to return variance instead.</param>
        public static void RunningVarianceIncDec(this IReadOnlyList<double[]> samples, Action<int, double[], double, double[], double> onCalculated, IReadOnlyList<double> weights, bool returnSSE = false)
        {
            //weights = weights.Select(x => x * 1000).ToArray();

            int sampleDim = samples.First().Length;

            double sumWeightInc = 0;
            double[] meanInc = new double[sampleDim];
            double M2_Inc = 0;
       
            double sumWeightDec = weights.Sum();
            double[] meanDec = samples.Average(weights);
            double M2_Dec = samples.Variance(weights).Multiply(sumWeightDec).Sum();

            for (int i = 0; i < samples.Count; i++)
            {
                var varInc = UpdateVarianceSumIncremental(ref M2_Inc, ref sumWeightInc, ref meanInc, samples[i], weights[i]);
                var varDec = UpdateVarianceSumDecremental(ref M2_Dec, ref sumWeightDec, ref meanDec, samples[i], weights[i]);

                /*var averageInc = samples.Take(i + 1).Average(weights.Take(i + 1));
                var averageDec = samples.Skip(i + 1).Average(weights.Skip(i + 1));

                if (System.Math.Abs(averageInc[0] - meanInc[0]) > 0.001 ||
                   System.Math.Abs(averageDec.FirstOrDefault() - meanDec[0]) > 0.001)
                {
                    Console.WriteLine();
                }*/

                if(!returnSSE)
                    onCalculated(i, meanInc, varInc, meanDec, varDec); 
                else
                    onCalculated(i, meanInc, M2_Inc, meanDec, M2_Dec); 
            }
        }

        private string GetModalString(IReadOnlyList<int> squarePopularity)
        {
            for (var idx = 0; idx < NumberOfSquares; ++idx)
            {
                Console.WriteLine("{0:00}: {1:00000000} ({2})", idx, squarePopularity[idx], squares[idx].Name);
            }

            var totalVisits = squarePopularity.Sum(sp => sp);
            var squaresWithIndex = squarePopularity.Select((item, index) => new { Popularity = (double)item / (double)totalVisits, Position = index });
            var mostPopularSquares = squaresWithIndex.OrderByDescending(sp => sp.Popularity).Take(3).ToList();

            return string.Format("{0:00}{1:00}{2:00}", mostPopularSquares[0].Position, mostPopularSquares[1].Position,
                mostPopularSquares[2].Position);
        }