Merge pull request #20 from ScottPJones/spj/node

Additional renaming, use node(s) instead of daughter(s), fix REQUIRE & README.md

Author: ChrisRackauckas

README.md

@@ -27,23 +27,23 @@ cells contain proteins whose concentrations are modeled as simply a vector
 of numbers (it can be anything linearly indexable).
 
 ```julia
-immutable Cell{B} <: AbstractMultiScaleArrayLeaf{B}
-  x::Vector{B}
+struct Cell{B} <: AbstractMultiScaleArrayLeaf{B}
+    values::Vector{B}
 end
-immutable Population{T<:AbstractMultiScaleArray,B<:Number} <: AbstractMultiScaleArray{B}
-  x::Vector{T}
-  y::Vector{B}
-  end_idxs::Vector{Int}
+struct Population{T<:AbstractMultiScaleArray,B<:Number} <: AbstractMultiScaleArray{B}
+    nodes::Vector{T}
+    values::Vector{B}
+    end_idxs::Vector{Int}
 end
-immutable Tissue{T<:AbstractMultiScaleArray,B<:Number} <: AbstractMultiScaleArray{B}
-  x::Vector{T}
-  y::Vector{B}
-  end_idxs::Vector{Int}
+struct Tissue{T<:AbstractMultiScaleArray,B<:Number} <: AbstractMultiScaleArray{B}
+    nodes::Vector{T}
+    values::Vector{B}
+    end_idxs::Vector{Int}
 end
-immutable Embryo{T<:AbstractMultiScaleArray,B<:Number} <: AbstractMultiScaleArrayHead{B}
-  x::Vector{T}
-  y::Vector{B}
-  end_idxs::Vector{Int}
+struct Embryo{T<:AbstractMultiScaleArray,B<:Number} <: AbstractMultiScaleArrayHead{B}
+    nodes::Vector{T}
+    values::Vector{B}
+    end_idxs::Vector{Int}
 end
 ```
 
@@ -55,22 +55,22 @@ version is the following:
 Let's build a version of this. Using the constructors we can directly construct leaf types:
 
 ```julia
-cell1 = Cell([1.0;2.0;3.0])
-cell2 = Cell([4.0;5])
+cell1 = Cell([1.0; 2.0; 3.0])
+cell2 = Cell([4.0; 5.0])
 ```
 
 and build types higher up in the hierarchy by using the `constuct` method. The method
-is `construct(T::AbstractMultiScaleArray,x,y)`, though if `y` is not given it's
+is `construct(T::AbstractMultiScaleArray, nodes, values)`, though if `values` is not given it's
 taken to be empty.
 
 ```julia
-population = construct(Population,deepcopy([cell1,cell2])) # Make a Population from cells
-cell3 = Cell([3.0;2.0;5.0])
-cell4 = Cell([4.0;6])
-population2 = construct(Population,deepcopy([cell3,cell4]))
-tissue1 = construct(Tissue,deepcopy([population,population2])) # Make a Tissue from Populations
-tissue2 = construct(Tissue,deepcopy([population2,population]))
-embryo = construct(Embryo,deepcopy([tissue1,tissue2])) # Make an embryo from Tissues
+population = construct(Population, deepcopy([cell1, cell2])) # Make a Population from cells
+cell3 = Cell([3.0; 2.0; 5.0])
+cell4 = Cell([4.0; 6.0])
+population2 = construct(Population, deepcopy([cell3, cell4]))
+tissue1 = construct(Tissue, deepcopy([population, population2])) # Make a Tissue from Populations
+tissue2 = construct(Tissue, deepcopy([population2, population]))
+embryo = construct(Embryo, deepcopy([tissue1, tissue2])) # Make an embryo from Tissues
 ```
 
 The head node then acts as the king. It is designed to have functionality which
@@ -108,8 +108,8 @@ level. Using `level_iter_idx`, we can have its changes update some other head no
 `d_embryo` via:
 
 ```julia
-for (cell,y,z) in LevelIterIdx(embryo,2)
-  f(t,cell,@view d_embryo[y:z])
+for (cell, y, z) in LevelIterIdx(embryo, 2)
+    f(t, cell, @view d_embryo[y:z])
 end
 ```
 
