Update URL to use jso.dev

abelsiqueira · abelsiqueira · commit 577dd2cd630d · 2023-09-05T22:38:04.000+02:00
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
@@ -14,5 +14,5 @@
   - [ ] The preview has your tutorial listed.
   - [ ] The preview looks like what you want.
 
-[preview]: https://juliasmoothoptimizers.github.io/JSOTutorials.jl/
+[preview]: https://jso.dev/JSOTutorials.jl/
 [Grammarly]: https://www.grammarly.com
diff --git a/.github/workflows/Deploy-internal.yml b/.github/workflows/Deploy-internal.yml
@@ -43,7 +43,7 @@ jobs:
       - name: Install Julia
         uses: julia-actions/setup-julia@v1
         with:
-           version: 1
+          version: 1
       - name: Build tutorial
         run: |
           bash .github/workflows/build_tutorial.sh ${{ matrix.tutorial }}
@@ -73,7 +73,7 @@ jobs:
           cd JSOTutorials.jl-gh-pages
           echo "## JSOTutorials preview page
 
-          For the complete list of tutorials, go to <https://juliasmoothoptimizers.github.io/tutorials/>.
+          For the complete list of tutorials, go to <https://jso.dev/tutorials/>.
 
           " > index.md
           for file in **/*.md; do NAME=$(echo $file | cut -d/ -f 1); TITLE=$(grep "title:" $file | cut -d\" -f2); echo "- [$TITLE]($NAME/)"; done >> index.md
@@ -88,11 +88,11 @@ jobs:
     runs-on: ubuntu-latest
     if: ${{ needs.generate-job-strategy-matrix.outputs.job-strategy-matrix != '[]' }}
     steps:
-      - name: 'Comment PR'
+      - name: "Comment PR"
         uses: actions/github-script@0.3.0
         if: github.event_name == 'pull_request' && github.repository == github.event.pull_request.head.repo.full_name # if this is a pull request build AND the pull request is NOT made from a fork
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |
             const { issue: { number: issue_number }, repo: { owner, repo }  } = context;
-            github.issues.createComment({ issue_number, owner, repo, body: 'Once the build has completed, you can preview your PR at this URL: https://juliasmoothoptimizers.github.io/JSOTutorials.jl/' });
+            github.issues.createComment({ issue_number, owner, repo, body: 'Once the build has completed, you can preview your PR at this URL: https://jso.dev/JSOTutorials.jl/' });
diff --git a/README.md b/README.md
@@ -1,7 +1,7 @@
 # JSO Tutorials
 
 Curated repository of tutorials regarding all things JSO.
-See the renderer tutorials in <https://juliasmoothoptimizers.github.io>.
+See the renderer tutorials in <https://jso.dev>.
 
 ## Development
 
diff --git a/src/JSOTutorials.jl b/src/JSOTutorials.jl
@@ -9,7 +9,7 @@ using Weave, Pkg, IJulia, InteractiveUtils, Markdown, YAML
 repo_directory = joinpath(@__DIR__, "..")
 # cssfile = joinpath(@__DIR__, "..", "templates", "skeleton_css.css")
 # latexfile = joinpath(@__DIR__, "..", "templates", "julia_tex.tpl")
-default_builds = (:github, )
+default_builds = (:github,)
 
 function weave_file(folder, file, build_list = default_builds)
   target = joinpath(repo_directory, "tutorials", folder, file)
@@ -54,7 +54,7 @@ function weave_file(folder, file, build_list = default_builds)
     dir = joinpath(repo_directory, "markdown", basename(folder))
     mkpath(dir)
     weave(target, doctype = "github", out_path = dir, args = args)
-    add_package_info(joinpath(dir, file[1:end-4] * ".md"))
+    add_package_info(joinpath(dir, file[1:(end - 4)] * ".md"))
   end
   if :notebook ∈ build_list
     println("Building Notebook")
@@ -89,7 +89,7 @@ end
 function package_information()
   proj = sprint(io -> Pkg.status(io = io))
   re_str = r"\[[0-f]+\]\s+(.*) v(.*)"
-  pkg_info = Dict{String,String}()
+  pkg_info = Dict{String, String}()
   for line in split(proj, "\n")
     m = match(re_str, line)
     if m !== nothing
@@ -108,7 +108,7 @@ function badge(name, version)
 
   badge_img = "![$name $version](https://img.shields.io/badge/$name-$version-$color?style=flat-square&labelColor=$lbl_color)"
   if name in jso_pkgs
-    link = "https://juliasmoothoptimizers.github.io/$name.jl/stable/"
+    link = "https://jso.dev/$name.jl/stable/"
     "[$badge_img]($link)"
   else
     badge_img
@@ -120,11 +120,11 @@ function add_package_info(filename)
   j = findall(lines .== "---")[2]
   pkg_info = package_information()
   out = [
-    lines[1:j];
-    "";
-    [badge(pkg, ver) for (pkg, ver) in pkg_info];
-    "";
-    lines[j+1:end]
+    lines[1:j]
+    ""
+    [badge(pkg, ver) for (pkg, ver) in pkg_info]
+    ""
+    lines[(j + 1):end]
   ]
   open(filename, "w") do io
     print(io, join(out, "\n"))
@@ -203,13 +203,16 @@ function parse_markdown_into_franklin(infile, outfile)
   end
 
   open(outfile, "w") do io
-    println(io, """
-    @def title = "$(yaml["title"])"
-    @def showall = true
-    @def tags = $(yaml["tags"])
-
-    \\preamble{$(yaml["author"])}
-    """)
+    println(
+      io,
+      """
+@def title = "$(yaml["title"])"
+@def showall = true
+@def tags = $(yaml["tags"])
+
+\\preamble{$(yaml["author"])}
+""",
+    )
 
     code_fence = startswith("```")
     inside_fenced_code = false
diff --git a/tutorials/generic-adnlpmodels/index.jmd b/tutorials/generic-adnlpmodels/index.jmd
@@ -10,10 +10,10 @@ using ADNLPModels, ForwardDiff, NLPModels, OptimizationProblems
 
 One of the main strengths of Julia for scientific computing is its native usage of [arbitrary precision arithmetic](https://docs.julialang.org/en/v1/manual/integers-and-floating-point-numbers/#Arbitrary-Precision-Arithmetic).
 The same can be exploited for optimization models and solvers.
-In the organization [JuliaSmoothOptimizers](https://juliasmoothoptimizers.github.io), the package [ADNLPModels.jl](https://github.com/JuliaSmoothOptimizers/ADNLPModels.jl) provides automatic differentiation (AD)-based model implementations that conform to the NLPModels API.
-This package is modular in the sense that it implements a backend system allowing the user to use essentially any AD system available, see [ADNLPModels.jl/dev/backend/](https://juliasmoothoptimizers.github.io/ADNLPModels.jl/dev/backend/) for a tutorial.
+In the organization [JuliaSmoothOptimizers](https://jso.dev), the package [ADNLPModels.jl](https://github.com/JuliaSmoothOptimizers/ADNLPModels.jl) provides automatic differentiation (AD)-based model implementations that conform to the NLPModels API.
+This package is modular in the sense that it implements a backend system allowing the user to use essentially any AD system available, see [ADNLPModels.jl/dev/backend/](https://jso.dev/ADNLPModels.jl/dev/backend/) for a tutorial.
 
-Note that most of the solvers available in [JuliaSmoothOptimizers](https://juliasmoothoptimizers.github.io) will accept generic types.
+Note that most of the solvers available in [JuliaSmoothOptimizers](https://jso.dev) will accept generic types.
 For instance, it is possible to use the classical L-BFGS method implemented in [JSOSolvers.jl](https://github.com/JuliaSmoothOptimizers/JSOSolvers.jl/) in single precision.
 
 ```julia
@@ -115,7 +115,7 @@ The same can be done for the other backends jacobian, hessian, etc.
 ## Multiprecision test problems
 
 Designing a multi-precision algorithm is very often connected with benchmarking and test problems.
-The package [OptimizationProblems.jl](https://github.com/JuliaSmoothOptimizers/OptimizationProblems.jl) provides a collection of optimization problems in JuMP and ADNLPModels syntax, see [introduction to OptimizationProblems.jl tutorial](https://juliasmoothoptimizers.github.io/tutorials/introduction-to-optimizationproblems/).
+The package [OptimizationProblems.jl](https://github.com/JuliaSmoothOptimizers/OptimizationProblems.jl) provides a collection of optimization problems in JuMP and ADNLPModels syntax, see [introduction to OptimizationProblems.jl tutorial](https://jso.dev/tutorials/introduction-to-optimizationproblems/).
 
 This package provides a `DataFrame` with all the information on the implemented problems.
 
@@ -145,4 +145,4 @@ grad!(nlp, x16, g) # returns a vector of Float16
 We should pay additional attention when using multiple precisions as casting, for instance `x0`, from `Float64` into `Float16` implies that rounding errors occur.
 Therefore, `x0` is different than `x16`, and the gradients evaluated for these values too.
 
-Feel free to look at [OptimizationProblems.jl documentation](https://juliasmoothoptimizers.github.io/OptimizationProblems.jl/dev/) to learn more or the tutorials at [juliasmoothoptimizers.github.io](https://juliasmoothoptimizers.github.io).
+Feel free to look at [OptimizationProblems.jl documentation](https://jso.dev/OptimizationProblems.jl/dev/) to learn more or the tutorials at [juliasmoothoptimizers.github.io](https://jso.dev).
diff --git a/tutorials/introduction-to-bundleadjustmentmodels/index.jmd b/tutorials/introduction-to-bundleadjustmentmodels/index.jmd
@@ -33,7 +33,7 @@ filter_df = df[ ( df.nequ .≥ 50000 ) .& ( df.nvar .≤ 34000 ), :]
 
 The `Dataframe` is listing the matrices that you can have access to, but they still need to be downloaded.
 
-Following the example above, we filtered two problems. 
+Following the example above, we filtered two problems.
 What we want to do now is to select the first one in the listing.
 
 ```julia
@@ -43,7 +43,7 @@ name = filter_df[1, :name] # select the name of the first problem
 Now that the name is selected, we need to access the problem itself, and there are 2 solutions:
 
 - You can download the problem's archive file;
-- You can automatically create a nonlinear least squares problem using [`NLPModels`](https://github.com/JuliaSmoothOptimizers/NLPModels.jl) from [JuliaSmoothOptimizers](https://juliasmoothoptimizers.github.io/).
+- You can automatically create a nonlinear least squares problem using [`NLPModels`](https://github.com/JuliaSmoothOptimizers/NLPModels.jl) from [JuliaSmoothOptimizers](https://jso.dev/).
 
 ## Get the problem archive file
 
@@ -53,21 +53,21 @@ This package uses Julia Artifacts to handle the problems archives so that
 2. They are identified with a unique hash;
 3. They can be deleted with a single command line.
 
-The method [`fetch_ba_name`](https://juliasmoothoptimizers.github.io/BundleAdjustmentModels.jl/dev/reference/#BundleAdjustmentModels.fetch_ba_name-Tuple{AbstractString}) will automatically download the problem (if needed) and return its path.
+The method [`fetch_ba_name`](https://jso.dev/BundleAdjustmentModels.jl/dev/reference/#BundleAdjustmentModels.fetch_ba_name-Tuple{AbstractString}) will automatically download the problem (if needed) and return its path.
 
 ```julia
 path = fetch_ba_name(name)
 ```
 
-It is also possible to directly download and get access to an entire group of problems using [`fetch_ba_group`](https://juliasmoothoptimizers.github.io/BundleAdjustmentModels.jl/dev/reference/#BundleAdjustmentModels.fetch_ba_group-Tuple{AbstractString}).
+It is also possible to directly download and get access to an entire group of problems using [`fetch_ba_group`](https://jso.dev/BundleAdjustmentModels.jl/dev/reference/#BundleAdjustmentModels.fetch_ba_group-Tuple{AbstractString}).
 
 ```julia
 paths = fetch_ba_group("ladybug")
 ```
 
 ## Generate a nonlinear least squares model
 
-Now, it is possible to load the model using [`BundleAdjustmentModel`](https://juliasmoothoptimizers.github.io/BundleAdjustmentModels.jl/dev/reference/#BundleAdjustmentModels.BundleAdjustmentModel-Tuple{AbstractString})
+Now, it is possible to load the model using [`BundleAdjustmentModel`](https://jso.dev/BundleAdjustmentModels.jl/dev/reference/#BundleAdjustmentModels.BundleAdjustmentModel-Tuple{AbstractString})
 
 ```julia
 df = problems_df()
@@ -84,21 +84,21 @@ model = BundleAdjustmentModel("problem-49-7776-pre");
 
 The function `BundleAdjustmentModel` will instantiate the model and automatically download it if needed.
 The resulting structure is an instance of `AbstractNLPModel`.
-So, it is possible to access its API as any other [`NLPModel`](https://juliasmoothoptimizers.github.io/NLPModels.jl/dev/).
+So, it is possible to access its API as any other [`NLPModel`](https://jso.dev/NLPModels.jl/dev/).
 
 ```julia
 using NLPModels
 ```
 
-Using [`residual`](https://juliasmoothoptimizers.github.io/NLPModels.jl/dev/api/#NLPModels.residual), it is possible to compute the residual of the model
+Using [`residual`](https://jso.dev/NLPModels.jl/dev/api/#NLPModels.residual), it is possible to compute the residual of the model
 
 ```julia
 model = BundleAdjustmentModel("problem-49-7776-pre.txt.bz2")
 x = get_x0(model) # or `model.meta.x0`
 Fx = residual(model, x)
 ```
 
-or use the in-place method [`residual!`](https://juliasmoothoptimizers.github.io/NLPModels.jl/dev/api/#NLPModels.residual!)
+or use the in-place method [`residual!`](https://jso.dev/NLPModels.jl/dev/api/#NLPModels.residual!)
 
 ```julia
 model = BundleAdjustmentModel("problem-49-7776-pre.txt.bz2")
@@ -110,7 +110,7 @@ residual!(model, x, Fx);
 
 You can also have access to the [`LinearOperator`](https://github.com/JuliaSmoothOptimizers/LinearOperators.jl) of the Jacobian matrix of the residual of the model which is calculated by hand (in contradiction to automatic differentiation).
 
-You need to call [`jac_structure_residual!`](https://juliasmoothoptimizers.github.io/NLPModels.jl/dev/api/#NLPModels.jac_structure_residual!) at least once before calling [`jac_op_residual!`](https://juliasmoothoptimizers.github.io/NLPModels.jl/dev/api/#NLPModels.jac_op_residual!).
+You need to call [`jac_structure_residual!`](https://jso.dev/NLPModels.jl/dev/api/#NLPModels.jac_structure_residual!) at least once before calling [`jac_op_residual!`](https://jso.dev/NLPModels.jl/dev/api/#NLPModels.jac_op_residual!).
 
 ```julia
 model = BundleAdjustmentModel("problem-49-7776")
@@ -121,7 +121,7 @@ cols = Vector{Int}(undef, nnzj)
 jac_structure_residual!(model, rows, cols);
 ```
 
-You need to call [`jac_coord_residual!`](https://juliasmoothoptimizers.github.io/NLPModels.jl/dev/api/#NLPModels.jac_coord_residual!) to update it to the current point.
+You need to call [`jac_coord_residual!`](https://jso.dev/NLPModels.jl/dev/api/#NLPModels.jac_coord_residual!) to update it to the current point.
 
 ```julia
 model = BundleAdjustmentModel("problem-49-7776")
@@ -130,7 +130,7 @@ vals = similar(x, nnzj)
 jac_coord_residual!(model, x, vals)
 ```
 
-Finally you can use [`jac_op_residual!`](https://juliasmoothoptimizers.github.io/NLPModels.jl/dev/api/#NLPModels.jac_op_residual!):
+Finally you can use [`jac_op_residual!`](https://jso.dev/NLPModels.jl/dev/api/#NLPModels.jac_op_residual!):
 
 ```julia
 model = BundleAdjustmentModel("problem-49-7776")
diff --git a/tutorials/introduction-to-cutest/index.jmd b/tutorials/introduction-to-cutest/index.jmd
@@ -21,7 +21,7 @@ CUTEst can be accessed in two ways.
 
 NLPModels defines an abstract interface to access the objective, constraints,
 derivatives, etc. of the problem. A
-[reference guide](https://juliasmoothoptimizers.github.io/NLPModels.jl/latest/api/)
+[reference guide](https://jso.dev/NLPModels.jl/latest/api/)
 is available to check what you need.
 
 Once CUTEst has been installed, open a problem with
@@ -59,7 +59,7 @@ println("Hx = $( hess(nlp, nlp.meta.x0) )")
 ```
 
 Remember to check the
-[API](https://juliasmoothoptimizers.github.io/NLPModels.jl/latest/api/)
+[API](https://jso.dev/NLPModels.jl/latest/api/)
 in case of doubts about these functions.
 
 Notice how `hess` returns a symmetric matrix.
@@ -228,5 +228,3 @@ length(problems)
 problems = CUTEst.select(objtype="quadratic", contype="linear")
 length(problems)
 ```
-
-
diff --git a/tutorials/introduction-to-jsosolvers/index.jmd b/tutorials/introduction-to-jsosolvers/index.jmd
@@ -9,7 +9,7 @@ author: "Tangi Migot"
 # JSOSolvers.jl Tutorial
 
 This package provides optimization solvers curated by the
-[JuliaSmoothOptimizers](https://juliasmoothoptimizers.github.io)
+[JuliaSmoothOptimizers](https://jso.dev)
 organization.
 All solvers are based on [NLPModels.jl](https://github.com/JuliaSmoothOptimizers/NLPModels.jl) and [SolverCore.jl](https://github.com/JuliaSmoothOptimizers/SolverCore.jl).
 
@@ -115,12 +115,12 @@ The following table provides the correspondance between the solvers and the solv
 
 | Algorithm           | Solver structure |
 | ------------------- | ---------------- |
-| [lbfgs](https://juliasmoothoptimizers.github.io/JSOSolvers.jl/stable/reference/#JSOSolvers.lbfgs-Union{Tuple{NLPModels.AbstractNLPModel},%20Tuple{V}}%20where%20V)               | LBFGSSolver      |
-| [R2](https://juliasmoothoptimizers.github.io/JSOSolvers.jl/stable/reference/#JSOSolvers.R2-Union{Tuple{NLPModels.AbstractNLPModel{T,%20V}},%20Tuple{V},%20Tuple{T}}%20where%20{T,%20V})                  | R2Solver         |
-| [tron](https://juliasmoothoptimizers.github.io/JSOSolvers.jl/stable/reference/#JSOSolvers.tron-Union{Tuple{V},%20Tuple{Val{:Newton},%20NLPModels.AbstractNLPModel}}%20where%20V)                | TronSolver       |
-| [trunk](https://juliasmoothoptimizers.github.io/JSOSolvers.jl/stable/reference/#JSOSolvers.trunk-Union{Tuple{V},%20Tuple{Val{:Newton},%20NLPModels.AbstractNLPModel}}%20where%20V)               | TrunkSolver      |
-| [tron (nls-variant)](https://juliasmoothoptimizers.github.io/JSOSolvers.jl/stable/reference/#JSOSolvers.tron-Union{Tuple{V},%20Tuple{Val{:GaussNewton},%20NLPModels.AbstractNLSModel}}%20where%20V)  | TronSolverNLS    |
-| [trunk (nls-variant)](https://juliasmoothoptimizers.github.io/JSOSolvers.jl/stable/reference/#JSOSolvers.trunk-Union{Tuple{V},%20Tuple{Val{:GaussNewton},%20NLPModels.AbstractNLSModel}}%20where%20V) | TrunkSolverNLS   |
+| [lbfgs](https://jso.dev/JSOSolvers.jl/stable/reference/#JSOSolvers.lbfgs-Union{Tuple{NLPModels.AbstractNLPModel},%20Tuple{V}}%20where%20V)               | LBFGSSolver      |
+| [R2](https://jso.dev/JSOSolvers.jl/stable/reference/#JSOSolvers.R2-Union{Tuple{NLPModels.AbstractNLPModel{T,%20V}},%20Tuple{V},%20Tuple{T}}%20where%20{T,%20V})                  | R2Solver         |
+| [tron](https://jso.dev/JSOSolvers.jl/stable/reference/#JSOSolvers.tron-Union{Tuple{V},%20Tuple{Val{:Newton},%20NLPModels.AbstractNLPModel}}%20where%20V)                | TronSolver       |
+| [trunk](https://jso.dev/JSOSolvers.jl/stable/reference/#JSOSolvers.trunk-Union{Tuple{V},%20Tuple{Val{:Newton},%20NLPModels.AbstractNLPModel}}%20where%20V)               | TrunkSolver      |
+| [tron (nls-variant)](https://jso.dev/JSOSolvers.jl/stable/reference/#JSOSolvers.tron-Union{Tuple{V},%20Tuple{Val{:GaussNewton},%20NLPModels.AbstractNLSModel}}%20where%20V)  | TronSolverNLS    |
+| [trunk (nls-variant)](https://jso.dev/JSOSolvers.jl/stable/reference/#JSOSolvers.trunk-Union{Tuple{V},%20Tuple{Val{:GaussNewton},%20NLPModels.AbstractNLSModel}}%20where%20V) | TrunkSolverNLS   |
 
 It is also possible to pre-allocate the output structure `stats` and call `solve!(solver, nlp, stats)`.
 ```julia
@@ -133,7 +133,7 @@ solve!(solver, nlp, stats)
 
 ## Callback
 
-All the solvers have a callback mechanism called at each iteration, see also the [Using callbacks tutorial](https://juliasmoothoptimizers.github.io/tutorials/using-callbacks/).
+All the solvers have a callback mechanism called at each iteration, see also the [Using callbacks tutorial](https://jso.dev/tutorials/using-callbacks/).
 The expected signature of the callback is `callback(nlp, solver, stats)`, and its output is ignored.
 Changing any of the input arguments will affect the subsequent iterations.
 In particular, setting `stats.status = :user` will stop the algorithm.
diff --git a/tutorials/introduction-to-linear-operators/index.jmd b/tutorials/introduction-to-linear-operators/index.jmd
@@ -4,7 +4,7 @@ tags: ["linear-algebra", "linear-operators"]
 author: "Geoffroy Leconte and Dominique Orban"
 ---
 
-[LinearOperators.jl](https://juliasmoothoptimizers.github.io/LinearOperators.jl/stable) is a package for matrix-like operators. Linear operators are defined by how they act on a vector, which is useful in a variety of situations where you don't want to materialize the matrix.
+[LinearOperators.jl](https://jso.dev/LinearOperators.jl/stable) is a package for matrix-like operators. Linear operators are defined by how they act on a vector, which is useful in a variety of situations where you don't want to materialize the matrix.
 
 \toc
 
diff --git a/tutorials/introduction-to-pdenlpmodels/index.jmd b/tutorials/introduction-to-pdenlpmodels/index.jmd
@@ -68,7 +68,7 @@ ncon = Gridap.FESpaces.num_free_dofs(Ycon)
 x0 = zeros(npde + ncon);
 ```
 
-Overall, we built a GridapPDENLPModel, which implements the [NLPModel](https://juliasmoothoptimizers.github.io/NLPModels.jl/stable/) API.
+Overall, we built a GridapPDENLPModel, which implements the [NLPModel](https://jso.dev/NLPModels.jl/stable/) API.
 
 ```julia
 nlp = GridapPDENLPModel(x0, f, trian, Ypde, Ycon, Xpde, Xcon, op, name = "Control elastic membrane")
@@ -128,7 +128,7 @@ Reinitialize the counters before re-solving.
 reset!(nlp);
 ```
 
-Most JSO-compliant solvers are using logger for printing iteration information. 
+Most JSO-compliant solvers are using logger for printing iteration information.
 `NullLogger` avoids printing iteration information.
 
 ```julia
diff --git a/tutorials/introduction-to-quadraticmodels/index.jmd b/tutorials/introduction-to-quadraticmodels/index.jmd
diff --git a/tutorials/introduction-to-ripqp/index.jmd b/tutorials/introduction-to-ripqp/index.jmd
diff --git a/tutorials/introduction-to-solverbenchmark/index.jmd b/tutorials/introduction-to-solverbenchmark/index.jmd
