Linear Algebra

lin_ind_vec(vectors::Vector{<:Number}...)

Test if the given vectors are linearly independent

matrix_inverse(A::Matrix)

Test if the square matrix A is invertible and return its inverse.

A matrix is invertible if and only if $\det(A) \neq 0$, equivalently if $\operatorname{rank}(A) = n$ where n is the number of rows (and columns).

Returns inv(A) if invertible, or nothing if the matrix is singular.

Examples

A = [2.0 1.0; 1.0 -1.0]
matrix_inverse(A)  # returns the 2×2 inverse
matrix_inverse([1.0 2.0; 2.0 4.0])  # singular — returns nothing

solve_linear_system(A::Matrix, b::Vector)

Diagnose and solve the linear system Ax = b.

Checks the rank of A against the augmented matrix [A b] to determine the nature of the system before solving:

• Inconsistent (no exact solution): returns the least-squares approximation via pinv(A) * b (minimises ‖Ax - b‖); works for both square and non-square singular matrices. Prints the residual to confirm inexactness.
• Underdetermined (infinite solutions): returns the minimum-norm solution via pinv(A) * b (smallest ‖x‖ among all solutions).
• Unique solution: returns the exact solution via A \ b.

Using pinv for the non-unique cases avoids the SingularException that A \ b throws when A is square and singular.

barycentric_coord(p::Point, q::Point, r::Point) -> t::Float64

Calculate the barycentric co-ordinate or parater of points p and q with center of gravity point r

calculate_param_line(p::Point, q::Point, n::Int64) → [Point]

Creates n points on a line defined by p and q, using the parametric equation of a line. Pure computational function - no plotting dependencies.

center of gravity(p::Point, q::Point, t) → r

Creates center of gravity of points p and qusing parametric equation of a line

distance_2_points(p::Point, q::Point) -> Norm(v)

Distance between two points

distance_to_implicit_line(a::Number, b::Number, c::Number, r::Point) -> Float64

distance_to_parametric_line(p::Point, v::Vector, r::Point) -> Float64

Definition of the line: l = p + tv

distance_to_pnf_implicit_line(â::RationalRoot, b̂::RationalRoot, ĉ::RationalRoot, r::Point) -> Float64

explicit_line(p::Point, q::Point) -> Tuple(Float64, Float64)

The orthogonal vector α is calculated as: v = Vector(q -p) α = [v[2], -v[1]] The explicit equation of the line requires slope & intercept

foot_of_line(P::Point, v::Vector, R::Point, r::Bool = false) -> Tuple(Point, Float64)

Definition of the line: l = P + tv Return the foot Q: the point on l closest to R Return the signed distance from P to Q along l, (v ⋅ (R - P)) / ‖v‖ If r is true, both are rounded to 3 digits

foot_of_line(A::Point, B::Point, r::Bool = false) -> Tuple(Point, Float64, Float64, Tuple(Point,Point,Point,Point))

The parallelogram with one vertex at the origin and sides A and B. Its base is the line through the origin along B: l = tB Using the original foot_of_line and some additional calculations Return the foot of A on l (the point on l closest to A) == t[1] Return the perpendicular distance from A to l (the height) == t[2] Return the area of the parallelogram, height * ‖B‖ == |det(A, B)| == t[3] Return the vertices of the parallelogram (origin, A, B, A + B) == t[4] If r is true, the foot, height and area are rounded to 3 digits

implicit_line_point_normal_form(a::Number, b::Number, c::Number) -> Tuple(RationalRoot, RationalRoot, RationalRoot)

implicit_to_parametric_line(a::Number, b::Number, c::Number) -> Tuple(Vector, Point)

intersection_2_implicit_lines(a₁::Number, b₁::Number, c₁::Number, a₂::Number, b₂::Number, c₂::Number) -> Vector

l₁: a₁x̂₁ + b₁x̂₂ + c₁ = 0 l₂: a₂x̂₁ + b₂x̂₂ + c₂ = 0 Solve for x̂₁ and x̂₂ which is the intersection point

intersection_2_parametric_lines(v::Vector, w::Vector, p::Point, q::Point) -> Vector

l₁ = p + tv l₂ = q + sw intersection: p + t̂v = q + ŝw The solution is a system of 2 equations in two unknowns expressed in equation: t̂*v - ŝ*w = q - p

is_orthogonal(p::Point, q::Point) -> bool

Check if two vectors are is_orthogonal

orthproj(v::Vector, w::Vector) -> Vector

Orthogonol projection of vector w onto v

parametric_to_implicit_line(p::Point, v::Vector) -> Tuple{Number, Number, Number}

The parametric equation is: l : l(t) = p + tv Use p and v to calculate: l : ax1 + bx2 + c = 0. And return co-efficient as tuple

plot_param_line(p::Point, q::Point, n::Int64) → [Point]

Creates n points on a line defined by p and q, using the parametric equation of a line, then plot

point_in_implicit_line(p::Point, q::Point, x::Point) -> Float64

The orthogonal vector α is calculated as: v = Vector(q - p) α = [v[2], -v[1]] The implicit equation of the line is: α * (x -p) = 0 a = α[1] b = α[2] c = -(a * p[1]) - (b * p[2]) Then calculate the distance of point x from the line using the formula: (a * x[1] + b * x[2] + c) / norm([a, b]) If 0 the point is in the line!

polar_unit(y::Vector) -> Vector{Float64}

Return unit vector in polar form for vector y

rationalize(x::Number; sigdigits=16) -> Rational(Number)

Rationalize a number to a rational number

reflection(v::Vector, w::Vector) -> Vector

The midpoint of the segment from v to the reflection of v around 'w', is the projection P from 'v' to the line along 'w'

rotation(θ::Number, v::Vector) -> Vector
θ : degrees to rotate v

vector_angle_cos(p::Vector, q::Vector) -> cos θ

Calculate cosine of angle between 2 points

projection_matrix(x::Vector) -> Matrix

value of Matrix with an actual vector x

projection_matrix_polar(n::Number) -> Matrix

value of projection polar matrix with an actual value for the angle of the vector

projection_matrix_symbolic() -> Matrix

Create symbolic matrix for projection on [u, v] using E₁ = [1,0] and E₂ =[0,1] to get first and second row

projection_matrix_symbolic_polar() -> Matrix

Create symbolic matrix for projection on [cos θ, sin θ]

projection_matrix_transpose(u::Vector) ->  Matrix

See

reflection_matrix(U::Vector) -> Matrix

value of reflection Matrix with an actual vector U

reflection_matrix_rational(U::Vector) -> Matrix

value of reflection Matrix with an actual vector U in rational form

reflection_matrix_symbolic() -> Matrix

Create symbolic matrix for reflection on [u, v] using E₁ = [1,0] and E₂ =[0,1] to get first and second column

rotation_matrix(d::Number) -> Matrix

value of rotation Matrix with an actual value for the rotation angle

rotation_matrix_ns(θ::Number) -> Matrix

value of rotation Matrix with an actual value for the rotation angle - non symbolic version

rotation_matrix_symbolic() -> Matrix

Create symbolic matrix for rotation θ degrees, using E₁ = [1,0] and E₂ =[0,1] to get first and second column

stretch_matrix(n::Number) -> Matrix

value of stretch Matrix with an actual value for the stretch factor

stretch_matrix_symbolic() -> Matrix

Create symbolic matrix for stretch λ₁, using E₁ = [1,0] and E₂ =[0,1] to get first and second column