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

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

distancetoparametric_line(p::Point, v::Vector, r::Point) -> Float64 Definition of the line: l = p + tv

distancetopnfimplicitline(â::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

function footofline(P::Point, v::Vector, R::Point) -> Tuple(Point, Float64) Definition of the line: l = P + tv Return point Q on l closest to R Calculate distance from Q to A (foot of the line)

function foot_of_line(A::Point, B::Point) -> Tuple(Point, Float64, Float64,Tuple(Point,Point,Point,Point))

Definition of the line: l = P + tv where v is the vector from P to B Using original footofline and some additional calculations Return point on l closest to A == t[1] Return distance from t[1] to A (foot of the line) == t[2] Return area of parallelogram defined by A and B Return points on the parallelogram

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

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

function 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

function 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!

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

Return unit vector in polar form for vector y

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

Rationalize a number to a rational number

function 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'

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

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

Calculate cosine of angle between 2 points

function projection_matrix(x::Vector) -> Matrix

value of Matrix with an actual vector x

function projection_matrix_polar(θ::Number) -> Matrix

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

function 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

function projection_matrix_symbolic_polar() -> Matrix

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

function projection_matrix_transpose(u::Vector) ->  Matrix

See

function reflection_matrix(U::Vector) -> Matrix

value of reflection Matrix with an actual vector U

function reflection_matrix_rational(U::Vector) -> Matrix

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

function 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 colomn

function rotation_matrix(d::Number) -> Matrix

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

function rotation_matrix_ns(θ::Number) -> Matrix

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

function rotation_matrix_symbolic() -> Matrix

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

function stretch_matrix_symbolic(n::Number) -> Matrix

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

function stretch_matrix_symbolic() -> Matrix

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