invert3x3Q16()

bool fl::invert3x3Q16	(	const i32(&)	in[3][3],
		i32(&)	out[3][3] )

Inverse of an s16.16 3x3 matrix, in s16.16, computed without floats.

The float-free half of P9 item 2 (FastLED#4043). buildRgbSolveMatrixQ16 still reaches this through invert3x3; a bind path that never touches float calls it directly.

False on a singular matrix, on a coefficient too large for s16.16, and on any input whose exact cofactors or determinant do not fit an i64. That last case is detected rather than bounded away: a deep-blue emitter at xy = (0.14, 0.03) already has a Z column near 28, so a fixed input limit generous enough to be safe would reject real parts.

Definition at line 212 of file device_solve.cpp.hpp.

                                                                        {
    const i32 a = in[0][0], b = in[0][1], c = in[0][2];
    const i32 d = in[1][0], e = in[1][1], f = in[1][2];
    const i32 g = in[2][0], h = in[2][1], i_ = in[2][2];
 
    // Cofactors are differences of two Q16 products, so Q32.
    i64 cof[3][3];
    if (!cofactorQ32(e, i_, f, h, &cof[0][0]) ||
        !cofactorQ32(c, h, b, i_, &cof[0][1]) ||
        !cofactorQ32(b, f, c, e, &cof[0][2]) ||
        !cofactorQ32(f, g, d, i_, &cof[1][0]) ||
        !cofactorQ32(a, i_, c, g, &cof[1][1]) ||
        !cofactorQ32(c, d, a, f, &cof[1][2]) ||
        !cofactorQ32(d, h, e, g, &cof[2][0]) ||
        !cofactorQ32(b, g, a, h, &cof[2][1]) ||
        !cofactorQ32(a, e, b, d, &cof[2][2])) {
        return false;
    }
 
    // Determinant is a Q16 times a Q32, so Q48.
    const i32 first_row[3] = {a, b, c};
    i64 determinant = 0;
    for (int col = 0; col < 3; ++col) {
        const i64 term_lhs = static_cast<i64>(first_row[col]);
        if (!productFitsI64(term_lhs, cof[col][0])) {
            return false;
        }
        const i64 term = term_lhs * cof[col][0];
        if (!sumFitsI64(determinant, term)) {
            return false;
        }
        determinant += term;
    }
    if (determinant == 0) {
        return false;
    }
 
    for (int row = 0; row < 3; ++row) {
        for (int col = 0; col < 3; ++col) {
            const i64 value = divideCoefficientQ16(cof[row][col], determinant);
            // The same bound the float path applies to its own result, and
            // for the same reason: past it the solve's accumulator can
            // overflow for an in-range XYZ input.
            const i64 limit = static_cast<i64>(kMaxCoefficient) << 16;
            if (value > limit || value < -limit) {
                return false;
            }
            out[row][col] = static_cast<i32>(value);
        }
    }
    return true;
}

References FL_NO_EXCEPT, g, and type_rank< T >::value.

Referenced by buildRgbSolveMatrixFromQ16(), and buildSourceMatrixQ16().

Here is the caller graph for this function: