add sort(A,dim), sortrows, and sortcols. closes #2484

Author: JeffBezanson

base/exports.jl

@@ -532,6 +532,8 @@ export
     sortby,
     sortby!,
     sortperm,
+    sortrows,
+    sortcols,
     squeeze,
     step,
     stride,

base/sort.jl

@@ -408,3 +408,42 @@ sort!{O<:Direct,T<:Floats}(v::Vector{Int}, a::Algorithm, o::Perm{O,Vector{T}}) =
 end # module Sort.Float
 
 end # module Sort
+
+# sorting multi-dimensional arrays
+sort(A::AbstractArray, dim::Integer, o::Base.Sort.Ordering = Base.Sort.Forward(),
+     alg::Base.Sort.Algorithm = DEFAULT_STABLE) =
+    mapslices(sort, A, [dim])
+
+sort(A::AbstractArray, dim::Integer, alg::Base.Sort.Algorithm) =
+    sort(A, dim, Base.Sort.Forward(), alg)
+
+sort(A::AbstractArray, dim::Integer, alg::Base.Sort.Algorithm, o::Base.Sort.Ordering) =
+    sort(A, dim, o, alg)
+
+function sortrows(A::AbstractMatrix, o::Base.Sort.Ordering = Base.Sort.Forward(),
+                  alg::Base.Sort.Algorithm = DEFAULT_STABLE)
+    c = 1:size(A,2)
+    rows = [ sub(A,i,c) for i=1:size(A,1) ]
+    p = sortperm(rows, o, alg)
+    A[p,:]
+end
+
+sortrows(A::AbstractMatrix, alg::Base.Sort.Algorithm) =
+    sortrows(A, Base.Sort.Forward(), alg)
+
+sortrows(A::AbstractMatrix, alg::Base.Sort.Algorithm, o::Base.Sort.Ordering) =
+    sortrows(A, o, alg)
+
+function sortcols(A::AbstractMatrix, o::Base.Sort.Ordering = Base.Sort.Forward(),
+                  alg::Base.Sort.Algorithm = DEFAULT_STABLE)
+    r = 1:size(A,1)
+    cols = [ sub(A,r,i) for i=1:size(A,2) ]
+    p = sortperm(cols, o, alg)
+    A[:,p]
+end
+
+sortcols(A::AbstractMatrix, alg::Base.Sort.Algorithm) =
+    sortcols(A, Base.Sort.Forward(), alg)
+
+sortcols(A::AbstractMatrix, alg::Base.Sort.Algorithm, o::Base.Sort.Ordering) =
+    sortcols(A, o, alg)

doc/stdlib/base.rst

@@ -485,7 +485,7 @@ Set-Like Collections
 
 .. function:: IntSet(i...)
 
-   Construct an ``IntSet`` of the given integers. Implemented as a bit string, and therefore good for dense integer sets.
+   Construct an ``IntSet`` of the given integers. Implemented as a bit string, and therefore designed for dense integer sets. If the set will be sparse (for example holding a single very large integer), use ``Set`` instead.
 
 .. function:: union(s1,s2...)
 

doc/stdlib/sort.rst

@@ -133,6 +133,18 @@ Sort Functions
    ``Sort.MergeSort``, or ``Sort.TimSort``), and ``ord`` to sort with
    a custom ordering (e.g., Sort.Reverse or a comparison function).
 
+.. function:: sort(A, dim, [alg[, ord]])
+
+   Sort a multidimensional array ``A`` along the given dimension.
+
+.. function:: sortrows(A, [alg[, ord]])
+
+   Sort the rows of matrix ``A`` lexicographically.
+
+.. function:: sortcols(A, [alg[, ord]])
+
+   Sort the columns of matrix ``A`` lexicographically.
+
 -------------------------
 Sorting-related Functions
 -------------------------

src/sys.c

@@ -206,23 +206,23 @@ DLLEXPORT double jl_stat_atime(char *statbuf)
 
 DLLEXPORT double jl_stat_mtime(char *statbuf)
 {
-  uv_statbuf_t *s;
-  s = (uv_statbuf_t*) statbuf;
+    uv_statbuf_t *s;
+    s = (uv_statbuf_t*) statbuf;
 #if defined(__WIN32__)
-  return (double)s->st_mtime;
+    return (double)s->st_mtime;
 #else
-  return (double)s->st_MTIM.tv_sec + (double)s->st_MTIM.tv_nsec * 1e-9;
+    return (double)s->st_MTIM.tv_sec + (double)s->st_MTIM.tv_nsec * 1e-9;
 #endif
 }
 
 DLLEXPORT double jl_stat_ctime(char *statbuf)
 {
-  uv_statbuf_t *s;
-  s = (uv_statbuf_t*) statbuf;
+    uv_statbuf_t *s;
+    s = (uv_statbuf_t*) statbuf;
 #if defined(__WIN32__)
-  return (double)s->st_ctime;
+    return (double)s->st_ctime;
 #else
-  return (double)s->st_CTIM.tv_sec + (double)s->st_CTIM.tv_nsec * 1e-9;
+    return (double)s->st_CTIM.tv_sec + (double)s->st_CTIM.tv_nsec * 1e-9;
 #endif
 }
 
@@ -351,7 +351,7 @@ DLLEXPORT int jl_cpu_cores(void)
 // Returns time in nanosec
 DLLEXPORT uint64_t jl_hrtime(void)
 {
-  return uv_hrtime();
+    return uv_hrtime();
 }
 
 // -- iterating the environment --

test/arrayops.jl

@@ -398,3 +398,34 @@ let
         @test a2[i] == a[I[i]]
     end
 end
+
+# sort on arrays
+begin
+    local a = rand(3,3)
+
+    asr = sortrows(a)
+    @test isless(asr[1,:],asr[2,:])
+    @test isless(asr[2,:],asr[3,:])
+
+    asc = sortcols(a)
+    @test isless(asc[:,1],asc[:,2])
+    @test isless(asc[:,2],asc[:,3])
+
+    asr = sortrows(a, Sort.Reverse())
+    @test isless(asr[2,:],asr[1,:])
+    @test isless(asr[3,:],asr[2,:])
+
+    asc = sortcols(a, Sort.Reverse())
+    @test isless(asc[:,2],asc[:,1])
+    @test isless(asc[:,3],asc[:,2])
+
+    as = sort(a, 1)
+    @test issorted(as[:,1])
+    @test issorted(as[:,2])
+    @test issorted(as[:,3])
+
+    as = sort(a, 2)
+    @test issorted(as[1,:])
+    @test issorted(as[2,:])
+    @test issorted(as[3,:])
+end