This closes #5 and closes #3

Author: jonniedie

.gitignore

@@ -5,4 +5,7 @@ research/
 .DS_Store
 /dev/
 /docs/build/
-/docs/site/
+/docs/site/
+/docs/make_local.jl
+/examples/wip
+/examples/.ipynb_checkpoints

Project.toml

@@ -1,7 +1,7 @@
 name = "ComponentArrays"
 uuid = "b0b7db55-cfe3-40fc-9ded-d10e2dbeff66"
 authors = ["Jonnie Diegelman <47193959+jonniedie@users.noreply.github.com>"]
-version = "0.1.1"
+version = "0.2.0"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"

README.md

@@ -6,48 +6,51 @@
 [![Codecov](https://codecov.io/gh/jonniedie/ComponentArrays.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/jonniedie/ComponentArrays.jl)
 [![GitHub](https://img.shields.io/github/license/jonniedie/ComponentArrays.jl)](https://github.com/jonniedie/ComponentArrays.jl/blob/master/LICENSE.txt)
 
-The main export of this package is the ````CArray```` type. "Components" of ````CArray````s
+The main export of this package is the ````ComponentArray```` type. "Components" of ````ComponentArray````s
 are really just array blocks that can be accessed through a named index. The magic here is
-that this named indexing can create a new ```CArray``` whose data is a view into the original,
+that this named indexing can create a new ```ComponentArray``` whose data is a view into the original,
 allowing for standalone models to be composed together by simple function composition. In
-essence, ```CArray```s allow you to do the things you would usually need a modeling
+essence, ```ComponentArray```s allow you to do the things you would usually need a modeling
 language for, but without actually needing a modeling language. The main targets are for use
 in [DifferentialEquations.jl](https://github.com/SciML/DifferentialEquations.jl) and
 [Optim.jl](https://github.com/JuliaNLSolvers/Optim.jl), but anything that requires
 flat vectors is fair game.
 
 ## General use
-The easiest way to construct 1-dimensional ```CArray```s is as if they were ```NamedTuple```s. In fact, a good way to think about them is as arbitrarily nested, mutable ```NamedTuple```s that can be passed through a solver.
+The easiest way to construct 1-dimensional ```ComponentArray```s is as if they were ```NamedTuple```s. In fact, a good way to think about them is as arbitrarily nested, mutable ```NamedTuple```s that can be passed through a solver.
 ```julia
 julia> c = (a=2, b=[1, 2]);
 
-julia> x = CArray(a=1, b=[2, 1, 4], c=c)
-CArray{Float64}(a = 1.0, b = [2.0, 1.0, 4.0], c = (a = 2.0, b = [1.0, 2.0]))
+julia> x = ComponentArray(a=5, b=[(a=20., b=0), (a=33., b=0), (a=44., b=3)], c=c)
+ComponentArray{Float64}(a = 5.0, b = [(a = 20.0, b = 0.0), (a = 33.0, b = 0.0), (a = 44.0, b = 3.0)], c = (a = 2.0, b = [1.0, 2.0]))
 
 julia> x.c.a = 400; x
-CArray{Float64}(a = 1.0, b = [2.0, 1.0, 4.0], c = (a = 400.0, b = [1.0, 2.0]))
+ComponentArray{Float64}(a = 5.0, b = [(a = 20.0, b = 0.0), (a = 33.0, b = 0.0), (a = 44.0, b = 3.0)], c = (a = 400.0, b = [1.0, 2.0]))
 
-julia> x[5]
+julia> x[8]
 400.0
 
 julia> collect(x)
-7-element Array{Float64,1}:
-   1.0
-   2.0
-   1.0
-   4.0
+10-element Array{Float64,1}:
+   5.0
+  20.0
+   0.0
+  33.0
+   0.0
+  44.0
+   3.0
  400.0
    1.0
    2.0
 
-julia> typeof(similar(x, Int32)) === typeof(CArray{Int32}(a=1, b=[2, 1, 4], c=c))
+julia> typeof(similar(x, Int32)) === typeof(ComponentArray{Int32}(a=5, b=[(a=20., b=0), (a=33., b=0), (a=44., b=3)], c=c))
 true
 ```
 
-Higher dimensional ```CArray```s can be created too, but it's a little messy at the moment. The nice thing for modeling is that dimension expansion through broadcasted operations can create higher-dimensional ```CArray```s automatically, so Jacobian cache arrays that are created internally with ```false .* x .* x'``` will be ```CArray```s with proper axes. Check out the [ODE with Jacobian](https://github.com/jonniedie/ComponentArrays.jl/blob/master/examples/ODE_jac_example.jl) example in the examples folder to see how this looks in practice.
+Higher dimensional ```ComponentArray```s can be created too, but it's a little messy at the moment. The nice thing for modeling is that dimension expansion through broadcasted operations can create higher-dimensional ```ComponentArray```s automatically, so Jacobian cache arrays that are created internally with ```false .* x .* x'``` will be ```ComponentArray```s with proper axes. Check out the [ODE with Jacobian](https://github.com/jonniedie/ComponentArrays.jl/blob/master/examples/ODE_jac_example.jl) example in the examples folder to see how this looks in practice.
 ```julia
 julia> x2 = x .* x'
-7×7 CArray{Tuple{Axis{(a = 1, b = 2:4, c = (5:7, (a = 1, b = 2:3)))},Axis{(a = 1, b = 2:4, c = (5:7, (a = 1, b = 2:3)))}},Float64,2,Array{Float64,2}}:
+7×7 ComponentArray{Tuple{Axis{(a = 1, b = 2:4, c = (5:7, (a = 1, b = 2:3)))},Axis{(a = 1, b = 2:4, c = (5:7, (a = 1, b = 2:3)))}},Float64,2,Array{Float64,2}}:
  1.0  2.0  1.0   4.0  2.0  1.0  2.0
  2.0  4.0  2.0   8.0  4.0  2.0  4.0
  1.0  2.0  1.0   4.0  2.0  1.0  2.0
@@ -57,7 +60,7 @@ julia> x2 = x .* x'
  2.0  4.0  2.0   8.0  4.0  2.0  4.0
 
 julia> x2[:c,:c]
-3×3 CArray{Tuple{Axis{(a = 1, b = 2:3)},Axis{(a = 1, b = 2:3)}},Float64,2,SubArray{Float64,2,Array{Float64,2},Tuple{UnitRange{Int64},UnitRange{Int64}},false}}:
+3×3 ComponentArray{Tuple{Axis{(a = 1, b = 2:3)},Axis{(a = 1, b = 2:3)}},Float64,2,SubArray{Float64,2,Array{Float64,2},Tuple{UnitRange{Int64},UnitRange{Int64}},false}}:
  4.0  2.0  4.0
  2.0  1.0  2.0
  4.0  2.0  4.0
@@ -66,10 +69,10 @@ julia> x2[:a,:a]
  1.0
 
 julia> x2[:a,:c]
-CArray{Float64}(a = 2.0, b = [1.0, 2.0])
+ComponentArray{Float64}(a = 2.0, b = [1.0, 2.0])
 
 julia> x2[:b,:c]
-3×3 CArray{Tuple{Axis{NamedTuple()},Axis{(a = 1, b = 2:3)}},Float64,2,SubArray{Float64,2,Array{Float64,2},Tuple{UnitRange{Int64},UnitRange{Int64}},false}}:
+3×3 ComponentArray{Tuple{Axis{NamedTuple()},Axis{(a = 1, b = 2:3)}},Float64,2,SubArray{Float64,2,Array{Float64,2},Tuple{UnitRange{Int64},UnitRange{Int64}},false}}:
  4.0  2.0  4.0
  2.0  1.0  2.0
  8.0  4.0  8.0
@@ -102,7 +105,7 @@ function lorenz!(D, u, p, t; f=0.0)
 end
 
 lorenz_p = (σ=10.0, ρ=28.0, β=8/3)
-lorenz_ic = CArray(x=0.0, y=0.0, z=0.0)
+lorenz_ic = ComponentArray(x=0.0, y=0.0, z=0.0)
 lorenz_prob = ODEProblem(lorenz!, lorenz_ic, tspan, lorenz_p)
 
 
@@ -117,7 +120,7 @@ function lotka!(D, u, p, t; f=0.0)
 end
 
 lotka_p = (α=2/3, β=4/3, γ=1.0, δ=1.0)
-lotka_ic = CArray(x=1.0, y=1.0)
+lotka_ic = ComponentArray(x=1.0, y=1.0)
 lotka_prob = ODEProblem(lotka!, lotka_ic, tspan, lotka_p)
 
 
@@ -132,7 +135,7 @@ function composed!(D, u, p, t)
 end
 
 comp_p = (lorenz=lorenz_p, lotka=lotka_p, c=0.01)
-comp_ic = CArray(lorenz=lorenz_ic, lotka=lotka_ic)
+comp_ic = ComponentArray(lorenz=lorenz_ic, lotka=lotka_ic)
 comp_prob = ODEProblem(composed!, comp_ic, tspan, comp_p)
 
 

docs/src/examples/ODE_jac.md

@@ -1,6 +1,6 @@
 # ODE with Jacobian
 
-This example shows how to use ComponentArrays for composing Jacobian update functions as well as ODE functions. Note using plain symbols to index into ```CArrays``` is still pretty slow. Until symbolic indexing is faster, the convenience function ```fastindices``` can be used to speed up simulation. The general syntax looks like
+This example shows how to use ComponentArrays for composing Jacobian update functions as well as ODE functions. Note using plain symbols to index into ```ComponentArrays``` is still pretty slow. Until symbolic indexing is faster, the convenience function ```fastindices``` can be used to speed up simulation. The general syntax looks like
 
 ```julia
 _x, _y, _z = fastindices(:x, :y, :z)
@@ -46,7 +46,7 @@ function lorenz_jac!(D, u, p, t)
 end
 
 lorenz_p = (σ=10.0, ρ=28.0, β=8/3)
-lorenz_ic = CArray(x=0.0, y=0.0, z=0.0)
+lorenz_ic = ComponentArray(x=0.0, y=0.0, z=0.0)
 lorenz_fun = ODEFunction(lorenz!, jac=lorenz_jac!)
 lorenz_prob = ODEProblem(lorenz_fun, lorenz_ic, tspan, lorenz_p)
 
@@ -73,7 +73,7 @@ function lotka_jac!(D, u, p, t)
 end
 
 lotka_p = (α=2/3, β=4/3, γ=1.0, δ=1.0)
-lotka_ic = CArray(x=1.0, y=1.0)
+lotka_ic = ComponentArray(x=1.0, y=1.0)
 lotka_fun = ODEFunction(lotka!, jac=lotka_jac!)
 lotka_prob = ODEProblem(lotka_fun, lotka_ic, tspan, lotka_p)
 
@@ -100,7 +100,7 @@ function composed_jac!(D, u, p, t)
 end
 
 comp_p = (lorenz=lorenz_p, lotka=lotka_p, c=0.01)
-comp_ic = CArray(lorenz=lorenz_ic, lotka=lotka_ic)
+comp_ic = ComponentArray(lorenz=lorenz_ic, lotka=lotka_ic)
 comp_fun = ODEFunction(composed!, jac=composed_jac!)
 comp_prob = ODEProblem(comp_fun, comp_ic, tspan, comp_p)
 

docs/src/index.md

@@ -1,10 +1,10 @@
 # ComponentArrays.jl
 
-The main export of this package is the ```CArray``` type. "Components" of ```CArray```s
+The main export of this package is the ```ComponentArray``` type. "Components" of ```ComponentArray```s
 are really just array blocks that can be accessed through a named index. The magic here is
-that this named indexing can create a new ```CArray``` whose data is a view into the original,
+that this named indexing can create a new ```ComponentArray``` whose data is a view into the original,
 allowing for standalone models to be composed together by simple function composition. In
-essence, ```CArray```s allow you to do the things you would usually need a modeling
+essence, ```ComponentArray```s allow you to do the things you would usually need a modeling
 language for, but without actually needing a modeling language. The main targets are for use
 in [DifferentialEquations.jl](https://github.com/SciML/DifferentialEquations.jl) and
 [Optim.jl](https://github.com/JuliaNLSolvers/Optim.jl), but anything that requires

docs/src/quickstart.md

@@ -1,15 +1,15 @@
 # Quick Start
 
 ## General use
-The easiest way to construct 1-dimensional ```CArray```s is as if they were ```NamedTuple```s. In fact, a good way to think about them is as arbitrarily nested, mutable ```NamedTuple```s that can be passed through a solver.
+The easiest way to construct 1-dimensional ```ComponentArray```s is as if they were ```NamedTuple```s. In fact, a good way to think about them is as arbitrarily nested, mutable ```NamedTuple```s that can be passed through a solver.
 ```julia
 julia> c = (a=2, b=[1, 2]);
 
-julia> x = CArray(a=1, b=[2, 1, 4], c=c)
-CArray{Float64}(a = 1.0, b = [2.0, 1.0, 4.0], c = (a = 2.0, b = [1.0, 2.0]))
+julia> x = ComponentArray(a=1, b=[2, 1, 4], c=c)
+ComponentArray{Float64}(a = 1.0, b = [2.0, 1.0, 4.0], c = (a = 2.0, b = [1.0, 2.0]))
 
 julia> x.c.a = 400; x
-CArray{Float64}(a = 1.0, b = [2.0, 1.0, 4.0], c = (a = 400.0, b = [1.0, 2.0]))
+ComponentArray{Float64}(a = 1.0, b = [2.0, 1.0, 4.0], c = (a = 400.0, b = [1.0, 2.0]))
 
 julia> x[5]
 400.0
@@ -24,14 +24,14 @@ julia> collect(x)
    1.0
    2.0
 
-julia> typeof(similar(x, Int32)) === typeof(CArray{Int32}(a=1, b=[2, 1, 4], c=c))
+julia> typeof(similar(x, Int32)) === typeof(ComponentArray{Int32}(a=1, b=[2, 1, 4], c=c))
 true
 ```
 
-Higher dimensional ```CArray```s can be created too, but it's a little messy at the moment. The nice thing for modeling is that dimension expansion through broadcasted operations can create higher-dimensional ```CArray```s automatically, so Jacobian cache arrays that are created internally with ```false .* x .* x'``` will be ```CArray```s with proper axes. Check out the [ODE with Jacobian](https://github.com/jonniedie/ComponentArrays.jl/blob/master/examples/ODE_jac_example.jl) example in the examples folder to see how this looks in practice.
+Higher dimensional ```ComponentArray```s can be created too, but it's a little messy at the moment. The nice thing for modeling is that dimension expansion through broadcasted operations can create higher-dimensional ```ComponentArray```s automatically, so Jacobian cache arrays that are created internally with ```false .* x .* x'``` will be ```ComponentArray```s with proper axes. Check out the [ODE with Jacobian](https://github.com/jonniedie/ComponentArrays.jl/blob/master/examples/ODE_jac_example.jl) example in the examples folder to see how this looks in practice.
 ```julia
 julia> x2 = x .* x'
-7×7 CArray{Tuple{Axis{(a = 1, b = 2:4, c = (5:7, (a = 1, b = 2:3)))},Axis{(a = 1, b = 2:4, c = (5:7, (a = 1, b = 2:3)))}},Float64,2,Array{Float64,2}}:
+7×7 ComponentArray{Tuple{Axis{(a = 1, b = 2:4, c = (5:7, (a = 1, b = 2:3)))},Axis{(a = 1, b = 2:4, c = (5:7, (a = 1, b = 2:3)))}},Float64,2,Array{Float64,2}}:
  1.0  2.0  1.0   4.0  2.0  1.0  2.0
  2.0  4.0  2.0   8.0  4.0  2.0  4.0
  1.0  2.0  1.0   4.0  2.0  1.0  2.0
@@ -41,7 +41,7 @@ julia> x2 = x .* x'
  2.0  4.0  2.0   8.0  4.0  2.0  4.0
 
 julia> x2[:c,:c]
-3×3 CArray{Tuple{Axis{(a = 1, b = 2:3)},Axis{(a = 1, b = 2:3)}},Float64,2,SubArray{Float64,2,Array{Float64,2},Tuple{UnitRange{Int64},UnitRange{Int64}},false}}:
+3×3 ComponentArray{Tuple{Axis{(a = 1, b = 2:3)},Axis{(a = 1, b = 2:3)}},Float64,2,SubArray{Float64,2,Array{Float64,2},Tuple{UnitRange{Int64},UnitRange{Int64}},false}}:
  4.0  2.0  4.0
  2.0  1.0  2.0
  4.0  2.0  4.0
@@ -50,10 +50,10 @@ julia> x2[:a,:a]
  1.0
 
 julia> x2[:a,:c]
-CArray{Float64}(a = 2.0, b = [1.0, 2.0])
+ComponentArray{Float64}(a = 2.0, b = [1.0, 2.0])
 
 julia> x2[:b,:c]
-3×3 CArray{Tuple{Axis{NamedTuple()},Axis{(a = 1, b = 2:3)}},Float64,2,SubArray{Float64,2,Array{Float64,2},Tuple{UnitRange{Int64},UnitRange{Int64}},false}}:
+3×3 ComponentArray{Tuple{Axis{NamedTuple()},Axis{(a = 1, b = 2:3)}},Float64,2,SubArray{Float64,2,Array{Float64,2},Tuple{UnitRange{Int64},UnitRange{Int64}},false}}:
  4.0  2.0  4.0
  2.0  1.0  2.0
  8.0  4.0  8.0

examples/ODE_example.jl

@@ -18,7 +18,7 @@ function lorenz!(D, u, p, t; f=0.0)
 end
 
 lorenz_p = (σ=10.0, ρ=28.0, β=8/3)
-lorenz_ic = CArray(x=0.0, y=0.0, z=0.0)
+lorenz_ic = ComponentArray(x=0.0, y=0.0, z=0.0)
 lorenz_prob = ODEProblem(lorenz!, lorenz_ic, tspan, lorenz_p)
 
 
@@ -33,7 +33,7 @@ function lotka!(D, u, p, t; f=0.0)
 end
 
 lotka_p = (α=2/3, β=4/3, γ=1.0, δ=1.0)
-lotka_ic = CArray(x=1.0, y=1.0)
+lotka_ic = ComponentArray(x=1.0, y=1.0)
 lotka_prob = ODEProblem(lotka!, lotka_ic, tspan, lotka_p)
 
 
@@ -48,7 +48,7 @@ function composed!(D, u, p, t)
 end
 
 comp_p = (lorenz=lorenz_p, lotka=lotka_p, c=0.01)
-comp_ic = CArray(lorenz=lorenz_ic, lotka=lotka_ic)
+comp_ic = ComponentArray(lorenz=lorenz_ic, lotka=lotka_ic)
 comp_prob = ODEProblem(composed!, comp_ic, tspan, comp_p)
 
 

examples/ODE_jac_example.jl

@@ -34,7 +34,7 @@ function lorenz_jac!(D, u, p, t)
 end
 
 lorenz_p = (σ=10.0, ρ=28.0, β=8/3)
-lorenz_ic = CArray(x=0.0, y=0.0, z=0.0)
+lorenz_ic = ComponentArray(x=0.0, y=0.0, z=0.0)
 lorenz_fun = ODEFunction(lorenz!, jac=lorenz_jac!)
 lorenz_prob = ODEProblem(lorenz_fun, lorenz_ic, tspan, lorenz_p)
 
@@ -61,7 +61,7 @@ function lotka_jac!(D, u, p, t)
 end
 
 lotka_p = (α=2/3, β=4/3, γ=1.0, δ=1.0)
-lotka_ic = CArray(x=1.0, y=1.0)
+lotka_ic = ComponentArray(x=1.0, y=1.0)
 lotka_fun = ODEFunction(lotka!, jac=lotka_jac!)
 lotka_prob = ODEProblem(lotka_fun, lotka_ic, tspan, lotka_p)
 
@@ -88,14 +88,14 @@ function composed_jac!(D, u, p, t)
 end
 
 comp_p = (lorenz=lorenz_p, lotka=lotka_p, c=0.01)
-comp_ic = CArray(lorenz=lorenz_ic, lotka=lotka_ic)
+comp_ic = ComponentArray(lorenz=lorenz_ic, lotka=lotka_ic)
 comp_fun = ODEFunction(composed!, jac=composed_jac!)
 comp_prob = ODEProblem(comp_fun, comp_ic, tspan, comp_p)
 
 
 ## Solve problem
 # We can solve the composed system...
-comp_sol = solve(comp_prob, alg_hints=[:stiff])
+comp_sol = solve(comp_prob, Rodas5())
 
 # ...or we can unit test one of the component systems
-lotka_sol = solve(lotka_prob, alg_hints=[:stiff])
+lotka_sol = solve(lotka_prob, Rodas5())

examples/Optim_example.jl

@@ -3,9 +3,9 @@ using Optim
 
 rosen(u) = (1.0 - u.x)^2 + 100.0 * (u.y - u.x^2)^2
 
-u₀ = CArray(x=0, y=0)
-lb = CArray(x=-0.5, y=-0.5)
-ub = CArray(x=0.5, y=0.5)
+u₀ = ComponentArray(x=0, y=0)
+lb = ComponentArray(x=-0.5, y=-0.5)
+ub = ComponentArray(x=0.5, y=0.5)
 
 df = TwiceDifferentiable(rosen, u₀; autodiff=:forward)
 dfc = TwiceDifferentiableConstraints(lb, ub)

src/Axis.jl

@@ -1,7 +1,7 @@
 """
     ax = Axis(nt::NamedTuple)
 
-Axes for named component access of CArrays. These are a little confusing and poorly
+Axes for named component access of ComponentArrays. These are a little confusing and poorly
     thought-out, so maybe don't use them directly.
 
 # Examples
@@ -14,9 +14,9 @@ Axis{(a = 1, b = 2:3, c = (4:10, (a = (1:3, (a = 1, b = 2:3)), b = 4:7)))}()
 
 julia> A = [100, 4, 1.3, 1, 1, 4.4, 0.4, 2, 1, 45];
 
-julia> cvec = CArray(A, ax);
+julia> cvec = ComponentArray(A, ax);
 
-julia> cmat = CArray(A .* A', ax, ax);
+julia> cmat = ComponentArray(A .* A', ax, ax);
 
 julia> cmat[:c,:c] * cvec.c
 7-element Array{Float64,1}:
@@ -43,17 +43,24 @@ const AxisorNAxis = Union{Axis, NAxis}
 const VarAxes = Tuple{Vararg{<:Axis}}
 
 Axis{IdxMap}(x) where {IdxMap} = Axis{IdxMap}()
-Axis(x::Type{Axis{IdxMap}}) where {IdxMap} = Axis{IdxMap}()
+Axis(::Type{Axis{IdxMap}}) where {IdxMap} = Axis{IdxMap}()
 Axis(L, IdxMap) = Axis{IdxMap}()
 Axis(::Number, IdxMap) = NullAxis()
 Axis(::Colon, IdxMap) = Axis{IdxMap}()
-Axis(i, IdxMap, N) = NAxis(N, Axis(i, IdxMap))
+Axis(i, N, IdxMap) = NAxis(N, Axis(i, IdxMap))
 Axis(tup) = Axis(tup...)
 Axis(nt::NamedTuple) = Axis{nt}()
 Axis(;kwargs...) = Axis{(;kwargs...)}()
+Axis(x::Axis) = x
+Axis(x::NAxis{N,IdxMap}) where {N,IdxMap} = Axis{IdxMap}()
 
 idxmap(::Axis{IdxMap}) where IdxMap = IdxMap
 idxmap(::Type{Axis{IdxMap}}) where IdxMap = IdxMap
+idxmap(::NAxis{N,IdxMap}) where {N,IdxMap} = IdxMap
+idxmap(::Type{NAxis{N,IdxMap}}) where {N,IdxMap} = IdxMap
+
+numaxes(::NAxis{N,IdxMap}) where {N,IdxMap} = N
+numaxes(::Type{NAxis{N,IdxMap}}) where {N,IdxMap} = N
 
 lastof(x) = x[end]
 lastof(x::Union{Tuple, NamedTuple}) = lastof(x[end])