C# ICollection.Average方法代码示例

 private static SummaryViewModel GetSummary(ICollection<TableProjection> tables)
 {
     return new SummaryViewModel
     {
         TablesCount = tables.Count,
         AverageColumnsPerTable = (int) Math.Round(tables.Average(x => x.ColumnsCount)),
         MaxColumnsPerTable = tables.Max(x => x.ColumnsCount)
     };
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="sequence"></param>
 /// <returns></returns>
 private static Double DeviationEstimation(ICollection<Double> sequence)
 {
     Double result;
     result = Math.Sqrt(sequence.Count / (Double)(sequence.Count - 1) * sequence.Average(x => Math.Pow(x - ExpectedValue, 2)));
     return result;
 }

        private static void DoStepResult(TaskSetting setting, StringBuilder writer, string stepName, ICollection<CaseStep> steps, int depth = 0,StepTimer st=null)
        {
            string preChar = "".PadLeft(depth * 4);
            double minTime = steps.Min(t => t.Timer.MinTime);
            double aveTime = steps.Average(t => t.Timer.AveTime);
            double maxTime = steps.Max(t => t.Timer.MaxTime);
            int successNum = steps.Sum(t => t.Timer.SuccessNum);
            int failNum = steps.Sum(t => t.Timer.FailNum);
            if (failNum > 0)
            {
                string error = string.Join("", steps.Select(t => t.Timer.Error).ToList());
                TraceLog.WriteError("{0}", error);
            }
            writer.AppendFormat("====={0}-{1}({2})", setting.TaskName, stepName, DateTime.Now.ToString());
            writer.AppendLine();
            writer.AppendFormat("====={0}", setting.TaskDes);
            writer.AppendLine();
            writer.AppendFormat("{0}>>Step {1}: success:{2}, fail:{3}", preChar, stepName, successNum, failNum);
            writer.AppendLine();
            writer.AppendFormat("{0}    AVE:\t{1}ms", preChar, aveTime.ToString("F6"));
            writer.AppendLine();
            writer.AppendFormat("{0}    Min:\t{1}ms", preChar, minTime.ToString("F6"));
            writer.AppendLine();
            writer.AppendFormat("{0}    Max:\t{1}ms", preChar, maxTime.ToString("F6"));
            writer.AppendLine();
            writer.AppendFormat("{0}    TotalTime:\t{1}ms",preChar,st!=null ? st.RunTotalTime.ToString("F6"):"");
            writer.AppendLine();
            string info = "";
            foreach(var v in steps)
            {
                if (v.DecodePacketInfo!="")
                    info += v.DecodePacketInfo + "\n";
            }
            if(info != "")
            {
                writer.AppendFormat("req/res:\n{0}",info);
                writer.AppendLine();
            }

            var childs = steps.Where(t => t.ChildStep != null).Select(t => t.ChildStep).ToArray();
            if (childs.Length > 0)
            {
                DoStepResult(setting,writer, childs[0].Action, childs, depth + 1);
            }
            writer.AppendFormat("====={0}-{1}:End", setting.TaskName,stepName);
            writer.AppendLine();
        }

        private void GetBestGenetically(int freezeGenesUpTo, int numberOfGenesToUse, Func<char> getRandomGene, List<GeneSequence> previousBests, List<GeneSequence> population, List<GeneSequence> spare, Func<string, FitnessResult> calcFitness, ICollection<int> generationsBetweenImprovments, ref int generation)
        {
            _slidingMutationRate = DefaultMutationRate;
            int fastSearchPopulationSize = GaPopsize / 10 + 4 * numberOfGenesToUse / _numberOfGenesInUnitOfMeaning;
            int maxGenerationsWithoutImprovement = (int)(generationsBetweenImprovments.Average() * 1.5);
            Console.WriteLine("> max generations to run without improvement: " + maxGenerationsWithoutImprovement);
            int maxGenerationsWithoutNewSequences = maxGenerationsWithoutImprovement / 10;
            int generationsWithoutNewSequences = 0;
            int i = 0;
            for (; i < maxGenerationsWithoutImprovement && generationsWithoutNewSequences <= maxGenerationsWithoutNewSequences; i++, generation++)
            {
                var previousBestLookup = new HashSet<string>(previousBests.Select(x => x.Fitness.UniqueKey ?? x.GetStringGenes()));
                var populationWithFitness = CalcFitness(population, calcFitness);

                var first = populationWithFitness.First();
                var worstFitness = previousBests[previousBests.Count / 2].Fitness.Value;
                var newSequences = populationWithFitness
                    .Take(UseFastSearch /*&& i < 20*/ ? fastSearchPopulationSize : GaPopsize)
                    .Where(x => x.Fitness.Value <= worstFitness)
                    .Where(x => previousBestLookup.Add(x.Fitness.UniqueKey ?? x.GetStringGenes()))
                    .Take(UseFastSearch ? MaxImprovmentsToKeepFromEachRound : (int)((1 - _slidingMutationRate) * GaPopsize))
                    .ToList();

                if (newSequences.Any())
                {
                    generationsWithoutNewSequences = 0;
                    SortByFitness(newSequences);
                    var previousBestFitness = previousBests.First().Fitness.Value;
                    if (newSequences.First().Fitness.Value < previousBestFitness)
                    {
                        PrintBest(generation, newSequences.First());
            //                        Console.WriteLine("> improved after generation " + i);
                        generationsBetweenImprovments.Add(i);
                        i = -1;
                    }
                    foreach (var copy in newSequences.Select(geneSequence => geneSequence.Clone()))
                    {
                        copy.Generation = generation;
                        previousBests.Add(copy);
                    }
                    int numberToKeep = Math.Max(100, previousBests.Count(x => x.Fitness.Value == first.Fitness.Value));
                    SortByFitness(previousBests);
                    if (numberToKeep < previousBests.Count)
                    {
                        previousBests.RemoveRange(numberToKeep, previousBests.Count - numberToKeep);
                    }
                    UpdateStrategyPercentages(previousBests, generation);

                    _slidingMutationRate = DefaultMutationRate;
                }
                else
                {
                    generationsWithoutNewSequences++;
                    if (generationsWithoutNewSequences > maxGenerationsWithoutNewSequences)
                    {
                        break;
                    }
                    _slidingMutationRate = Math.Max(_slidingMutationRate - SlideRate, 0);
                }

                if (first.Fitness.Value == 0)
                {
                    break;
                }

                CreateNextGeneration(freezeGenesUpTo, numberOfGenesToUse, population, spare, getRandomGene, previousBests);
                var temp = spare;
                spare = population;
                population = temp;
            }

            generationsBetweenImprovments.Add(i);

            //            previousBests.First().GetStringGenes();
        }

 private static void DoStepResult(StringBuilder writer, string stepName, ICollection<CaseStep> steps, int depth = 0)
 {
     string preChar = "".PadLeft(depth * 4);
     double minTime = steps.Min(t => t.Timer.MinTime);
     double aveTime = steps.Average(t => t.Timer.AveTime);
     double maxTime = steps.Max(t => t.Timer.MaxTime);
     int successNum = steps.Sum(t => t.Timer.SuccessNum);
     int failNum = steps.Sum(t => t.Timer.FailNum);
     if (failNum > 0)
     {
         string error = string.Join("", steps.Select(t => t.Timer.Error).ToList());
         TraceLog.WriteError("{0}", error);
     }
     writer.AppendFormat("{0}>>Step {1}: success:{2}, fail:{3}", preChar, stepName, successNum, failNum);
     writer.AppendLine();
     writer.AppendFormat("{0}    AVE:\t{1}ms", preChar, aveTime.ToString("F6"));
     writer.AppendLine();
     writer.AppendFormat("{0}    Min:\t{1}ms", preChar, minTime.ToString("F6"));
     writer.AppendLine();
     writer.AppendFormat("{0}    Max:\t{1}ms", preChar, maxTime.ToString("F6"));
     writer.AppendLine();
     var childs = steps.Where(t => t.ChildStep != null).Select(t => t.ChildStep).ToArray();
     if (childs.Length > 0)
     {
         DoStepResult(writer, childs[0].Action, childs, depth + 1);
     }
 }

        public static void FillAggregates(this AggregateRow row, ICollection<EmployeeRow> employees)
        {
            row.EmployeeCount = employees.Count;

            row.GrossPayAvg = employees.Average(e => e.GrossPay);
            row.GrossPayMin = employees.Min(e => e.GrossPay);
            row.GrossPayMax = employees.Max(e => e.GrossPay);
            row.GrossPaySum = employees.Sum(e => e.GrossPay);
            row.GrossPayMed = employees.Median(e => e.GrossPay);

            row.SalaryAvg = employees.Average(e => e.Salary);
            row.SalaryMin = employees.Min(e => e.Salary);
            row.SalaryMax = employees.Max(e => e.Salary);
            row.SalarySum = employees.Sum(e => e.Salary);
            row.SalaryMed = employees.Median(e => e.Salary);
        }