fix links

Author: kanav99

docs/src/analysis/parameter_estimation.md

@@ -312,8 +312,8 @@ parameter list.
 ### turing_inference
 
 ```julia
-function turing_inference(prob::DiffEqBase.DEProblem,alg,t,data,priors; 
-                              likelihood_dist_priors, likelihood, num_samples=1000, 
+function turing_inference(prob::DiffEqBase.DEProblem,alg,t,data,priors;
+                              likelihood_dist_priors, likelihood, num_samples=1000,
                               sampler = Turing.NUTS(num_samples, 0.65), syms, kwargs...)
 ```
 
@@ -702,7 +702,7 @@ or MOSEK a try!
 
 ### Using JuMP with DiffEqParamEstim
 
-[JuMP](https://github.com/JuliaOpt/JuMP.jl) is a domain-specific modeling language 
+[JuMP](https://github.com/JuliaOpt/JuMP.jl) is a domain-specific modeling language
 for mathematical optimization embedded in Julia.
 
 ```julia
@@ -721,27 +721,27 @@ end
 ```
 
 Let's get a solution of the system with parameter values `σ=10.0` `ρ=28.0` `β=8/3` to use as our
-data. We define some convenience functions `model_ode` (to create an `ODEProblem`) and `solve_model`(to obtain 
+data. We define some convenience functions `model_ode` (to create an `ODEProblem`) and `solve_model`(to obtain
 solution of the `ODEProblem`) to use in a custom objective function later.
 
 ```julia
 u0 = [1.0;0.0;0.0]
 t = 0.0:0.01:1.0
 tspan = (0.0,1.0)
-model_ode(p_) = ODEProblem(g, u0, tspan,p_) 
+model_ode(p_) = ODEProblem(g, u0, tspan,p_)
 solve_model(mp_) = OrdinaryDiffEq.solve(model_ode(mp_), Tsit5(),saveat=0.01)
 mock_data = Array(solve_model([10.0,28.0,8/3]))
 ```
 Now we define a custom objective function to pass for optimization to JuMP using
-the `build_loss_objective` described above provided by DiffEqParamEstim that defines an objective 
+the `build_loss_objective` described above provided by DiffEqParamEstim that defines an objective
 function for the parameter estimation problem.
 
 ```julia
 loss_objective(mp_, dat) = build_loss_objective(model_ode(mp_), Tsit5(), L2Loss(t,dat))
 ```
 
-We create a JuMP model, variables, set the objective function and the choice of 
-optimization algorithm to be used in the JuMP syntax. You can read more about this in 
+We create a JuMP model, variables, set the objective function and the choice of
+optimization algorithm to be used in the JuMP syntax. You can read more about this in
 JuMP's [documentation](http://www.juliaopt.org/JuMP.jl/0.18/index.html).
 
 ```julia
@@ -763,7 +763,7 @@ Let's call the optimizer to obtain the fitted parameter values.
 sol = JuMP.solve(jumodel)
 best_mp = getvalue.(getindex.((jumodel,), Symbol.(jumodel.colNames)))
 ```
-Let's compare the solution at the obtained parameter values and our data. 
+Let's compare the solution at the obtained parameter values and our data.
 
 ```julia
 sol = OrdinaryDiffEq.solve(best_mp |> model_ode, Tsit5())
@@ -961,7 +961,7 @@ obj = build_loss_objective(monte_prob,SOSRI(),L2Loss(t,aggregate_data),
                                      parallel_type = :threads)
 result = Optim.optimize(obj, [1.0,0.5], Optim.BFGS())
 ```
-Parameter Estimation in case of SDE's with a regular `L2Loss` can have poor accuracy due to only fitting against the mean properties as mentioned in [First Differencing](http://docs.juliadiffeq.org/latest/analysis/parameter_estimation.html#First-differencing-1).
+Parameter Estimation in case of SDE's with a regular `L2Loss` can have poor accuracy due to only fitting against the mean properties as mentioned in [First Differencing](http://docs.juliadiffeq.org/latest/analysis/parameter_estimation/#First-differencing-1).
 
 ```julia
 Results of Optimization Algorithm

docs/src/analysis/sensitivity.md

@@ -98,7 +98,7 @@ end
 ```
 
 What this function does is use the `remake` function
-[from the Problem Interface page](http://docs.juliadiffeq.org/latest/basics/problem.html#Modification-of-problem-types-1)
+[from the Problem Interface page](http://docs.juliadiffeq.org/latest/basics/problem/#Modification-of-problem-types-1)
 to generate a new ODE problem with the new parameters, solves it, and returns
 the solution at the final time point. Notice that it takes care to make sure
 that the type of `u0` matches the type of `p`. This is because ForwardDiff.jl

docs/src/analysis/uncertainty_quantification.md

@@ -68,7 +68,7 @@ cb = ProbIntsUncertainty(0.2,1)
 ```
 
 This is akin to having an error of approximately 0.2 at each step. We now build
-and solve a [EnsembleProblem](../../features/ensemble.html) for 100 trajectories:
+and solve a [EnsembleProblem](../../../features/ensemble/) for 100 trajectories:
 
 ```julia
 ensemble_prob = EnsembleProblem(prob)

docs/src/basics/common_solver_opts.md

@@ -53,8 +53,8 @@ section at the end of this page for some example usage.
   most efficient manner available to the solver. Note that this
   can be used even if `dense=false`. If only `saveat` is given, then
   the arguments `save_everystep` and `dense` are `false` by default.   
-  If `saveat` is given a number, then it will automatically expand to 
-  `tspan[1]:saveat:tspan[2]`. For methods where interpolation is not possible, 
+  If `saveat` is given a number, then it will automatically expand to
+  `tspan[1]:saveat:tspan[2]`. For methods where interpolation is not possible,
   `saveat` may be equivalent to `tstops`. The default value is `[]`.
 * `save_idxs`: Denotes the indices for the components of the equation to save.
   Defaults to saving all indices. For example, if you are solving a 3-dimensional ODE,
@@ -87,7 +87,7 @@ section at the end of this page for some example usage.
 
 Note that `dense` requires `save_everystep=true` and `saveat=false`. If you need
 additional saving while keeping dense output, see
-[the SavingCallback in the Callback Library](http://docs.juliadiffeq.org/latest/features/callback_library.html).
+[the SavingCallback in the Callback Library](http://docs.juliadiffeq.org/latest/features/callback_library).
 
 ## Stepsize Control
 
@@ -147,7 +147,7 @@ Note that if a method does not have adaptivity, the following rules apply:
 These arguments control more advanced parts of the internals of adaptive timestepping
 and are mostly used to make it more efficient on specific problems. For detained
 explanations of the timestepping algorithms, see the
-[timestepping descriptions](../../extras/timestepping.html)
+[timestepping descriptions](../../../extras/timestepping/)
 
 * `internalnorm`: The norm function `internalnorm(u,t)` which error estimates
   are calculated. Required are two dispatches: one dispatch for the state variable
@@ -192,7 +192,7 @@ explanations of the timestepping algorithms, see the
 * `maxiters`: Maximum number of iterations before stopping. Defaults to 1e5.
 * `callback`: Specifies a callback. Defaults to a callback function which
   performs the saving routine. For more information, see the
-  [Event Handling and Callback Functions manual page](../../features/callback_functions.html).
+  [Event Handling and Callback Functions manual page](../../../features/callback_functions/).
 * `isoutofdomain`: Specifies a function `isoutofdomain(u,p,t)` where, when it
   returns true, it will reject the timestep. Disabled by default.
 * `unstable_check`: Specifies a function `unstable_check(dt,u,p,t)` where, when

docs/src/basics/faq.md

@@ -16,9 +16,9 @@ algorithms utilize standard arithmetical functions. Both additionally utilize
 the user's norm specified via the common interface options and, if a stiff
 solver, ForwardDiff/DiffEqDiffTools for the Jacobian calculation, and Base linear
 factorizations for the linear solve. For your type, you may likely need to give
-a [better form of the norm](http://docs.juliadiffeq.org/latest/basics/common_solver_opts.html#Advanced-Adaptive-Stepsize-Control-1),
-[Jacobian](http://docs.juliadiffeq.org/latest/features/performance_overloads.html),
-or [linear solve calculations](http://docs.juliadiffeq.org/latest/features/linear_nonlinear.html)
+a [better form of the norm](http://docs.juliadiffeq.org/latest/basics/common_solver_opts#Advanced-Adaptive-Stepsize-Control-1),
+[Jacobian](http://docs.juliadiffeq.org/latest/features/performance_overloads),
+or [linear solve calculations](http://docs.juliadiffeq.org/latest/features/linear_nonlinear)
 to fully utilize parallelism.
 
 GPUArrays.jl (CuArrays.jl), ArrayFire.jl, DistributedArrays.jl have been tested and work in
@@ -53,7 +53,7 @@ apply. What you want to do first is make sure your function does not allocate.
 If your system is small (`<=100` ODEs/SDEs/DDEs/DAEs?), then you should set your
 system up to use [StaticArrays.jl](https://github.com/JuliaArrays/StaticArrays.jl).
 This is demonstrated
-[in the ODE tutorial](http://docs.juliadiffeq.org/latest/tutorials/ode_example.html#Example-3:-Using-Other-Types-for-Systems-of-Equations-1)
+[in the ODE tutorial](http://docs.juliadiffeq.org/latest/tutorials/ode_example#Example-3:-Using-Other-Types-for-Systems-of-Equations-1)
 with static matrices. Static vectors/arrays are stack-allocated, and thus creating
 new arrays is free and the compiler doesn't have to heap-allocate any of the
 temporaries (that's the expensive part!). These have specialized super fast
@@ -102,7 +102,7 @@ and do a dense factorization. However, in many cases you may want to use alterna
 that are more tuned for your problem.
 
 First of all, when available, it's recommended that you pass a function for computing
-your Jacobian. This is discussed in the [performance overloads](http://docs.juliadiffeq.org/latest/features/performance_overloads.html#Declaring-Explicit-Jacobians-1)
+your Jacobian. This is discussed in the [performance overloads](http://docs.juliadiffeq.org/latest/features/performance_overloads#Declaring-Explicit-Jacobians-1)
 section. Jacobians are especially helpful for Rosenbrock methods.
 
 Secondly, if your Jacobian isn't dense, you shouldn't use a dense Jacobian! In
@@ -111,9 +111,9 @@ for example. More support is coming for this soon.
 
 But lastly, you shouldn't use a dense factorization for large sparse matrices.
 Instead, if you're using  a `*DiffEq` library you should
-[specify a linear solver](http://docs.juliadiffeq.org/latest/features/linear_nonlinear.html).
+[specify a linear solver](http://docs.juliadiffeq.org/latest/features/linear_nonlinear).
 For Sundials.jl, you should change the `linear_solver` option. See
-[the ODE solve Sundials portion](http://docs.juliadiffeq.org/latest/solvers/ode_solve.html#Sundials.jl-1)
+[the ODE solve Sundials portion](http://docs.juliadiffeq.org/latest/solvers/ode_solve#Sundials.jl-1)
 for details on that. Right now, Sundials.jl is the recommended method for stiff
 problems with large sparse Jacobians. `linear_solver=:Band` should be used
 if your Jacobian is banded and you can specify the band sizes. If you only
@@ -186,7 +186,7 @@ Of course, there's always a tradeoff between accuracy and efficiency, so play
 around to find out what's right for your problem.
 
 Another thing you can do is use a callback. There are some
-[premade callbacks in the callback library](http://docs.juliadiffeq.org/latest/features/callback_library.html) which
+[premade callbacks in the callback library](http://docs.juliadiffeq.org/latest/features/callback_library) which
 handle these sorts of things like projecting to manifolds and preserving positivity.
 
 ##### The symplectic integrator doesn't conserve energy?
@@ -208,7 +208,7 @@ will reduce the error. The results in the
 [DiffEqBenchmarks](https://github.com/JuliaDiffEq/DiffEqBenchmarks.jl) show
 that using a `DPRKN` method with low tolerance can be a great choice. Another
 thing you can do is use
-[the ManifoldProjection callback from the callback library](http://docs.juliadiffeq.org/latest/features/callback_library.html).
+[the ManifoldProjection callback from the callback library](http://docs.juliadiffeq.org/latest/features/callback_library).
 
 #### How do I get to zero error?
 
@@ -221,7 +221,7 @@ like BigFloats or [ArbFloats.jl](https://github.com/JuliaArbTypes/ArbFloats.jl).
 #### Are the native Julia solvers compatible with autodifferentiation?
 
 Yes! Take a look at the
-[sensitivity analysis](http://docs.juliadiffeq.org/latest/analysis/sensitivity.html)
+[sensitivity analysis](http://docs.juliadiffeq.org/latest/analysis/sensitivity)
 page for more details.
 
 If the algorithm does not have differentiation of parameter-depedendent events,

docs/src/basics/overview.md

@@ -47,7 +47,7 @@ sol = solve(prob,alg;kwargs)
 Into the command, one passes the differential equation problem that they defined
 `prob`, optionally choose an algorithm `alg` (a default is given if not
 chosen), and change the properties of the solver using keyword arguments. The common
-arguments which are accepted by most methods is defined in [the common solver options manual page](../common_solver_opts.html).
+arguments which are accepted by most methods is defined in [the common solver options manual page](../common_solver_opts).
 The solver returns a solution object `sol` which hold all of the details for the solution.
 
 ## Analyzing the Solution
@@ -56,7 +56,7 @@ With the solution object, you do the analysis as you please! The solution type
 has a common interface which makes handling the solution similar between the
 different types of differential equations. Tools such as interpolations
 are seamlessly built into the solution interface to make analysis easy. This
-interface is described in the [solution handling manual page](../solution.html).
+interface is described in the [solution handling manual page](../solution).
 
 Plotting functionality is provided by a recipe to Plots.jl. To
 use plot solutions, simply call the `plot(sol)` and the plotter will generate

docs/src/features/callback_functions.md

@@ -102,7 +102,7 @@ DiscreteCallback(condition,affect!;
 ### CallbackSet
 
 Multiple callbacks can be chained together to form a `CallbackSet`. A `CallbackSet`
-is constructed by passing the constructor `ContinuousCallback`, `DiscreteCallback`, 
+is constructed by passing the constructor `ContinuousCallback`, `DiscreteCallback`,
 `VectorContinuousCallback` or other `CallbackSet` instances:
 
 ```julia
@@ -135,7 +135,7 @@ VectorContinuousCallback(condition,affect!,len;
                    abstol=10eps(),reltol=0)
 ```
 
-`VectorContinuousCallback` is also a subtype of `AbstractContinuousCallback`. `CallbackSet` is not feasible when you have a large number of callbacks, as it doesn't scale well. For this reason, we have `VectorContinuousCallback` - it allows you to have a single callback for multiple events. 
+`VectorContinuousCallback` is also a subtype of `AbstractContinuousCallback`. `CallbackSet` is not feasible when you have a large number of callbacks, as it doesn't scale well. For this reason, we have `VectorContinuousCallback` - it allows you to have a single callback for multiple events.
 
 * `condition` - This is a function `condition(out, u, t, integrator)` which should save the condition value in the array `out` at the right index. Maximum index of `out` should be specified in the `len` property of callback. So this way you can have a chain of `len` events, which would cause the `i`th event to trigger when `out[i] = 0`.
 
@@ -168,7 +168,7 @@ be true for at least one callback.
 
 A common issue with callbacks is that they cause a large discontinuous change,
 and so it may be wise to pull down `dt` after such a change. To control the
-timestepping from a callback, please see [the timestepping controls in the integrator interface](../basics/integrator.html#Stepping-Controls-1). Specifically, `set_proposed_dt!` is used to set the next stepsize,
+timestepping from a callback, please see [the timestepping controls in the integrator interface](../basics/integrator#Stepping-Controls-1). Specifically, `set_proposed_dt!` is used to set the next stepsize,
 and `terminate!` can be used to cause the simulation to stop.
 
 ## DiscreteCallback Examples
@@ -251,7 +251,7 @@ a library of useful callbacks for JuliaDiffEq solvers.
 
 ### Example 2: A Control Problem
 
-Another example of a `DiscreteCallback` is the [control problem demonstrated on the DiffEq-specific arrays page](http://docs.juliadiffeq.org/latest/features/diffeq_arrays.html#Example:-A-Control-Problem-1).
+Another example of a `DiscreteCallback` is the [control problem demonstrated on the DiffEq-specific arrays page](http://docs.juliadiffeq.org/latest/features/diffeq_arrays#Example:-A-Control-Problem-1).
 
 ## ContinuousCallback Examples
 
@@ -509,7 +509,7 @@ This allows you to build sophisticated models of populations with births and dea
 
 ### Example 1: Bouncing Ball with multiple walls
 
-This is similar to the above Bouncing Ball example, but now we have two more vertical walls, at `x = 0` and `x = 10.0`. We have our ODEFunction as - 
+This is similar to the above Bouncing Ball example, but now we have two more vertical walls, at `x = 0` and `x = 10.0`. We have our ODEFunction as -
 
 ```julia
 function f(du,u,p,t)
@@ -520,7 +520,7 @@ function f(du,u,p,t)
 end
 ```
 
-where `u[1]` denotes `y`-coordinate, `u[2]` denotes velocity in `y`-direction, `u[3]` denotes `x`-coordinate and `u[4]` denotes velocity in `x`-direction. We will make a `VectorContinuousCallback` of length 2 - one for `x` axis collision, one for walls parallel to `y` axis. 
+where `u[1]` denotes `y`-coordinate, `u[2]` denotes velocity in `y`-direction, `u[3]` denotes `x`-coordinate and `u[4]` denotes velocity in `x`-direction. We will make a `VectorContinuousCallback` of length 2 - one for `x` axis collision, one for walls parallel to `y` axis.
 
 ```julia
 function condition(out,u,t,integrator) # Event when event_f(u,t) == 0
@@ -550,6 +550,6 @@ prob = ODEProblem(f,u0,tspan,p)
 sol = solve(prob,Tsit5(),callback=cb,dt=1e-3,adaptive=false)
 plot(sol,vars=(1,3))
 ```
-And you get the following output: 
+And you get the following output:
 
 ![Cell1](../assets/ball2.png)