Tools for easily handling objects like arrays of arrays and deeper nestings
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Failed to load latest commit information.
src Merge pull request #41 from vchuravy/vc/broadcast Oct 10, 2018
test rewrite broadcast and remove generated functions Sep 22, 2018
.codecov.yml RecursiveArrayTools.jl generated files. Oct 30, 2016
.gitignore
.travis.yml Update .travis.yml Aug 11, 2018
LICENSE.md Update LICENSE.md May 27, 2017
README.md deprecate vecarr_to_arr Jun 28, 2017
REQUIRE Update REQUIRE Aug 11, 2018
appveyor.yml

README.md

RecursiveArrayTools.jl

Build Status Build status Coverage Status codecov.io

RecursiveArrayTools.jl is a set of tools for dealing with recursive arrays like arrays of arrays. The current functionality includes:

Types

VectorOfArray

VectorOfArray(u::AbstractVector)

A VectorOfArray is an array which has the underlying data structure Vector{AbstractArray{T}} (but hopefully concretely typed!). This wrapper over such data structures allows one to lazily act like it's a higher dimensional vector, and easily convert to different forms. The indexing structure is:

A[i] # Returns the ith array in the vector of arrays
A[j,i] # Returns the jth component in the ith array
A[j1,...,jN,i] # Returns the (j1,...,jN) component of the ith array

which presents itself as a column-major matrix with the columns being the arrays from the vector. The AbstractArray interface is implemented, giving access to copy, push, append!, etc. function which act appropriate. Points to note are:

  • The length is the number of vectors, or length(A.u) where u is the vector of arrays.
  • Iteration follows the linear index and goes over the vectors

Additionally, the convert(Array,VA::AbstractVectorOfArray) function is provided which transforms the VectorOfArray into a matrix/tensor. Also, vecarr_to_vectors(VA::AbstractVectorOfArray) returns a vector of the series for each component, that is A[i,:] for each i. A plot recipe is provided which plots the A[i,:] series.

DiffEqArray

Related to the VectorOfArray is the DiffEqArray

DiffEqArray(u::AbstractVector,t::AbstractVector)

This is a VectorOfArray which stores A.t which matches A.u. This will plot (A.t[i],A[i,:]). The function tuples(diffeq_arr) returns tuples of (t,u).

ArrayPartition

ArrayPartition(x::AbstractArray...)

An ArrayPartition A is an array which is made up of different arrays A.x. These index like a single array, but each subarray may have a different type. However, broadcast is overloaded to loop in an efficient manner, meaning that A .+= 2.+B is type-stable in its computations, even if A.x[i] and A.x[j] do not match types. A full array interface is included for completeness, which allows this array type to be used in place of a standard array in places where such a type stable broadcast may be needed. One example is in heterogeneous differential equations for DifferentialEquations.jl.

An ArrayPartition acts like a single array. A[i] indexes through the first array, then the second, etc. all linearly. But A.x is where the arrays are stored. Thus for

using RecursiveArrayTools
A = ArrayPartition(y,z)

We would have A.x[1]==y and A.x[2]==z. Broadcasting like f.(A) is efficient.

Functions

recursivecopy!(b::Array{T,N},a::Array{T,N})

A recursive copy! function. Acts like a deepcopy! on arrays of arrays, but like copy! on arrays of scalars.

convert(Array,vecvec)

Technically just a Base fallback that works well. Takes in a vector of arrays, returns an array of dimension one greater than the original elements. Works on AbstractVectorOfArray. If the vecvec is ragged, i.e. not all of the elements are the same, then it uses the size of the first element to determine the conversion.

vecvecapply(f::Base.Callable,v)

Calls f on each element of a vecvec v.

copyat_or_push!{T}(a::AbstractVector{T},i::Int,x)

If i<length(x), it's simply a recursivecopy! to the ith element. Otherwise it will push! a deepcopy.

recursive_one(a)

Calls one on the bottom container to get the "true element one type"

mean{T<:AbstractArray}(vecvec::Vector{T})
mean{T<:AbstractArray}(matarr::Matrix{T},region=0)

Generalized mean functions for vectors of arrays and matrix of arrays.