C# IEnumerable.Last方法代码示例

        private IList<TripleExponentialEntry> BuildLastSeason(IList<TripleExponentialEntry> currSeason,
                                                              IEnumerable<DataEntry> dataEntries, int currPeriod)
        {
            //building the last season is similar to NextSeason, but uses the same Ft and Tt once calculated for the first entry.
            var currentFt = currSeason.Last().Ft;
            var currentTt = currSeason.Last().Tt;
            double currentSt = currSeason.Last().St, lastSt = currSeason.Last().St;
            var lastActual = dataEntries.Last().Value;
            IList<TripleExponentialEntry> newSeason = new List<TripleExponentialEntry>();

            currentFt = (_alpha*(lastActual/lastSt)) + ((1 - _alpha)*(currentTt + currentFt));
            currentTt = (_beta*(currentFt - currSeason.Last().Ft)) + ((1 - _beta)*currentTt);

            for (var currSeasonIndex = 1; currSeasonIndex <= _periodsPerSeason; currSeasonIndex++)
            {
                var lastPeriodActual =
                    dataEntries.ElementAt((currPeriod + currSeasonIndex) - _periodsPerSeason - 2).Value;
                var lastPeriodFt = currSeason.ElementAt(currSeasonIndex - 1).Ft;
                var lastPeriodSt = currSeason.ElementAt(currSeasonIndex - 1).St;

                currentSt = (_gamma*(lastPeriodActual/lastPeriodFt)) + ((1 - _gamma)*lastPeriodSt);

                newSeason.Add(new TripleExponentialEntry
                    {
                        Ft = currentFt,
                        Tt = currentTt,
                        St = currentSt,
                        Forecast = (currentFt + (currentTt*currSeasonIndex))*currentSt
                    });
            }

            return newSeason;
        }

