/// <summary> /// sort data in A along dimension 'dim' /// </summary> /// <param name="A">input array: empty, scalar, vector or matrix</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> ///</remarks> public static ILArray <string> sort(ILArray <string> 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 (A.Dimensions.NumberOfDimensions > 2) { throw new ILArgumentException("sort: for element type string only matrices are supported!"); } if (dim < 0 || dim >= A.Dimensions.NumberOfDimensions) { throw new ILArgumentException("sort: invalid dimension argument"); } // early exit: scalar/ empty if (A.IsEmpty || A.IsScalar) { Indices = 0.0; return(A.C); } ILArray <string> ret = new ILArray <string>(new string[A.Dimensions.NumberOfElements], A.Dimensions); int dim1 = dim % A.Dimensions.NumberOfDimensions; int dim2 = (dim1 + 1) % A.Dimensions.NumberOfDimensions; int maxRuns = A.Dimensions[dim2]; ILQueueList <string, double> ql; ILArray <int>[] ind = new ILArray <int> [2]; int [] indI = new int[2]; ILASCIIKeyMapper km = new ILASCIIKeyMapper(); Indices = ILMath.counter(0.0, 1.0, A.Dimensions.ToIntArray()); for (int c = 0; c < maxRuns; c++) { ind[dim2] = c; ind[dim1] = null; ql = ILBucketSort.BucketSort <string, char, double>(A[ind].Values, Indices[ind].Values, km, ILBucketSort.SortMethod.ConstantLength); indI[dim2] = c; if (descending) { for (int i = ql.Count; i-- > 0;) { indI[dim1] = i; ILListItem <string, double> item = ql.Dequeue(); ret.SetValue(item.Data, indI); Indices.SetValue(item.m_index, indI); } } else { for (int i = 0; ql.Count > 0; i++) { indI[dim1] = i; ILListItem <string, double> item = ql.Dequeue(); ret.SetValue(item.Data, indI); Indices.SetValue(item.m_index, indI); } } } return(ret); }
/// <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); }
public IronPython.Runtime.List this[IronPython.Runtime.Slice xslice, IronPython.Runtime.Slice yslice] { get { if ((xslice.start == null) || (xslice.stop == null) || (yslice.start == null) || (yslice.stop == null)) { throw new ILArgumentException("mgrid: start and stop of slices must be provided"); } double xStep = 1, yStep = 1, xStart = 0, yStart = 0, xStop = 1, yStop = 1; // if (xslice.start is int) { xStart = (double)(int)(xslice.start); } if (xslice.start is double) { xStart = (double)(xslice.start); } if (xslice.stop is int) { xStop = (double)(int)(xslice.stop); } if (xslice.stop is double) { xStop = (double)(xslice.stop); } // if (yslice.start is int) { yStart = (double)(int)(yslice.start); } if (yslice.start is double) { yStart = (double)(yslice.start); } if (yslice.stop is int) { yStop = (double)(int)(yslice.stop); } if (yslice.stop is double) { yStop = (double)(yslice.stop); } // if (xslice.step == null) { if (xStop >= xStart) { xStep = 1; } else { xStep = -1; } } else { if (xslice.step is int) { xStep = (double)(int)(xslice.step); } if (xslice.step is double) { xStep = (double)(xslice.step); } } if (yslice.step == null) { if (yStop >= yStart) { yStep = 1; } else { yStep = -1; } } else { if (yslice.step is int) { yStep = (double)(int)(yslice.step); } if (yslice.step is double) { yStep = (double)(yslice.step); } } // IronPython.Runtime.List list = new IronPython.Runtime.List(); int nx = (int)Math.Floor((xStop - xStart) / xStep) + 1; int ny = (int)Math.Floor((yStop - yStart) / yStep) + 1; ILArray <double> x = ILMath.counter(xStart, xStep, nx); ILArray <double> y = ILMath.counter(yStart, yStep, ny); List <ILArray <double> > meshgrid = ILMath.meshgrid(x, y); list.Add(meshgrid[0]); list.Add(meshgrid[1]); return(list); } }