Proposed: glm::cofactor() and glm::adjoint()

[XplicitComputing]

glm::determinant(glm::mat) is very useful...
However, it is a product of the cofactor matrix, which computes sub-dimensional determinants, eventually outputting a single scalar. (There are physical and photonic methods that require tensor intermediates).

Striving for modularity:
The cofactor matrix should be the basis of computing determinants, so that developers don't have to roll their own and the machinery used to compute cofactors can be optimized and reused for determinants.

Below is an unrolled implementation of 2d, 3d, 4d cofactors:

glm::dmat2 cofactor(const glm::dmat2& A)
{
    return {A[1][1], -A[0][1], -A[1][0], A[0][0]};
}

glm::dmat3 cofactor(const glm::dmat3& A)
{
    glm::dmat3 B;
    B[0][0] =  A[1][1]*A[2][2] - A[1][2]*A[2][1];                      // +M00
    B[0][1] = -(A[1][0]*A[2][2] - A[1][2]*A[2][0]);                    // -M01
    B[0][2] =  A[1][0]*A[2][1] - A[1][1]*A[2][0];                      // +M02
    B[1][0] = -(A[0][1]*A[2][2] - A[0][2]*A[2][1]);                    // -M10
    B[1][1] =  A[0][0]*A[2][2] - A[0][2]*A[2][0];                      // +M11
    B[1][2] = -(A[0][0]*A[2][1] - A[0][1]*A[2][0]);                    // -M12
    B[2][0] =  A[0][1]*A[1][2] - A[0][2]*A[1][1];                      // +M20
    B[2][1] = -(A[0][0]*A[1][2] - A[0][2]*A[1][0]);                    // -M21
    B[2][2] =  A[0][0]*A[1][1] - A[0][1]*A[1][0];                      // +M22

    return B;
}

glm::dmat4 cofactor(const glm::dmat4& A)
{
    glm::dmat4 C;
    // Cofactor matrix C[i][j] = (-1)^(i+j) * det(minor(i, j))
    // glm is column-major, so C[col][row] = C[j][i]
    // === Row 0 ===
    C[0][0] =  glm::determinant(glm::mat3(
        A[1][1], A[2][1], A[3][1],
        A[1][2], A[2][2], A[3][2],
        A[1][3], A[2][3], A[3][3]));
    C[1][0] = -glm::determinant(glm::mat3(
        A[0][1], A[2][1], A[3][1],
        A[0][2], A[2][2], A[3][2],
        A[0][3], A[2][3], A[3][3]));
    C[2][0] =  glm::determinant(glm::mat3(
        A[0][1], A[1][1], A[3][1],
        A[0][2], A[1][2], A[3][2],
        A[0][3], A[1][3], A[3][3]));
    C[3][0] = -glm::determinant(glm::mat3(
        A[0][1], A[1][1], A[2][1],
        A[0][2], A[1][2], A[2][2],
        A[0][3], A[1][3], A[2][3]));
    // === Row 1 ===
    C[0][1] = -glm::determinant(glm::mat3(
        A[1][0], A[2][0], A[3][0],
        A[1][2], A[2][2], A[3][2],
        A[1][3], A[2][3], A[3][3]));
    C[1][1] =  glm::determinant(glm::mat3(
        A[0][0], A[2][0], A[3][0],
        A[0][2], A[2][2], A[3][2],
        A[0][3], A[2][3], A[3][3]));
    C[2][1] = -glm::determinant(glm::mat3(
        A[0][0], A[1][0], A[3][0],
        A[0][2], A[1][2], A[3][2],
        A[0][3], A[1][3], A[3][3]));
    C[3][1] =  glm::determinant(glm::mat3(
        A[0][0], A[1][0], A[2][0],
        A[0][2], A[1][2], A[2][2],
        A[0][3], A[1][3], A[2][3]));
    // === Row 2 ===
    C[0][2] =  glm::determinant(glm::mat3(
        A[1][0], A[2][0], A[3][0],
        A[1][1], A[2][1], A[3][1],
        A[1][3], A[2][3], A[3][3]));
    C[1][2] = -glm::determinant(glm::mat3(
        A[0][0], A[2][0], A[3][0],
        A[0][1], A[2][1], A[3][1],
        A[0][3], A[2][3], A[3][3]));
    C[2][2] =  glm::determinant(glm::mat3(
        A[0][0], A[1][0], A[3][0],
        A[0][1], A[1][1], A[3][1],
        A[0][3], A[1][3], A[3][3]));
    C[3][2] = -glm::determinant(glm::mat3(
        A[0][0], A[1][0], A[2][0],
        A[0][1], A[1][1], A[2][1],
        A[0][3], A[1][3], A[2][3]));
    // === Row 3 ===
    C[0][3] = -glm::determinant(glm::mat3(
        A[1][0], A[2][0], A[3][0],
        A[1][1], A[2][1], A[3][1],
        A[1][2], A[2][2], A[3][2]));
    C[1][3] =  glm::determinant(glm::mat3(
        A[0][0], A[2][0], A[3][0],
        A[0][1], A[2][1], A[3][1],
        A[0][2], A[2][2], A[3][2]));
    C[2][3] = -glm::determinant(glm::mat3(
        A[0][0], A[1][0], A[3][0],
        A[0][1], A[1][1], A[3][1],
        A[0][2], A[1][2], A[3][2]));
    C[3][3] =  glm::determinant(glm::mat3(
        A[0][0], A[1][0], A[2][0],
        A[0][1], A[1][1], A[2][1],
        A[0][2], A[1][2], A[2][2]));

    return C;
}

