/// <summary>
/// 数组排序
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <param name="values">待排序数组</param>
/// <param name="getKey">排序键值获取器</param>
/// <param name="startIndex">起始位置</param>
/// <param name="count">排序数据数量</param>
/// <returns>排序后的数组</returns>
public static valueType[] GetSortDesc <valueType>(valueType[] values, Func <valueType, ulong> getKey, int startIndex, int count)
{
int length = count * sizeof(ULongSortIndex);
AutoCSer.Memory.UnmanagedPool pool = AutoCSer.Memory.UnmanagedPool.GetPool(length);
AutoCSer.Memory.Pointer data = pool.GetMinSize(length);
try
{
return(getSortDesc(values, getKey, startIndex, count, (ULongSortIndex *)data.Data));
}
finally { pool.Push(ref data); }
}
/// <summary>
/// 排序取Top N
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <param name="values">待排序数组</param>
/// <param name="getKey">排序键值获取器</param>
/// <param name="count">排序数据数量</param>
/// <returns>排序后的数据</returns>
private static valueType[] getTopDesc <valueType>(valueType[] values, Func <valueType, ulong> getKey, int count)
{
uint sqrtMod;
int length = Math.Min(Math.Max(count << 2, count + (int)AutoCSer.Extensions.NumberExtension.sqrt((uint)values.Length, out sqrtMod)), values.Length), size = length * sizeof(ULongSortIndex);
AutoCSer.Memory.UnmanagedPool pool = AutoCSer.Memory.UnmanagedPool.GetPool(size);
AutoCSer.Memory.Pointer data = pool.GetMinSize(size);
try
{
return(getTopDesc(values, getKey, count, length, (ULongSortIndex *)data.Data));
}
finally { pool.Push(ref data); }
}
/// <summary>
/// 数组范围排序
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="returnType">返回数据类型</typeparam>
/// <param name="array">待排序数组</param>
/// <param name="getKey">排序键值获取器</param>
/// <param name="skipCount">跳过数据数量</param>
/// <param name="getCount">排序数据数量</param>
/// <param name="getValue">获取返回数据</param>
/// <returns>排序后的数组</returns>
internal static returnType[] UnsafeGetRangeSortDesc <valueType, returnType>(valueType[] array, Func <valueType, ulong> getKey, int skipCount, int getCount, Func <valueType, returnType> getValue)
{
if (getCount == 0)
{
return(EmptyArray <returnType> .Array);
}
int size = array.Length * sizeof(ULongSortIndex);
AutoCSer.Memory.UnmanagedPool pool = AutoCSer.Memory.UnmanagedPool.GetPool(size);
AutoCSer.Memory.Pointer data = pool.GetMinSize(size);
try
{
return(getRangeSortDesc(array, getKey, skipCount, getCount, getValue, (ULongSortIndex *)data.Data));
}
finally { pool.Push(ref data); }
}
/// <summary>
/// 获取匹配数组
/// </summary>
/// <param name="array">数组数据</param>
/// <param name="isValue">数据匹配器</param>
/// <returns>匹配数组</returns>
public static ulong[] getFindArray(this SubArray <ulong> array, Func <ulong, bool> isValue)
{
if (array.Length == 0)
{
return(EmptyArray <ulong> .Array);
}
int length = ((array.Length + 63) >> 6) << 3;
AutoCSer.Memory.UnmanagedPool pool = AutoCSer.Memory.UnmanagedPool.GetPool(length);
AutoCSer.Memory.Pointer data = pool.GetMinSize(length);
try
{
AutoCSer.Memory.Common.Clear(data.ULong, length >> 3);
return(FixedArray.GetFindArray(array.Array, array.Start, array.Length, isValue, new MemoryMap(data.Data)));
}
finally { pool.Push(ref data); }
}
/// <summary>
/// 数组子串排序
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <param name="array">待排序数组子串</param>
/// <param name="getKey">排序键</param>
/// <param name="index">起始位置</param>
/// <param name="count">数量</param>
/// <returns>排序后的数组</returns>
internal static valueType[] GetSortDesc <valueType>(valueType[] array, Func <valueType, ulong> getKey, int index, int count)
{
if (count >= AutoCSer.Algorithm.RadixSort.SortSize64)
{
int size = (count << 1) * sizeof(AutoCSer.Algorithm.ULongSortIndex);
AutoCSer.Memory.UnmanagedPool pool = AutoCSer.Memory.UnmanagedPool.GetPool(size);
AutoCSer.Memory.Pointer data = pool.GetMinSize(size);
try
{
AutoCSer.Algorithm.ULongSortIndex *indexFixed = (AutoCSer.Algorithm.ULongSortIndex *)data.Data;
AutoCSer.Algorithm.ULongSortIndex.Create(indexFixed, array, getKey, index, count);
AutoCSer.Algorithm.RadixSort.SortDesc(indexFixed, indexFixed + count, count);
return(AutoCSer.Algorithm.ULongSortIndex.Create(indexFixed, array, count));
}
finally { pool.Push(ref data); }
}
return(AutoCSer.Algorithm.FixedArrayQuickSort.GetSortDesc(array, getKey, index, count));
}
