Concepts — Algebraic Concepts

Overview

The sangi::concepts namespace defines the major structures of abstract algebra as C++20 concepts. Groups, rings, fields, vector spaces, Hilbert spaces, and more can be verified at compile time, enabling explicit type constraints on template arguments.

• Compile-time type verification — clear error messages when template arguments do not satisfy algebraic requirements
• Hierarchical design — AdditiveMonoid → AdditiveGroup → Ring → Field mirrors the mathematical inclusion hierarchy
• Over 40 concepts — covering basic arithmetic, algebraic structures, vector spaces, linear maps, numeric types, matrices/tensors, and algebras/modules
• Header-only — no linking required; just #include
• C++23 extensions — additional concepts like SparseMatrixOf, BandMatrixOf, RealField, ComplexField (C++23 mode)

Mathematical axioms (associativity, commutativity, distributivity, etc.) cannot be verified at compile time. Only syntactic requirements (operator existence, return type compatibility) are checked. Semantic correctness is the user's responsibility.

Header

#include <math/concepts/algebraic_concepts.hpp>

Header-only. No library linkage required. Internally includes <math/core/traits.hpp>.

Namespace: sangi::concepts

Concept Hierarchy

sangi's algebraic concepts mirror the mathematical inclusion hierarchy. The diagram below shows the inclusion relationships between the major structures (an arrow A → B means "A is a super-structure of B", i.e. B satisfies A).

Algebraic structure of major types

Basic Arithmetic Concepts

HasBasicArithmetic<T> conformance table

Algebraic Structures

The following inclusion relationships hold:

Note on unsigned types: Unsigned integer types such as unsigned int satisfy AdditiveMonoid, but the additive inverse (-a) is not mathematically closed for unsigned types. Therefore, they do not satisfy AdditiveGroup or any higher algebraic structure (Ring, Field, etc.).

About "semantic markers": Mathematical properties such as commutativity, completeness, and the absence of zero divisors cannot be verified at compile time. These concepts function as declarations of intent (markers). No runtime checks are performed; it is the user's responsibility to ensure the type satisfies the stated property.

Ring<T> conformance table

Field<T> conformance table

DivisionRing<T> conformance table

OrderedField<T> conformance table

Vector Spaces

Vector spaces and their extensions. The scalar type S defaults to double.

Template parameters

VectorSpace<V, S> conformance table

Linear Maps

Template parameters

Numeric Type Concepts

Matrix & Tensor Concepts

Template parameters

MatrixOf<M, T> conformance table

Algebras & Modules

Template parameters

Examples

Generic function constrained by Field

#include <math/concepts/algebraic_concepts.hpp>
using namespace sangi::concepts;

// Inverse computation for any type satisfying Field
template<Field T>
T safe_inverse(const T& x) {
    if (x == T(0)) return T(0);  // avoid division by zero
    return T(1) / x;
}

// Works with double, Float, Rational, Complex<double>
auto inv_d = safe_inverse(3.14);
auto inv_r = safe_inverse(Rational(3, 7));
// Run output:
//   inv_d = 0.318471337579618
//   inv_r = 7/3
//   safe_inverse(0.0) = 0     (zero guard fires)

Vector space algorithm

// Linear combination for any type satisfying VectorSpace
template<typename V, typename S>
    requires VectorSpace<V, S>
V linear_combination(S a, const V& v, S b, const V& w) {
    return a * v + b * w;
}
// Run output:
//   v = {1,2,3}, w = {4,5,6}, a = 2.0, b = 3.0
//   linear_combination = {14, 19, 24}

Polynomial evaluation over a Ring

// Horner's method for any type satisfying Ring
template<Ring T>
T horner(const std::vector<T>& coeffs, const T& x) {
    T result = T{0};
    for (auto it = coeffs.rbegin(); it != coeffs.rend(); ++it) {
        result = result * x + *it;
    }
    return result;
}

// Works with int, double, Int, Float, Rational
std::vector<double> poly = {1.0, -2.0, 3.0}; // 3x^2 - 2x + 1
double val = horner(poly, 2.0); // = 9.0
// Run output: val = 9   (= 3·4 − 2·2 + 1)

Quaternion type detection

// Combining QuaternionType and DivisionRing constraints
template<typename T>
    requires QuaternionType<T> && DivisionRing<T>
auto rotation_axis(const T& q) {
    auto v_norm = std::sqrt(q.x * q.x + q.y * q.y + q.z * q.z);
    return std::make_tuple(q.x / v_norm, q.y / v_norm, q.z / v_norm);
}
// Run output:
//   Quaternion(0, 1, 2, 2) → axis = (1/3, 2/3, 2/3),  |axis| = 1

Concept-based overloading

// OrderedField: field with ordering (double, Float, Rational)
template<OrderedField T>
T clamp(const T& x, const T& lo, const T& hi) {
    if (x < lo) return lo;
    if (x > hi) return hi;
    return x;
}

// Field: includes non-orderable fields (Complex<double>)
template<Field T>
T midpoint(const T& a, const T& b) {
    return (a + b) / T(2);
}
// Run output:
//   clamp(2.5, 0, 1)         = 1
//   clamp(-0.3, 0, 1)        = 0
//   midpoint(1.0, 5.0)       = 3
//   midpoint(1+0i, 3+4i)     = 2+2i

Concept membership can be verified with static_assert sanity checks.