format

Author: ErikQQY

docs/src/basics/plot.md

@@ -75,52 +75,49 @@ the following conveniences are provided:
   - Everywhere in a tuple position where we only find an integer, this
     variable is plotted as a function of time.  For example, the list above
     is equivalent to:
-
+    
     ```julia
     idxs = [1, (1, 3), (4, 5)]
     ```
-
+    
     and
-
+    
     ```julia
     idxs = [1, 3, 4]
     ```
-
+    
     is the most concise way to plot the variables 1, 3, and 4 as a function
     of time.
 
   - It is possible to omit the list if only one plot is wanted: `(2,3)`
     and `4` are respectively equivalent to `[(2,3)]` and `[(0,4)]`.
-
   - A tuple containing one or several lists will be expanded by
     associating corresponding elements of the lists with each other:
-
+    
     ```julia
     idxs = ([1, 2, 3], [4, 5, 6])
     ```
-
+    
     is equivalent to
-
+    
     ```julia
     idxs = [(1, 4), (2, 5), (3, 6)]
     ```
-
+    
     and
-
+    
     ```julia
     idxs = (1, [2, 3, 4])
     ```
-
+    
     is equivalent to
-
+    
     ```julia
     idxs = [(1, 2), (1, 3), (1, 4)]
     ```
-
   - Instead of using integers, one can use the symbols from a `ParameterizedFunction`.
     For example, `idxs=(:x,:y)` will replace the symbols with the integer values for
     components `:x` and `:y`.
-
   - n-dimensional groupings are allowed. For example, `(1,2,3,4,5)` would be a
     5-dimensional plot between the associated variables.
 

docs/src/examples/kepler_problem.md