// ReSharper restore InconsistentNaming
#pragma warning restore 169

        static void Verify(IEnumerable<Tuple<string, int>> tuples, string item1, int item2)
        {
            tuples.Count().ShouldEqual(item2);
            tuples.First().Item1.ShouldEqual("I");
            tuples.First().Item2.ShouldEqual(1);
            tuples.Last().Item1.ShouldEqual(item1);
            tuples.Last().Item2.ShouldEqual(item2);
        }

        public static double DistanceBetweenLineSegments(IEnumerable<Coordinate> linesegment1, IEnumerable<Coordinate> linesegment2)
        {
            double perpendicularDist =  WEIGHT_PERPENIDCULAR * perpendicularDistance (linesegment1.First(), linesegment1.Last(), linesegment2.First(), linesegment2.Last());
            double parallelDist = WEIGHT_PARALLEL * parallelDistance (linesegment1, linesegment2);
            double angleDist = WEIGHT_ANGLE * angleDistance(linesegment1.First(), linesegment1.Last(), linesegment2.First(), linesegment2.Last());

            Console.WriteLine("PerpendicularDistance: " + perpendicularDist);
            Console.WriteLine("ParallelDistance: " + parallelDist);
            Console.WriteLine("AngleDistance: " + angleDist);

            return perpendicularDist + parallelDist + angleDist;
        }

        public string ComposeUri(string baseUri, string location, object[] functionParameters, IEnumerable<KeyValuePair<string, string>> queryDictionary)
        {
            //Part 1 the basics http://thing.com/base/ + the nouns "/test"
            var part1 = (baseUri != null ? baseUri + "/" : "") + location;
            //Part 2 the parameters passed to the function call that aren't needed for the
            //output editor.
            var part2 = functionParameters == null || !functionParameters.Any()
                            ? ""
                            : "/" + functionParameters.Aggregate ((l, r) => l + "/" + r) + "/";
            //Part 3 the querystring
            var part3 = "";

            if (queryDictionary != null && queryDictionary.Any())
            {
                part3 += "?";
                foreach (var element in queryDictionary)
                {
                    if (element.Equals (queryDictionary.Last ()))
                        part3 += element.Key + "=" + element.Value;
                    else
                        part3 += element.Key + "=" + element.Value + "&";
                }
            }

            return part1 + part2 + part3;
        }

        /// <summary>
        /// Get coords and altitude for point by it time and track
        /// </summary>
        /// <param name="pointTimeGTC">time for point</param>
        /// <param name="track">track</param>
        /// <returns>geo information for point</returns>
        public GeoData? GetGeoForPointByTime(DateTime pointTimeGTC, IEnumerable<GeoData> track)
        {
            if (pointTimeGTC > track.Last().CreatingDate)
                return null;
            if (pointTimeGTC < track.First().CreatingDate)
                return null;
            var trackArray = track.OrderBy(el=> el.CreatingDate).ToArray();
            for (int i = 0; i < trackArray.Length - 1; i++)
            {
                var before = trackArray[i];
                var after = trackArray[i + 1];
                if (after.CreatingDate.Ticks == before.CreatingDate.Ticks)
                    continue;

                if (pointTimeGTC >= before.CreatingDate &&
                    pointTimeGTC <= after.CreatingDate)
                {
                    // acount real coords by time
                    var koef = (double)(pointTimeGTC.Ticks- before.CreatingDate.Ticks)
                        / (double)(after.CreatingDate.Ticks - before.CreatingDate.Ticks);
                    return new GeoData()
                    {
                        Latitude = getRatioValue(before.Latitude, after.Latitude, koef),
                        Longitude = getRatioValue(before.Longitude, after.Longitude, koef),
                        Altitude = getRatioValue(before.Altitude, after.Altitude, koef),
                        CreatingDate = pointTimeGTC
                    };
                }
            }
            return null;
        }

        IPackageInfo PackageInfo(IEnumerable<IPackageInfo> packageInfos)
        {
            if (Version != null)
                return packageInfos.OrderByDescending(x => x.Version).FirstOrDefault(x => x.Version.Major.Equals(Version.Major) && x.Version.Major.Equals(Version.Major));

            return packageInfos.Last();
        }

        Expression CompileNullGuard(IEnumerable<Expression> progression) {
            var last = progression.Last();
            var lastType = last.Type;

            if(!_guardNulls)
                return last;

            Expression allTests = null;

            foreach(var i in progression) {
                if(i == last)
                    break;

                var type = i.Type;
                if(!Utils.CanAssignNull(type))
                    continue;

                var test = Expression.Equal(i, Expression.Constant(null, type));
                if(allTests == null)
                    allTests = test;
                else
                    allTests = Expression.OrElse(allTests, test);
            }

            return Expression.Condition(
                allTests,
                Expression.Constant(Utils.GetDefaultValue(lastType), lastType),
                last
            );
        }

 public ExternVariableToken(Token parent, Scope scope, IEnumerable<Token> tokens, Token dataTypeToken, IEnumerable<WordToken> nameTokens)
     : base(parent, scope, new Span(tokens.First().Span.Start, tokens.Last().Span.End))
 {
     _tokens = tokens.ToArray();
     _dataTypeToken = dataTypeToken;
     _nameTokens = nameTokens.ToArray();
 }

        private static string buildMessage(string address, IEnumerable<INetwork> networks)
        {
            StringBuilder result = new StringBuilder();

            result.Append("\"");
            result.Append(address);
            result.Append("\"");
            result.Append(" could refer to multiple devices: ");

            if (networks == null || !networks.Any())
            {
                result.Append("(no devices given)");
            }
            else
            {
                result.Append("{");
                //TODO: use TextUtilities
                foreach (var network in networks)
                {
                    result.Append("\"");
                    result.Append(network.Name);
                    result.Append("\"");

                    if (network != networks.Last())
                    {
                        result.Append(", ");
                    }
                }
                result.Append("}");
            }

            return result.ToString();
        }

 /// <summary>
 /// 专门生成为MiniUi生成json数据(List->json)
 /// </summary>
 /// <typeparam name="T">泛型</typeparam>
 /// <param name="list">实现了Ilist接口的list</param>
 /// <param name="total">记录总数</param>
 /// <param name="paramMaxMin">这里放排序的参数例如,string para=""maxAge":37,"avgAge":27,"minAge":24"</param>
 /// <returns>返回json数据</returns>
 public static string MiniUiListToJson(IEnumerable<SystemLog> SystemLogInfo, int total, string paramMaxMinAvg)
 {
     StringBuilder Json = new StringBuilder();
     Json.Append("{\"total\":" + total + ",\"data\":");
     Json.Append("[");
     foreach (SystemLog Info in SystemLogInfo)
     {
         Json.Append("{");
         Json.Append("\"Id\":\"" + Info.Id + "\"");
         Json.Append(",");
         Json.Append("\"Title\":\"" + Info.Title + "\"");
         Json.Append(",");
         Json.Append("\"AddTime\":\"" + Info.AddTime.Value.GetDateTimeFormats('s')[0].ToString() + "\"");
         Json.Append(",");
         Json.Append("\"Url\":\"" + Info.Url + "\"");
         Json.Append(",");
         Json.Append("\"UserName\":\"" + Info.UserName + "\"");
         Json.Append("}");
         if (Info != SystemLogInfo.Last())
         {
             Json.Append(",");
         }
     }
     Json.Append("]}");
     return Json.ToString();
 }

        public ForecastEntry Forecast(IEnumerable<DataEntry> dataEntries, int period, dynamic strategyParameters)
        {
            if (period - 1 < 0)
                return null;

            double alpha = strategyParameters.Alpha;
            double beta = strategyParameters.Beta;
            double value;

            if (dataEntries.Count() < 3 || period < 3)
                value = dataEntries.ElementAt(0).Value;
            else if (dataEntries.Count() > 1 && period <= dataEntries.Count() + 1)
                value = GenerateForecast(3, period, alpha, beta, dataEntries, dataEntries.First().Value, 0);
            else
                value = GenerateForecast(3, dataEntries.Count() + 1, alpha, beta, dataEntries, dataEntries.First().Value,
                                         0);

            return new ForecastEntry
                {
                    Period = period,
                    DataEntry = period > dataEntries.Count() ? dataEntries.Last() : dataEntries.ElementAt(period - 1),
                    ForecastValue = value,
                    ConfidenceIntervalLow = value,
                    ConfidenceIntervalHigh = value,
                    IsHoldout = period > dataEntries.Count()*0.7 //holdout data is always 70 percent
                };
        }

        private static void CalculatePath(IEnumerable<int> indices)
        {
            double path = 0;
            int prev = -1;

            foreach (var current in indices)
            {
                if (prev > -1)
                {
                    path += Distance(points[prev], points[current]);
                }

                prev = current;
            }

            var last = points[indices.Last()];
            var first = points[indices.First()];

            path += Distance(last, first);

            if (path < minLength)
            {
                minLength = path;
                shortestPath = PathToString(indices);
            }
        }

        private static string buildMessage(string address, IEnumerable<IDeviceState> devices)
        {
            var result = new StringBuilder();

            result.Append("\"");
            result.Append(address);
            result.Append("\"");
            result.Append(" could refer to multiple devices: ");

            if (devices == null || !devices.Any())
            {
                result.Append("(no devices given)");
            }
            else
            {
                result.Append("{");
                foreach (var device in devices)
                {
                    result.Append("\"");
                    result.Append(device.Name);
                    result.Append("\"");

                    if (device != devices.Last())
                    {
                        result.Append(", ");
                    }
                }
                result.Append("}");
            }

            return result.ToString();
        }

        public ForecastEntry Forecast(IEnumerable<DataEntry> dataEntries, int period, dynamic strategyParameters)
        {
            if (period - 1 < 0)
                return null;

            int numberOfPeriods = strategyParameters.PeriodCount;

            if (numberOfPeriods > dataEntries.Count())
                throw new ArgumentException("The number of periods can not be greater than the number of entries.");

            double value;

            if (dataEntries.Count() == 1 || period == 1)
                value = dataEntries.ElementAt(0).Value;
            else if (period < numberOfPeriods)
                value = dataEntries.ElementAt(period - 1).Value;
            else if (dataEntries.Count() > 1 && period <= dataEntries.Count() + 1)
                value =
                    dataEntries.Take(period - 1).Reverse().Take(numberOfPeriods).Reverse().Sum(entry => (entry.Value))/
                    numberOfPeriods;
            else
                value = dataEntries.Reverse().Take(numberOfPeriods).Reverse().Sum(entry => (entry.Value))/
                        numberOfPeriods;

            return new ForecastEntry
                {
                    Period = period,
                    DataEntry = period > dataEntries.Count() ? dataEntries.Last() : dataEntries.ElementAt(period - 1),
                    ForecastValue = value,
                    ConfidenceIntervalLow = value,
                    ConfidenceIntervalHigh = value,
                    IsHoldout = period > dataEntries.Count()*0.7 //holdout data is always 70 percent
                };
        }

        private static void WriteCalls(IEnumerable<CallInfo> callInfos, IOutputWriter writer)
        {
            var lastCall = callInfos.Last();
            var numberOfDigitsInLastCallNumber = lastCall.NumberOfDigitsInCallNumber();
            
            foreach (var call in callInfos)
            {
                if (call.CallNumber > 1)
                {
                    writer.WriteLine();
                }

                writer.Write(call.CallNumber);
                writer.Write(": ");

                WriteSpaces(writer, numberOfDigitsInLastCallNumber - call.NumberOfDigitsInCallNumber());

                using (writer.Indent())
                {
                    writer.Write(call.StringRepresentation);
                }
                
                if (call.Repeat > 1)
                {
                    writer.Write(" repeated ");
                    writer.Write(call.Repeat);
                    writer.Write(" times");
                    writer.WriteLine();
                    writer.Write("...");
                }
            }
        }