Merge pull request #1068 from JuliaSymbolics/docs2

Try fixing docs builds

docs/make.jl

@@ -23,7 +23,7 @@ makedocs(
     authors="Chris Rackauckas",
     modules=[Symbolics,SymbolicUtils],
     clean=true, doctest=false, linkcheck = true,
-    warnonly = [:docs_block, :missing_docs, :cross_references],
+    warnonly = [:docs_block, :missing_docs, :cross_references, :linkcheck],
     format = Documenter.HTML(assets = ["assets/favicon.ico"],
                              mathengine = mathengine,
                              canonical="https://docs.sciml.ai/Symbolics/stable/"),

docs/src/getting_started.md

@@ -80,7 +80,7 @@ f(u)
     O(n) compute and memory but is a very general representation. Symbolics.jl also has the
     ability to represent symbolic arrays which gives an O(1) representation but is more
     limited in its functionality. For more information, see the
-    [Symbolic Arrays](@symbolic_arrays) page.
+    [Symbolic Arrays](@ref symbolic_arrays) page.
 
 ## Derivatives
 

docs/src/manual/arrays.md

@@ -158,16 +158,16 @@ Here we indexed for the element (2,3), but we got back a symbolic indexing expre
 ```@example arrays
 Symbolics.scalarize(AAt[2,3])
 ```
-```@example arrays
+```julia
 @syms i::Int j::Int
 Symbolics.scalarize(AAt[i,j])
 ```
 
 In general, any scalar expression which is derived from array expressions can be scalarized.
 
-```@example arrays
+```julia
 #sum(A[:,1]) + sum(A[2,:])#latexify not working
 ```
-```@example arrays
+```julia
 Symbolics.scalarize(sum(A[:,1]) + sum(A[2,:]))
 ```

docs/src/manual/variables.md

@@ -11,7 +11,7 @@ written as `op1 ~ op2`, defines the symbolic equality between two operations.
 ## Types
 
 `Sym`, `Term`, and `FnType` are from
-[SymbolicUtils.jl](https://juliasymbolics.github.io/SymbolicUtils.jl/api/). Note that in
+[SymbolicUtils.jl](https://symbolicutils.juliasymbolics.org/api/). Note that in
 Symbolics, we always use `Sym{Real}`, `Term{Real}`, and
 `FnType{Tuple{Any}, Real}`. To get the arguments of an `istree` object, use
 `arguments(t::Term)`, and to get the operation, use `operation(t::Term)`.

src/equations.jl

@@ -61,7 +61,7 @@ Base.@kwdef struct Transition{A, B, C} <: StateMachineOperator
                                                     priority)
     end
 end
-function Base.:(==)(transtion1::Transition, transition2::Transition)
+function Base.:(==)(transition1::Transition, transition2::Transition)
     transition1.from == transition2.from &&
     transition1.to == transition2.to &&
     isequal(transition1.cond, transition2.cond) &&

src/struct.jl

@@ -44,25 +44,25 @@ function encodetyp(::Type{T}) where {T}
 end
 
 function decodetyp(typ::TypeT)
-    siz = TypeT(8) * (typ >> SIZE_OFFSET)
+    _size = TypeT(8) * (typ >> SIZE_OFFSET)
     if !iszero(typ & (TypeT(1) << ISINTEGER))
         if !iszero(typ & TypeT(1) << SIGNED_OFFSET)
-            siz == 8 ? Int8 :
-            siz == 16 ? Int16 :
-            siz == 32 ? Int32 :
-            siz == 64 ? Int64 :
+            _size == 8 ? Int8 :
+            _size == 16 ? Int16 :
+            _size == 32 ? Int32 :
+            _size == 64 ? Int64 :
             error("invalid type $(typ)!")
         else # unsigned
-            siz == 8 ? UInt8 :
-            siz == 16 ? UInt16 :
-            siz == 32 ? UInt32 :
-            siz == 64 ? UInt64 :
+            _size == 8 ? UInt8 :
+            _size == 16 ? UInt16 :
+            _size == 32 ? UInt32 :
+            _size == 64 ? UInt64 :
             error("invalid type $(typ)!")
         end
     else # float
-        siz == 16 ? Float16 :
-        siz == 32 ? Float32 :
-        siz == 64 ? Float64 :
+        _size == 16 ? Float16 :
+        _size == 32 ? Float32 :
+        _size == 64 ? Float64 :
         error("invalid type $(typ)!")
     end
 end