public void Bst()
{
var n = 100000;
var a = RandomHelper.CreateData(n);
var expected = (int[])a.Clone();
var actual = new List <int>();
var q = new BstPriorityQueue <int>();
foreach (var x in a)
{
q.Push(x);
}
while (q.Count > 0)
{
actual.Add(q.Pop());
}
Array.Sort(expected);
CollectionAssert.AreEqual(expected, actual);
actual.Clear();
q = new BstPriorityQueue <int>(ComparerHelper <int> .Create(true));
foreach (var x in a)
{
q.Push(x);
}
while (q.Count > 0)
{
actual.Add(q.Pop());
}
Array.Reverse(expected);
CollectionAssert.AreEqual(expected, actual);
}
public void Keyed_1()
{
var n = 100000;
var a = RandomHelper.CreateData(n);
var actual = new List <int>();
var q = new KeyedPriorityQueue <int, int>(x => x / 10);
foreach (var x in a)
{
q.Push(x);
}
while (q.Count > 0)
{
actual.Add(q.Pop());
}
var expected = a.OrderBy(x => x / 10).ToArray();
CollectionAssert.AreEqual(expected, actual);
actual.Clear();
q = new KeyedPriorityQueue <int, int>(x => x / 10, ComparerHelper <int> .Create(true));
foreach (var x in a)
{
q.Push(x);
}
while (q.Count > 0)
{
actual.Add(q.Pop());
}
expected = a.OrderByDescending(x => x / 10).ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public void CreateComparerFromDelegate()
{
var source = new List <int> {
1, 2, 3, 0, 4, 5, 6, 7
};
var comparer = ComparerHelper.CreateComparer <int>(
(x, y) =>
{
if (x == 0)
{
return(y == 0 ? 0 : -1);
}
if (y == 0)
{
return(1);
}
return(y.CompareTo(x));
});
var sorted = source.OrderBy(x => x, comparer).ToList();
var expected = new List <int> {
0, 7, 6, 5, 4, 3, 2, 1
};
CollectionAssert.AreEqual(expected, sorted);
}
public void CommonComparer_Test()
{
var testers = Generate();
var testersOrdered = testers.OrderBy(m => m.Id).ToArray();
var comparer = ComparerHelper.Create <Tester>((x, y) => Comparer <int> .Default.Compare(x.Id, y.Id));
var sortList = new SortedSet <Tester>(testers, comparer);
Assert.True(testersOrdered.SequenceEqual(sortList));
}
public void KeyComparer_Test()
{
var testers = Generate();
var testersOrdered = testers.OrderBy(m => m.Id).ToArray();
var comparer = ComparerHelper.Create <Tester, int>(m => m.Id);
var sortList = new SortedSet <Tester>(testers, comparer);
Assert.True(testersOrdered.SequenceEqual(sortList));
}
public void Test()
{
TestA a = new TestA()
{
Name = null
};
TestA b = new TestA()
{
Name = "",
};
var list = ComparerHelper.GetFieldModityRecords <TestA>(a, b);
}
public void Create()
{
var n = 100000;
var expected = RandomHelper.CreateData(n);
var actual = (int[])expected.Clone();
Array.Sort(expected);
Array.Sort(actual, ComparerHelper <int> .Create());
CollectionAssert.AreEqual(expected, actual);
Array.Reverse(expected);
Array.Sort(actual, ComparerHelper <int> .Create(true));
CollectionAssert.AreEqual(expected, actual);
}
public void Create_Key2()
{
var n = 100000;
var a = RandomHelper.CreateData(n);
var actual = (int[])a.Clone();
var expected = a.OrderBy(x => x.ToString().Length).ThenByDescending(x => x).ToArray();
Array.Sort(actual, ComparerHelper <int> .Create(x => x.ToString().Length, false, x => x, true));
CollectionAssert.AreEqual(expected, actual);
Array.Reverse(expected);
Array.Sort(actual, ComparerHelper <int> .Create(x => x.ToString().Length, true, x => x, false));
CollectionAssert.AreEqual(expected, actual);
}
public void Create_Key1()
{
var n = 100000;
var a = RandomHelper.CreateData(n);
var actual = (int[])a.Clone();
var expected = a.OrderBy(x => x.ToString()).ToArray();
Array.Sort(actual, ComparerHelper <int> .Create(x => x.ToString()));
CollectionAssert.AreEqual(expected, actual);
Array.Reverse(expected);
Array.Sort(actual, ComparerHelper <int> .Create(x => x.ToString(), true));
CollectionAssert.AreEqual(expected, actual);
}
public void Min_ShouldReturnCorrectValue(
int year1,
int year2,
int expectedYear)
{
//arrange
var date1 = new DateTimeOffset(year1, 1, 1, 1, 1, 1, TimeSpan.Zero);
var date2 = new DateTimeOffset(year2, 1, 1, 1, 1, 1, TimeSpan.Zero);
var expected = new[] { date1, date2 }.First(d => d.Year == expectedYear);
//act
var actual = ComparerHelper.Min(date1, date2);
//assert
actual.Should().Be(expected);
}
public static FilterDefinition GetFilter(string expression)
{
if (string.IsNullOrWhiteSpace(expression))
{
return(null);
}
expression = expression.Replace(" ", " ");
expression = expression.Trim();
var trysymbol = GetFilterBySymbol(expression);
if (trysymbol != null)
{
return(trysymbol);
}
FilterDefinition filter = new FilterDefinition();
int index = expression.IndexOf(" ");
if (index == -1)
{
filter.FieldName = expression;
filter.Comparer = Comparer.EqualTo;
filter.FieldValue = "true";
}
else
{
filter.FieldName = expression.Substring(0, index);
var nextindex = expression.IndexOf(" ", index + 1);
if (nextindex == -1)
{
string compare = expression.Substring(index).Trim();
filter.Comparer = ComparerHelper.GetComparer(compare);
}
else
{
string compare = expression.Substring(index, nextindex - index);
filter.Comparer = ComparerHelper.GetComparer(compare);
filter.FieldValue = expression.Substring(nextindex).Trim();
}
}
return(filter);
}
public HashSet(int c, Generic.IEqualityComparer <T> comparer)
{
#if DEBUG
if (comparer == null)
{
throw new ArgumentNullException("comparer should not be null!");
}
#endif
m_comparer = comparer ?? ComparerHelper.GetComparer <T>();
m_lastIndex = 0;
Count = 0;
m_freeList = -1;
int prime = HashHelpers.GetPrime(c);
m_buckets = new int[prime];
m_slots = new Slot[prime];
}
/// <summary>
/// Find the index of a rectangle that contains the specified point.
/// </summary>
/// <param name="point">the target point</param>
/// <returns>the rectangle index</returns>
private int FindRectangleIndex(ScreenPoint point)
{
IComparer <OxyRect> comparer;
if (this.IsTransposed())
{
comparer = ComparerHelper.CreateComparer <OxyRect>(
(x, y) =>
{
if (x.Bottom < point.Y)
{
return(1);
}
if (x.Top > point.Y)
{
return(-1);
}
return(0);
});
}
else
{
comparer = ComparerHelper.CreateComparer <OxyRect>(
(x, y) =>
{
if (x.Right < point.X)
{
return(-1);
}
if (x.Left > point.X)
{
return(1);
}
return(0);
});
}
return(this.rectangles.BinarySearch(0, this.rectangles.Count, new OxyRect(), comparer));
}
/// <summary>
/// Find the index of a rectangle that contains the specified point.
/// </summary>
/// <param name="point">the target point</param>
/// <returns>the rectangle index</returns>
private int FindRectangleIndex(ScreenPoint point)
{
var comparer = ComparerHelper.CreateComparer <OxyRect>(
(x, y) =>
{
if (x.Right < point.X)
{
return(-1);
}
if (x.Left > point.X)
{
return(1);
}
return(0);
});
return(this.rectangles.BinarySearch(0, this.rectangles.Count, new OxyRect(), comparer));
}
public static FilterDefinition GetFilterBySymbol(string expression)
{
foreach (var item in ComparerList)
{
int index = expression.IndexOf(item);
if (index > -1)
{
FilterDefinition filter = new FilterDefinition();
filter.FieldName = expression.Substring(0, index).Trim();
filter.FieldValue = expression.Substring(index + item.Length).Trim();
filter.Comparer = ComparerHelper.GetComparer(item);
return(filter);
}
}
return(null);
}
public int Compare(int[] left, int[] right)
{
return(ComparerHelper.CompareEmptyOrNull(left, right) ?? left.Max().CompareTo(right.Max()));
}
public int Compare(int[] left, int[] right)
{
return(ComparerHelper.CompareEmptyOrNull(right, left) ?? right.Min().CompareTo(left.Min()));
}
public static bool Check(string FieldValue, Comparer Comparer, string CompareValue, Type ClrType = null)
{
if (ClrType == null)
{
ClrType = ComparerHelper.DetermineCompareType(FieldValue, CompareValue);
}
if (ClrType == null)
{
return(false);
}
if (Comparer == Comparer.EqualTo)
{
return(Lib.Helper.StringHelper.IsSameValue(FieldValue, CompareValue));
}
else if (Comparer == Comparer.NotEqualTo)
{
return(!Lib.Helper.StringHelper.IsSameValue(FieldValue, CompareValue));
}
else if (Comparer == Comparer.Contains)
{
return(FieldValue.Contains(CompareValue));
}
else if (Comparer == Comparer.StartWith)
{
return(FieldValue.StartsWith(CompareValue));
}
else
{
try
{
var value = Convert.ChangeType(FieldValue, ClrType);
var tovale = Convert.ChangeType(CompareValue, ClrType);
if (Comparer == Comparer.GreaterThan)
{
if (value != null && value is IComparable && tovale is IComparable)
{
return(((IComparable)value).CompareTo((IComparable)tovale) > 0);
}
}
else if (Comparer == Comparer.GreaterThanOrEqual)
{
if (value != null && value is IComparable && tovale is IComparable)
{
return(((IComparable)value).CompareTo((IComparable)tovale) >= 0);
}
}
else if (Comparer == Comparer.LessThan)
{
if (value != null && value is IComparable && tovale is IComparable)
{
return(((IComparable)value).CompareTo((IComparable)tovale) < 0);
}
}
else if (Comparer == Comparer.LessThanOrEqual)
{
if (value != null && value is IComparable && tovale is IComparable)
{
return(((IComparable)value).CompareTo((IComparable)tovale) <= 0);
}
}
}
catch (Exception)
{
return(false);
}
}
return(true);
}