@@ -27,6 +27,7 @@ sol = solve(prob, KahanLi6(), dt = 1 // 10);
 ```
 
 !!! note
+    
     Note that NonlinearSolve.jl is required to be imported for ManifoldProjection
 
 Let's plot the orbit and check the energy and angular momentum variation. We know that energy and angular momentum should be constant, and they are also called first integrals.

docs/src/extras/timestepping.md

@@ -190,7 +190,8 @@ end
 
 function StochasticDiffEq.stepsize_controller!(integrator::StochasticDiffEq.SDEIntegrator,
         controller::CustomController, alg)
-    integrator.q11 = DiffEqBase.value(FastPower.fastpower(integrator.EEst, controller.beta1))
+    integrator.q11 = DiffEqBase.value(FastPower.fastpower(
+        integrator.EEst, controller.beta1))
     integrator.q = DiffEqBase.value(integrator.q11 /
                                     FastPower.fastpower(integrator.qold, controller.beta2))
     integrator.q = DiffEqBase.value(max(inv(integrator.opts.qmax),

docs/src/features/io.md

@@ -81,11 +81,11 @@ work. If none of these are put into scope, the solution type
 will still load and hold all of the values (so `sol.u` and `sol.t`
 will work), but none of the interface will be available.
 
-If you want a copy of the solution that contains no function information 
+If you want a copy of the solution that contains no function information
 you can use the function `SciMLBase.strip_solution(sol)`.
-This will return a copy of the solution that doesn't have any functions, 
+This will return a copy of the solution that doesn't have any functions,
 which you can serialize and deserialize without having any of the problems
-that typically come with serializing functions. 
+that typically come with serializing functions.
 
 ## JLD
 

docs/src/solvers/bvp_solve.md

@@ -1,10 +1,10 @@
 # [BVP Solvers](@id bvp_solve)
 
 ```julia
-solve(prob::BVProblem,alg,dt;kwargs)
-solve(prob::TwoPointBVProblem,alg,dt;kwargs)
-solve(prob::SecondOrderBVProblem,alg,dt;kwargs)
-solve(prob::SecondOrderTwoPointBVProblem,alg,dt;kwargs)
+solve(prob::BVProblem, alg, dt; kwargs)
+solve(prob::TwoPointBVProblem, alg, dt; kwargs)
+solve(prob::SecondOrderBVProblem, alg, dt; kwargs)
+solve(prob::SecondOrderTwoPointBVProblem, alg, dt; kwargs)
 ```
 
 Solves the BVP defined by `prob` using the algorithm `alg`. All algorithms except `Shooting` and `MultipleShooting` methods should specify a `dt` which is the step size for the discretized mesh.
@@ -39,20 +39,18 @@ off via the keyword argument `adaptive = false`.
 Similar to `MIRK` methods, fully implicit Runge-Kutta methods construct nonlinear problems from the collocation equations of a BVP and solve such nonlinear systems to obtain numerical solutions of BVP. When solving large boundary value problems, choose a nested NonlinearSolve.jl solver by setting `nested_nlsolve=true` in FIRK solvers can achieve better performance.
 
   - `LobattoIIIa2` - A 2nd stage LobattoIIIa collocation method.
+
   - `LobattoIIIa3` - A 3rd stage LobattoIIIa collocation method.
   - `LobattoIIIa4` - A 4th stage LobattoIIIa collocation method.
   - `LobattoIIIa5` - A 5th stage LobattoIIIa collocation method.
-
   - `LobattoIIIb2` - A 2nd stage LobattoIIIa collocation method, doesn't support defect control adaptivity.
   - `LobattoIIIb3` - A 3rd stage LobattoIIIa collocation method.
   - `LobattoIIIb4` - A 4th stage LobattoIIIa collocation method.
   - `LobattoIIIb5` - A 5th stage LobattoIIIa collocation method.
-
   - `LobattoIIIc2` - A 2nd stage LobattoIIIa collocation method, doesn't support defect control adaptivity.
   - `LobattoIIIc3` - A 3rd stage LobattoIIIa collocation method.
   - `LobattoIIIc4` - A 4th stage LobattoIIIa collocation method.
   - `LobattoIIIc5` - A 5th stage LobattoIIIa collocation method.
-
   - `RadauIIa1` - A 1st stage Radau collocation method, doesn't support defect control adaptivity.
   - `RadauIIa2` - A 2nd stage Radau collocation method.
   - `RadauIIa3` - A 3rd stage Radau collocation method.

docs/src/solvers/ode_solve.md

@@ -959,20 +959,24 @@ using IRKGaussLegendre
 
 `IRKGL16(;kwargs...)` has the following arguments:
 
-- second_order_ode (boolean):
-  - =false (default): for a ODEProblem type 
-  - =true: for a second-order differential equation 
-- simd (boolean):
-  - =true: SIMD-vectorized implementation only available for Float32 or Float64 computations
-  - =false (default):  generic implementation that can use with arbitrary Julia-defined number systems 
-- mstep: output saved at every 'mstep' steps. Default 1.
-- initial_extrapolation: initialization method for stages.
-  - =false: simplest initialization
-  - =true (default): extrapolation from the stage values of previous step
-- maxtrials: maximum number of attempts to accept adaptive step size
-- threading
-  - =false (default): sequential execution of the numerical integration
-  - =true: computations using threads (shared memory multi-threading) for stage-wise parallelization
+  - second_order_ode (boolean):
+    
+      + =false (default): for a ODEProblem type
+      + =true: for a second-order differential equation
+  - simd (boolean):
+    
+      + =true: SIMD-vectorized implementation only available for Float32 or Float64 computations
+      + =false (default):  generic implementation that can use with arbitrary Julia-defined number systems
+  - mstep: output saved at every 'mstep' steps. Default 1.
+  - initial_extrapolation: initialization method for stages.
+    
+      + =false: simplest initialization
+      + =true (default): extrapolation from the stage values of previous step
+  - maxtrials: maximum number of attempts to accept adaptive step size
+  - threading
+    
+      + =false (default): sequential execution of the numerical integration
+      + =true: computations using threads (shared memory multi-threading) for stage-wise parallelization
 
 ### SimpleDiffEq.jl
 

docs/src/tutorials/bvp_example.md

@@ -40,8 +40,8 @@ The boundary conditions are specified by a function that calculates the residual
 
 ```@example bvp
 function bc1!(residual, u, p, t)
-    residual[1] = u(pi/4)[1] + pi / 2 # the solution at the middle of the time span should be -pi/2
-    residual[2] = u(pi/2)[1] - pi / 2 # the solution at the end of the time span should be pi/2
+    residual[1] = u(pi / 4)[1] + pi / 2 # the solution at the middle of the time span should be -pi/2
+    residual[2] = u(pi / 2)[1] - pi / 2 # the solution at the end of the time span should be pi/2
 end
 bvp1 = BVProblem(simplependulum!, bc1!, [pi / 2, pi / 2], tspan)
 sol1 = solve(bvp1, MIRK4(), dt = 0.05)
@@ -174,4 +174,4 @@ tspan = (0.0, 1.0)
 fun = BVPFunction(f!, bc!, mass_matrix = [1 0 0 0; 0 1 0 0; 0 0 1 0; 0 0 0 0])
 prob = BVProblem(fun, u0, tspan)
 sol = solve(prob, Ascher4(zeta = [0.0, 0.0, 1.0]), dt = 0.01)
-```
+```