private void TestQuickSortLoop(int len, int rep)
{
try {
m_stopwatch.Stop();
m_stopwatch.Reset();
for (int r = 0; r < rep; r++)
{
double[] p = ILMath.rand(1, len).m_data;
m_stopwatch.Start();
ILQuickSort.QuickSortAscSolid_IT(p, 0, len - 1, 1);
m_stopwatch.Stop();
if (!ILMath.IsSorted(p, false))
{
throw new Exception("unsorted values detected (asc). Size: " + p.Length);
}
// descending
ILQuickSort.QuickSortDescSolid_IT(p, 0, len - 1, 1);
if (!ILMath.IsSorted(p, true))
{
throw new Exception("unsorted values detected (desc). Size: " + p.Length);
}
}
Success(" elapsed: " + m_stopwatch.ElapsedMilliseconds + " ms");
} catch (Exception e) {
Error(0, e.Message);
}
}
/// <summary>
/// sort data in A along dimension 'dim'
/// </summary>
/// <param name="A">input array, n-dimensional</param>
/// <param name="descending">Specifies the direction of sorting</param>
/// <param name="dim">dimension to sort along</param>
/// <param name="Indices">output parameter: returns permutation matrix also</param>
/// <returns>sorted array of the same size as A</returns>
/// <remarks><para>The data in A will be sorted using the quick sort algorithm. Data
/// along the dimension <paramref name="dim"/> will therefore get sorted independently from data
/// in the next row/column.</para>
/// <para>This overload also returns an array 'Indices' which will hold the indices into the original
/// elements <b>after sorting</b>. Elements of 'Indices' are of type double.</para>
/// <example><code>ILArray<double> A = ILMath.rand(1,5);
/// //A:
/// // 0.4324 0.9231 0.1231 0.1423 0.2991
/// ILArray<double> I;
/// ILArray<double> R = ILMath.sort(A, out I, 1, false);
/// //R:
/// // 0.1231 0.1423 0.2991 0.4324 0.9231
/// //I:
/// // 2 3 4 0 1
/// </code>
/// </example></remarks>
public static ILArray <byte> sort(ILArray <byte> A, out ILArray <double> Indices, int dim, bool descending)
{
if (object.Equals(A, null))
{
throw new Exception("sort: parameter A must not be null");
}
if (dim < 0 || dim >= A.Dimensions.NumberOfDimensions)
{
throw new ILArgumentException("sort: invalid dimension argument");
}
// early exit: scalar/ empty
Indices = ILMath.counter(0.0, 1.0, A.Dimensions.ToIntArray());
if (A.IsEmpty || A.IsScalar)
{
return(A.C);
}
ILArray <byte> ret = A.C;
int inc = ret.Dimensions.SequentialIndexDistance(dim);
int dimLen = A.Dimensions[dim];
int maxRuns = A.Dimensions.NumberOfElements / dimLen;
int posInArr = 0;
if (descending)
{
for (int c = 0; c < maxRuns; c++)
{
if (posInArr >= A.Dimensions.NumberOfElements)
{
posInArr -= (A.Dimensions.NumberOfElements - 1);
}
ILQuickSort.QuickSortDescSolidIDX(ret.m_data, Indices.m_data, posInArr, posInArr + (dimLen - 1) * inc, inc);
posInArr += dimLen * inc;
}
}
else
{
// ascending
for (int c = 0; c < maxRuns; c++)
{
if (posInArr >= A.Dimensions.NumberOfElements)
{
posInArr -= (A.Dimensions.NumberOfElements - 1);
}
ILQuickSort.QuickSortAscSolidIDX(ret.m_data, Indices.m_data, posInArr, posInArr + (dimLen - 1) * inc, inc);
posInArr += dimLen * inc;
}
}
return(ret);
}
private void TestQuickSort(double[] p)
{
int errCode = 0;
try {
m_stopwatch.Reset();
ILQuickSort.QuickSortAscSolid_IT(p, 0, p.Length - 1, 1);
m_stopwatch.Stop();
if (!ILMath.IsSorted(p, false))
{
throw new Exception("unsorted values detected. Size: " + p.Length);
}
Success();
} catch (Exception e) {
Error(errCode, e.Message);
}
}
