Updated documentation

Author: kaandocal

README.md

@@ -52,7 +52,7 @@ end ρ σ_on σ_off d
 
 # This automatically reduces the dimensionality of the
 # network by exploiting conservation laws
-ih = ReducedIndexHandler(rn)
+ih = ReducingIndexHandler(rn)
 sys = FSPSystem(rn, ih)
 
 # There is one conserved quantity: G_on + G_off

docs/make.jl

@@ -1,7 +1,6 @@
 using Documenter
 using FiniteStateProjection
 using SparseArrays
-using FiniteStateProjection: AbstractIndexHandler
 
 makedocs(sitename="FiniteStateProjection.jl", 
          modules=[FiniteStateProjection],
@@ -12,7 +11,7 @@ makedocs(sitename="FiniteStateProjection.jl",
              "Index Handlers" => "indexhandlers.md",
              "Matrix Conversions" => "matrix.md",
              "Internal API" => "internal.md",
-             "Tips & Tricks" => "tips.md"
+             "Tips & Tricks" => "tips.md",
              "Examples" => "examples.md"
          ])
 

docs/src/examples.md

@@ -47,7 +47,7 @@ end ρ σ_on σ_off d
 
 # This automatically reduces the dimensionality of the
 # network by exploiting conservation laws
-ih = ReducedIndexHandler(rn)
+ih = ReducingIndexHandler(rn)
 sys = FSPSystem(rn, ih)
 
 # There is one conserved quantity: G_on + G_off

docs/src/index.md

@@ -20,3 +20,7 @@ This function is generated dynamically as an `ODEFunction` for use with Differen
 - The Chemical Master Equation can be generated as a `SparseMatrixCSC`
 - Flexible API for user-defined array types via `IndexHandler`s
 - Automatic dimensionality reduction for systems with conserved quantities
+
+## Acknowledgments
+
+Special thanks to [Xiamong Fu](https://github.com/palmtree2013), [Brian Munsky](https://www.engr.colostate.edu/~munsky/) and [Huy Vo](https://github.com/voduchuy) for their examples and suggestions and for contributing most of the content in the [Tips & Tricks](@ref tips) page!

docs/src/indexhandlers.md

@@ -1,12 +1,12 @@
 # Index Handlers
 
-The task of an index handler is to provide a mapping between the system state and the way it is stored in memory, usually as a multidimensional array. The standard approach is to represent the states of a system with ``s`` reactions as an ``s``-dimensional array and have the index ``(i_1, \ldots, i_s)`` correspond to the state ``(n_1 = i_1, \ldots, n_s = i_s)``. This is implemented by the class [`NaiveIndexHandler`](@ref), which accepts an offset argument to deal with Julia's 1-based indexing (so the Julia index $(1,\ldots,1)$ corresponds to the state with no molecules). For systems with conservation laws the [`DefaultIndexHandler`](@ref) class generally stores the data more efficiently.
+The task of an index handler is to provide a mapping between the system state and the way it is stored in memory, usually as a multidimensional array. The standard approach is to represent the states of a system with ``s`` reactions as an ``s``-dimensional array and have the index ``(i_1, \ldots, i_s)`` correspond to the state ``(n_1 = i_1, \ldots, n_s = i_s)``. This is implemented by the class [`NaiveIndexHandler`](@ref), which accepts an offset argument to deal with Julia's 1-based indexing (so the Julia index $(1,\ldots,1)$ corresponds to the state with no molecules). For systems with conservation laws the [`ReducingIndexHandler`](@ref) class generally stores the data more efficiently.
 
 See the [internal API](@ref index_handlers_internal) on how to define your own `IndexHandler` type.
 
 ```@docs
 NaiveIndexHandler
-DefaultIndexHandler
+ReducingIndexHandler
 reducedspecies
-elidedspecies(::DefaultIndexHandler)
+elidedspecies(::ReducingIndexHandler)
 ```

docs/src/internal.md

@@ -26,18 +26,18 @@ For matrix conversions they should additionally implement:
 singleindices
 pairedindices
 getsubstitutions
-build_rhs_header(::AbstractIndexHandler, ::FSPSystem)
+build_rhs_header
 LinearIndices
 ```
 
 ### Built-in implementations
 ```@docs
 elidedspecies(::AbstractMatrix{Int})
 elisions
-getsubstitutions(::NaiveIndexHandler, ::FSPSystem)
-getsubstitutions(::DefaultIndexHandler, ::FSPSystem)
-build_rhs_header(::DefaultIndexHandler, ::FSPSystem)
-pairedindices(::DefaultIndexHandler, ::AbstractArray, ::CartesianIndex)
+getsubstitutions(::NaiveIndexHandler, ::ReactionSystem)
+getsubstitutions(::ReducingIndexHandler, ::ReactionSystem)
+build_rhs_header(::FSPSystem{ReducingIndexHandler})
+pairedindices(::ReducingIndexHandler, ::AbstractArray, ::CartesianIndex)
 ```
 
 ## Function Building

docs/src/mainapi.md

@@ -18,6 +18,6 @@ conservedquantities
 The following methods are the main way to create a system of ODEs representing the time-dependent FSP. This package provides a flexible way to represent the FSP in memory via index handlers, see [Index Handlers] for more information. 
 
 ```@docs
-Base.convert(::Type{ODEFunction}, ::AbstractIndexHandler, ::FSPSystem)
-Base.convert(::Type{ODEProblem}, ::AbstractIndexHandler, ::FSPSystem, u0, tmax, p)
+Base.convert(::Type{ODEFunction}, ::FSPSystem)
+Base.convert(::Type{ODEProblem}, ::FSPSystem, u0, tmax, p)
 ```

docs/src/matrix.md

@@ -3,11 +3,11 @@
 CurrentModule = FiniteStateProjection
 ```
 
-FiniteStateProjection.jl provides functionality for building the right-hand side of the CME as a (sparse) matrix. This provides another way to solve the CME in time via
+FiniteStateProjection.jl provides functionality for building the right-hand side of the CME as a (sparse) matrix. This provides another way to solve the CME in time:
 ```julia
 ...
 
-A = convert(SparseMatrixCSC, sys, idxhandler, dims, p)
+A = convert(SparseMatrixCSC, sys, dims, p, 0)
 
 prob = ODEProblem((du,u,p,t) -> mul!(du, p, u), u0, tt, A)
 
@@ -18,7 +18,6 @@ Note that the matrix `A` has to be rebuilt for every truncation size and every s
 a restriction not shared by the `ODEFunction` returned by FiniteStateProjection.jl.
 
 ```@docs
-convert(::Type{SparseMatrixCSC}, ::FSPSystem, ::AbstractIndexHandler, 
-::NTuple, ps; combinatoric_ratelaw::Bool=true)
+convert(::Type{SparseMatrixCSC}, ::FSPSystem, ::NTuple, ps, t)
 vec
 ```

docs/src/theory.md

@@ -1,4 +1,4 @@
-# Tips and Tricks
+# [Tips and Tricks](@id tips)
 
 The FSP approximates an infinite-dimensional system of equations by truncating it to a finite number of variables. The accuracy of the FSP therefore depends on how many variables are retained, ie.~what portion of the state space is modelled. While simple reaction networks with 1 or 2 species are not too difficult to handle using the FSP, a naive approach will require unfeasibly large truncations for systems of even moderate complexity.