References
FunctionIndices.AbstractFunctionIndex
— TypeAbstractFunctionIndex
Supertype of all function index types.
FunctionIndices.AbstractNotIndex
— TypeAbstractNotIndex{T}
Supertype of all not types which create by not
.
FunctionIndices.FunctionIndex
— TypeFunctionIndex{F} <: AbstractFunctionIndex
FI
A implementation of function index, which make indexing with function possible. 1-d indexing A[FI(f)]
is equivalent to A[map(f, begin:end)]
, multi-dimensional indexing A[FI(f1), ..., FI(fn)]
is equivalent to A[map(FI(f1), axes(A, 1)), ..., map(FI(fn), axes(A, n))]
.
FunctionIndices.NotIndex
— TypeNotIndex{T} <: AbstractNotIndex{T}
The default implementation of not
. There are some optimization for NotIndex(x)
comparing to FI(!in(x))
. For large arrays, this implementation may be faster. but for small arrays this implementation may be slower. See performance comparing for more details.
FunctionIndices.indextype
— Methodindextype([A::AbstractArray,] I::AbstractFunctionIndex)
indextype([::Type{TA},] ::Type{TI})
Determine the index type which the function index type TI
will be converted to by Base.to_indices
for array type TA
. By default, it's AbstractArray
.
If you define a methods indextype(::Type{TA}, ::Type{TI}) = T
, while to_index(::Type{T}, inds, I::TI)
is not defined, the to_indices
will not convert a index of type TI
to a T
, but a Base.LogicalIndex
, the default return type of to_index
.
FunctionIndices.not
— Methodnot(x)
Create a NotIndex
with given x
, which is similar to Not
of InvertedIndices
. In most cases, not
is much faster than Not
. See performance comparing for more details.
Main differences between not
and Not
For CartesianIndex
, A[not(CartesianIndex(i, j,..., n))]
is equivalent to A[not(i), not(j), ..., not(n)]
and will return a array with same dimension, but A[Not(CartesianIndex(i, j,..., n))]
will convert the CartesianIndex
to a linear index and return a vector:
julia> A = reshape(1:12, 3, 4)
3×4 reshape(::UnitRange{Int64}, 3, 4) with eltype Int64:
0 3 6 9
1 4 7 10
2 5 8 11
julia> A[not(CartesianIndex(1, 2))] # equivalent to A[not(1), not(2)]
2×3 Matrix{Int64}:
1 7 10
2 8 11
julia> A[Not(CartesianIndex(1, 2))] # equivalent to A[Not(3)]
11-element Vector{Int64}:
0
1
2
4
5
⋮
8
9
10
11
Besides, for index like A[4, 5]
which is out of bounds, A[not(4), not(5)]
is equivalent to A[:, :]
, because inbounds indices are always not equal to the given value, while A[Not[4], Not(5)]
causes an error.
FunctionIndices.notin
— Methodnotin(item, collection)
notin(collection)
The same as !in
, used in the default to_function
for AbstractNotIndex
.
FunctionIndices.to_function
— Functionto_function(I::AbstractFunctionIndex)
Converts a AbstractFunctionIndex
to a Function
. By default, to_function(I::AbstractNotIndex)
returns notin(parent(I))
.
FunctionIndices.to_index
— MethodFunctionIndices.to_index(::Type{T<:AbstractArray}, A, ind, i)
Convert a AbstractFunctionIndex
i
to a array index of type T
for A
with ind
. By default, to_index(::AbstractArray, ind, i)
will return a Base.LogicalIndex{Bool, ReadonlyMappedArray{Bool...}}
.