Please consider the minor fixes

examples/cantilever/cantilever.jl

@@ -24,7 +24,7 @@ function structure()
     # Mesh
     # -------------
     x_coords = range(0, L, N + 1)
-    nodes = [Node(xi, 0.0, 0.0) for xi in x_coords]
+    nodes = [Node(promote(xi, 0, 0.0)) for xi in x_coords]  # to be safe when arguments supplied to Node command are not of  same types
     S = Rectangle(h, b)
     frames = [Frame(nodes[j], nodes[j + 1], S) for j in 1:(length(nodes) - 1)]
     mesh = Mesh(; nodes=nodes, elements=frames)

src/Entities/Entities.jl

@@ -95,7 +95,7 @@ abstract type AbstractFace{dim,T} <: AbstractEntity{dim,T} end
 "Return the `AbstractFace` `f` area."
 function area(f::AbstractFace) end
 
-"Return the `AbstractFace` `f` normal."
+"Return the `AbstractFace` `f` normal direction."
 function normal_direction(f::AbstractFace) end
 
 ## =================
@@ -109,6 +109,7 @@ An `AbstractElement` object facilitates the process of evaluating:
     - The mechanical stresses and strains.
 
 **Abstract Methods**
+* [`cross_section`](@ref)
 * [`coordinates`](@ref)
 * [`dimension`](@ref)
 * [`dofs`](@ref)
@@ -196,7 +197,7 @@ Cache for internal forces computations.
 """
 abstract type AbstractElementCache end
 
-"Fallbaack cache for any element."
+"Fallback cache for any element."
 elements_cache(::Type{<:AbstractElement}) = nothing
 
 """

src/Entities/Nodes.jl

@@ -89,28 +89,24 @@ function Base.show(io::IO, ::MIME"text/plain", n::Node)
     println("• Node at $(n.x) and dofs $(n.dofs)")
 end
 
-"1D node constructor with one dim coordinates."
-function Node(x₁::T, dofs::Dictionary=Dictionary{Field,Vector{Dof}}()) where {T<:Real}
-    Node(Point(x₁), dofs)
-end
-
-"2D node constructor with two coordinates."
-function Node(x₁::T, x₂::T, dofs::Dictionary=Dictionary{Field,Vector{Dof}}()) where {T<:Real}
-    Node(Point(x₁, x₂), dofs)
-end
-
-"3D node constructor with coordinates."
-function Node(x₁::T, x₂::T, x₃::T,
-              dofs::Dictionary=Dictionary{Field,Vector{Dof}}()) where {T<:Real}
-    Node(Point(x₁, x₂, x₃), dofs)
-end
-
 "Node constructor with a `NTuple`."
 function Node(t::NTuple{dim,T},
               dofs::Dictionary=Dictionary{Field,Vector{Dof}}()) where {dim,T<:Real}
     Node(Point(t), dofs)
 end
 
+"`Node` constructor to promote types of coordinates of Point"
+function Node(t)
+    dofs = if length(t) > 1 && t[end] isa Dictionary
+        t[end]
+    else
+        Dictionary{Field,Vector{Dof}}()
+    end
+    coords = length(t) > 1 ? t[1:(end - 1)] : (t)
+    Node(promote(coords)..., dofs)
+end
+
+
 "`Node` constructor with an `AbstractVector` data type."
 function Node(v::AbstractVector{T},
               dofs::Dictionary=Dictionary{Field,Vector{Dof}}()) where {T<:Real}

src/StructuralAnalyses/LinearStaticAnalyses.jl

@@ -68,7 +68,7 @@
 
 function Base.show(io::IO, sa::LinearStaticAnalysis)
     println("LinearStaticAnalysis for:")
-    println("• Current load factor $(sa.current_step))/$(length(load_factors(sa))).")
+    println("• Current load factor $(sa.current_step)/$(length(load_factors(sa))).")
     show(io, sa.s)
     show(io, sa.state)
 end

src/StructuralAnalyses/StaticStates.jl

@@ -77,7 +77,7 @@ end
 "Default constructor for static state given an structure and iteration state."
 function FullStaticState(s::AbstractStructure,
                          iter_state::ResidualsIterationStep=ResidualsIterationStep(),
-                         linear_solver=DEFAULT_LINEAR_SOLVER())
+                         linear_solver=DEFAULT_LINEAR_SOLVER)
     n_dofs = num_dofs(s)
     n_fdofs = num_free_dofs(s)
     Uᵏ = zeros(n_dofs)

src/StructuralSolvers/StructuralSolvers.jl

@@ -1,6 +1,6 @@
 """
 Module defining structural solvers that can be used to solved different analyses.
-Each solver consists of a data type with a convergence criterion and a the iteration status.
+Each solver consists of a data type with a convergence criterion and the iteration status.
 A step! method is used to perform a single iteration step.
 """
 module StructuralSolvers