@@ -123,9 +123,9 @@ passed to the event handling. MultiScaleArrays includes behavior for changing th
 structure. For example:
 
 ```julia
-tissue3 = construct(Tissue,deepcopy([population;population2]))
-add_daughter!(embryo,tissue3) # Adds a new tissue to the embryo
-remove_daughter!(embryo,2,1) # Removes population 1 from tissue 2 of the embryo
+tissue3 = construct(Tissue, deepcopy([population; population2]))
+add_node!(embryo, tissue3) # Adds a new tissue to the embryo
+remove_node!(embryo, 2, 1) # Removes population 1 from tissue 2 of the embryo
 ```
 
 Combined with event handling, this allows for dynamic structures to be derived from
@@ -153,38 +153,38 @@ techniques for each new model.
 
 The required interface is as follows. Leaf types must extend AbstractMultiScaleArrayLeaf, the
 highest level of the model or the head extends MultiScaleModelHead, and all
-intermediate types extend AbstractMultiScaleArray. The leaf has an array `x::Vector{B}`.
+intermediate types extend AbstractMultiScaleArray. The leaf has an array `values::Vector{B}`.
 Each type above then contains three fields:
 
-- `x::Vector{T}`
-- `y::Vector{B}`
+- `nodes::Vector{T}`
+- `values::Vector{B}`
 - `end_idxs::Vector{Int}``
 
 `B` is the `BottomType`, which has to be the same as the eltype for the array
 in the leaf types. `T` is another `AbstractMultiScaleArray`. Thus at each level,
-an` AbstractMultiScaleArray` contains some information of its own (`y`), the
-next level down in the heirarchy (`x`), and caching for indices (`end_idxs`).
+an` AbstractMultiScaleArray` contains some information of its own (`values`), the
+next level down in the heirarchy (`nodes`), and caching for indices (`end_idxs`).
 You can add and use extra fields as you please, and even make the types immutable.
 
 ## The MultiScaleModel API
 
 The resulting type acts as an array. A leaf type `l` acts exactly as an array
-with `l[i]==l.x[i]`. Higher nodes also act as a linear array. If `ln` is level
-`n` in the heirarchy, then `ln.x` is the vector of level `n-1` objects, and `ln.y`
+with `l[i] == l.values[i]`. Higher nodes also act as a linear array. If `ln` is level
+`n` in the heirarchy, then `ln.nodes` is the vector of level `n-1` objects, and `ln.values`
 are its "intrinsic values". There is an indexing scheme on `ln`, where:
 
-- `ln[i,j,k]` gets the `k`th `n-3` obejct in the `j`th `n-2` object in the `i`th level `n-1`
+- `ln[i,j,k]` gets the `k`th `n-3` object in the `j`th `n-2` object in the `i`th level `n-1`
   object. Of course, this recurses for the whole hierarchy.
-- `ln[i]` provides a linear index through all `.x` and `.y` values in every lower
-  level and `ln.y` itself.
+- `ln[i]` provides a linear index through all `.nodes` and `.values` values in every lower
+  level and `ln.values` itself.
 
-Thus `typeof(ln) <: AbstarctArray{B,1}` where `B` is the eltype of its leaves and
-all `.y`'s.
+Thus `typeof(ln) <: AbstractVector{B}` where `B` is the eltype of its leaves and
+all `.values`'s.
 
 In addition, iterators are provided to make it easy to iterate through levels.
 For `h` being the head node, `level_iter(h,n)` iterates through all level objects
 `n` levels down from the top, while `level_iter_idx(h,n)` is an enumeration
-`(x,y,z)` where `x` are the `n`th from the head objects, with `h[y:z]` being
+`(node,y,z)` where `node` are the `n`th from the head objects, with `h[y:z]` being
 the values it holds in the linear indexing.
 
 ### Extensions
@@ -194,50 +194,50 @@ extended as one pleases. For example, we can change the definition of the cell
 to have:
 
 ```julia
-immutable Cell{B} <: AbstractMultiScaleArrayLeaf{B}
-  x::Vector{B}
-  celltype::Symbol
+struct Cell{B} <: AbstractMultiScaleArrayLeaf{B}
+    values::Vector{B}
+    celltype::Symbol
 end
 ```
 
-Then we'd construct cells with `cell3 = Cell([3.0;2.0;5.0],:BCell)`, and can
+Then we'd construct cells with `cell3 = Cell([3.0; 2.0; 5.0], :BCell)`, and can
 give it a cell type. This information is part of the call, so
 
 ```julia
-for (cell,y,z) in level_iter_idx(embryo,2)
-  f(t,cell,@view embryo[y:z])
+for (cell, y, z) in level_iter_idx(embryo, 2)
+    f(t, cell, @view embryo[y:z])
 end
 ```
 
 can allow one to check the `cell.celltype` in `f` an apply a different ODE depending
 on the cell type. You can add fields however you want, so you can use them
 to name cells and track lineages.
 
-Showing the use of `y`, you just pass it to the constructor. Let's pass it an array
+Showing the use of `values`, you just pass it to the constructor. Let's pass it an array
 of 3 values:
 
 ```julia
-tissue = construct(Tissue,deepcopy([population;population2]),[0.0;0.0;0.0])
+tissue = construct(Tissue, deepcopy([population; population2]), [0.0; 0.0; 0.0])
 ```
 
-We can selectively apply some function on these `y` values via:
+We can selectively apply some function on these `values` via:
 
 ```julia
-for (tissue,y,z) in level_iter_idx(embryo,1)
-  f(t,tissue,@view embryo[y:z])
+for (tissue, y, z) in level_iter_idx(embryo, 1)
+    f(t, tissue, @view embryo[y:z])
 end
 ```
 
-and mutatate `tis.y` in `f`. For example, we could have
+and mutate `tis.values` in `f`. For example, we could have
 
 ```julia
-function f(t,tissue::Tissue,du)
-  du .+= randn(3)
+function f(t, tissue::Tissue, du)
+    du .+= randn(3)
 end
 ```
 
 applies normal random numbers to the three values. We could use this to add to the
-model the fact that `tissue.y[1:3]` are the tissue's position, and `f` would then be
+model the fact that `tissue.values[1:3]` are the tissue's position, and `f` would then be
 adding Brownian motion.
 
 Of course, you can keep going and kind of do whatever you want. The power is yours!

REQUIRE

@@ -1,4 +1,4 @@
-julia 0.5
+julia 0.6
 RecursiveArrayTools 0.8.0
 DiffEqBase 0.11.0
-Compat 0.19.0
+

src/MultiScaleArrays.jl

@@ -34,10 +34,10 @@ export AbstractMultiScaleArray, AbstractMultiScaleArrayLeaf,
 export construct, recursivecopy!
 
 # Addition Deletion
-export add_daughter!, remove_daughter!
+export add_node!, remove_node!
 
 # Indexing
-export num_daughters, getindices
+export num_nodes, getindices
 
 # Misc
 export LevelIterIdx, level_iter

src/addition_deletion.jl

@@ -1,55 +1,55 @@
-function __add_daughter!(m::AbstractMultiScaleArray, nodes::AbstractMultiScaleArray)
-    push!(m.end_idxs, m.end_idxs[end] + length(nodes) + length(m.values))
-    push!(m.nodes, nodes)
+function __add_node!(m::AbstractMultiScaleArray, node::AbstractMultiScaleArray)
+    push!(m.end_idxs, m.end_idxs[end] + length(node) + length(m.values))
+    push!(m.nodes, node)
     nothing
 end
 
 function __update_lengths(m::AbstractMultiScaleArray, beg, len)
-    for j = beg:num_daughters(m)
+    for j = beg:num_nodes(m)
         m.end_idxs[j] += len
     end
     isempty(m.values) || (m.end_idxs[end] += len)
     nothing
 end
 
-function __add_daughter!(m::AbstractMultiScaleArray, nodes::AbstractMultiScaleArray, i::Int)
-    __add_daughter!(m.nodes[i], nodes)
-    __update_lengths(m, i, length(nodes))
+function __add_node!(m::AbstractMultiScaleArray, node::AbstractMultiScaleArray, i::Int)
+    __add_node!(m.nodes[i], node)
+    __update_lengths(m, i, length(node))
 end
 
-function __add_daughter!(m::AbstractMultiScaleArray, nodes::AbstractMultiScaleArray, i, I::Int...)
-    __add_daughter!(m.nodes[i], nodes, I...)
-    __update_lengths(m, i, length(nodes))
+function __add_node!(m::AbstractMultiScaleArray, node::AbstractMultiScaleArray, i, I::Int...)
+    __add_node!(m.nodes[i], node, I...)
+    __update_lengths(m, i, length(node))
 end
 
-add_daughter!(m::AbstractMultiScaleArrayHead, nodes::AbstractMultiScaleArray) =
-    __add_daughter!(m, nodes)
+add_node!(m::AbstractMultiScaleArrayHead, node::AbstractMultiScaleArray) =
+    __add_node!(m, node)
 
-add_daughter!(m::AbstractMultiScaleArrayHead, nodes::AbstractMultiScaleArray, i::Int) =
-    __add_daughter!(m, nodes, i)
+add_node!(m::AbstractMultiScaleArrayHead, node::AbstractMultiScaleArray, i::Int) =
+    __add_node!(m, node, i)
 
-add_daughter!(m::AbstractMultiScaleArrayHead, nodes::AbstractMultiScaleArray, i, I::Int...) =
-    __add_daughter!(m, nodes, i, I...)
+add_node!(m::AbstractMultiScaleArrayHead, node::AbstractMultiScaleArray, i, I::Int...) =
+    __add_node!(m, node, i, I...)
 
-function __remove_daughter!(m::AbstractMultiScaleArray, i::Int)
+function __remove_node!(m::AbstractMultiScaleArray, i::Int)
     del_length = length(m.nodes[i])
     deleteat!(m.nodes, i)
     deleteat!(m.end_idxs, i)
-    for j = i:num_daughters(m)
+    for j = i:num_nodes(m)
         m.end_idxs[j] -= del_length
     end
     isempty(m.values) || (m.end_idxs[end] -= del_length)
     del_length
 end
 
-function __remove_daughter!(m::AbstractMultiScaleArrayLeaf, i::Int)
+function __remove_node!(m::AbstractMultiScaleArrayLeaf, i::Int)
     deleteat!(m.nodes, i)
     1
 end
 
-function remove_daughter!(m::AbstractMultiScaleArrayHead, i, I::Int...)
-    del_length = __remove_daughter!(m.nodes[i], I...)
-    for j = i:num_daughters(m)
+function remove_node!(m::AbstractMultiScaleArrayHead, i, I::Int...)
+    del_length = __remove_node!(m.nodes[i], I...)
+    for j = i:num_nodes(m)
         m.end_idxs[j] -= del_length
     end
     isempty(m.values) || (m.end_idxs[end] -= del_length)
@@ -60,15 +60,15 @@ function remove_daughter!(m::AbstractMultiScaleArrayHead, i, I::Int...)
     nothing
 end
 
-function __remove_daughter!(m::AbstractMultiScaleArray, i, I::Int...)
-    del_length = __remove_daughter!(m.nodes[i], I...)
-    for j = i:num_daughters(m)
+function __remove_node!(m::AbstractMultiScaleArray, i, I::Int...)
+    del_length = __remove_node!(m.nodes[i], I...)
+    for j = i:num_nodes(m)
         m.end_idxs[j] -= del_length
     end
     isempty(m.values) || (m.end_idxs[end] -= del_length)
     isempty(m.nodes[i]) && deleteat!(m.nodes, i)
     del_length
 end
 
-remove_daughter!(m::AbstractMultiScaleArrayHead, i::Int) =
-    (__remove_daughter!(m, i); nothing)
+remove_node!(m::AbstractMultiScaleArrayHead, i::Int) =
+    (__remove_node!(m, i); nothing)

src/diffeq.jl

@@ -1,16 +1,16 @@
-function remove_daughter!(integrator::DEIntegrator, I...)
+function remove_node!(integrator::DEIntegrator, I...)
     idxs = getindices(integrator.u, I...)
     for c in user_cache(integrator)
-        remove_daughter!(c, I...)
+        remove_node!(c, I...)
     end
     deleteat_non_user_cache!(integrator, idxs)
 end
 
-function add_daughter!(integrator::DEIntegrator, x, I...)
+function add_node!(integrator::DEIntegrator, x, I...)
     cur_len = length(integrator.u)
     add_len = length(x)
     for c in user_cache(integrator)
-        add_daughter!(c, similar(x, eltype(c)), I...)
+        add_node!(c, similar(x, eltype(c)), I...)
     end
     last_idx = length(integrator.u[I...].nodes)
     idxs = getindices(integrator.u, I..., last_idx)