# PartedArrays.jl

PartedArrays was written to make it easier to work with arrays that are naturally partitioned into sub-arrays. PartedArrays keeps the memory together in one block and simply stores fixed views into the arrays rather that storing the sub-arrays as separate entities, like BlockArrays.jl.

For example, say we have a function, `f(x,u)`

with vector-valued input `x`

and `u`

of size `n`

and `m`

, respectively. The Hessian of the function, `H`

, is a symmetric matrix of size `(n+m,n+m)`

. It is naturally partitioned into the partial second derivatives of f: A = df/dxdx, B = df/dudu, C = df/dxdu. `H`

is then equivalent to `[A C; C' B]`

. However, we don't really want to break up `H`

(since we may want to invert it) but may want to extract/modify particular partial derivatives, which we could do by indexing, but that can get tedious to write and even more difficult to read. PartedArrays simplifies this by making it easy to store views into the partial derivatives along with the matrix itself.

PartedArrays was written to avoid repetitive indexing and clean up complicated indexing expressions, especially when they have a regular structure.

## Usage

A `PartedArray`

is basically just a normal Julia array with a list of convenient views attached. This list of views can either be of type `Dict{Symbol,<:Any}`

or a `NamedTuple`

.

```
using PartedArrays
# Vector
x = rand(4)
y = rand(3)
z = [x; y]
parts = (x=1:4, y=5:7)
Z = PartedArray(z, parts)
Z.x == x # true
Z.y == y # true
# Matrix
A = rand(4,4)
B = rand(3,3)
C = rand(4,3)
H= [A C; C' B]
parts = (xx=(1:4,1:4), xy=(1:4,5:7), yx=(5:7,1:4), yy=(5:7,5:7))
Z = PartedArray(H, parts)
Z.xx == A # true
parts2 = Dict(:xx=>(1:4,1:4), :yy=>(5:7,5:7), :top=>(1,:))
Z2 = PartedArray(H, parts2)
Z2.top == H[1,:] # true
```

Since `PartedArray`

uses the `AbstractArray`

interface, most array-like operations are preserved

```
Z[1:4,1:4] == A # true
Z + Z2 == 2Z # true
Z[1] = 10
Z.xx[1,1] == 10 # true
```

## Partitioning

For many cases, the partitioning of the array is non-overlapping and includes the whole array. It can be cumbersome to create these partitions by hand, so some convenient constructors are provided for vectors and matrices.

```
part = create_partition((4,3), (:x,:u))
Z = PartedArray(z, part)
Z.x == x # true
part2 = create_partition2((4,3), (4,3), Val((:xx,:xu,:ux,:uu)))
Z = PartedMatrix(H, part2)
Z.xx == A # true
```

The names of the partitions need to be passed in as Value Types for type stability (still need to make this change for 1D partitioning).