Merge pull request #26 from ChrisRackauckas/fix-formatting

Apply JuliaFormatter to fix code formatting

Author: ChrisRackauckas

.JuliaFormatter.toml

@@ -0,0 +1,3 @@
+style = "sciml"
+format_markdown = true
+format_docstrings = true

README.md

@@ -5,14 +5,17 @@
 Finite State Projection [[1]](#1)  algorithms for chemical reaction networks based on [Catalyst.jl](https://github.com/SciML/Catalyst.jl) and [ModelingToolkit.jl](https://github.com/SciML/ModelingToolkit.jl). Converts descriptions of reaction networks into `ODEProblem`s and `SteadyStateProblem`s for use with [DifferentialEquations.jl](https://github.com/SciML/DifferentialEquations.jl).
 
 ## Features:
-- Built on top of [Catalyst.jl](https://github.com/SciML/Catalyst.jl)
-- FSP equations are generated as `ODEFunction`/`ODEProblem`s and can be solved with [DifferentialEquations.jl](https://github.com/SciML/DifferentialEquations.jl), with on-the-fly generation of targeted functions for improved performance
-- The Chemical Master Equation can be represented as a `SparseMatrixCSC`
+
+  - Built on top of [Catalyst.jl](https://github.com/SciML/Catalyst.jl)
+  - FSP equations are generated as `ODEFunction`/`ODEProblem`s and can be solved with [DifferentialEquations.jl](https://github.com/SciML/DifferentialEquations.jl), with on-the-fly generation of targeted functions for improved performance
+  - The Chemical Master Equation can be represented as a `SparseMatrixCSC`
 
 More information is available in the [documentation](https://kaandocal.github.io/FiniteStateProjection.jl/dev/). Please feel free to open issues and submit pull requests!
 
 ## Examples
+
 ### Birth-Death System
+
 ```julia
 using FiniteStateProjection
 using OrdinaryDiffEq
@@ -25,7 +28,7 @@ end
 sys = FSPSystem(rn)
 
 # Parameters for our system
-ps = [ :σ => 10.0, :d => 1.0 ]
+ps = [:σ => 10.0, :d => 1.0]
 
 # Initial distribution (over 1 species)
 # Here we start with 0 copies of A
@@ -35,9 +38,11 @@ u0[1] = 1.0
 prob = ODEProblem(sys, u0, (0, 10.0), ps)
 sol = solve(prob, Vern7())
 ```
+
 ![Visualisation](docs/src/assets/birth_death.png)
 
 ### Telegraph Model
+
 ```julia
 using FiniteStateProjection
 using OrdinaryDiffEq
@@ -52,16 +57,17 @@ end
 sys = FSPSystem(rn)
 
 # Parameters for our system
-ps = [ :σ_on => 0.25, :σ_off => 0.15, :ρ => 15.0, :d => 1.0 ]
+ps = [:σ_on => 0.25, :σ_off => 0.15, :ρ => 15.0, :d => 1.0]
 
 # Initial distribution (over two species)
 # Here we start with 0 copies of G_on and M
 u0 = zeros(2, 50)
-u0[1,1] = 1.0
+u0[1, 1] = 1.0
 
 prob = ODEProblem(sys, u0, (0, 10.0), ps)
 sol = solve(prob, Vern7())
 ```
+
 ![Visualisation](docs/src/assets/telegraph.png)
 
 ## References

demo/birth_death.jl

@@ -14,7 +14,7 @@ end
 sys = FSPSystem(rs)
 
 # Parameters for our system
-ps = [ :r1 => 10.0, :r2 => 1.0 ]
+ps = [:r1 => 10.0, :r2 => 1.0]
 
 # Initial values
 u0 = zeros(50)
@@ -26,12 +26,12 @@ prob = ODEProblem(sys, u0, 10.0, ps)
 
 ##
 
-sol = solve(prob, Vern7(), dense=false, save_everystep=false, abstol=1e-6)
+sol = solve(prob, Vern7(), dense = false, save_everystep = false, abstol = 1e-6)
 
 ##
 
 plt.suptitle(L"Distribution at $t = 10$")
-plt.bar(0:49, sol.u[end], width=1);
+plt.bar(0:49, sol.u[end], width = 1);
 plt.xlabel("# of Molecules")
 plt.ylabel("Probability")
 plt.xlim(-0.5, 49.5)

demo/telegraph.jl

@@ -16,7 +16,7 @@ end
 sys = FSPSystem(rs)
 
 # Parameters for our system
-ps = [ :r1 => 0.25, :r2 => 0.15, :r3 => 15.0, :r4 => 1.0 ]
+ps = [:r1 => 0.25, :r2 => 0.15, :r3 => 15.0, :r4 => 1.0]
 
 # Initial values
 # Since G_on + G_off = const. we do not have to model the two
@@ -29,20 +29,20 @@ ps = [ :r1 => 0.25, :r2 => 0.15, :r3 => 15.0, :r4 => 1.0 ]
 #  2
 #
 u0 = zeros(2, 50)
-u0[1,1] = 1.0
+u0[1, 1] = 1.0
 
 ##
 
 prob = ODEProblem(sys, u0, 10.0, ps)
 
 ##
 
-sol = solve(prob, Vern7(), dense=false, save_everystep=false, abstol=1e-6)
+sol = solve(prob, Vern7(), dense = false, save_everystep = false, abstol = 1e-6)
 
 ##
 
 plt.suptitle(L"Distribution at $t = 10$")
-plt.bar(0:49, sol.u[end][1,:] + sol.u[end][2,:], width=1);
+plt.bar(0:49, sol.u[end][1, :] + sol.u[end][2, :], width = 1);
 plt.xlabel("# of mRNA")
 plt.ylabel("Probability")
 plt.xlim(-0.5, 49.5)

docs/make.jl

@@ -2,19 +2,18 @@ using Documenter
 using FiniteStateProjection
 using SparseArrays
 
-makedocs(sitename="FiniteStateProjection.jl", 
-         modules=[FiniteStateProjection],
-         format = Documenter.HTML(prettyurls = false),
-         pages = [
-             "Home" => "index.md",
-             "Main API" => "mainapi.md",
-             "Index Handlers" => "indexhandlers.md",
-             "Matrix Conversions" => "matrix.md",
-             "Internal API" => "internal.md",
-             "Tips & Tricks" => "tips.md",
-             "Troubleshooting" => "troubleshoot.md",
-             "Examples" => "examples.md"
-         ])
- 
+makedocs(sitename = "FiniteStateProjection.jl",
+    modules = [FiniteStateProjection],
+    format = Documenter.HTML(prettyurls = false),
+    pages = [
+        "Home" => "index.md",
+        "Main API" => "mainapi.md",
+        "Index Handlers" => "indexhandlers.md",
+        "Matrix Conversions" => "matrix.md",
+        "Internal API" => "internal.md",
+        "Tips & Tricks" => "tips.md",
+        "Troubleshooting" => "troubleshoot.md",
+        "Examples" => "examples.md"
+    ])
 
-deploydocs(repo = "github.com/kaandocal/FiniteStateProjection.jl.git", devbranch="main")
+deploydocs(repo = "github.com/kaandocal/FiniteStateProjection.jl.git", devbranch = "main")

docs/src/examples.md

@@ -16,7 +16,7 @@ end
 sys = FSPSystem(rn)
 
 # Parameters for our system
-ps = [ 10.0, 1.0 ]
+ps = [10.0, 1.0]
 
 # Initial distribution (over 1 species)
 # Here we start with 0 copies of A
@@ -26,6 +26,7 @@ u0[1] = 1.0
 prob = ODEProblem(sys, u0, (0, 10.0), ps)
 sol = solve(prob, Vern7())
 ```
+
 ![Visualisation](assets/birth_death.png)
 
 ## Telegraph Model
@@ -35,7 +36,7 @@ Here we showcase the telegraph model, a simplistic description of mRNA transcrip
 The most straightforward description of this system includes three species: two gene states, `G_on` and `G_off`, and mRNA `M`. The state space for this system is 3-dimensional. We know, however, that `G_on` and `G_off` never occur at the same time, indeed the conservation law `[G_on] + [G_off] = 1` allows us to express the state of the system in terms of `G_on` and `M` only. The state space of this reduced system is 2-dimensional.If we use an mRNA cutoff of 100, the state space for the original model has size ``2 \times 2 \times 100 = 400``, while the reduced state space has size ``2 \times 100 = 200``, a two-fold saving. Since the FSP get computationally more expensive for each species in a system, eliminating redundant species as above is recommended for improved performance.
 
 !!! note
-
+    
     The class `ReducingIndexHandler`, which performed such reduction on the fly, has been deprecated and will be moved into [Catalyst.jl](https://github.com/SciML/Catalyst.jl).
 
 ```julia
@@ -52,14 +53,15 @@ end
 sys = FSPSystem(rn)
 
 # Parameters for our system
-ps = [ 0.25, 0.15, 15.0, 1.0 ]
+ps = [0.25, 0.15, 15.0, 1.0]
 
 # Initial distribution (over two species)
 # Here we start with 0 copies of G_on and M
 u0 = zeros(2, 50)
-u0[1,1] = 1.0
+u0[1, 1] = 1.0
 
 prob = ODEProblem(sys, u0, (0, 10.0), ps)
 sol = solve(prob, Vern7())
 ```
+
 ![Visualisation](assets/telegraph.png)

docs/src/index.md

@@ -8,9 +8,9 @@ CurrentModule=FiniteStateProjection
 
 FiniteStateProjection.jl is a package that implements Finite State Projection algorithms for chemical reaction networks based on [Catalyst.jl](https://github.com/SciML/Catalyst.jl) and [ModelingToolkit](https://github.com/SciML/ModelingToolkit.jl). FiniteStateProjection.jl converts descriptions of reaction networks into `ODEProblem`s that can be used to compute approximate solutions of the Chemical Master Equation with packages such as [DifferentialEquations.jl](https://github.com/SciML/DifferentialEquations.jl).
 
-The Chemical Master Equation allows us to compute the probability of a reaction system to be in a given state ``\vec n`` at a time ``t``. The state of a system with ``s`` species is described by a vector ``\vec n = (n_1, n_2, \ldots, n_s)`` of length ``s``, where ``n_1, n_2, \ldots`` are the abundances of the different species. The reaction system itself can be represented by an ``s``-dimensional array ``P[n_1,\ldots,n_s]`` that describes the probability of the system being in state ``(n_1,\ldots,n_s)``. Here ``P`` depends on time as the system evolves. Given initial conditions ``P(0)``, the time evolution of ``P`` is given by the Chemical Master Equation, which is a set of linear ODEs that can be solved numerically to predict the probability distribution of the system in the future. 
+The Chemical Master Equation allows us to compute the probability of a reaction system to be in a given state ``\vec n`` at a time ``t``. The state of a system with ``s`` species is described by a vector ``\vec n = (n_1, n_2, \ldots, n_s)`` of length ``s``, where ``n_1, n_2, \ldots`` are the abundances of the different species. The reaction system itself can be represented by an ``s``-dimensional array ``P[n_1,\ldots,n_s]`` that describes the probability of the system being in state ``(n_1,\ldots,n_s)``. Here ``P`` depends on time as the system evolves. Given initial conditions ``P(0)``, the time evolution of ``P`` is given by the Chemical Master Equation, which is a set of linear ODEs that can be solved numerically to predict the probability distribution of the system in the future.
 
-Since the number of states for a system can be infinite, the Finite State Projection approximates the Chemical Master Equation by only considering a finite number of states, namely those which are most probable. There are various ways to truncate the state space, but the most common is to provide an upper limit for each species, that is, to require ``n_1 < M_1``, ``n_2 < M_2``, etc. for fixed thresholds ``M_1, M_2, \ldots``. The number of states considered will be ``M_1 \times M_2 \times \ldots \times M_s``, and ``P`` can be represented as an array with those dimensions. While truncating the CME allows us to solve the equations numerically, the amount of space required to store ``P`` increases quickly as more species are added. 
+Since the number of states for a system can be infinite, the Finite State Projection approximates the Chemical Master Equation by only considering a finite number of states, namely those which are most probable. There are various ways to truncate the state space, but the most common is to provide an upper limit for each species, that is, to require ``n_1 < M_1``, ``n_2 < M_2``, etc. for fixed thresholds ``M_1, M_2, \ldots``. The number of states considered will be ``M_1 \times M_2 \times \ldots \times M_s``, and ``P`` can be represented as an array with those dimensions. While truncating the CME allows us to solve the equations numerically, the amount of space required to store ``P`` increases quickly as more species are added.
 
 FiniteStateProjection.jl works by converting a `ReactionSystem` into a function that computes the right-hand side of the (truncated) Chemical Master Equation:
 
@@ -19,11 +19,12 @@ FiniteStateProjection.jl works by converting a `ReactionSystem` into a function
 This function is generated dynamically as an `ODEFunction` for use with DifferentialEquations.jl and specialised for each `ReactionSystem`. Users can use their preferred array types and provide additional features by overloading the functions in this package. Alternatively the matrix `A` can be constructed as a `SparseMatrixCSC`. FiniteStateProjection.jl supports both the time-dependent Chemical Master Equation and its steady-state version.
 
 ## Features
-- Built on top of [Catalyst.jl](https://github.com/SciML/Catalyst.jl)
-- FSP equations are generated as `ODEFunction`/`ODEProblem`s and can be solved with [DifferentialEquations.jl](https://github.com/SciML/DifferentialEquations.jl), with on-the-fly generation of targeted functions for improved performance
-- The Chemical Master Equation can be generated as a `SparseMatrixCSC`
-- Flexible API for user-defined array types via `IndexHandler`s
+
+  - Built on top of [Catalyst.jl](https://github.com/SciML/Catalyst.jl)
+  - FSP equations are generated as `ODEFunction`/`ODEProblem`s and can be solved with [DifferentialEquations.jl](https://github.com/SciML/DifferentialEquations.jl), with on-the-fly generation of targeted functions for improved performance
+  - The Chemical Master Equation can be generated as a `SparseMatrixCSC`
+  - Flexible API for user-defined array types via `IndexHandler`s
 
 ## 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!
+Special thanks to [Xiamong Fu](https://github.com/palmtree2013), [Brian Munsky](https://www.engr.colostate.edu/%7Emunsky/) 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,6 +1,6 @@
 # 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 [`DefaultIndexHandler`](@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). 
+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 [`DefaultIndexHandler`](@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).
 
 See the [internal API](@ref index_handlers_internal) on how to define your own `IndexHandler` type.
 

docs/src/internal.md

@@ -1,4 +1,5 @@
 # Internal API
+
 ```@meta
 CurrentModule = FiniteStateProjection
 ```
@@ -8,14 +9,16 @@ CurrentModule = FiniteStateProjection
 ### Index Handler Interface
 
 User-defined index handlers should inherit from `AbstractIndexHandler` and implement the following methods:
-- [`getsubstitutions`](@ref getsubstitutions)
-- [`build_rhs_header`](@ref build_rhs_header)
-- [`singleindices`](@ref singleindices)
-- [`pairedindices`](@ref pairedindices)
+
+  - [`getsubstitutions`](@ref getsubstitutions)
+  - [`build_rhs_header`](@ref build_rhs_header)
+  - [`singleindices`](@ref singleindices)
+  - [`pairedindices`](@ref pairedindices)
 
 For matrix conversions they should additionally implement:
-- [`LinearIndices`](@ref Base.LinearIndices)
-- [`vec`](@ref Base.vec)
+
+  - [`LinearIndices`](@ref Base.LinearIndices)
+  - [`vec`](@ref Base.vec)
 
 ```@docs
 singleindices
@@ -26,11 +29,13 @@ LinearIndices
 ```
 
 ### Built-in implementations
+
 ```@docs
 getsubstitutions(::DefaultIndexHandler, ::ReactionSystem)
 ```
 
 ## Function Building
+
 ```@docs
 build_rhs
 unpackparams
@@ -40,6 +45,7 @@ build_rhs_secondpass
 ```
 
 ## Steady-State Functions
+
 ```@docs
 build_rhs_ss
 build_rhs_singlepass_ss

docs/src/mainapi.md

@@ -1,4 +1,5 @@
 # Main API
+
 ```@meta
 CurrentModule = FiniteStateProjection
 ```
@@ -13,8 +14,8 @@ FSPSystem
 
 ## Creating ODE systems
 
-The following methods convert a reaction network into 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. 
- 
+The following methods convert a reaction network into 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}, ::FSPSystem)
 DiffEqBase.ODEProblem(::FSPSystem, u0, tmax, p)