import org.apache.commons.math3.exception.util.ExceptionContext; //导入依赖的package包/类
/**
 * Performs a symmetry check on the specified linear operator, and throws an
 * exception in case this check fails. Given a linear operator L, and a
 * vector x, this method checks that
 * x' · L · y = y' · L · x
 * (within a given accuracy), where y = L · x.
 *
 * @param l the linear operator L
 * @param x the candidate vector x
 * @param y the candidate vector y = L · x
 * @param z the vector z = L · y
 * @throws NonSelfAdjointOperatorException when the test fails
 */
private static void checkSymmetry(final RealLinearOperator l,
    final RealVector x, final RealVector y, final RealVector z)
    throws NonSelfAdjointOperatorException {
    final double s = y.dotProduct(y);
    final double t = x.dotProduct(z);
    final double epsa = (s + MACH_PREC) * CBRT_MACH_PREC;
    if (FastMath.abs(s - t) > epsa) {
        final NonSelfAdjointOperatorException e;
        e = new NonSelfAdjointOperatorException();
        final ExceptionContext context = e.getContext();
        context.setValue(SymmLQ.OPERATOR, l);
        context.setValue(SymmLQ.VECTOR1, x);
        context.setValue(SymmLQ.VECTOR2, y);
        context.setValue(SymmLQ.THRESHOLD, Double.valueOf(epsa));
        throw e;
    }
}
 

import org.apache.commons.math3.exception.util.ExceptionContext; //导入依赖的package包/类
/**
 * Performs a symmetry check on the specified linear operator, and throws an
 * exception in case this check fails. Given a linear operator L, and a
 * vector x, this method checks that
 * x' · L · y = y' · L · x
 * (within a given accuracy), where y = L · x.
 *
 * @param l the linear operator L
 * @param x the candidate vector x
 * @param y the candidate vector y = L · x
 * @param z the vector z = L · y
 * @throws NonSelfAdjointOperatorException when the test fails
 */
private static void checkSymmetry(final RealLinearOperator l,
    final RealVector x, final RealVector y, final RealVector z)
    throws NonSelfAdjointOperatorException {
    final double s = y.dotProduct(y);
    final double t = x.dotProduct(z);
    final double epsa = (s + MACH_PREC) * CBRT_MACH_PREC;
    if (FastMath.abs(s - t) > epsa) {
        final NonSelfAdjointOperatorException e;
        e = new NonSelfAdjointOperatorException();
        final ExceptionContext context = e.getContext();
        context.setValue(OPERATOR, l);
        context.setValue(VECTOR1, x);
        context.setValue(VECTOR2, y);
        context.setValue(THRESHOLD, Double.valueOf(epsa));
        throw e;
    }
}
 

import org.apache.commons.math3.exception.util.ExceptionContext; //导入依赖的package包/类
/**
 * Simple constructor.
 *
 * @param cause Root cause.
 * @param pattern Message pattern explaining the cause of the error.
 * @param args Arguments.
 */
public MathIllegalStateException(Throwable cause,
                                 Localizable pattern,
                                 Object ... args) {
    super(cause);
    context = new ExceptionContext(this);
    context.addMessage(pattern, args);
}
 

import org.apache.commons.math3.exception.util.ExceptionContext; //导入依赖的package包/类
/**
 * Construct an exception.
 *
 * @param wrong Value that fails the positivity check.
 * @param index Row (and column) index.
 * @param threshold Absolute positivity threshold.
 */
public NonPositiveDefiniteMatrixException(double wrong,
                                          int index,
                                          double threshold) {
    super(wrong, threshold, false);
    this.index = index;
    this.threshold = threshold;

    final ExceptionContext context = getContext();
    context.addMessage(LocalizedFormats.NOT_POSITIVE_DEFINITE_MATRIX);
    context.addMessage(LocalizedFormats.ARRAY_ELEMENT, wrong, index);
}
 

import org.apache.commons.math3.exception.util.ExceptionContext; //导入依赖的package包/类
/**
 * Throws a new {@link NonPositiveDefiniteOperatorException} with
 * appropriate context.
 *
 * @param l the offending linear operator
 * @param v the offending vector
 * @throws NonPositiveDefiniteOperatorException in any circumstances
 */
private static void throwNPDLOException(final RealLinearOperator l,
    final RealVector v) throws NonPositiveDefiniteOperatorException {
    final NonPositiveDefiniteOperatorException e;
    e = new NonPositiveDefiniteOperatorException();
    final ExceptionContext context = e.getContext();
    context.setValue(OPERATOR, l);
    context.setValue(VECTOR, v);
    throw e;
}