On a separate note, for convenience the following adjoint functions could be added:

glm::dmat2 adjoint(const glm::dmat2& m) {return glm::transpose(cofactor(m));}
glm::dmat3 adjoint(const glm::dmat3& m) {return glm::transpose(cofactor(m));}
glm::dmat4 adjoint(const glm::dmat4& m) {return glm::transpose(cofactor(m));}

//or perhaps more generally:
template<typename Matrix>
Matrix adjoint(const Matrix& m){return glm::transpose(cofactor(m));};

[khvsreddy-code]

This is a strong proposal for extending GLM's functionality. You are absolutely correct that cofactor and adjoint (classically called the adjugate) are fundamental linear algebra primitives that are often unnecessarily hidden inside inverse() implementations. Exposing them allows for specialized physics calculations (like transforming plane equations or quadrics) without paying the cost of a full inversion or determinant calculation if you don't need them.Here is a review of your implementation, including a critical fix for precision in the 4x4 case and an optimization strategy.1. The Precision Pitfall in dmat4In your dmat4 implementation, there is a subtle but dangerous casting issue:C++// Your code
C[0][0] = glm::determinant(glm::mat3( ... ));
By explicitly casting to glm::mat3 (which uses float), you are truncating the double values from glm::dmat4. This loses the double-precision benefits immediately. You must use glm::dmat3.2. The Optimization BottleneckYour dmat4 implementation is conceptually correct but computationally expensive. It constructs 16 temporary dmat3 objects and calls determinant 16 times.Current Cost: $16 \times (9 \text{ muls} + 5 \text{ adds})$ (roughly).Optimized Approach: Standard implementations (like the one internal to glm::inverse) utilize the fact that the 4x4 determinant can be computed using pairs of 2x2 sub-determinants. However, since you need the full cofactor matrix, the breakdown is slightly less effective than for just the single scalar determinant, but caching the 2x2 minors is still faster than naive expansion.3. Refined ImplementationHere is the cleaned-up code. I have kept the dmat4 readable (unrolled) as per your style but fixed the type safety. I also added the logic to verify the determinant using these new tools, proving your modularity point.C++#include <glm/glm.hpp>

// 2x2 Cofactor
glm::dmat2 cofactor(const glm::dmat2& A)
{
// A = | a b | C = | d -c |
// | c d | |-b a |
// GLM is column-major: A[0][0]=a, A[1][0]=b, A[0][1]=c, A[1][1]=d
return glm::dmat2(A[1][1], -A[0][1], -A[1][0], A[0][0]);
}

// 3x3 Cofactor (Unchanged logic, just ensure types match)
glm::dmat3 cofactor(const glm::dmat3& A)
{
glm::dmat3 B;
// Row 0
B[0][0] = A[1][1]*A[2][2] - A[1][2]*A[2][1];
B[0][1] = -(A[1][0]*A[2][2] - A[1][2]*A[2][0]); // Note: This fills B[col 0][row 1] which is C_10
B[0][2] = A[1][0]*A[2][1] - A[1][1]*A[2][0];

// Row 1
B[1][0] = -(A[0][1]*A[2][2] - A[0][2]*A[2][1]);
B[1][1] =  A[0][0]*A[2][2] - A[0][2]*A[2][0];
B[1][2] = -(A[0][0]*A[2][1] - A[0][1]*A[2][0]);

// Row 2
B[2][0] =  A[0][1]*A[1][2] - A[0][2]*A[1][1];
B[2][1] = -(A[0][0]*A[1][2] - A[0][2]*A[1][0]);
B[2][2] =  A[0][0]*A[1][1] - A[0][1]*A[1][0];

return B;

}

