C# LinkedList.Sum方法代码示例

        private static void ConnectPathsWithGivenSum(TreeNode<int> node, LinkedList<int> currentPath, IList<List<int>> allPaths, int sum)
        {
            currentPath.AddLast(node.Value);

            if (node.Childrens.Count == 0 && currentPath.Sum() == sum)
            {
                allPaths.Add(currentPath.ToList());
                return;
            }

            foreach (var child in node.Childrens)
            {
                ConnectPathsWithGivenSum(child, currentPath, allPaths, sum);
                currentPath.RemoveLast();
            }
        }

        private void ConnectPathsWithGivenSumInTreeUsingRecursivelyDfs(Node<int> node, LinkedList<int> currentPath, IList<List<int>> allPaths, int sum)
        {
            currentPath.AddLast(node.Value);

            if (node.Children.Count == 0 && currentPath.Sum() == sum)
            {
                allPaths.Add(currentPath.ToList());
                return;
            }

            foreach (var childNode in node.Children)
            {
                this.ConnectPathsWithGivenSumInTreeUsingRecursivelyDfs(childNode, currentPath, allPaths, sum);
                currentPath.RemoveLast();
            }
        }

//.........这里部分代码省略.........
                    Load(file);
            };

            var previousSteps = new LinkedList<int>();

            var ipX = 0;
            var ipY = 0;
            var spX = 0;
            var spY = 0;

            while (window.IsOpen())
            {
                window.DispatchEvents();

                #region Stepping
                var requestedSteps = 0;
                var steps = 0;

                switch (speed)
                {
                    case VmSpeed.Slow:
                        requestedSteps = Config.Slow;
                        break;
                    case VmSpeed.Medium:
                        requestedSteps = Config.Medium;
                        break;
                    case VmSpeed.Fast:
                        requestedSteps = Config.Fast;
                        break;
                    case VmSpeed.Unlimited:
                        requestedSteps = int.MaxValue; // "unlimited"
                        break;
                }

                if (running && error == null)
                {
                    try
                    {
                        var stopwatch = Stopwatch.StartNew();
                        while (stopwatch.Elapsed.TotalSeconds < (0.95 / Config.Framerate))
                        {
                            if (steps >= requestedSteps)
                                break;

                            for (var i = 0; i < 100; i++, steps++)
                            {
                                machine.Step();
                            }
                        }
                    }
                    catch (VmException e)
                    {
                        error = e.Message;
                    }
                }

                previousSteps.AddLast(steps);
                if (previousSteps.Count > Config.Framerate)
                    previousSteps.RemoveFirst();
                #endregion

                display.DrawImage(0, 0, memory);

                #region IP and SP markers
                display.Set(ipX, ipY, Character.Create(background: 0));
                display.Set(spX, spY, Character.Create(background: 0));

                var ip = machine.IP / 2;
                ipX = ip % 200;
                ipY = ip / 200;
                var sp = machine.SP / 2;
                spX = sp % 200;
                spY = sp / 200;

                if (ipY < 80)
                    display.Set(ipX, ipY, Character.Create(background: 255));
                if (spY < 80)
                    display.Set(spX, spY, Character.Create(background: 255));
                #endregion

                var statusString = "Paused";

                if (error != null)
                    statusString = string.Format("ERROR: {0}", error);
                else if (machine.Flags.HasFlag(VirtualMachine.Flag.Trap))
                    statusString = "Trapped";
                else if (running)
                    statusString = string.Format("Running: {0} instructions per second ({1})", previousSteps.Sum(), speed);

                statusDisplay.Clear(Character.Create(' '));
                statusDisplay.DrawText(0, 0, statusString, Character.Create(foreground: 255));

                display.Draw(window, new Vector2f(0, 0));
                statusDisplay.Draw(window, new Vector2f(0, 80 * CharHeight));

                window.Display();
            }

            machine.Dispose();
        }

