internal override Expression MakeCompareExpression(Expression lhs, Expression rhs) { var tProperty = typeof(TProperty); var lhsProperty = GetProperty.MakeInvocation(lhs); var rhsProperty = GetProperty.MakeInvocation(rhs); if (Comparer == null) { var compareTo = tProperty.GetMethod( "CompareTo", new [] { tProperty } ); if (compareTo != null) { return(Expression.Call( lhsProperty, compareTo, rhsProperty )); } } var compare = RuntimeComparer.GetType().GetMethod("Compare", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); return(Expression.Call( Expression.Constant(RuntimeComparer), compare, lhsProperty, rhsProperty )); }
static void SortAndPrint(Person[] persons, IComparer <Person> theComparer) { Console.WriteLine("=================="); Console.WriteLine($"== Sort by {theComparer.GetType()}"); Console.WriteLine("=================="); Array.Sort(persons, theComparer); PrintPersons(persons); }
private static string GetComparerName <T>(IComparer <T> comparer) { string comparerStr = comparer.ToString(); if (comparerStr == comparer.GetType().ToString()) { comparerStr = comparer.GetType().Name; } comparerStr = AssertUtility.FormatArgument(comparerStr); if (comparer == EqualityComparer <T> .Default) { comparerStr += " (default)"; } return(comparerStr); }
/// <summary> /// Modifies the constraint to use an <see cref="IComparer{T}"/> and returns self. /// </summary> public CollectionOrderedConstraint Using <T>(IComparer <T> comparer) { if (_activeStep.ComparerName != null) { throw new InvalidOperationException("Only one Using modifier may be used"); } _activeStep.Comparer = ComparisonAdapter.For(comparer); _activeStep.ComparerName = comparer.GetType().FullName; return(this); }
public bool Remove <T>(IComparer <T> comparer) { if (comparer == null) { return(false); } Type type = comparer.GetType().GetGenericArguments()[0]; return(Remove(type)); }
public void Add <T>(IComparer <T> comparer) { if (comparer == null) { return; } Type type = comparer.GetType().GetGenericArguments()[0]; Cache.AddOrUpdate(type, comparer as IComparer); }
private void TestSpeed(IEnumerable <INode> nodes, IComparer <INode> comparer, bool expectFaster) { List <INode> defaultSorted = new List <INode>(nodes); Stopwatch timer = new Stopwatch(); timer.Start(); defaultSorted.Sort(); timer.Stop(); Console.WriteLine("Default Sort: " + timer.Elapsed); long defTime = timer.ElapsedTicks; defaultSorted.Clear(); defaultSorted = null; GC.GetTotalMemory(true); List <INode> custSorted = new List <INode>(nodes); timer.Reset(); timer.Start(); custSorted.Sort(comparer); timer.Stop(); custSorted.Clear(); custSorted = null; GC.GetTotalMemory(true); Console.WriteLine(comparer.GetType().Name + " Sort: " + timer.Elapsed); long custTime = timer.ElapsedTicks; if (expectFaster) { Console.WriteLine("Speed Up: " + ((double)defTime) / ((double)custTime)); Assert.True(custTime <= defTime, comparer.GetType().Name + " should be faster"); } else { Console.WriteLine("Slow Down: " + ((double)defTime) / ((double)custTime)); Assert.True(defTime <= custTime, comparer.GetType().Name + " should be slower"); } }
void CorrectOnOneTransactionTypeExists() { if (CurrentPriceIndex == -1 && transactions.Count != 0) { int lastIndex = transactions.Count - 1; string transantionType = transactions[0].Bid == 0 ? "Bid" : "Ask"; int volume = transactions[lastIndex].Volume + 5; double price; if (comparer.GetType() == typeof(PriceAscedingComparer)) { price = IsDownMoving(transantionType) ? transactions[lastIndex].Price + 0.5 : transactions[0].Price - 0.5; } else { price = IsDownMoving(transantionType) ? transactions[lastIndex].Price - 0.5 : transactions[0].Price + 0.5; } TransactionData tdvm = new TransactionData(transantionType, volume, price); transactions.Add(tdvm); CurrentPriceIndex = transactions.IndexOf(tdvm); } }
public override void OnResponse(NetState sender, RelayInfo info) { base.OnResponse(sender, info); PlayerMobile pm = sender.Mobile as PlayerMobile; if (pm == null || !IsMember(pm, guild)) { return; } int id = info.ButtonID; switch (id) { case 5: //Filter { TextRelay t = info.GetTextEntry(1); pm.SendGump(GetResentGump(player, guild, m_Comparer, m_Ascending, (t == null) ? "" : t.Text, 0)); break; } case 6: //Back { pm.SendGump(GetResentGump(player, guild, m_Comparer, m_Ascending, m_Filter, m_StartNumber - itemsPerPage)); break; } case 7: //Forward { pm.SendGump(GetResentGump(player, guild, m_Comparer, m_Ascending, m_Filter, m_StartNumber + itemsPerPage)); break; } } if (id >= 100 && id < (100 + m_Fields.Length)) { IComparer <T> comparer = m_Fields[id - 100].Comparer; if (m_Comparer.GetType() == comparer.GetType()) { m_Ascending = !m_Ascending; } pm.SendGump(GetResentGump(player, guild, comparer, m_Ascending, m_Filter, 0)); } else if (id >= 200 && id < (200 + m_List.Count)) { pm.SendGump(GetObjectInfoGump(player, guild, m_List[id - 200])); } }
protected bool GetComparerExpression(Expression arg, out Expression comparerExpression) { if (_comparer != null) { var compareInfo = GetComparerCompareMethodInfo(_comparer.GetType()); comparerExpression = _compareExpression( Expression.Call(Expression.Constant(_comparer), compareInfo, arg, Expression.Constant(Limit, typeof(T))), Expression.Constant(0)); return(true); } comparerExpression = null; return(false); }
private void ShowOrdering(IEnumerable<INode> nodes, IComparer<INode> comparer) { Console.WriteLine("Standard Ordering"); NTriplesFormatter formatter = new NTriplesFormatter(); foreach (INode n in nodes.OrderBy(x => x)) { Console.WriteLine(n.ToString(formatter)); } Console.WriteLine(); Console.WriteLine(comparer.GetType().Name + " Ordering"); foreach (INode n in nodes.OrderBy(x => x, comparer)) { Console.WriteLine(n.ToString(formatter)); } Console.WriteLine(); }
private ParetoRanked doOneRanking(IEnumerable <T> scores, IComparer <T> comparer) { if (scores.Count() == 0) { throw new ArgumentException("Cannot (pareto) rank on an array of zero length"); } List <T> nonDominated = new List <T>(); List <T> dominated = new List <T>(); foreach (var scoreA in scores) { bool isNonDominant = true; foreach (var scoreB in scores) { if (object.ReferenceEquals(scoreB, scoreA)) { continue; } int comparison = comparer.Compare(scoreA, scoreB); if (comparison > 0) // then scores[j] dominates score[i]. { isNonDominant = false; break; } } if (isNonDominant) { nonDominated.Add(scoreA); } else { dominated.Add(scoreA); } } if (nonDominated.Count == 0) { throw new Exception("Invalid result: the Pareto front should always have at least one element. The comparer " + comparer.GetType().FullName + " may have errors"); } return(new ParetoRanked(nonDominated.ToArray(), dominated.ToArray())); }
internal override Pair <MethodInfo, Expression[]> GetOperator() { Type sourceType = this.m_keySelector.Parameters[0].Type; MethodInfo operation = TypeSystem.FindStaticMethod( typeof(Microsoft.Research.DryadLinq.HpcLinqQueryable), "RangePartition", new Type[] { typeof(IQueryable <>).MakeGenericType(sourceType), m_keySelector.GetType(), m_partitionKeys.GetType(), m_comparer.GetType(), typeof(bool) }, new Type[] { sourceType, typeof(TKey) }); Expression[] arguments = new Expression[] { this.m_keySelector, Expression.Constant(this.m_partitionKeys), Expression.Constant(this.m_comparer, typeof(IComparer <TKey>)), Expression.Constant(this.m_isDescending) }; return(new Pair <MethodInfo, Expression[]>(operation, arguments)); }
private void InternalCompareSort(IComparer <T> comparer) { this._list = this._list.OrderBy(item => item, comparer).ToList(); if (this._from != null) { if (comparer is IComparer) { System.Reflection.MethodInfo compareSortMethod = this._from.GetType().GetMethod("InternalCompareSort2", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance); compareSortMethod.Invoke(this._from, new object[] { comparer }); } else { Type toType = this._from.GetType().GetProperty("ValueType").GetValue(this._from) as Type; throw new InvalidCastException(string.Format("Cannot cast from {0} to System.Collections.Generic.IComparer<{1}>", comparer.GetType(), toType)); } } }
protected virtual async Task SortItems(IComparer <PlaylistItem> comparer, bool descending) { Logger.Write(this, LogLevel.Debug, "Sorting playlist using comparer: \"{0}\"", comparer.GetType().Name); using (var transaction = this.Database.BeginTransaction(this.Database.PreferredIsolationLevel)) { var set = this.Database.Set <PlaylistItem>(transaction); var playlistItems = set.ToArray(); Array.Sort(playlistItems, comparer); if (descending) { Logger.Write(this, LogLevel.Debug, "Sort is descending, reversing sequence."); Array.Reverse(playlistItems); } for (var a = 0; a < playlistItems.Length; a++) { playlistItems[a].Sequence = a; } await EntityHelper <PlaylistItem> .Create( this.Database, this.Database.Tables.PlaylistItem, transaction ).UpdateAsync( playlistItems, new[] { nameof(PlaylistItem.Sequence) } ).ConfigureAwait(false); if (transaction.HasTransaction) { transaction.Commit(); } } }
private void CheckCombinations(List<INode> nodes, IComparer<INode> comparer) { if (nodes.Count == 0) Assert.Fail("No Input"); Console.WriteLine("INode Typed Tests"); for (int i = 0; i < nodes.Count; i++) { for (int j = 0; j < nodes.Count; j++) { INode a = nodes[i]; INode b = nodes[j]; if (i == j || ReferenceEquals(a, b)) { Assert.AreEqual(0, a.CompareTo(b), i + " == " + j + " was expected"); Assert.AreEqual(0, b.CompareTo(a), j + " == " + i + " was expected"); Console.WriteLine(i + " compareTo " + j + " => i == j"); Assert.AreEqual(0, comparer.Compare(a, b), i + " == " + j + " was expected (" + comparer.GetType().Name + ")"); Assert.AreEqual(0, comparer.Compare(b, a), j + " == " + i + " was expected (" + comparer.GetType().Name + ")"); } else { int c = a.CompareTo(b); int d = comparer.Compare(a, b); Assert.AreEqual(c * -1, b.CompareTo(a), j + " compare " + i + " was expected to be inverse of " + i + " compareTo " + j); Assert.AreEqual(d * -1, comparer.Compare(b, a), j + " compare " + i + " was expected to be inverse of " + i + " compareTo " + j + " (" + comparer.GetType().Name + ")"); if (c > 0) { Console.WriteLine(i + " compareTo " + j + " => i > j"); } else if (c == 0) { Console.WriteLine(i + " compareTo " + j + " => i == j"); } else { Console.WriteLine(i + " compareTo " + j + " => i < j"); } } } Console.WriteLine(); } Console.WriteLine(); }
void SortAndLog(IComparer <IVIEntry> cmp) { dir.Entries.Sort(cmp); Debug.Log("Sorted by " + cmp.GetType().FullName + " ..."); LogDentries(); }
public override void PopulateGump() { base.PopulateGump(); List <T> list = m_List; if (WillFilter) { m_List = new List <T>(); for (int i = 0; i < list.Count; i++) { if (!IsFiltered(list[i], m_Filter)) { m_List.Add(list[i]); } } } else { m_List = new List <T>(list); } m_List.Sort(m_Comparer); m_StartNumber = Math.Max(Math.Min(m_StartNumber, m_List.Count - 1), 0); AddBackground(130, 75, 385, 30, 0xBB8); AddTextEntry(135, 80, 375, 30, 0x481, 1, m_Filter); AddButton(520, 75, 0x867, 0x868, 5, GumpButtonType.Reply, 0); //Filter Button int width = 0; for (int i = 0; i < m_Fields.Length; i++) { InfoField <T> f = m_Fields[i]; AddImageTiled(65 + width, 110, f.Width + 10, 26, 0xA40); AddImageTiled(67 + width, 112, f.Width + 6, 22, 0xBBC); AddHtmlText(70 + width, 113, f.Width, 20, f.Name, false, false); bool isComparer = (m_Fields[i].Comparer.GetType() == m_Comparer.GetType()); int ButtonID = (isComparer) ? (m_Ascending ? 0x983 : 0x985) : 0x2716; AddButton(59 + width + f.Width, 117, ButtonID, ButtonID + (isComparer ? 1 : 0), 100 + i, GumpButtonType.Reply, 0); width += (f.Width + 12); } if (m_StartNumber <= 0) { AddButton(65, 80, 0x15E3, 0x15E7, 0, GumpButtonType.Page, 0); } else { AddButton(65, 80, 0x15E3, 0x15E7, 6, GumpButtonType.Reply, 0); // Back } if (m_StartNumber + itemsPerPage > m_List.Count) { AddButton(95, 80, 0x15E1, 0x15E5, 0, GumpButtonType.Page, 0); } else { AddButton(95, 80, 0x15E1, 0x15E5, 7, GumpButtonType.Reply, 0); // Forward } int itemNumber = 0; if (m_Ascending) { for (int i = m_StartNumber; i < m_StartNumber + itemsPerPage && i < m_List.Count; i++) { DrawEntry(m_List[i], i, itemNumber++); } } else //descending, go from bottom of list to the top { for (int i = m_List.Count - 1 - m_StartNumber; i >= 0 && i >= (m_List.Count - itemsPerPage - m_StartNumber); i--) { DrawEntry(m_List[i], i, itemNumber++); } } DrawEndingEntry(itemNumber); }
static void PrintSortedArray(Person[] people, IComparer <Person> methodComparer) { Console.WriteLine($"Sorting by {methodComparer.GetType()}"); Array.Sort(people, methodComparer); PrintPersonArray(people); }