Gridap.Arrays
Gridap.Arrays
— ModuleThis module provides:
- An extension of the
AbstractArray
interface in order to properly deal with mutable caches. - A mechanism to generate lazy arrays resulting from operations between arrays.
- A collection of concrete implementations of
AbstractArray
.
The exported names in this module are:
AddEntriesMap
AppendedArray
AutoDiffMap
Broadcasting
CachedArray
CachedMatrix
CachedVector
CompressedArray
ConfigMap
DualizeMap
FilterMap
IdentityVector
KeyToValMap
LazyArray
Map
MulAddMap
Operation
PosNegPartition
PosNegReindex
Reindex
Table
TouchEntriesMap
TreeNode
UNSET
VectorWithEntryInserted
VectorWithEntryRemoved
append_ptrs
append_ptrs!
append_tables_globally
append_tables_locally
array_cache
autodiff_array_gradient
autodiff_array_hessian
autodiff_array_jacobian
collect1d
empty_table
evaluate
evaluate!
find_inverse_index_map
find_inverse_index_map!
find_local_index
flatten_partition
generate_data_and_ptrs
get_array
get_data_eltype
get_local_item
get_ptrs_eltype
getindex!
identity_table
inverse_map
lazy_append
lazy_map
lazy_split
length_to_ptrs!
pair_arrays
print_op_tree
return_cache
return_type
return_value
rewind_ptrs!
setsize!
similar_tree_node
test_array
test_map
testargs
testitem
testvalue
unpair_arrays
∑
Gridap.Arrays.UNSET
— ConstantGridap.Arrays.Broadcasting
— TypeBroadcasting(f)
Returns a mapping that represents the "broadcasted" version of the function f
.
Example
using Gridap.Arrays
a = [3,2]
b = [2,1]
bm = Broadcasting(+)
c = evaluate(bm,a,b)
println(c)
# output
[5, 3]
Gridap.Arrays.CachedArray
— Typemutable struct CachedArray{T, N, A<:AbstractArray{T, N}} <: AbstractArray{T, N}
Type providing a re-sizable array.
The size of a CachedArray
is changed via the setsize!
function.
A CachedArray
can be build with the constructors
using Gridap.Arrays
# Create an empty CachedArray
a = CachedArray(Float64,2)
# Resize to new shape (2,3)
setsize!(a,(2,3))
size(a)
# output
(2, 3)
Gridap.Arrays.CachedArray
— MethodCachedArray(T,N)
Constructs an empty CachedArray
of element type T
and N
dimensions.
Gridap.Arrays.CachedArray
— MethodCachedArray(a::AbstractArray)
Constructs a CachedArray
from a given array.
Gridap.Arrays.CachedMatrix
— Typeconst CachedMatrix{T,A} = CachedArray{T,2,A}
Gridap.Arrays.CachedMatrix
— MethodCachedMatrix(a)
Gridap.Arrays.CachedMatrix
— MethodCachedMatrix(T)
Gridap.Arrays.CachedVector
— Typeconst CachedVector{T,A} = CachedArray{T,1,A}
Gridap.Arrays.CachedVector
— MethodCachedVector(a)
Gridap.Arrays.CachedVector
— MethodCachedVector(T)
Gridap.Arrays.CompressedArray
— Typestruct CompressedArray{T,N,A,P} <: AbstractArray{T,N}
values::A
ptrs::P
end
Type representing an array with a reduced set of values. The array is represented by a short array of values, namely the field values
, and a large array of indices, namely the field ptrs
. The i
-th component of the resulting array is defined as values[ptrs[i]]
. The type parameters A
, and P
are restricted to be array types by the inner constructor of this struct
.
Gridap.Arrays.CompressedArray
— MethodCompressedArray(values::AbstractArray,ptrs::AbstractArray)
Creates a CompressedArray
object by the given arrays of values
and ptrs
.
Gridap.Arrays.IdentityVector
— TypeGridap.Arrays.LazyArray
— TypeSubtype of AbstractArray
which is the result of lazy_map
. It represents the result of lazy_mapping a Map
to a set of arrays that contain the mapping arguments. This struct makes use of the cache provided by the mapping in order to compute its indices (thus allowing to prevent allocation). The array is lazy, i.e., the values are only computed on demand. It extends the AbstractArray
API with two methods:
array_cache(a::AbstractArray)
getindex!(cache,a::AbstractArray,i...)
Gridap.Arrays.Map
— TypeAbstract type representing a function (mapping) that provides a cache and an in-place evaluation for performance. This is the type to be used in the lazy_map
function.
Derived types must implement the following method:
and optionally these ones:
The mapping interface can be tested with the test_map
function.
Note that most of the functionality implemented in terms of this interface relies in duck typing. That is, it is not strictly needed to work with types that inherit from Map
. This is specially useful in order to accommodate existing types into this framework without the need to implement a wrapper type that inherits from Map
. For instance, a default implementation is available for Function
objects. However, we recommend that new types inherit from Map
.
Gridap.Arrays.Operation
— TypeOperation(op)
Returns the map that results after applying an operation f
over a set of map(s) args
. That is Operation(f)(args)(x...)
is formally defined as f(map(a->a(x...),args)...)
.
Example
using Gridap.Arrays
fa(x) = x.*x
fb(x) = sqrt.(x)
x = collect(0:5)
fab = Operation(fa)(fb)
c = evaluate(fab,x)
println(c)
# output
[0.0, 1.0, 2.0, 3.0, 4.0, 5.0]
Gridap.Arrays.OperationMap
— TypeOperationMap(f,args)
Returns a mapping that represents the result of applying the function f
to the arguments in the tuple args
. That is, OperationMap(f,args)(x...)
is formally defined as f(map(a->a(x...),args)...)
Gridap.Arrays.PosNegPartition
— Typestruct representing a binary partition of a range of indices
Using this allows one to do a number of important optimizations when working with PosNegReindex
Gridap.Arrays.PosNegReindex
— TypePosNegReindex(values_pos,values_neg)
Gridap.Arrays.Reindex
— TypeReindex(values) -> Map
Gridap.Arrays.SubVector
— Typestruct SubVector{T,A<:AbstractVector{T}} <: AbstractVector{T}
vector::A
pini::Int
pend::Int
end
SubVector
is deprecated, use view
instead.
Gridap.Arrays.Table
— Type struct Table{T,Vd<:AbstractVector{T},Vp<:AbstractVector} <: AbstractVector{Vector{T}}
data::Vd
ptrs::Vp
end
Type representing a list of lists (i.e., a table) in compressed format.
Gridap.Arrays.Table
— MethodTable(a::AbstractArray{<:AbstractArray})
Build a table from a vector of vectors. If the inputs are multidimensional arrays instead of vectors, they are flattened.
Gridap.Arrays.append_ptrs!
— MethodGridap.Arrays.append_ptrs
— Methodappend_ptrs(pa,pb)
Append two vectors of pointers.
Gridap.Arrays.append_tables_globally
— MethodGridap.Arrays.append_tables_locally
— MethodGridap.Arrays.append_tables_locally
— Methodappend_tables_locally(tables::Table...)
Gridap.Arrays.array_cache
— Methodarray_cache(a::AbstractArray)
Returns a cache object to be used in the getindex!
function. It defaults to
array_cache(a::T) where T = nothing
for types T
such that uses_hash(T) == Val(false)
, and
function array_cache(a::T) where T
hash = Dict{UInt,Any}()
array_cache(hash,a)
end
for types T
such that uses_hash(T) == Val(true)
, see the uses_hash
function. In the later case, the type T
should implement the following signature:
array_cache(hash::Dict,a::AbstractArray)
where we pass a dictionary (i.e., a hash table) in the first argument. This hash table can be used to test if the object a
has already built a cache and re-use it as follows
id = objectid(a)
if haskey(hash,id)
cache = hash[id] # Reuse cache
else
cache = ... # Build a new cache depending on your needs
hash[id] = cache # Register the cache in the hash table
end
This mechanism is needed, e.g., to re-use intermediate results in complex lazy operation trees. In multi-threading computations, a different hash table per thread has to be used in order to avoid race conditions.
Gridap.Arrays.collect1d
— Methodcollect1d(a)
Equivalent to
[a[i] for in 1:length(a)]
Gridap.Arrays.empty_table
— Methodempty_table(::Type{T},::Type{P}, l::Integer) where {T,P}
empty_table(l::Integer)
Gridap.Arrays.evaluate!
— Methodevaluate!(cache,f,x...)
Applies the mapping f
at the arguments x...
using the scratch data provided in the given cache
object. The cache
object is built with the return_cache
function using arguments of the same type as in x
. In general, the returned value y
can share some part of its state with the cache
object. If the result of two or more calls to this function need to be accessed simultaneously (e.g., in multi-threading), create and use several cache
objects (e.g., one cache per thread).
Gridap.Arrays.evaluate
— Methodevaluate(f,x...)
evaluates the mapping f
at the arguments in x
by creating a temporary cache internally. This functions is equivalent to
cache = return_cache(f,x...)
evaluate!(cache,f,x...)
Gridap.Arrays.find_inverse_index_map
— FunctionGridap.Arrays.find_inverse_index_map!
— MethodGridap.Arrays.find_local_index
— Methodfind_local_index(a_to_b, b_to_la_to_a)
Gridap.Arrays.flatten_partition
— Functionflatten_partition(a_to_bs::Table,nb::Integer)
flatten_partition(a_to_bs::Table)
Gridap.Arrays.generate_data_and_ptrs
— Methoddata, ptrs = generate_data_and_ptrs(vv)
Given a vector of vectors, compress it and return the corresponding data and and ptrs
Gridap.Arrays.get_array
— Methodget_array(a::AbstractArray)
Returns a
.
Gridap.Arrays.get_data_eltype
— MethodGridap.Arrays.get_ptrs_eltype
— MethodGridap.Arrays.getindex!
— Methodgetindex!(cache,a::AbstractArray,i...)
Returns the item of the array a
associated with index i
by (possibly) using the scratch data passed in the cache
object.
It defaults to
getindex!(cache,a::AbstractArray,i...) = a[i...]
As for standard Julia arrays, the user needs to implement only one of the following signatures depending on the IndexStyle
of the array.
getindex!(cache,a::AbstractArray,i::Integer)
getindex!(cache,a::AbstractArray{T,N},i::Vararg{Integer,N}) where {T,N}
Examples
Iterating over an array using the getindex!
function
using Gridap.Arrays
a = collect(10:15)
cache = array_cache(a)
for i in eachindex(a)
ai = getindex!(cache,a,i)
println("$i -> $ai")
end
# output
1 -> 10
2 -> 11
3 -> 12
4 -> 13
5 -> 14
6 -> 15
Gridap.Arrays.identity_table
— MethodGridap.Arrays.inverse_map
— MethodGridap.Arrays.lazy_append
— MethodGridap.Arrays.lazy_map
— Methodlazy_map(f,::Type{T},a::AbstractArray...) where T
Like lazy_map(f,a::AbstractArray...)
, but the user provides the element type of the resulting array in order to circumvent type inference.
Gridap.Arrays.lazy_map
— Methodlazy_map(f,a::AbstractArray...) -> AbstractArray
Applies the Map
(or Function
) f
to the entries of the arrays in a
(see the definition of Map
).
The resulting array r
is such that r[i]
equals to evaluate(f,ai...)
where ai
is the tuple containing the i
-th entry of the arrays in a
(see function evaluate
for more details). In other words, the resulting array is numerically equivalent to:
map( (x...)->evaluate(f,x...), a...)
Examples
Using a function as mapping
using Gridap.Arrays
a = collect(0:5)
b = collect(10:15)
c = lazy_map(+,a,b)
println(c)
# output
[10, 12, 14, 16, 18, 20]
Using a user-defined mapping
using Gridap.Arrays
import Gridap.Arrays: evaluate!
a = collect(0:5)
b = collect(10:15)
struct MySum <: Map end
evaluate!(cache,::MySum,x,y) = x + y
k = MySum()
c = lazy_map(k,a,b)
println(c)
# output
[10, 12, 14, 16, 18, 20]
Gridap.Arrays.lazy_split
— MethodGridap.Arrays.pair_arrays
— MethodGridap.Arrays.return_cache
— Methodreturn_cache(f,x...)
Returns the cache
needed to lazy_map mapping f
with arguments of the same type as the objects in x
. This function returns nothing
by default, i.e., no cache.
Gridap.Arrays.return_type
— Methodreturn_type(f,x...)
Returns the type of the result of calling mapping f
with arguments of the types of the objects x
.
Gridap.Arrays.setsize!
— Methodsetsize!(a, s)
Changes the size of the CachedArray
a
to the size described the the tuple s
. After calling setsize!
, the array can store uninitialized values.
Gridap.Arrays.test_array
— Methodtest_array(
a::AbstractArray{T,N}, b::AbstractArray{S,N},cmp=(==)) where {T,S,N}
Checks if the entries in a
and b
are equal using the comparison function cmp
. It also stresses the new methods added to the AbstractArray
interface.
Gridap.Arrays.test_map
— Methodtest_map(y,f,x...;cmp=(==))
Function used to test if the mapping f
has been implemented correctly. f
is a Map
sub-type, x
is a tuple in the domain of the mapping and y
is the expected result. Function cmp
is used to compare the computed result with the expected one. The checks are done with the @test
macro.
Gridap.Arrays.testargs
— Methodtestargs(f,x...)
The default implementation of this function is testargs(f,x...) = x
. One can overload it in order to use lazy_map
with 0-length array and maps with non-trivial domains.
Gridap.Arrays.testitem
— Methodtestitem(a::AbstractArray{T}) -> Any
Returns an arbitrary instance of eltype(a)
. The default returned value is the first entry in the array if length(a)>0
and testvalue(eltype(a))
if length(a)==0
See the testvalue
function.
Examples
using Gridap.Arrays
a = collect(3:10)
ai = testitem(a)
b = Int[]
bi = testitem(b)
(ai, bi)
# output
(3, 0)
Gridap.Arrays.testvalue
— Functiontestvalue(::Type{T}) where T
Returns an arbitrary instance of type T
. It defaults to zero(T)
for non-array types and to an empty array for array types. It can be overloaded for new types T
if zero(T)
does not makes sense. This function is used to compute testitem
for 0-length arrays.
Gridap.Arrays.unpair_arrays
— MethodGridap.Arrays.uses_hash
— Methoduses_hash(::Type{<:AbstractArray})
This function is used to specify if the type T
uses the hash-based mechanism to reuse caches. It should return either Val(true)
or Val(false)
. It defaults to
uses_hash(::Type{<:AbstractArray}) = Val(false)
Once this function is defined for the type T
it can also be called on instances of T
.