//.........这里部分代码省略.........
              state = ReaderState.Cluster;
              goto parse_retry;
            }
            else if (elt.ID.BinaryEquals(Elements.Info)) {
              await elt.ReadBodyAsync(stream, cancel_token);
              var s = new MemoryStream(elt.Data);
              while (s.Position<s.Length) {
                var child = Element.ReadHeader(s);
                if (child.ID.BinaryEquals(Elements.TimecodeScale)) {
                  timecode_scale = Element.ReadUInt(s, child.Size.Value) * 1.0;
                }
                else {
                  child.ReadBody(s);
                }
              }
              headers.Add(elt);
            }
            else {
              await elt.ReadBodyAsync(stream, cancel_token);
              headers.Add(elt);
            }
            break;
          case ReaderState.Cluster:
            if (elt.ID.BinaryEquals(Elements.Segment)) {
              state = ReaderState.Segment;
              goto parse_retry;
            }
            else if (elt.ID.BinaryEquals(Elements.EBML)) {
              state = ReaderState.EBML;
              goto parse_retry;
            }
            else if (elt.ID.BinaryEquals(Elements.Cluster)) {
              if (clusters.Count>0) {
                var timespan = clusters.Sum(c => c.Timespan);
                if (timespan>=30.0) {
                  var sz = clusters.Sum(c => c.Timespan>0 ? c.BlockSize : 0);
                  var kbps = (int)((sz*8/timespan+900) / 1000.0);
                  var info = new AtomCollection();
                  info.SetChanInfoBitrate(kbps);
                  sink.OnChannelInfo(new ChannelInfo(info));
                  while (clusters.Count>1) clusters.RemoveFirst();
                }
              }
              var cluster = new Cluster(elt);
              clusters.AddLast(cluster);
              sink.OnContent(
                new Content(stream_index, DateTime.Now-stream_origin, position, elt.ToArray())
              );
              position += elt.ByteSize;
              state = ReaderState.Timecode;
            }
            else if (elt.ID.BinaryEquals(Elements.Void) ||
                     elt.ID.BinaryEquals(Elements.CRC32)) {
              await elt.ReadBodyAsync(stream, cancel_token);
              sink.OnContent(
                new Content(stream_index, DateTime.Now-stream_origin, position, elt.ToArray())
              );
              position += elt.ByteSize;
            }
            else {
              throw new BadDataException();
            }
            break;
          case ReaderState.Timecode:
            if (elt.ID.BinaryEquals(Elements.Segment)) {
              state = ReaderState.Segment;

        public int run(GeneticRunParameters parameters)
        {
            if (!(parameters is FuzzyGeneticsRunParameters))
                throw new WrongParameterTypeException("Fuzzy Genetics only accepts Fuzzy Genetics Run Parameters");

            FuzzyGeneticsRunParameters fgParameters = (FuzzyGeneticsRunParameters)parameters;

            subGenetics = fgParameters.algorithm.newInstance(initial, fgParameters.algorithmInstanceParameters);

            int bestFitness = 0;
            int periodSinceLastImprovement = 0;

            LinkedList<int> lastFitnesses = new LinkedList<int>();
            for (int n = 0; n < fgParameters.numberToAverageScoreOver; n++) { lastFitnesses.AddFirst(0); }

            while (periodSinceLastImprovement < fgParameters.waitSinceLastImprovement)
            {
                int fitness = subGenetics.run(fgParameters.algorithmRunParameters);

                lastFitnesses.RemoveFirst();
                lastFitnesses.AddLast(fitness);

                int summedFitness = lastFitnesses.Sum();

                periodSinceLastImprovement++;
                if (bestFitness < summedFitness)
                {
                    bestFitness = summedFitness;
                    periodSinceLastImprovement = 0;
                    result = subGenetics.getAll();
                    resultPairs = subGenetics.getAllPairs();
                }

                if (fgParameters.verbose) Console.WriteLine("best of round: " + fitness + ". average = " + summedFitness / fgParameters.numberToAverageScoreOver +
                    " (" + periodSinceLastImprovement + ")");
            }

            return lastFitnesses.Last.Value;
        }

//.........这里部分代码省略.........
								&& allSendersUp.CurrentCount < maxSenders)
							{
								senders.AddLast(endpoint);
								allSendersUp.Signal();
							}
						}
					});

				_logger.Info("waiting for all senders ...");
				allSendersUp.Wait();

				_logger.Info("sending 'ReadySetGo' to all senders");

				lock (senders)
					senders.Each(sender => sender.Send<ReadySetGo>(new {}));

				//unsubscribeMe = sb.SubscribeHandler<IConsumeContext<ZoomZoom>>(consumeContext =>
				unsubscribeMe += sb.SubscribeHandler<ZoomZoom>(payment =>
					{
						//var payment = consumeContext.Message;
						
						long currentReceived;
						if ((currentReceived = Interlocked.Increment(ref received)) == rampUp)
							watch.Start();
						else if (currentReceived < rampUp) return;

						var localFailures = new long?();
						if (Math.Abs(payment.Amount - 1024m) > 0.0001m)
						{
							localFailures = Interlocked.Increment(ref failures);
						}

						if (currentReceived + rampUp == sampleSize || _isStopping)
						{
							unsubscribeMe();
							watch.Stop();
							stopping.Set();
						}

						if (currentReceived % 100 == 0)
						{
							var point = new DataPoint
								{
									Received = currentReceived,
									Ticks = watch.ElapsedTicks,
									Failures = localFailures ?? failures,
									SampleMessage = payment,
									Instance = DateTime.UtcNow
									/* assume all prev 100 msgs same size */
									//Size = consumeContext.BaseContext.BodyStream.Length * 100 
								};
							lock (datapoints) datapoints.AddLast(point);
							_logger.Debug(string.Format("Logging {0}", point));
						}
					});

				PipelineViewer.Trace(sb.InboundPipeline);

				_logger.Info("waiting for all messages!");
				stopping.WaitOne();


				sb.GetEndpoint(creds.BuildUri("sender")).Send<ZoomDone>(new{});
			}

			_logger.Info(
string.Format(@"
Performance Test Done
=====================

Total messages received:  {0}
Time taken:               {1}

of which:
  Corrupt messages count: {2}
  Valid messages count:   {3}

metrics:
  Message per second:     {4}
  Total bytes transferred:{5}
  All samples' data equal:{6}

data points:
{7}
",
 sampleSize, watch.Elapsed, failures,
 sampleSize-failures,
 1000d * sampleSize / (double)watch.ElapsedMilliseconds,
 datapoints.Sum(dp => dp.Size),
 datapoints.Select(x => x.SampleMessage).All(x => x.Payload.Equals(TestData.PayloadMessage, StringComparison.InvariantCulture)),
 datapoints.Aggregate("", (str, dp) => str + dp.ToString() + Environment.NewLine)));

			_logger.Info("Idling... aka. softar.");
			
			while (true)
				Thread.Sleep(10000);

			// now have a look in Server Explorer, WADLogsTable, w/ Filter similar to "Timestamp gt datetime'2012-02-03T10:06:50Z'" 
			// (if this isn't your first deployment, or no filter if you feel like that)
		}