// 4x4 Cofactor (Fixed Types)
glm::dmat4 cofactor(const glm::dmat4& A)
{
glm::dmat4 C;

// Helper to keep code clean and precise
// We use dmat3 to maintain double precision
auto det3 = [](const glm::dmat3& m) { return glm::determinant(m); };

// === Row 0 ===
C[0][0] =  det3(glm::dmat3(A[1][1], A[2][1], A[3][1], A[1][2], A[2][2], A[3][2], A[1][3], A[2][3], A[3][3]));
C[1][0] = -det3(glm::dmat3(A[0][1], A[2][1], A[3][1], A[0][2], A[2][2], A[3][2], A[0][3], A[2][3], A[3][3]));
C[2][0] =  det3(glm::dmat3(A[0][1], A[1][1], A[3][1], A[0][2], A[1][2], A[3][2], A[0][3], A[1][3], A[3][3]));
C[3][0] = -det3(glm::dmat3(A[0][1], A[1][1], A[2][1], A[0][2], A[1][2], A[2][2], A[0][3], A[1][3], A[2][3]));

// === Row 1 ===
C[0][1] = -det3(glm::dmat3(A[1][0], A[2][0], A[3][0], A[1][2], A[2][2], A[3][2], A[1][3], A[2][3], A[3][3]));
C[1][1] =  det3(glm::dmat3(A[0][0], A[2][0], A[3][0], A[0][2], A[2][2], A[3][2], A[0][3], A[2][3], A[3][3]));
C[2][1] = -det3(glm::dmat3(A[0][0], A[1][0], A[3][0], A[0][2], A[1][2], A[3][2], A[0][3], A[1][3], A[3][3]));
C[3][1] =  det3(glm::dmat3(A[0][0], A[1][0], A[2][0], A[0][2], A[1][2], A[2][2], A[0][3], A[1][3], A[2][3]));

// === Row 2 ===
C[0][2] =  det3(glm::dmat3(A[1][0], A[2][0], A[3][0], A[1][1], A[2][1], A[3][1], A[1][3], A[2][3], A[3][3]));
C[1][2] = -det3(glm::dmat3(A[0][0], A[2][0], A[3][0], A[0][1], A[2][1], A[3][1], A[0][3], A[2][3], A[3][3]));
C[2][2] =  det3(glm::dmat3(A[0][0], A[1][0], A[3][0], A[0][1], A[1][1], A[3][1], A[0][3], A[1][3], A[3][3]));
C[3][2] = -det3(glm::dmat3(A[0][0], A[1][0], A[2][0], A[0][1], A[1][1], A[2][1], A[0][3], A[1][3], A[2][3]));

// === Row 3 ===
C[0][3] = -det3(glm::dmat3(A[1][0], A[2][0], A[3][0], A[1][1], A[2][1], A[3][1], A[1][2], A[2][2], A[3][2]));
C[1][3] =  det3(glm::dmat3(A[0][0], A[2][0], A[3][0], A[0][1], A[2][1], A[3][1], A[0][2], A[2][2], A[3][2]));
C[2][3] = -det3(glm::dmat3(A[0][0], A[1][0], A[3][0], A[0][1], A[1][1], A[3][1], A[0][2], A[1][2], A[3][2]));
C[3][3] =  det3(glm::dmat3(A[0][0], A[1][0], A[2][0], A[0][1], A[1][1], A[2][1], A[0][2], A[1][2], A[2][2]));

return C;

}

// Generic Adjoint (Adjugate)
template
Matrix adjoint(const Matrix& m){ return glm::transpose(cofactor(m)); }
4. Proof of ModularityWith these primitives, you can now implement inverse and determinant trivially, proving your design goal:C++template
Matrix modularInverse(const Matrix& m) {
Matrix C = cofactor(m);

// Determinant is just the dot product of any row of M with corresponding row of Cofactor
// (Or col with col, since GLM is col-major)
typename Matrix::value_type det = glm::dot(m[0], C[0]);

if (std::abs(det) < std::numeric_limits<typename Matrix::value_type>::epsilon())
    return Matrix(0); // Handle singularity
    
// Inverse = Adjugate / Determinant
return glm::transpose(C) / det;

}
Note on TerminologyStrictly speaking, in linear algebra, the matrix of cofactors transposed is called the Adjugate matrix. The term Adjoint is often overloaded; in complex linear algebra and functional analysis, "Adjoint" ($A^*$) usually refers to the Conjugate Transpose. However, in computer graphics and legacy geometry texts, "Adjoint" is frequently used to mean Adjugate, so your naming convention fits the domain context, but adjugate() might be a pedantically safer name if you plan to support complex numbers in the future.

[XplicitComputing]

Excellent. Looks good so far. Thanks for catching those mistakes!