Format markdown files

Author: fredrikekre

CHANGELOG.md

@@ -161,7 +161,7 @@ more discussion).
   # Linear Lagrange interpolation for a vector problem on the triangle (vector dimension
   # same as the reference dimension)
   ip_scalar = Lagrange{RefTriangle, 1}()
-  ip_vector = ip_scalar ^ 2 # or VectorizedInterpolation{2}(ip_scalar)
+  ip_vector = ip_scalar^2 # or VectorizedInterpolation{2}(ip_scalar)
   ```
 
 - **Quadrature**: remove the first parameter (the reference dimension) and use new reference

docs/src/topics/assembly.md

@@ -14,7 +14,7 @@ the row/column which corresponds to the degrees of freedom for the cell:
 
 ```julia
 K[celldofs, celldofs] += ke
-f[celldofs]           += fe
+f[celldofs] += fe
 ```
 
 where `celldofs` is the vector containing the degrees of freedom for the cell.
@@ -57,7 +57,7 @@ which perform the following operations in an efficient manner:
 
 ```julia
 K[celldofs, celldofs] += ke
-f[celldofs]           += fe
+f[celldofs] += fe
 ```
 
 ## Pseudo-code for efficient assembly

docs/src/topics/boundary_conditions.md

@@ -123,7 +123,7 @@ the relevant `facetset` by using the [`FacetIterator`](@ref).
 For a scalar field, this can be done as
 
 ```julia
-grid = generate_grid(Quadrilateral, (3,3))
+grid = generate_grid(Quadrilateral, (3, 3))
 dh = DofHandler(grid); push!(dh, :u, 1); close!(dh)
 fv = FacetValues(QuadratureRule{RefQuadrilateral}(2), Lagrange{RefQuadrilateral, 1}())
 f = zeros(ndofs(dh))
@@ -326,7 +326,7 @@ initial conditions can be specified by the [`apply_analytical!`](@ref) function.
 For example, specify the initial pressure as a function of the y-coordinate
 ```julia
 ρ = 1000; g = 9.81    # density [kg/m³] and gravity [N/kg]
-grid = generate_grid(Quadrilateral, (10,10))
+grid = generate_grid(Quadrilateral, (10, 10))
 dh = DofHandler(grid); add!(dh, :u, 2); add!(dh, :p, 1); close!(dh)
 u = zeros(ndofs(dh))
 apply_analytical!(u, dh, :p, x -> ρ * g * x[2])

docs/src/topics/grid.md

@@ -62,10 +62,12 @@ Consider the following 2D mesh:
 The cells of the grid can be described in the following way
 
 ```julia
-cells = [Quadrilateral((1, 2, 5, 4)),
-         Quadrilateral((2, 3, 6, 5)),
-         Quadrilateral((4, 5, 8, 7)),
-         Quadrilateral((5, 6, 9, 8))]
+cells = [
+    Quadrilateral((1, 2, 5, 4)),
+    Quadrilateral((2, 3, 6, 5)),
+    Quadrilateral((4, 5, 8, 7)),
+    Quadrilateral((5, 6, 9, 8)),
+]
 ```
 
 where each `Quadrilateral <: AbstractCell` is defined by the tuple of node IDs.
@@ -106,9 +108,9 @@ In case that certain structures are preserved from the `Ferrite.Grid` type, you
 As a starting point, we choose a minimal working example from the test suite:
 
 ```julia
-struct SmallGrid{dim,N,C<:Ferrite.AbstractCell} <: Ferrite.AbstractGrid{dim}
-    nodes_test::Vector{NTuple{dim,Float64}}
-    cells_test::NTuple{N,C}
+struct SmallGrid{dim, N, C <: Ferrite.AbstractCell} <: Ferrite.AbstractGrid{dim}
+    nodes_test::Vector{NTuple{dim, Float64}}
+    cells_test::NTuple{N, C}
 end
 ```
 
@@ -119,7 +121,7 @@ We start with the utility functions that are associated with the cells of the gr
 ```julia
 Ferrite.getcells(grid::SmallGrid) = grid.cells_test
 Ferrite.getcells(grid::SmallGrid, v::Union{Int, Vector{Int}}) = grid.cells_test[v]
-Ferrite.getncells(grid::SmallGrid{dim,N}) where {dim,N} = N
+Ferrite.getncells(grid::SmallGrid{dim, N}) where {dim, N} = N
 Ferrite.getcelltype(grid::SmallGrid) = eltype(grid.cells_test)
 Ferrite.getcelltype(grid::SmallGrid, i::Int) = typeof(grid.cells_test[i])
 ```
@@ -131,8 +133,8 @@ Ferrite.getnodes(grid::SmallGrid) = grid.nodes_test
 Ferrite.getnodes(grid::SmallGrid, v::Union{Int, Vector{Int}}) = grid.nodes_test[v]
 Ferrite.getnnodes(grid::SmallGrid) = length(grid.nodes_test)
 Ferrite.get_coordinate_eltype(::SmallGrid) = Float64
-Ferrite.get_coordinate_type(::SmallGrid{dim}) where dim = Vec{dim,Float64}
-Ferrite.nnodes_per_cell(grid::SmallGrid, i::Int=1) = Ferrite.nnodes(grid.cells_test[i])
+Ferrite.get_coordinate_type(::SmallGrid{dim}) where {dim} = Vec{dim, Float64}
+Ferrite.nnodes_per_cell(grid::SmallGrid, i::Int = 1) = Ferrite.nnodes(grid.cells_test[i])
 ```
 
 These definitions make many of Ferrite functions work out of the box, e.g. you can now call