insert_matrix()

void MayaFlux::Kakshya::EigenInsertion::insert_matrix	(	const Eigen::MatrixXd &	matrix,
		MatrixInterpretation	interpretation = MatrixInterpretation::AUTO,
		bool	preserve_precision = true
	)

Insert Eigen matrix with automatic interpretation.

Parameters

matrix	Source matrix (columns are data points)
interpretation	How to interpret matrix structure
preserve_precision	If true, use double for scalars

AUTO interpretation rules:

• 1 row → scalar (double or float based on preserve_precision)
• 2 rows → complex<double> or glm::vec2 (use interpretation to specify)
• 3 rows → glm::vec3
• 4 rows → glm::vec4
• 16 rows → glm::mat4
• Other → error (must specify interpretation)

Definition at line 67 of file EigenInsertion.cpp.

{
    if (interpretation == MatrixInterpretation::AUTO) {
        switch (matrix.rows()) {
        case 1:
            interpretation = MatrixInterpretation::SCALAR;
            break;
        case 2:
            error<std::invalid_argument>(
                Journal::Component::Kakshya,
                Journal::Context::Runtime,
                std::source_location::current(),
                "Ambiguous 2-row matrix. Specify {} or {}",
                Reflect::enum_to_string(MatrixInterpretation::COMPLEX),
                Reflect::enum_to_string(MatrixInterpretation::VEC2));
            break;
        case 3:
            interpretation = MatrixInterpretation::VEC3;
            break;
        case 4:
            interpretation = MatrixInterpretation::VEC4;
            break;
        case 16:
            interpretation = MatrixInterpretation::MAT4;
            break;
        default:
            error<std::invalid_argument>(
                Journal::Component::Kakshya,
                Journal::Context::Runtime,
                std::source_location::current(),
                "Cannot auto-interpret {}-row matrix. Specify MatrixInterpretation explicitly.",
                matrix.rows());
        }
    }
 
    validate_matrix_dimensions(matrix, interpretation);
 
    switch (interpretation) {
    case MatrixInterpretation::SCALAR:
        if (preserve_precision) {
            std::vector<double> data(matrix.cols());
            for (Eigen::Index i = 0; i < matrix.cols(); ++i) {
                data[i] = matrix(0, i);
            }
            m_variant = Kakshya::DataVariant { std::move(data) };
        } else {
            std::vector<float> data(matrix.cols());
            for (Eigen::Index i = 0; i < matrix.cols(); ++i) {
                data[i] = static_cast<float>(matrix(0, i));
            }
            m_variant = Kakshya::DataVariant { std::move(data) };
        }
        break;
 
    case MatrixInterpretation::COMPLEX:
        if (preserve_precision) {
            std::vector<std::complex<double>> data(matrix.cols());
            for (Eigen::Index i = 0; i < matrix.cols(); ++i) {
                data[i] = std::complex<double>(matrix(0, i), matrix(1, i));
            }
            m_variant = Kakshya::DataVariant { std::move(data) };
        } else {
            std::vector<std::complex<float>> data(matrix.cols());
            for (Eigen::Index i = 0; i < matrix.cols(); ++i) {
                data[i] = std::complex<float>(
                    static_cast<float>(matrix(0, i)),
                    static_cast<float>(matrix(1, i)));
            }
            m_variant = Kakshya::DataVariant { std::move(data) };
        }
        break;
 
    case MatrixInterpretation::VEC2: {
        std::vector<glm::vec2> data(matrix.cols());
        for (Eigen::Index i = 0; i < matrix.cols(); ++i) {
            data[i] = glm::vec2(
                static_cast<float>(matrix(0, i)),
                static_cast<float>(matrix(1, i)));
        }
        m_variant = Kakshya::DataVariant { std::move(data) };
        break;
    }
 
    case MatrixInterpretation::VEC3: {
        std::vector<glm::vec3> data(matrix.cols());
        for (Eigen::Index i = 0; i < matrix.cols(); ++i) {
            data[i] = glm::vec3(
                static_cast<float>(matrix(0, i)),
                static_cast<float>(matrix(1, i)),
                static_cast<float>(matrix(2, i)));
        }
        m_variant = Kakshya::DataVariant { std::move(data) };
        break;
    }
 
    case MatrixInterpretation::VEC4: {
        std::vector<glm::vec4> data(matrix.cols());
        for (Eigen::Index i = 0; i < matrix.cols(); ++i) {
            data[i] = glm::vec4(
                static_cast<float>(matrix(0, i)),
                static_cast<float>(matrix(1, i)),
                static_cast<float>(matrix(2, i)),
                static_cast<float>(matrix(3, i)));
        }
        m_variant = Kakshya::DataVariant { std::move(data) };
        break;
    }
 
    case MatrixInterpretation::MAT4: {
        std::vector<glm::mat4> data(matrix.cols());
        for (Eigen::Index i = 0; i < matrix.cols(); ++i) {
            float mat_data[16];
            for (int j = 0; j < 16; ++j) {
                mat_data[j] = static_cast<float>(matrix(j, i));
            }
            data[i] = glm::make_mat4(mat_data);
        }
        m_variant = Kakshya::DataVariant { std::move(data) };
        break;
    }
 
    default:
        error<std::invalid_argument>(
            Journal::Component::Kakshya,
            Journal::Context::Runtime,
            std::source_location::current(),
            "Invalid MatrixInterpretation: {}",
            Reflect::enum_to_string(interpretation));
    }
}

References MayaFlux::Kakshya::AUTO, MayaFlux::Kakshya::COMPLEX, MayaFlux::Reflect::enum_to_string(), MayaFlux::Journal::Kakshya, m_variant, MayaFlux::Kakshya::MAT4, MayaFlux::Journal::Runtime, MayaFlux::Kakshya::SCALAR, validate_matrix_dimensions(), MayaFlux::Kakshya::VEC2, MayaFlux::Kakshya::VEC3, and MayaFlux::Kakshya::VEC4.

Referenced by MayaFlux::Kakshya::from_eigen_matrix().

Here is the call graph for this function:

Here is the caller graph for this function: