Merge pull request #117 from mkg33/master

Documentation changes

Author: ChrisRackauckas

README.md

@@ -17,8 +17,8 @@ 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
+(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:
 
 ```julia
@@ -28,16 +28,16 @@ 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 `AbstractArray` interface is implemented, giving access to `copy`, `push`, `append!`, etc. functions,
+which act appropriately. 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
+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.
+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
 
@@ -47,7 +47,7 @@ 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
+This is a `VectorOfArray`, which stores `A.t` that matches `A.u`. This will plot
 `(A.t[i],A[i,:])`. The function `tuples(diffeq_arr)` returns tuples of `(t,u)`.
 
 To construct a DiffEqArray
@@ -67,25 +67,25 @@ A.t
 ArrayPartition(x::AbstractArray...)
 ```
 
-An `ArrayPartition` `A` is an array which is made up of different arrays `A.x`.
+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
+allows this array type to be used in place of a standard array where
 such a type stable broadcast may be needed. One example is in heterogeneous
 differential equations for [DifferentialEquations.jl](https://github.com/JuliaDiffEq/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
+array, then the second, etc., all linearly. But `A.x` is where the arrays are stored.
+Thus, for:
 
 ```julia
 using RecursiveArrayTools
 A = ArrayPartition(y,z)
 ```
 
-We would have `A.x[1]==y` and `A.x[2]==z`. Broadcasting like `f.(A)` is efficient.
+we would have `A.x[1]==y` and `A.x[2]==z`. Broadcasting like `f.(A)` is efficient.
 
 ### Functions
 
@@ -100,9 +100,9 @@ like `copy!` on arrays of scalars.
 convert(Array,vecvec)
 ```
 
-Technically just a Base fallback that works well. Takes in a vector of arrays,
+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
+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.
 
@@ -116,18 +116,18 @@ 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 `i`th element. Otherwise it will
+If `i<length(x)`, it's simply a `recursivecopy!` to the `i`th element. Otherwise, it will
 `push!` a `deepcopy`.
 
 ```julia
 recursive_one(a)
 ```
 
-Calls `one` on the bottom container to get the "true element one type"
+Calls `one` on the bottom container to get the "true element one type".
 
 ```julia
 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.
+Generalized mean functions for vectors of arrays and a matrix of arrays.

src/array_partition.jl

@@ -155,7 +155,7 @@ end
 """
     getindex(A::ArrayPartition, i::Int, j...)
 
-Return the entry at index `j...` of the `i`th partition of `A`.
+Returns the entry at index `j...` of the `i`th partition of `A`.
 """
 Base.@propagate_inbounds function Base.getindex(A::ArrayPartition, i::Int, j...)
   @boundscheck 0 < i <= length(A.x) || throw(BoundsError(A.x, i))
@@ -167,7 +167,7 @@ end
 """
     getindex(A::ArrayPartition, ::Colon)
 
-Return vector with all elements of array partition `A`.
+Returns a vector with all elements of array partition `A`.
 """
 Base.getindex(A::ArrayPartition{T,S}, ::Colon) where {T,S} = T[a for a in Chain(A.x)]
 

src/vector_of_array.jl

@@ -61,7 +61,7 @@ Base.@propagate_inbounds function Base.setindex!(VA::AbstractVectorOfArray{T,N},
     return VA.u[i][jj] = x
 end
 
-# Interface for the two dimensional indexing, a more standard AbstractArray interface
+# Interface for the two-dimensional indexing, a more standard AbstractArray interface
 @inline Base.size(VA::AbstractVectorOfArray) = (size(VA.u[1])..., length(VA.u))
 Base.@propagate_inbounds Base.getindex(VA::AbstractVectorOfArray{T, N}, I::Int...) where {T, N} = VA.u[I[end]][Base.front(I)...]
 Base.@propagate_inbounds Base.getindex(VA::AbstractVectorOfArray{T, N}, ::Colon, I::Int) where {T, N} = VA.u[I]
@@ -191,7 +191,7 @@ end
 """
     narrays(A...)
 
-Retrieve number of arrays in the AbstractVectorOfArrays of a broadcast
+Retrieve number of arrays in the AbstractVectorOfArrays of a broadcast.
 """
 narrays(A) = 0
 narrays(A::AbstractVectorOfArray) = length(A)