Concepts — Algebraic Concepts

Overview

The calx::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: calx::concepts

Basic Arithmetic Concepts

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.

Vector Spaces

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

Linear Maps

Numeric Type Concepts

Matrix & Tensor Concepts

Algebras & Modules

Examples

Generic function constrained by Field

#include <math/concepts/algebraic_concepts.hpp>
using namespace calx::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));

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;
}

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

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);
}

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);
}