Features/metrics

docs/make.jl

@@ -25,8 +25,8 @@ makedocs(;
         "API" => Any[
             "CliffordNumbers" => "api/clifford.md",
             "Indexing" => "api/indexing.md",
-            "Math" => "api/indexing.md",
-            "Quadratic forms" => "api/quadratic.md",
+            "Math" => "api/math.md",
+            "Metric signatures" => "api/metric.md",
             "Internals" => "api/internal.md",
         ]
     ],

docs/src/api/metric.md

@@ -0,0 +1,42 @@
+# Metric signatures
+
+## Signature types
+
+```@docs
+CliffordNumbers.Metrics.AbstractSignature
+CliffordNumbers.Metrics.Signature
+CliffordNumbers.Metrics.VGA
+CliffordNumbers.Metrics.PGA
+CliffordNumbers.Metrics.CGA
+CliffordNumbers.Metrics.LGA
+CliffordNumbers.Metrics.LGAEast
+CliffordNumbers.Metrics.LGAWest
+CliffordNumbers.Metrics.Exterior
+```
+
+## Aliases for common signatures
+
+```@docs
+CliffordNumbers.Metrics.VGA2D
+CliffordNumbers.Metrics.VGA3D
+CliffordNumbers.Metrics.PGA2D
+CliffordNumbers.Metrics.PGA3D
+CliffordNumbers.Metrics.CGA2D
+CliffordNumbers.Metrics.CGA3D
+CliffordNumbers.Metrics.STAEast
+CliffordNumbers.Metrics.STAWest
+CliffordNumbers.Metrics.STA
+CliffordNumbers.Metrics.STAPEast
+CliffordNumbers.Metrics.STAPWest
+CliffordNumbers.Metrics.STAP
+```
+
+## Associated methods
+
+```@docs
+CliffordNumbers.dimension
+CliffordNumbers.basis_blades
+CliffordNumbers.grades
+CliffordNumbers.is_degenerate
+CliffordNumbers.is_positive_definite
+```

src/CliffordNumbers.jl

@@ -20,14 +20,18 @@ const BaseNumber = Union{Real,Complex}
 
 # Contains tools for working with Hamming weights of integers
 include("hamming.jl")
-# Tools for defining quadratic forms/metric signatures (convention may not be great)
-include("quadratic.jl")
-export QuadraticForm, APS, STA, VGA, PGA, CGA
-export dimension, elements, grades
+# New module for metric signatures
+include("metrics.jl")
+using .Metrics
+import .Metrics: dimension, blade_count, grades, is_degenerate, is_positive_definite
+export Metrics
+export Signature, VGA, PGA, CGA, LGA, LGAEast, LGAWest, Exterior
+export dimension, blade_count, grades, is_degenerate, is_positive_definite
+export VGA2D, VGA3D, PGA2D, PGA3D, CGA2D, CGA3D, STA, STAEast, STAWest, STAP, STAPEast, STAPWest
 # Abstract supertype for all Clifford numbers
 include("abstract.jl")
 export AbstractCliffordNumber
-export numeric_type
+export signature, numeric_type
 # Working with the grades represented by an AbstractCliffordNumber subtype
 include("grades.jl")
 export RepresentedGrades

src/abstract.jl

@@ -23,17 +23,22 @@ with each basis blade represented by `C`.
 `getfield(x, :data)::Tuple`, so any type declared with a `NTuple` field named `data` should have
 this defined automatically.
 """
-abstract type AbstractCliffordNumber{Q<:QuadraticForm,T<:BaseNumber} <: Number
+abstract type AbstractCliffordNumber{Q,T<:BaseNumber} <: Number
 end
 
 #---Default varargs constructors for types---------------------------------------------------------#
 
 (::Type{T})(x::Vararg{BaseNumber}) where {Q,T<:AbstractCliffordNumber{Q}} = T(x)
 
 #---Get type parameters----------------------------------------------------------------------------#
+"""
+    signature(T::Type{<:AbstractCliffordNumber{Q}}) = Q
+    signature(x::AbstractCliffordNumber{Q}) = Q
 
-QuadraticForm(::Type{<:AbstractCliffordNumber{Q}}) where Q = Q
-QuadraticForm(::AbstractCliffordNumber{Q}) where Q = Q
+Returns the metric signature object associated with an `AbstractCliffordNumber` `x` or its type `T`.
+"""
+signature(::Type{<:AbstractCliffordNumber{Q}}) where Q = Q
+signature(::AbstractCliffordNumber{Q}) where Q = Q
 
 """
     numeric_type(::Type{<:AbstractCliffordNumber{Q,T}}) = T
@@ -91,20 +96,21 @@ oneunit(::Union{T,Type{T}}) where T<:AbstractCliffordNumber = convert(T, one(T))
     CliffordNumbers.similar_type(
         C::Type{<:AbstractCliffordNumber},
         [N::Type{<:BaseNumber} = numeric_type(C)],
-        [Q::Type{<:QuadraticForm} = QuadraticForm(C)]
+        [Q::Val = Val(signature(C))]
     ) -> Type{<:AbstractCliffordNumber{Q,N}}
 
-Constructs a type similar to `T` but with numeric type `N` and quadratic form `Q`.
+Constructs a type similar to `T` but with numeric type `N` and quadratic form `Q`. The quadratic
+form must be wrapped in a `Val` to preserve type stability.
 
 This function must be defined with all its arguments for each concrete type subtyping
 `AbstractCliffordNumber`.
 """
-function similar_type(x::AbstractCliffordNumber, T::Type{<:BaseNumber}, Q::Type{<:QuadraticForm})
+function similar_type(x::AbstractCliffordNumber, T::Type{<:BaseNumber}, Q::Val)
     return similar_type(typeof(x), T, Q)
 end
 
-similar_type(x, T::Type{<:BaseNumber}) = similar_type(x, T, QuadraticForm(x))
-similar_type(x, Q::Type{<:QuadraticForm}) = similar_type(x, numeric_type(x), Q)
+similar_type(x, T::Type{<:BaseNumber}) = similar_type(x, T, Val(signature(x)))
+similar_type(x, Q::Val) = similar_type(x, numeric_type(x), Q)
 
 similar(C::Type{<:AbstractCliffordNumber}, args...) = zero(similar_type(C, args...))
 similar(x::AbstractCliffordNumber, args...) = zero(similar_type(x, args...))
@@ -144,7 +150,7 @@ end
 
 Base.complex(x::AbstractCliffordNumber{<:Any,<:Complex}) = x
 
-function Base.complex(x::T, y::T) where T<:AbstractCliffordNumber{<:QuadraticForm,<:Real}
+function Base.complex(x::T, y::T) where T<:AbstractCliffordNumber{<:Any,<:Real}
     C = similar_type(x, complex(numeric_type(x)))
     return C(complex.(Tuple(x), Tuple(y)))
 end
@@ -153,7 +159,7 @@ Base.complex(x::AbstractCliffordNumber, y::AbstractCliffordNumber) = complex(pro
 
 #---Error checking---------------------------------------------------------------------------------#
 """
-    CliffordNumbers.check_element_count(sz, Q::Type{<:QuadraticForm}, [L], data)
+    CliffordNumbers.check_element_count(sz, [L], data)
 
 Ensures that the number of elements in `data` is the same as the result of `f(Q)`, where `f` is a
 function that generates the expected number of elements for the type. This function is used in the