Function assertMatrExpIsHermitian

quest/src/core/validation.cpp:2513–2545

// type T can be DiagMatr, FullStateDiagMatr
template <class T> 
void assertMatrExpIsHermitian(T matr, qreal exponent, const char* caller) {

    // below validation can invoke communication and expensive data processing,
    // even when numerical-epsilon is zero, which we avoid when all validation is off.
    // we always proceed however if merely numerical-validation is disabled (via zero
    // epsilon) because some checks below are epsilon independent
    if (!global_isValidationEnabled)
        return;

    // the calling function will use the std::pow(qreal,qreal) overload, rather than
    // std::pow(qcomp,qcomp), passing in the real components of matr and the given
    // exponent. As such, the result must never be complex which instead becomes NaN.
    // The validation below ergo ensures that pow(a,b) is always real and stable. 
    // All validations upon 'matr' consult existing properties (like .isHermitian),
    // computing them fresh and recording them if not already known

    // the matrix itself must be approximately real, since we consult only its reals.
    // this also validates the matrix fields, and whether GPU-matrices are synced
    validate_matrixIsHermitian(matr, caller);

    // when the exponent is not STRICTLY an integer, it is required that every matrix
    // elem's real component is STRICTLY positive, so that real-pow doesn't create NaNs.
    // this can overwrite matr.isStrictlyNonNegative even when validation epsilon=0
    if (!util_isStrictlyInteger(exponent))
        assertThat(util_isStrictlyNonNegative(matr), report::HERMITIAN_DIAG_MATR_NEGATIVE_WHILE_EXPONENT_NOT_INTEGER, caller);

    // divergences don't break Hermiticity per se, but do sabotage numerical accuracy.
    validate_matrixExpIsNonDiverging(matr, qcomp(exponent,0), caller);

    // the final plausible scenario we have not checked is when both the matrix elem
    // and exponent are strictly positive but very close to zero. In that case, the
    // result tends to 1 so does not vanish or blow up unexpectedly. All fine!
}

void validate_matrixExpIsHermitian(DiagMatr          m, qreal p, const char* caller) { assertMatrExpIsHermitian(m, p, caller); }
void validate_matrixExpIsHermitian(FullStateDiagMatr m, qreal p, const char* caller) { assertMatrExpIsHermitian(m, p, caller); }