minimum/maximum/issorted for RangeCumSum of AbstractUnitRange (#221)

* minimum/maximum/issorted for RangeCumSum of AbstractUnitRange

* Restrict issorted to integer AbstractUnitRanges

* Tests for infinite ranges

Author: jishnub

src/cumsum.jl

@@ -64,16 +64,52 @@ union(a::RangeCumsum{<:Any,<:OneTo}, b::RangeCumsum{<:Any,<:OneTo}) =
 
 sort!(a::RangeCumsum{<:Any,<:Base.OneTo}) = a
 sort(a::RangeCumsum{<:Any,<:Base.OneTo}) = a
+Base.issorted(a::RangeCumsum{<:Any,<:Base.OneTo}) = true
+function Base.issorted(a::RangeCumsum{<:Any,<:AbstractUnitRange{<:Integer}})
+    r = parent(a)
+    r2 = r[firstindex(r):searchsortedlast(r, zero(eltype(r)))]
+    # at max one negative value is allowed
+    length(r2) <= 1 + (last(r) >= 0)
+end
+
+function Base.minimum(a::RangeCumsum{<:Any, <:OneTo})
+    isempty(a) && throw(ArgumentError("RangeCumsum must be non-empty"))
+    first(a)
+end
+function Base.maximum(a::RangeCumsum{<:Any, <:OneTo})
+    isempty(a) && throw(ArgumentError("RangeCumsum must be non-empty"))
+    last(a)
+end
+function Base.maximum(a::RangeCumsum{<:Any, <:AbstractUnitRange{<:Integer}})
+    isempty(a) && throw(ArgumentError("RangeCumsum must be non-empty"))
+    r = parent(a)
+    if -first(r) in r
+        r2 = r[searchsortedfirst(r, -first(r)+1):end]
+        max(zero(eltype(r)), sum(r2))
+    else
+        max(first(r), sum(r))
+    end
+end
+function Base.minimum(a::RangeCumsum{<:Any, <:AbstractUnitRange{<:Integer}})
+    isempty(a) && throw(ArgumentError("RangeCumsum must be non-empty"))
+    r = parent(a)
+    if zero(eltype(r)) in r
+        r2 = r[firstindex(r):searchsortedlast(r, zero(eltype(r)))]
+        min(sum(r2), zero(eltype(r)))
+    else
+        min(first(r), sum(r))
+    end
+end
 
 convert(::Type{RangeCumsum{T,R}}, r::RangeCumsum) where {T,R} = RangeCumsum{T,R}(convert(R, r.range))
 
-function Broadcast.broadcasted(::Broadcast.DefaultArrayStyle{1}, ::typeof(-), r::RangeCumsum)
+function Broadcast.broadcasted(::typeof(-), r::RangeCumsum)
     RangeCumsum(.-r.range)
 end
-function Broadcast.broadcasted(::Broadcast.DefaultArrayStyle{1}, ::typeof(*), x::Number, r::RangeCumsum)
+function Broadcast.broadcasted(::typeof(*), x::Number, r::RangeCumsum)
     RangeCumsum(x * r.range)
 end
-function Broadcast.broadcasted(::Broadcast.DefaultArrayStyle{1}, ::typeof(*), r::RangeCumsum, x::Number)
+function Broadcast.broadcasted(::typeof(*), r::RangeCumsum, x::Number)
     RangeCumsum(r.range * x)
 end
 

test/infinitearrays.jl

@@ -11,6 +11,7 @@ module InfiniteArrays
     Base.axes(r::AbstractInfUnitRange) = (OneToInf(),)
 
     Base.IteratorSize(::Type{<:AbstractInfUnitRange}) = Base.IsInfinite()
+    Base.sum(r::AbstractInfUnitRange) = last(r)
 
     """
         OneToInf(n)
@@ -26,6 +27,7 @@ module InfiniteArrays
     Base.first(r::OneToInf{T}) where {T} = oneunit(T)
     Base.oneto(::InfiniteCardinal{0}) = OneToInf()
 
+
     struct InfUnitRange{T<:Real} <: AbstractInfUnitRange{T}
         start::T
     end
@@ -34,8 +36,16 @@ module InfiniteArrays
     InfUnitRange{T}(a::AbstractInfUnitRange) where T<:Real = InfUnitRange{T}(first(a))
     InfUnitRange(a::AbstractInfUnitRange{T}) where T<:Real = InfUnitRange{T}(first(a))
     Base.:(:)(start::T, stop::InfiniteCardinal{0}) where {T<:Integer} = InfUnitRange{T}(start)
-    function getindex(v::InfUnitRange{T}, i::Integer) where T
-        @boundscheck i > 0 || Base.throw_boundserror(v, i)
+    function Base.getindex(v::InfUnitRange{T}, i::Integer) where T
+        @boundscheck i > 0 || throw(BoundsError(v, i))
         convert(T, first(v) + i - 1)
     end
+    function Base.getindex(v::InfUnitRange{T}, i::AbstractUnitRange{<:Integer}) where T
+        @boundscheck checkbounds(v, i)
+        v[first(i)]:v[last(i)]
+    end
+    function Base.getindex(v::InfUnitRange{T}, i::AbstractInfUnitRange{<:Integer}) where T
+        @boundscheck checkbounds(v, first(i))
+        v[first(i)]:ℵ₀
+    end
 end

test/test_cumsum.jl

@@ -1,6 +1,6 @@
 module TestCumsum
 
-using ArrayLayouts, Test
+using ArrayLayouts, Test, Infinities
 
 include("infinitearrays.jl")
 
@@ -84,6 +84,46 @@ cmpop(p) = isinteger(real(first(p))) && isinteger(real(step(p))) ? (==) : (≈)
             test_broadcast(3.5 + 2im, r)
         end
     end
+
+    @testset "issorted" begin
+        @testset "RangeCumsum($start:$stop)" for start in -15:15, stop in start-1:20
+            a = RangeCumsum(start:stop)
+            v = Vector(a)
+            @test issorted(a) == issorted(v)
+        end
+        a = RangeCumsum(Base.OneTo(4))
+        @test issorted(a)
+        a = RangeCumsum(Base.OneTo(0))
+        @test issorted(a)
+    end
+
+    @testset "minimum/maximum" begin
+        @testset "RangeCumsum($start:$stop)" for start in -15:15, stop in start:20
+            a = RangeCumsum(start:stop)
+            v = Vector(a)
+            @test minimum(a) == minimum(v)
+            @test maximum(a) == maximum(v)
+        end
+        a = RangeCumsum(2:1)
+        @test_throws ArgumentError minimum(a)
+        @test_throws ArgumentError maximum(a)
+
+        a = RangeCumsum(Base.OneTo(4))
+        @test maximum(a) == 10
+        @test minimum(a) == 1
+        a = RangeCumsum(Base.OneTo(0))
+        @test_throws ArgumentError minimum(a)
+        @test_throws ArgumentError maximum(a)
+
+        @testset "infinite" begin
+            r = RangeCumsum(-5:ℵ₀)
+            @test maximum(r) == ℵ₀
+            @test minimum(r) == minimum(RangeCumsum(-5:5))
+            r = RangeCumsum(InfiniteArrays.OneToInf())
+            @test maximum(r) == ℵ₀
+            @test minimum(r) == 1
+        end
+    end
 end
 
 end