protected bool ChunkIsStable(IEnumerable<Point> points) { const int maxVariance = 50; var xVariance = points.Max(p => p.X) - points.Min(p => p.Y); var yVariance = points.Max(p => p.X) - points.Min(p => p.Y); return xVariance < maxVariance && yVariance < maxVariance; }
protected bool ChunkIsStable(IEnumerable<Zipping.Pair<int, int>> points) { const int maxVariance = 50; var xVariance = points.Max(p => p.First) - points.Min(p => p.First); var yVariance = points.Max(p => p.Second) - points.Min(p => p.Second); return xVariance < maxVariance && yVariance < maxVariance; }
public static BoundingBox MinimumOf(IEnumerable<BoundingBox> boxes) { decimal northmost = boxes.Max(b => b.North); decimal southmost = boxes.Min(b => b.South); decimal eastmost = boxes.Max(b => b.East); decimal westmost = boxes.Min(b => b.West); return new BoundingBox { North = northmost, South = southmost, East = eastmost, West = westmost }; }
public void SetPlotModelAxes( IEnumerable<DataPoint> seriesPoints, string xAxisTitle, string yAxisTitle) { double minXVal = seriesPoints.Min<DataPoint>(dp => dp.X); double maxXVal = seriesPoints.Max<DataPoint>(dp => dp.X); double minYVal = seriesPoints.Min<DataPoint>(dp => dp.Y); double maxYVal = seriesPoints.Max<DataPoint>(dp => dp.Y); PlotType = PlotType.XY; SetXAxisForPlotModel(minXVal, maxXVal, xAxisTitle); SetYAxisForPlotModel(minYVal, maxYVal, yAxisTitle); }
public OctreeLookup(IEnumerable<float[]> points) { tree = new Octree( points.Max(p => p[0]), points.Min(p => p[0]), points.Max(p => p[1]), points.Min(p => p[1]), points.Max(p => p[2]), points.Min(p => p[2]), points.Count()); foreach (var p in points) tree.AddNode(p[0], p[1], p[2], p); }
public static IEnumerable<double> Normalize(IEnumerable<double> collection) { double min = collection.Min(); double max = collection.Max(); return collection.Select(f => Normalize(f, min, max)); }
public static VehicleStatisticsModel Calculate(IEnumerable<Model.FillupEntry> fillUps, bool includeFirst = true) { if (!fillUps.Any()) return new VehicleStatisticsModel(); var firstFillUp = fillUps.OrderBy(x => x.Date).FirstOrDefault(); double totalFuelCost = 0.0; double totalUnits = 0.0; double totalCost = 0.0; int totalDistance = 0; foreach (var fillUp in fillUps) { if (includeFirst || fillUp != firstFillUp) { totalFuelCost += fillUp.PricePerUnit*fillUp.TotalUnits; totalUnits += fillUp.TotalUnits; totalCost += fillUp.TotalCost; totalDistance += fillUp.Distance ?? 0; } } var odometer = fillUps.Max(x => x.Odometer); var earliestEntryDate = fillUps.Min(x => x.Date).ToUniversalTime(); var today = DateTime.UtcNow.Date; var totalMonths = CalculateDifferenceInMonths(earliestEntryDate.Date, today.Date); return new VehicleStatisticsModel(totalFuelCost, totalUnits, totalCost, totalDistance, odometer, totalMonths); }
/// <summary> /// Gets area that's occupied by user selected points /// </summary> /// <param name="selector">Selected points container</param> /// <param name="maxWorkingArea">Minimum allowed area size</param> /// <returns></returns> public static System.Drawing.Rectangle GetArea(IEnumerable<PointSelector.SelectedPoint> selector, int workingAreaSize) { var minX = selector.Min(p => p.Location.X); var maxX = selector.Max(p => p.Location.X); var minY = selector.Min(p => p.Location.Y); var maxY = selector.Max(p => p.Location.Y); int areaWidth = maxX - minX; int areaHeight = maxY - minY; areaWidth = areaWidth > workingAreaSize ? workingAreaSize : areaWidth; areaWidth = areaHeight > workingAreaSize ? workingAreaSize : areaHeight; if (areaWidth < workingAreaSize) { minX = minX - (workingAreaSize - areaWidth) / 2; minX = minX < 0 ? 0 : minX; areaWidth = workingAreaSize; } if (areaHeight < workingAreaSize) { minY = minY - (workingAreaSize - areaHeight) / 2; minY = minY < 0 ? 0 : minY; areaHeight = workingAreaSize; } return new System.Drawing.Rectangle(minX, minY, areaWidth, areaHeight); }
public static DateTime MinDate(this IEnumerable<DateTime> left, IEnumerable<DateTime> right) { var minLeft = left.Any() ? left.Min() : DateTime.MaxValue; var minRight = right.Any() ? right.Min() : DateTime.MaxValue; return minLeft.Ticks < minRight.Ticks ? minLeft : minRight; }
public List<ILNode> ConvertToAst(List<Instruction> body, IEnumerable<ExceptionHandler> ehs) { List<ILNode> ast = new List<ILNode>(); while (ehs.Any()) { ILTryCatchBlock tryCatchBlock = new ILTryCatchBlock(); // Find the first and widest scope int tryStart = ehs.Min(eh => eh.TryStart.Offset); int tryEnd = ehs.Where(eh => eh.TryStart.Offset == tryStart).Max(eh => eh.TryEnd.Offset); var handlers = ehs.Where(eh => eh.TryStart.Offset == tryStart && eh.TryEnd.Offset == tryEnd).ToList(); // Cut all instructions up to the try block { int tryStartIdx; for (tryStartIdx = 0; body[tryStartIdx].Offset != tryStart; tryStartIdx++); ast.AddRange(ConvertToAst(body.CutRange(0, tryStartIdx))); } // Cut the try block { List<ExceptionHandler> nestedEHs = ehs.Where(eh => (tryStart <= eh.TryStart.Offset && eh.TryEnd.Offset < tryEnd) || (tryStart < eh.TryStart.Offset && eh.TryEnd.Offset <= tryEnd)).ToList(); int tryEndIdx; for (tryEndIdx = 0; tryEndIdx < body.Count && body[tryEndIdx].Offset != tryEnd; tryEndIdx++); tryCatchBlock.TryBlock = ConvertToAst(body.CutRange(0, tryEndIdx), nestedEHs); } // Cut all handlers tryCatchBlock.CatchBlocks = new List<ILTryCatchBlock.CatchBlock>(); foreach(ExceptionHandler eh in handlers) { int start; for (start = 0; body[start] != eh.HandlerStart; start++); int end; for (end = 0; body[end] != eh.HandlerEnd; end++); int count = end - start; List<ExceptionHandler> nestedEHs = ehs.Where(e => (start <= e.TryStart.Offset && e.TryEnd.Offset < end) || (start < e.TryStart.Offset && e.TryEnd.Offset <= end)).ToList(); List<ILNode> handlerAst = ConvertToAst(body.CutRange(start, count), nestedEHs); if (eh.HandlerType == ExceptionHandlerType.Catch) { tryCatchBlock.CatchBlocks.Add(new ILTryCatchBlock.CatchBlock() { ExceptionType = eh.CatchType, Body = handlerAst }); } else if (eh.HandlerType == ExceptionHandlerType.Finally) { tryCatchBlock.FinallyBlock = handlerAst; } else { // TODO } } ehs = ehs.Where(eh => eh.TryStart.Offset > tryEnd).ToList(); ast.Add(tryCatchBlock); } // Add whatever is left ast.AddRange(ConvertToAst(body)); return ast; }
public IEnumerable<Card> Play(IEnumerable<Card> hand, IEnumerable<Card> table, int rank, Suit suit, Mode mode, bool revolution, History history) { if (revolution && rank != Card.RankOfJoker) { rank = 14 - rank; } if (hand == null || hand.Count() == 0) return null; int count = table.Count(); // 初手はとりあえず一番弱いのを出しとく。 if (mode.Match(Mode.First)) { var min = hand.Min(x => Game.Rank(x, revolution)); return hand.Where(x => Game.Rank(x, revolution) == min); } if (mode.Match(Mode.Normal)) { if(mode.Match(Mode.SuitBound)) { return hand.MinCard(x => Game.Rank(x, revolution) > rank && x.Suit == suit, revolution); } else { return hand.MinCard(x => Game.Rank(x, revolution) > rank, revolution); } } if(mode.Match(Mode.Multiple)) { for (int i = rank + 1; i <= 13; i++) { // 出せる var c = hand.Where(x => Game.Rank(x, revolution) == i); if (c.Count() >= count) return c.Take(count); // Joker含めれば出せる if (c.Count() + 1 == count && hand.FirstOrDefault(x => x.Suit == Suit.Joker) != null) return c.Concat(hand.Where(x => x.Suit == Suit.Joker).Take(count)); } } if (mode.Match(Mode.SequenceBound)) return null; //todo また未対応 if (mode.Match(Mode.Sequence)) { if (mode.Match(Mode.SuitBound)) return hand.Sequence(rank, revolution, count, suit); else return hand.Sequence(rank, revolution, count); } return null; }
public override Character GetTarget(IEnumerable<Character> targetsList) { Character target = targetsList .Where(t => t.Team == this.Team && t.IsAlive == true && t.Id != this.Id) .FirstOrDefault(t => t.HealthPoints == targetsList.Min(h => h.HealthPoints)); return target; }
public PerfIteratorResult(IEnumerable<PerfRoundResult> resultsList) { this.ResultsList = resultsList; this.RepeatCount = resultsList.Count(); this.OverallAverageTicks = resultsList.Average(r => r.AverageTicks); this.OverallMaxTicks = resultsList.Max(r => r.MaxTicks); this.OverallMinTicks = resultsList.Min(r => r.MinTicks); }
protected void ConfigureParameters(IEnumerable<double> data) { double originalRangeStart = data.Min(); double originalRangeEnd = data.Max(); double originalRangeWidth = originalRangeEnd - originalRangeStart; double targetRangeWidth = Range.End - Range.Start; Multiplier = targetRangeWidth / originalRangeWidth; Addend = Range.Start - originalRangeStart * Multiplier; }
/// <summary> /// Creates a Polyline from a list of points and calculates the lines and bounds of the result /// </summary> /// <param name="points">The list of points that define the polyline</param> /// <returns>a Polyline object</returns> public static Polyline FromPoints(IEnumerable<Point> points) { Polyline poly = new Polyline(); poly.Points = points.ToArray(); if (poly.Points.Length > 1) { poly.Lines = new Line[poly.Points.Length - 1]; for (int i = 0; i < poly.Lines.Length; i++) { poly.Lines[i] = Line.FromPoints( new Vector2(poly.Points[i].X, poly.Points[i].Y), new Vector2(poly.Points[i + 1].X, poly.Points[i + 1].Y)); } } poly.Bounds.X = points.Min(x => x.X); poly.Bounds.Y = points.Min(x => x.Y); poly.Bounds.Width = points.Max(x => x.X) - points.Min(x => x.X); poly.Bounds.Height = points.Max(x => x.Y) - points.Min(x => x.Y); return poly; }
private void ExecuteIndexingInternal(IEnumerable<IndexToWorkOn> indexesToWorkOn, Action<JsonDocument[]> indexingOp) { var lastIndexedGuidForAllIndexes = indexesToWorkOn.Min(x => new ComparableByteArray(x.LastIndexedEtag.ToByteArray())).ToGuid(); JsonDocument[] jsonDocs = null; try { transactionalStorage.Batch(actions => { jsonDocs = actions.Documents.GetDocumentsAfter(lastIndexedGuidForAllIndexes) .Where(x => x != null) .Select(doc => { DocumentRetriever.EnsureIdInMetadata(doc); return doc; }) .Take(context.Configuration.MaxNumberOfItemsToIndexInSingleBatch) // ensure that we won't go overboard with reading and blow up with OOM .ToArray(); }); if (jsonDocs.Length > 0) indexingOp(jsonDocs); } finally { if (jsonDocs != null && jsonDocs.Length > 0) { var last = jsonDocs.Last(); Debug.Assert(last.Etag != null); Debug.Assert(last.LastModified != null); var lastEtag = last.Etag.Value; var lastModified = last.LastModified.Value; var lastIndexedEtag = new ComparableByteArray(lastEtag.ToByteArray()); // whatever we succeeded in indexing or not, we have to update this // because otherwise we keep trying to re-index failed documents transactionalStorage.Batch(actions => { foreach (var indexToWorkOn in indexesToWorkOn) { if (new ComparableByteArray(indexToWorkOn.LastIndexedEtag.ToByteArray()).CompareTo(lastIndexedEtag) > 0) continue; actions.Indexing.UpdateLastIndexed(indexToWorkOn.IndexName, lastEtag, lastModified); } }); } } }
public static int GetHexShade(IEnumerable<KMLData> data, decimal current) { decimal min = data.Min(i => i.Amount); decimal value = (data.Max(i => i.Amount) - min) / 4; if (current <= min + value) return 0; else if (current <= min + (value * 2)) return 1; else if (current <= min + (value * 3)) return 2; else return 3; }
public PersonApiResponse GetPeopleInfo(IEnumerable<Person> personList) { PersonApiResponse response = new PersonApiResponse(); response.NumberOfPeople = personList.Count(); response.MaxAge = personList.Max(c=>c.Age); response.MinAge = personList.Min(c=>c.Age); response.AverageOfAge = personList.Average(c=>c.Age); response.NumberOfAngles = personList.Where(c => c.Race == PersonRace.Angles).Count(); response.NumberOfAsians = personList.Where(c => c.Race == PersonRace.Asians).Count(); response.NumberOfJutes = personList.Where(c => c.Race == PersonRace.Jutes).Count(); response.NumberOfSaxons = personList.Where(c => c.Race == PersonRace.Saxons).Count(); return response; }
//Naive calculation of Hausdorff distance between two sets of points public static double Distance(IEnumerable<Coordinate> a, IEnumerable<Coordinate> b) { var distance = 0D; //drive distance up var shortest = double.MaxValue; //drive shortest found down foreach(var d in a.Select(pa => b.Min(pb => pb.Distance(pa)))) { if(d < shortest) shortest = d; if(shortest > distance) distance = shortest; } return distance; //return a.Max(pa => b.Min(pb => pb.Distance(pa))); }
private async Task<IEnumerable<SnapshotSpan>> ExpandSelectionAsync(IEnumerable<SnapshotSpan> selectedSpans, CommandArgs args, CancellationToken cancellationToken) { var selectedSpansStart = selectedSpans.Min(span => span.Start); var selectedSpansEnd = selectedSpans.Max(span => span.End); ITextSnapshot snapshot = args.TextView.TextSnapshot; IEnumerable<SnapshotSpan> newSpans = await GetExecutableSyntaxTreeNodeSelectionAsync( TextSpan.FromBounds(selectedSpansStart, selectedSpansEnd), args, snapshot, cancellationToken).ConfigureAwait(true); return newSpans.Any() ? newSpans.Select(n => new SnapshotSpan(snapshot, n.Span.Start, n.Span.Length)) : selectedSpans; }
private static void PlaySong(IEnumerable<Note> notes) { var offset = (int)notes.Min(x => x.Pitch); foreach (var note in notes) { if (note.Pitch == Pitch.Rest) { Thread.Sleep(note.Duration); } else { Console.WriteLine("{0}#", new String('.', (int)note.Pitch - offset)); Console.Beep((int)Constants.Frequencies[note.Pitch], note.Duration); } } }
public static CalendarioViewModel ContruirCalendario(IEnumerable<Evento> eventos) { List<EventoCalendarioViewModel> listaEventos = new List<EventoCalendarioViewModel>(); //TODO RETIRAR listaEventos.Add(new EventoCalendarioViewModel() { Id = "1", Subject = "Teste", Description = "", StartTime = "11/5/2011 08:00", EndTime = "11/5/2011 10:00", Location = "", IsAllDayEvent = 0, Color = "0", RecurringRule = "" }); foreach (Evento evento in eventos) { listaEventos.Add(new EventoCalendarioViewModel() { Id = evento.Id, Subject = evento.Nome, Description = evento.Descricao, StartTime = evento.DataInicio.ToString("M/d/yyyy HH:mm"), EndTime = evento.DataFim.ToString("M/d/yyyy HH:mm"), Location = ObterTextoLocais(evento), IsAllDayEvent = 0, Color = ObterCor(evento), RecurringRule = "" }); } var calendario = new CalendarioViewModel(); foreach (EventoCalendarioViewModel item in listaEventos) { calendario.events.Add(item.GetValues()); } calendario.start = eventos.Count() > 0 ? eventos.Min(e => e.DataInicio).ToString("M/d/yyyy HH:mm") : ""; calendario.end = eventos.Count() > 0 ? eventos.ToList().Max(e => e.DataFim).ToString("M/d/yyyy HH:mm") : ""; calendario.issort = true; return calendario; }
public void AddOrUpdate(IEnumerable<WeatherDataEntity> source) { var time = source.Min(t => t.DateTime); var same = new Func<WeatherDataEntity, WeatherDataEntity, bool>((x, y) => x.DateTime == y.DateTime && x.Provider == y.Provider && x.CityId == y.CityId); var destination = this.context.Database.SqlQuery<WeatherDataEntity>("SELECT * FROM WeatherData WHERE DateTime >= {0}", time).ToList(); var insert = source.Where(x => !destination.Any(y => same(x, y))).ToList(); var update = source.Except(insert).ToList(); this.context.BulkInsert(insert); foreach (var item in update) { var margeItem = Mapper.Map(item, destination.First(x => same(item, x))); this.context.Database.ExecuteSqlCommandSmart("WeatherData_Update", margeItem); } }
/// <summary> /// Calculates the midrange of the specified collection of numbers. /// </summary> /// <param name="numbers">The numbers whose midrange is to be calculated.</param> /// <returns> /// The midrange of the specified collection of numbers. /// </returns> /// <exception cref="System.ArgumentNullException"> /// The specified collection must not be null. /// </exception> /// <exception cref="System.InvalidOperationException"> /// The specified collection must not be empty. /// </exception> public static double Midrange(IEnumerable<double> numbers) { if (numbers == null) { throw ArgumentNullException; } if (!numbers.Any()) { throw EmptyNumbersCollectionException; } double minValue = numbers.Min(); double maxValue = numbers.Max(); double midrange = ArithmeticMeanCalculator.ArithmeticMean(minValue, maxValue); return midrange; }
public bool AreOrdersValid(IEnumerable<int> orders) { var itemCount = orders.Count(); var maxOrder = orders.Max(); var minOrder = orders.Min(); var distinctOrders = orders.Distinct(); var distinctCount = distinctOrders.Count(); if (minOrder == 1 && maxOrder == itemCount && itemCount == distinctCount) { return true; } else { return false; } }
int FindPrimeSievecounts(IEnumerable<int> nums, int n) { int result = 0; if (n < nums.Min() || n > nums.Max()) { return 0; } else { for (int i = 2 ; i < n; i++) { int currentN = nums.ElementAt(i); if (currentN % 2 != 0) { result = result + 1; } } return result; } }
public static string ToBitmask(this IEnumerable <DateTime> dates, bool defaultOnEmpty = false) { var result = default(string); if (dates?.Any() ?? false) { result = dates?.ToBitmask( begin: dates?.Min() ?? DateTime.MinValue, end: dates?.Max() ?? DateTime.MinValue, defaultOnEmpty: defaultOnEmpty); } if (result == default) { result = defaultOnEmpty ? default : string.Empty; } return(result); }
public static List<int> Bucketize(IEnumerable<decimal> source, int totalBuckets) { var min = source.Min(); var max = source.Max(); var buckets = new List<int>(new int[totalBuckets]); var bucketSize = (max - min) / totalBuckets; foreach (var value in source) { int bucketIndex = 0; if (bucketSize > (decimal)0.0) { bucketIndex = (int)((value - min) / bucketSize); if (bucketIndex == totalBuckets) { bucketIndex--; } } buckets[bucketIndex]++; } return buckets; }
private static IEnumerable <DataRow> GetFields(Page page) { DataTable table = page.GetMetadata().GetFieldsOnPageAsDataTable(page.Id); table.SetColumnDataType(ColumnNames.TAB_INDEX, typeof(double)); IDictionary <string, DataRow> fields = table.Rows.Cast <DataRow>() .ToDictionary(field => field.Field <string>(ColumnNames.NAME), StringComparer.OrdinalIgnoreCase); IEnumerable <DataRow> groups = fields.Values .Where(field => (MetaFieldType)field.Field <int>(ColumnNames.FIELD_TYPE_ID) == MetaFieldType.Group); foreach (DataRow group in groups) { IEnumerable <DataRow> members = group.Field <string>(ColumnNames.LIST) ?.Split(Constants.LIST_SEPARATOR) ?.Select(fieldName => fields.TryGetValue(fieldName, out DataRow field) ? field : null); double?tabIndexMin = members?.Min(member => member?.Field <double?>(ColumnNames.TAB_INDEX)); if (tabIndexMin == null) { continue; } group.SetField(ColumnNames.TAB_INDEX, tabIndexMin.Value - GroupTabIndexDifference); } return(fields.Values.OrderBy(field => field.Field <double?>(ColumnNames.TAB_INDEX))); }
public static IEnumerable <T> FindMin <T>(this IEnumerable <T> values, Func <T, double> selector) { var min = values.Min(selector); return(values.Where(v => selector(v) == min)); }
private static string GetMinimumValue(IEnumerable <int> numbers) => numbers?.Min().ToString(CultureInfo.InvariantCulture);
protected override decimal CalculateAggregate(IEnumerable <CalculatorValue> values) => values.Min(x => x.Value);
private static int GetAssemblyWeight(IEnumerable <DeclaredSymbolInfo> resultsInAssembly) { return(resultsInAssembly.Min(d => d.Weight)); }
///<summary></summary> public static T SingleWithMin <T, TResult>(this IEnumerable <T> local, Func <T, TResult> selector) => local.Min(selector) .Make(x => local.Single(y => selector(y).Equals(x)));
protected static Vector2 UpdateBounds(IEnumerable <float> range) { return(new Vector2(range.Min() - 1, range.Max() + 1)); }
static void Main(string[] args) { Console.WindowHeight = 50; Console.WindowWidth = 200; Console.Title = "Lambda lambda lambda :>"; Console.Clear(); var consoleHelper = new ConsoleHelper(); var consoleWriter = new RecieveAndWriteConsoleMessage(); consoleHelper.WritingMessage += consoleWriter.OnMessageWriting; consoleHelper.WriteConsoleMessage("----------------------------------------------------------------------"); //My Extension Methods consoleHelper.WriteConsoleMessage("Upper first letter of any name that starts with lower case"); foreach (var employee in Employee.GetAllEmployees()) { string newEmployeeName = employee.Name.ChangeFirstLetterCaseToUpper(); consoleHelper.WriteConsoleMessage(newEmployeeName); } IEnumerable <Employee> employees = Employee.GetAllEmployees(); double totalEmployeeRaiseCost = 0; totalEmployeeRaiseCost = totalEmployeeRaiseCost.SumEmployeeSalariesWithAnnualPercentRaise(Employee.GetAllEmployees(), 2); consoleHelper.WriteConsoleMessage("-------------------------"); consoleHelper.WriteConsoleMessage(string.Format("Total cost for all raises: {0:C}", totalEmployeeRaiseCost)); //LINQ Aggregate Operators consoleHelper.WriteConsoleMessage("-------------------------"); consoleHelper.WriteConsoleMessage("Max salary"); consoleHelper.WriteConsoleMessage(employees.Max(e => e.Salary).ToString()); consoleHelper.WriteConsoleMessage("-------------------------"); consoleHelper.WriteConsoleMessage("Min salary"); consoleHelper.WriteConsoleMessage(employees.Min(e => e.Salary).ToString()); consoleHelper.WriteConsoleMessage("-------------------------"); consoleHelper.WriteConsoleMessage("Average of all salaries"); consoleHelper.WriteConsoleMessage(employees.Average(e => e.Salary).ToString()); consoleHelper.WriteConsoleMessage("-------------------------"); consoleHelper.WriteConsoleMessage("Sum of all salaries"); consoleHelper.WriteConsoleMessage(employees.Sum(e => e.Salary).ToString()); //Aggregate Function //How Aggregate() function works ? //Step 1.First "India" is concatenated with "US" to produce result "India, US" //Step 2.Result in Step 1 is then concatenated with "UK" to produce result "India, US, UK" //Step 3: Result in Step 2 is then concatenated with "Canada" to produce result "India, US, UK, Canada" consoleHelper.WriteConsoleMessage("-------------------------"); consoleHelper.WriteConsoleMessage("Aggragate all employee names into a single comma seperated string"); string nameList = employees.Select(e => e.Name) .ToArray <string>() .Aggregate((a, b) => a + ", " + b); consoleHelper.WriteConsoleMessage(nameList); consoleHelper.WriteConsoleMessage("-------------------------"); consoleHelper.WriteConsoleMessage("Using modula in Where restriction operator predicate to get only even numbers\nthen aggregate to comma seperated string"); List <int> numbers = new List <int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; IEnumerable <int> evenNumbers = numbers.Where(num => num % 2 == 0); string evenNumberString = evenNumbers.Select(n => n.ToString()).ToArray <string>().Aggregate((a, b) => a + ", " + b); consoleHelper.WriteConsoleMessage(evenNumberString); //Projection operator //Select Many--IEnumerable<string> sequences, which are then flattened to form a single sequence i.e a single IEnumerable<string> sequence. //Select many list<string> of AllStates a complany resides in and print a distinct list of the state codes consoleHelper.WriteConsoleMessage("-------------------------"); consoleHelper.WriteConsoleMessage("Select Many"); IEnumerable <string> statesList = Company.GetAllCompanies().SelectMany(c => c.AllStates).Distinct(); foreach (var states in statesList) { consoleHelper.WriteConsoleMessage(states); } consoleHelper.WriteConsoleMessage("-------------------------"); consoleHelper.WriteConsoleMessage("Select multiple columns from company list"); var companies = Company.GetAllCompanies().Select(c => new { CompanyName = c.Name, CompanyId = c.ID, CompanyState = c.State }).Distinct(); foreach (var company in companies) { consoleHelper.WriteConsoleMessage(string.Format("Company ID: {0} - Company Name {1} - Company State {2}", company.CompanyId, company.CompanyName, company.CompanyState)); } //Ordering operators var esd = employees.OrderByDescending(e => e.Name); consoleHelper.WriteConsoleMessage("-------------------------"); consoleHelper.WriteConsoleMessage("Order name descending"); foreach (var e in esd) { consoleHelper.WriteConsoleMessage(string.Format("Emp Name: {0}", e.Name)); } var esa = employees.OrderBy(e => e.Name); consoleHelper.WriteConsoleMessage("-------------------------"); consoleHelper.WriteConsoleMessage("Order name ascending"); foreach (var e in esa) { consoleHelper.WriteConsoleMessage(string.Format("Emp Name: {0}", e.Name)); } var esb = employees.OrderBy(e => e.Name).ThenBy(e => e.ID); consoleHelper.WriteConsoleMessage("-------------------------"); consoleHelper.WriteConsoleMessage("OrderBy name ThenBy ID"); foreach (var e in esb) { consoleHelper.WriteConsoleMessage(string.Format("Name: {0} ID:{1}", e.Name, e.ID)); } //Take,Skip,Take While,Skip While Partitioning Operators var est = employees.Take(4); consoleHelper.WriteConsoleMessage("-------------------------"); consoleHelper.WriteConsoleMessage("Take the first 4 employees"); foreach (var e in est) { consoleHelper.WriteConsoleMessage(string.Format("Name: {0} ID:{1}", e.Name, e.ID)); } var ess = employees.Skip(4); consoleHelper.WriteConsoleMessage("-------------------------"); consoleHelper.WriteConsoleMessage("Skip the first 4 employees"); foreach (var e in ess) { consoleHelper.WriteConsoleMessage(string.Format("Name: {0} ID:{1}", e.Name, e.ID)); } //SkipWhile must be sorted first consoleHelper.WriteConsoleMessage("-------------------------"); consoleHelper.WriteConsoleMessage("Skip while salary is > 55000 -- Don't forget to sort before skipping while"); var esw = employees.OrderByDescending(e => e.Salary).SkipWhile(e => e.Salary > 55000); foreach (var e in esw) { consoleHelper.WriteConsoleMessage(string.Format("Name: {0} Salary is <= 55000: {1}", e.Name, e.Salary)); } //TakeWhile must be sorted first consoleHelper.WriteConsoleMessage("-------------------------"); consoleHelper.WriteConsoleMessage("Take while salary is > 55000 -- Don't forget to sort before taking while"); var estake = employees.OrderByDescending(e => e.Salary).TakeWhile(e => e.Salary > 55000); foreach (var e in estake) { consoleHelper.WriteConsoleMessage(string.Format("Name: {0} Salary is > 55000: {1}", e.Name, e.Salary)); } Console.ReadLine(); }
float CenteredMinimumAt(IEnumerable <TextLine> lineset) { return(lineset.Min(t => t.CenteredAt)); }
float BoundaryLeft(IEnumerable <TextLine> lineset) { return(lineset.Min(t => t.MarginLeft)); }
public static TResult MinOrDefault <T, TResult>(this IEnumerable <T> list, Func <T, TResult> selector) { return(!list.Any() ? default(TResult) : list.Min(selector)); }
public static int MinOrDefault <T>( this IEnumerable <T> source, Func <T, int> selector, int defaultValue = 0) { return(source.Any() ? source.Min(selector) : defaultValue); }
public static TResult MinOrDefault <TSource, TResult>(this IEnumerable <TSource> source, Func <TSource, TResult> selector, TResult defaultValue) { return(source.Any() ? source.Min(selector) : defaultValue); }
/// <summary> /// Processes a set of data. /// </summary> /// <param name="values">A set of data to consider into the limits.</param> public void ProcessData(IEnumerable <double> values) { AutoMax = Math.Max(AutoMax, values.Max()); AutoMin = Math.Min(AutoMin, values.Min()); Count += values.Count(); }
protected void UpdateElementEditors(IList[] values, bool getValueOnNewEditors) { PropertyInfo indexer = typeof(IList).GetProperty("Item"); IEnumerable <IList> valuesNotNull = values.Where(v => v != null); int visibleElementCount = valuesNotNull.Min(o => (int)o.Count); bool showOffset = false; if (visibleElementCount > 10) { this.offset = Math.Min(this.offset, visibleElementCount - 10); this.offsetEditor.Maximum = visibleElementCount - 10; this.offsetEditor.ValueBarMaximum = this.offsetEditor.Maximum; visibleElementCount = 10; showOffset = true; } else { this.offset = 0; } if (this.sizeEditor.ParentEditor == null) { this.AddPropertyEditor(this.sizeEditor, 0); } if (showOffset && this.offsetEditor.ParentEditor == null) { this.AddPropertyEditor(this.offsetEditor, 1); } else if (!showOffset && this.offsetEditor.ParentEditor != null) { this.RemovePropertyEditor(this.offsetEditor); } this.internalEditors = showOffset ? 2 : 1; this.BeginUpdate(); // Add missing editors Type elementType = GetIListElementType(this.EditedType); Type reflectedArrayType = PropertyEditor.ReflectDynamicType(elementType, valuesNotNull.Select(a => GetIListElementType(a.GetType()))); for (int i = this.internalEditors; i < visibleElementCount + this.internalEditors; i++) { int elementIndex = i - this.internalEditors + this.offset; Type reflectedElementType = PropertyEditor.ReflectDynamicType( reflectedArrayType, valuesNotNull.Select(v => indexer.GetValue(v, new object[] { elementIndex }))); bool elementEditorIsNew = false; PropertyEditor elementEditor; // Retrieve and Update existing editor if (i < this.ChildEditors.Count()) { elementEditor = this.ChildEditors.ElementAt(i); if (elementEditor.EditedType != reflectedElementType) { // If the editor has the wrong type, we'll need to create a new one PropertyEditor oldEditor = elementEditor; elementEditor = this.ParentGrid.CreateEditor(reflectedElementType, this); elementEditorIsNew = true; this.AddPropertyEditor(elementEditor, oldEditor); this.RemovePropertyEditor(oldEditor); this.ParentGrid.ConfigureEditor(elementEditor); } } // Create a new editor else { elementEditor = this.ParentGrid.CreateEditor(reflectedElementType, this); elementEditorIsNew = true; this.AddPropertyEditor(elementEditor); this.ParentGrid.ConfigureEditor(elementEditor); } elementEditor.Getter = this.CreateElementValueGetter(indexer, elementIndex); elementEditor.Setter = this.CreateElementValueSetter(indexer, elementIndex); elementEditor.PropertyName = "[" + elementIndex + "]"; // Immediately retrieve a valid value for the newly created editor when requested if (elementEditorIsNew && getValueOnNewEditors) { elementEditor.PerformGetValue(); } } // Remove overflowing editors for (int i = this.ChildEditors.Count() - (this.internalEditors + 1); i >= visibleElementCount; i--) { PropertyEditor child = this.ChildEditors.Last(); this.RemovePropertyEditor(child); } this.EndUpdate(); }
public static void SkipWhile_SomeFalse(Labeled<ParallelQuery<int>> labeled, int count, IEnumerable<int> skip) { ParallelQuery<int> query = labeled.Item; int seen = skip.Min(); Assert.All(query.SkipWhile(x => !skip.Contains(x)), x => Assert.Equal(seen++, x)); Assert.Equal(count, seen); }
private static int GetSmallestOffset(IEnumerable <string> lines) { return(lines.Min(line => String.IsNullOrEmpty(line) ? Int32.MaxValue : GetLineInfo(line)[1])); }
private static void RenderDropDown(HtmlWriter writer, IEnumerable<GridCell> cells, GridCell selectedCell, IEnumerable<int> validOptions) { writer.RenderBeginTag(HtmlTextWriterTag.Select); writer.AddAttribute("value", ""); if (selectedCell == null) writer.AddAttribute("selected","selected"); writer.RenderFullTag(HtmlTextWriterTag.Option, "None"); foreach (var cell in cells.Where(c => c.ColumnSpan >= validOptions.Min())) { writer.AddAttribute(HtmlTextWriterAttribute.Value, cell.Key); if (cell == selectedCell) writer.AddAttribute("selected", "selected"); writer.RenderFullTag(HtmlTextWriterTag.Option, cell.Key); } writer.RenderEndTag(); }
private void SendResults(IEnumerable <ScanResult> results) { var msg = new MailMessage(_settings.EmailFrom, _settings.EmailTo) { // ReSharper disable PossibleMultipleEnumeration Subject = results.Any() ? string.Format(_settings.EmailSubjectResultsFormat, results.Sum(x => x.Items), results.Min(x => x.LastScan)) : _settings.EmailSubjectEmptyFormat, // ReSharper restore PossibleMultipleEnumeration SubjectEncoding = Encoding.UTF8, BodyEncoding = Encoding.UTF8, IsBodyHtml = true }; var sb = new StringBuilder(@"<!DOCTYPE html> <html lang='en'> <head> <meta charset='UTF-8'> <title>QTH search results</title> <style> * {box-sizing: border-box} html, body {margin:0; padding:0} .ext-link {text-align: right; width: 100%;} .ext-link a {color: #aaa;} .source {width: 100%; font-size: 2rem; font-weight: bold; text-align: center; color: cadetblue; } table {border: 1px solid #aaa; margin-bottom: 5px; width: 100%} tr, td {border: none; padding: 0; margin: 0} td.thumb {vertical-align: top; max-width: 300px} td.thumb img {width: 300px} td.thumb img.qth {max-width: 300px} td.thumb img.eham {max-width: 300px} td.title {height: 1.5rem; padding: 2px 5px; font: 1.2rem bold; font-family: helvetica; color: azure; background-color: cornflowerblue; width: 100%} td.title a.link {color: azure; text-decoration: none} td.title a.cat {float: right; font-size: 1rem; font-style: italic; color: oldlace} tr.content {height: 100%} tr.content td {padding: 10px 5px 0 5px; height: 100%; font-family: trebuchet ms; vertical-align: top} tr.content td .price {color: crimson} td.info {height: 1rem; padding: 10px 5px 0 5px; font-family: monospace; font-size: 0.8rem; vertical-align: bottom} td.info a.call {color: black;} td.info .modified {color: crimson} </style> </head> <body> "); if (!string.IsNullOrEmpty(_settings.BodyFileName) && !string.IsNullOrEmpty(_settings.ResourceUrl)) { sb.AppendLine($"<div class='ext-link'><a href='{_settings.ResourceUrl}/{_settings.BodyFileName}' target='_blank'>View this email in a separate browser window</a></div>"); } // ReSharper disable once PossibleMultipleEnumeration foreach (var res in results) { sb.AppendLine($"<div class='source'>{res.Title}</div>\n<div>"); sb.AppendLine(res.Html); sb.AppendLine("</div>"); } sb.AppendLine("</body>\n</html>"); msg.Body = sb.ToString(); if (string.IsNullOrEmpty(_settings.BodyFileName)) { return; } _logger.LogDebug("Saving file"); File.WriteAllText($"{_settings.ResourceFolder}/{_settings.BodyFileName}", msg.Body); #if !DEBUG _logger.LogDebug($"Sending email to {_settings.EmailTo}"); var client = new SmtpClient(_settings.SmtpServer); if (!string.IsNullOrWhiteSpace(_settings.User)) { client.Credentials = new NetworkCredential(_settings.User, _settings.Password); } if (_settings.AttachFile && !string.IsNullOrEmpty(_settings.BodyFileName)) { msg.Attachments.Add(new Attachment(_settings.BodyFileName)); } try { client.Send(msg); } catch (Exception e) { _logger.LogError(e.ToString()); } #endif }
static public RectI2 CreatePoints(IEnumerable <VectorI2> points) { return(new RectI2(points.Min(), points.Max())); }
public override void DesignateMultiCell(IEnumerable <IntVec3> cells) { var planDesignations = cells.Select(cell => MapUtility.GetPlanDesignationAt(cell, Map)).Where(designation => designation != null).ToList(); cells = planDesignations.Select(plan => plan.target.Cell); if (planDesignations.Count == 0) { Messages.Message("MorePlanning.MissingPlanningDesignations".Translate(), MessageTypeDefOf.RejectInput); return; } int left = cells.Min(cell => cell.x); int top = cells.Max(cell => cell.z); int right = cells.Max(cell => cell.x); int bottom = cells.Min(cell => cell.z); IntVec2 mousePos = new IntVec2((int)Math.Floor(UI.MouseMapPosition().x), (int)Math.Floor(UI.MouseMapPosition().z)); // Adjust mouse position to nearest planning designation if (mousePos.x < left) { mousePos.x = left; } else if (mousePos.x > left) { mousePos.x = right; } if (mousePos.z > top) { mousePos.z = top; } else if (mousePos.z < bottom) { mousePos.z = bottom; } int sizeCompX = mousePos.x; int sizeCompZ = mousePos.z; List <PlanInfo> planDesignationInfo = new List <PlanInfo>(); // Copy all data from designations foreach (var planDesignation in planDesignations) { var moddedPlanDesignation = planDesignation as PlanDesignation; var planInfo = new PlanInfo { Color = moddedPlanDesignation != null ? moddedPlanDesignation.Color : 0, Pos = new IntVec3(planDesignation.target.Cell.x - sizeCompX, planDesignation.target.Cell.y, planDesignation.target.Cell.z - sizeCompZ) }; planDesignationInfo.Add(planInfo); } var planCopy = new PlanInfoSet(planDesignationInfo); PasteDesignator.CurrentPlanCopy = planCopy; Finalize(true); var designatorPlanPaste = MenuUtility.GetPlanningDesignator <PasteDesignator>(); Find.DesignatorManager.Select(designatorPlanPaste); }
protected override MatchingScore selectScoreInternally(IEnumerable <MatchingScore> scores) { return(scores.Min()); }
public ActionResult History(int year = 0, bool displayMonth = false) { year = (year == 0) ? DateTime.Now.Year : year; DashboardViewModel viewModel = new DashboardViewModel(); viewModel.CurrentYear = year; viewModel.DisplayMonth = displayMonth; IEnumerable <BillPayment> billPayments = db.BillPayments.Where(x => x.User.Id == user.Id || x.SharedWith.Where(y => y.SharedWithUser.Id == user.Id).Any()).Include(x => x.Bill).Include(x => x.User).Include(x => x.SharedWith.Select(y => y.SharedWithUser)).OrderBy(x => x.DatePaid); IEnumerable <LoanPayment> loanPayments = db.LoanPayments.Where(x => x.User.Id == user.Id || x.SharedWith.Where(y => y.SharedWithUser.Id == user.Id).Any()).Include(x => x.Loan).Include(x => x.User).Include(x => x.SharedWith.Select(y => y.SharedWithUser)).OrderBy(x => x.DatePaid); IEnumerable <IncomePayment> incomePayments = db.IncomePayments.Where(x => x.User.Id == user.Id).Include(x => x.Income).Include(x => x.User).OrderBy(x => x.Date); int maxYear = 0; int minYear = DateTime.Now.Year; if (billPayments.Any()) { int maxYearBill = billPayments.Max(x => x.DatePaid).Year; int minYearBill = billPayments.Min(x => x.DatePaid).Year; maxYear = (maxYearBill > maxYear) ? maxYearBill : maxYear; minYear = (minYearBill < minYear) ? minYearBill : minYear; } if (loanPayments.Any()) { int maxYearLoan = loanPayments.Max(x => x.DatePaid).Year; int minYearLoan = loanPayments.Min(x => x.DatePaid).Year; maxYear = (maxYearLoan > maxYear) ? maxYearLoan : maxYear; minYear = (minYearLoan < minYear) ? minYearLoan : minYear; } if (incomePayments.Any()) { int maxYearIncome = incomePayments.Max(x => x.Date).Year; int minYearIncome = incomePayments.Min(x => x.Date).Year; maxYear = (maxYearIncome > maxYear) ? maxYearIncome : maxYear; minYear = (minYearIncome < minYear) ? minYearIncome : minYear; } viewModel.StartYear = minYear; viewModel.EndYear = maxYear; IEnumerable <BillPayment> yearBillPayments = billPayments.Where(x => x.DatePaid.Year == year); IEnumerable <LoanPayment> yearLoanPayments = loanPayments.Where(x => x.DatePaid.Year == year); IEnumerable <IncomePayment> yearIncomePayments = incomePayments.Where(x => x.Date.Year == year); if (yearBillPayments.Any() || yearLoanPayments.Any() || yearIncomePayments.Any()) { DateTime startDate = DateTime.Now; if (yearBillPayments.Any()) { DateTime billStartDate = yearBillPayments.Min(x => x.DatePaid); startDate = (billStartDate < startDate) ? billStartDate : startDate; } if (yearLoanPayments.Any()) { DateTime loanStartDate = yearLoanPayments.Min(x => x.DatePaid); startDate = (loanStartDate < startDate) ? loanStartDate : startDate; } if (yearIncomePayments.Any()) { DateTime incomeStartDate = yearIncomePayments.Min(x => x.Date); startDate = (incomeStartDate < startDate) ? incomeStartDate : startDate; } startDate = GetUserStartDate(startDate, viewModel.DisplayMonth); viewModel.DateRanges = InitiateDateRanges(startDate, viewModel.DisplayMonth, true); viewModel.DateRanges = (user.PrimaryIncome.PaymentFrequency == PaymentFrequency.SemiMonthly) ? viewModel.DateRanges.OrderByDescending(x => x.StartDate.Month) : viewModel.DateRanges.OrderByDescending(x => x.StartDate); foreach (DashboardDateRange range in viewModel.DateRanges) { List <DashboardItem> items = new List <DashboardItem>(); items.AddRange(yearBillPayments.Where(x => x.DatePaid >= range.StartDate && x.DatePaid <= range.EndDate).Select(x => new DashboardItem(x, user))); items.AddRange(yearLoanPayments.Where(x => x.DatePaid >= range.StartDate && x.DatePaid <= range.EndDate).Select(x => new DashboardItem(x, user))); range.Items = items.OrderBy(x => x.Date); List <DashboardIncomeItem> incomeItems = new List <DashboardIncomeItem>(); incomeItems.AddRange(yearIncomePayments.Where(x => x.Date >= range.StartDate && x.Date <= range.EndDate).Select(x => new DashboardIncomeItem(x))); range.IncomeItems = incomeItems.OrderBy(x => x.Date).ToList(); } viewModel.DateRanges = viewModel.DateRanges.Where(x => x.Items.Any() || x.IncomeItems.Any()); } return(View(viewModel)); }
public double MinimumAtRange(double leftX, double rightX) { IEnumerable <DataPoint> elements = curve.Points.Where((DataPoint x) => x.XValue >= leftX && x.XValue <= rightX); return(elements.Count() == 0 ? MaximumY : elements.Min((DataPoint p) => { return p.YValues.Min(); })); }
private static string TrackTimeQueryMin(IEnumerable <ITrack> tracks) { var track = tracks.Min(); return(track.Name + "\t\t" + track.Milliseconds + "/ 1000"); }
/// <summary> /// Returns the racer's best lap. /// </summary> /// <param name="race"></param> /// <returns></returns> public Lap GetBestLap(Race race) { Laps = race.Laps.Where(x => x.Racer.RacerId == RacerId); return(Laps.FirstOrDefault(x => x.LapTime == Laps.Min(y => y.LapTime))); }
public static Date Start(this IEnumerable <DateRange> source) { return(source.Min(period => period.Start)); }
float BoundaryRight(IEnumerable <TextLine> lineset) { return(lineset.Min(t => t.MarginRight)); }
public static UInt16[] IEnumerableToIndexArray(IEnumerable<double> data, int width, int height, int nIndices) { double max = data.Max(); double min = data.Min(); double Scale = (nIndices - 1) / (max - min); int count = width * height; int index = 0; UInt16[] indices = new UInt16[count]; foreach (double value in data) { indices[index] = (UInt16)((value - min) * Scale); index++; } return indices; }
} // CreateBody() #endregion #region CalcSize private Vector2 _calcSize(IEnumerable <Vector2> vert) { return(new Vector2(vert.Max(v => v.X) - vert.Min(v => v.X), vert.Max(v => v.Y) - vert.Min(v => v.Y))); } // _calcSize(vertices)
private EngineSettings GetBaseSettings(IEnumerable <EngineSettings> settings) { var minPrice = settings.Min(cur => cur.Price); return(settings.FirstOrDefault(cur => cur.Price == minPrice)); }
private static long GetDuration(IEnumerable <Span> spans) { var timeSpan = spans.Max(x => x.FinishTimestamp) - spans.Min(x => x.StartTimestamp); return(timeSpan.GetMicroseconds()); }