Add Trues type and methods (#110)

* Add Trues

* Export

* Test Trues

* Add comments

* Bump release

* Check axes

* More strings in DimensionMismatch

* Use BoundsError

* Refine errors

* Use DimensionMismatch

* Test throws

* Restrict getindex to OneTo axes

* Revert strings in throw

* Restrict setindex! to OneTo

Author: JeffFessler

Project.toml

@@ -1,6 +1,6 @@
 name = "FillArrays"
 uuid = "1a297f60-69ca-5386-bcde-b61e274b549b"
-version = "0.8.14"
+version = "0.9"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"

src/FillArrays.jl

@@ -15,7 +15,7 @@ import Base.Broadcast: broadcasted, DefaultArrayStyle, broadcast_shape
 
 
 
-export Zeros, Ones, Fill, Eye
+export Zeros, Ones, Fill, Eye, Trues, Falses
 
 """
     AbstractFill{T, N, Axes} <: AbstractArray{T, N}
@@ -269,11 +269,11 @@ for (Typ, funcs, func) in ((:Zeros, :zeros, :zero), (:Ones, :ones, :one))
             $Typ{T}(length.(kj))
         end
         function getindex(A::$Typ{T}, kr::AbstractVector{Bool}) where T
-            length(A) == length(kr) || throw(DimensionMismatch())
+            length(A) == length(kr) || throw(DimensionMismatch("lengths must match"))
             $Typ{T}(count(kr))
         end
         function getindex(A::$Typ{T}, kr::AbstractArray{Bool}) where T
-            size(A) == size(kr) || throw(DimensionMismatch())
+            size(A) == size(kr) || throw(DimensionMismatch("sizes must match"))
             $Typ{T}(count(kr))
         end
 
@@ -563,6 +563,7 @@ count(f, x::AbstractFill) = f(getindex_value(x)) ? length(x) : 0
 
 include("fillalgebra.jl")
 include("fillbroadcast.jl")
+include("trues.jl")
 
 ##
 # print

src/trues.jl

@@ -0,0 +1,50 @@
+
+"""
+    Trues = Ones{Bool, N, Axes} where {N, Axes}
+
+Lazy version of `trues` with axes.
+Typically created using `Trues(dims)` or `Trues(dims...)`
+
+# Example
+```jldoctest
+julia> Trues(1,3)
+1×3 Ones{Bool,2,Tuple{Base.OneTo{Int64},Base.OneTo{Int64}}} = true
+
+julia> Trues((2,3))
+2×3 Ones{Bool,2,Tuple{Base.OneTo{Int64},Base.OneTo{Int64}}} = true
+```
+"""
+const Trues = Ones{Bool, N, Axes} where {N, Axes}
+
+
+""" `Falses = Zeros{Bool, N, Axes}` (see `Trues`) """
+const Falses = Zeros{Bool, N, Axes} where {N, Axes}
+
+
+# y[mask] = x when mask isa Trues (cf y[:] = x)
+# Supported here only for arrays with standard OneTo axes.
+function Base.setindex!(y::AbstractArray{T,N}, x,
+    mask::Trues{N, NTuple{N,Base.OneTo{Int}}},
+) where {T,N}
+    if axes(x) isa NTuple{N,Base.OneTo{Int}} &&
+       axes(y) isa NTuple{N,Base.OneTo{Int}}
+        @boundscheck size(y) == size(mask) || throw(BoundsError(y, mask))
+        @boundscheck size(x) == size(mask) || throw(DimensionMismatch(
+            "tried to assign $(length(x)) elements to $(length(y)) destinations"))
+        @boundscheck checkbounds(y, mask)
+        return copyto!(y, x)
+    end
+    return setindex!(y, x, trues(size(mask))) # fall back on usual setindex!
+end
+
+# x[mask] when mask isa Trues (cf x[trues(size(x))] or x[:])
+# Supported here only for arrays with standard OneTo axes.
+function Base.getindex(x::AbstractArray{T,N},
+    mask::Trues{N, NTuple{N,Base.OneTo{Int}}},
+) where {T,N}
+    if axes(x) isa NTuple{N,Base.OneTo{Int}} where N
+       @boundscheck size(x) == size(mask) || throw(BoundsError(x, mask))
+       return vec(x)
+    end
+    return x[trues(size(x))] # else revert to usual getindex method
+end

test/runtests.jl

@@ -1015,3 +1015,18 @@ end
         @test axes(U) == (Base.OneTo(3),Base.OneTo(3))
     end
 end
+
+@testset "Trues" begin
+    @test Trues(2,3) == Trues((2,3)) == trues(2,3)
+    @test Falses(2,3) == Falses((2,3)) == falses(2,3)
+    dim = (4,5)
+    mask = Trues(dim)
+    x = randn(dim)
+    @test x[mask] == vec(x) # getindex
+    y = similar(x)
+    y[mask] = x # setindex!
+    @test y == x
+    @test_throws BoundsError ones(3)[Trues(2)]
+    @test_throws BoundsError setindex!(ones(3), zeros(3), Trues(2))
+    @test_throws DimensionMismatch setindex!(ones(2), zeros(3), Trues(2))
+end