Java MathIllegalStateException类代码示例

import org.apache.commons.math3.exception.MathIllegalStateException; //导入依赖的package包/类
/**
 * Create a {@link LeastSquaresProblem} from the given data.
 *
 * @param model          the model function
 * @param target         the observed data
 * @param start          the initial guess
 * @param checker        the convergence checker
 * @param maxEvaluations the allowed evaluations
 * @param maxIterations  the allowed iterations
 * @param lazyEvaluation Whether the call to {@link Evaluation#evaluate(RealVector)}
 * will defer the evaluation until access to the value is requested.
 * @param paramValidator Model parameters validator.
 */
LocalLeastSquaresProblem(final MultivariateJacobianFunction model,
                         final RealVector target,
                         final RealVector start,
                         final ConvergenceChecker<Evaluation> checker,
                         final int maxEvaluations,
                         final int maxIterations,
                         final boolean lazyEvaluation,
                         final ParameterValidator paramValidator) {
    super(maxEvaluations, maxIterations, checker);
    this.target = target;
    this.model = model;
    this.start = start;
    this.lazyEvaluation = lazyEvaluation;
    this.paramValidator = paramValidator;

    if (lazyEvaluation &&
        !(model instanceof ValueAndJacobianFunction)) {
        // Lazy evaluation requires that value and Jacobian
        // can be computed separately.
        throw new MathIllegalStateException(LocalizedFormats.INVALID_IMPLEMENTATION,
                                            model.getClass().getName());
    }
}
 

import org.apache.commons.math3.exception.MathIllegalStateException; //导入依赖的package包/类
/**
 * Get the value of the objective function.
 * @return the objective function evaluation as double value
 * @throws MathIllegalStateException if {@link #cluster(Collection)} has not been called before
 */
public double getObjectiveFunctionValue() {
    if (points == null || clusters == null) {
        throw new MathIllegalStateException();
    }

    int i = 0;
    double objFunction = 0.0;
    for (final T point : points) {
        int j = 0;
        for (final CentroidCluster<T> cluster : clusters) {
            final double dist = distance(point, cluster.getCenter());
            objFunction += (dist * dist) * FastMath.pow(membershipMatrix[i][j], fuzziness);
            j++;
        }
        i++;
    }
    return objFunction;
}
 

import org.apache.commons.math3.exception.MathIllegalStateException; //导入依赖的package包/类
/**
 * Returns an estimate for the pth percentile of the stored values.
 * <p>
 * The implementation provided here follows the first estimation procedure presented
 * <a href="http://www.itl.nist.gov/div898/handbook/prc/section2/prc252.htm">here.</a>
 * </p><p>
 * <strong>Preconditions</strong>:<ul>
 * <li><code>0 &lt; p &le; 100</code> (otherwise an
 * <code>MathIllegalArgumentException</code> is thrown)</li>
 * <li>at least one value must be stored (returns <code>Double.NaN
 *     </code> otherwise)</li>
 * </ul></p>
 *
 * @param p the requested percentile (scaled from 0 - 100)
 * @return An estimate for the pth percentile of the stored data
 * @throws MathIllegalStateException if percentile implementation has been
 *  overridden and the supplied implementation does not support setQuantile
 * @throws MathIllegalArgumentException if p is not a valid quantile
 */
public double getPercentile(double p) throws MathIllegalStateException, MathIllegalArgumentException {
    if (percentileImpl instanceof Percentile) {
        ((Percentile) percentileImpl).setQuantile(p);
    } else {
        try {
            percentileImpl.getClass().getMethod(SET_QUANTILE_METHOD_NAME,
                    new Class[] {Double.TYPE}).invoke(percentileImpl,
                            new Object[] {Double.valueOf(p)});
        } catch (NoSuchMethodException e1) { // Setter guard should prevent
            throw new MathIllegalStateException(
                  LocalizedFormats.PERCENTILE_IMPLEMENTATION_UNSUPPORTED_METHOD,
                  percentileImpl.getClass().getName(), SET_QUANTILE_METHOD_NAME);
        } catch (IllegalAccessException e2) {
            throw new MathIllegalStateException(
                  LocalizedFormats.PERCENTILE_IMPLEMENTATION_CANNOT_ACCESS_METHOD,
                  SET_QUANTILE_METHOD_NAME, percentileImpl.getClass().getName());
        } catch (InvocationTargetException e3) {
            throw new IllegalStateException(e3.getCause());
        }
    }
    return apply(percentileImpl);
}
 

import org.apache.commons.math3.exception.MathIllegalStateException; //导入依赖的package包/类
/**
 * Generates a text report displaying univariate statistics from values
 * that have been added.  Each statistic is displayed on a separate
 * line.
 *
 * @return String with line feeds displaying statistics
 */
@Override
public String toString() {
    StringBuilder outBuffer = new StringBuilder();
    String endl = "\n";
    outBuffer.append("DescriptiveStatistics:").append(endl);
    outBuffer.append("n: ").append(getN()).append(endl);
    outBuffer.append("min: ").append(getMin()).append(endl);
    outBuffer.append("max: ").append(getMax()).append(endl);
    outBuffer.append("mean: ").append(getMean()).append(endl);
    outBuffer.append("std dev: ").append(getStandardDeviation())
        .append(endl);
    try {
        // No catch for MIAE because actual parameter is valid below
        outBuffer.append("median: ").append(getPercentile(50)).append(endl);
    } catch (MathIllegalStateException ex) {
        outBuffer.append("median: unavailable").append(endl);
    }
    outBuffer.append("skewness: ").append(getSkewness()).append(endl);
    outBuffer.append("kurtosis: ").append(getKurtosis()).append(endl);
    return outBuffer.toString();
}
 

import org.apache.commons.math3.exception.MathIllegalStateException; //导入依赖的package包/类
/** {@inheritDoc} */
public PointValuePair optimize(final LinearObjectiveFunction f,
                               final Collection<LinearConstraint> constraints,
                               final GoalType goalType, final boolean restrictToNonNegative)
    throws MathIllegalStateException {

    // store linear problem characteristics
    this.function          = f;
    this.linearConstraints = constraints;
    this.goal              = goalType;
    this.nonNegative       = restrictToNonNegative;

    iterations  = 0;

    // solve the problem
    return doOptimize();

}
 

import org.apache.commons.math3.exception.MathIllegalStateException; //导入依赖的package包/类
/**
 * Get the real part of the {@code k}-th {@code n}-th root of unity.
 *
 * @param k index of the {@code n}-th root of unity
 * @return real part of the {@code k}-th {@code n}-th root of unity
 * @throws MathIllegalStateException if no roots of unity have been
 * computed yet
 * @throws MathIllegalArgumentException if {@code k} is out of range
 */
public synchronized double getReal(int k)
        throws MathIllegalStateException, MathIllegalArgumentException {

    if (omegaCount == 0) {
        throw new MathIllegalStateException(
                LocalizedFormats.ROOTS_OF_UNITY_NOT_COMPUTED_YET);
    }
    if ((k < 0) || (k >= omegaCount)) {
        throw new OutOfRangeException(
                LocalizedFormats.OUT_OF_RANGE_ROOT_OF_UNITY_INDEX,
                Integer.valueOf(k),
                Integer.valueOf(0),
                Integer.valueOf(omegaCount - 1));
    }

    return omegaReal[k];
}
 

import org.apache.commons.math3.exception.MathIllegalStateException; //导入依赖的package包/类
/**
 * Get the imaginary part of the {@code k}-th {@code n}-th root of unity.
 *
 * @param k index of the {@code n}-th root of unity
 * @return imaginary part of the {@code k}-th {@code n}-th root of unity
 * @throws MathIllegalStateException if no roots of unity have been
 * computed yet
 * @throws OutOfRangeException if {@code k} is out of range
 */
public synchronized double getImaginary(int k)
        throws MathIllegalStateException, OutOfRangeException {

    if (omegaCount == 0) {
        throw new MathIllegalStateException(
                LocalizedFormats.ROOTS_OF_UNITY_NOT_COMPUTED_YET);
    }
    if ((k < 0) || (k >= omegaCount)) {
        throw new OutOfRangeException(
                LocalizedFormats.OUT_OF_RANGE_ROOT_OF_UNITY_INDEX,
                Integer.valueOf(k),
                Integer.valueOf(0),
                Integer.valueOf(omegaCount - 1));
    }

    return isCounterClockWise ? omegaImaginaryCounterClockwise[k] :
        omegaImaginaryClockwise[k];
}
 

import org.apache.commons.math3.exception.MathIllegalStateException; //导入依赖的package包/类
/**
 * Returns the next generated value, generated according
 * to the mode value (see MODE constants).
 *
 * @return generated value
 * @throws IOException in REPLAY_MODE if a file I/O error occurs
 * @throws MathIllegalStateException if mode is not recognized
 * @throws MathIllegalArgumentException if the underlying random generator thwrows one
 */
public double getNext() throws IOException, MathIllegalStateException, MathIllegalArgumentException {
    switch (mode) {
        case DIGEST_MODE: return getNextDigest();
        case REPLAY_MODE: return getNextReplay();
        case UNIFORM_MODE: return getNextUniform();
        case EXPONENTIAL_MODE: return getNextExponential();
        case GAUSSIAN_MODE: return getNextGaussian();
        case CONSTANT_MODE: return mu;
        default: throw new MathIllegalStateException(
                LocalizedFormats.UNKNOWN_MODE,
                mode,
                "DIGEST_MODE",   DIGEST_MODE,   "REPLAY_MODE",      REPLAY_MODE,
                "UNIFORM_MODE",  UNIFORM_MODE,  "EXPONENTIAL_MODE", EXPONENTIAL_MODE,
                "GAUSSIAN_MODE", GAUSSIAN_MODE, "CONSTANT_MODE",    CONSTANT_MODE);
    }
}
 

import org.apache.commons.math3.exception.MathIllegalStateException; //导入依赖的package包/类
@Test(expected=MathIllegalStateException.class)
public void testMath844() {
    final double[] y = { 0, 1, 2, 3, 2, 1,
                         0, -1, -2, -3, -2, -1,
                         0, 1, 2, 3, 2, 1,
                         0, -1, -2, -3, -2, -1,
                         0, 1, 2, 3, 2, 1, 0 };
    final int len = y.length;
    final WeightedObservedPoint[] points = new WeightedObservedPoint[len];
    for (int i = 0; i < len; i++) {
        points[i] = new WeightedObservedPoint(1, i, y[i]);
    }

    // The guesser fails because the function is far from an harmonic
    // function: It is a triangular periodic function with amplitude 3
    // and period 12, and all sample points are taken at integer abscissae
    // so function values all belong to the integer subset {-3, -2, -1, 0,
    // 1, 2, 3}.
    new HarmonicFitter.ParameterGuesser(points);
}
 

import org.apache.commons.math3.exception.MathIllegalStateException; //导入依赖的package包/类
@Test(expected=MathIllegalStateException.class)
public void testMath844() {
    final double[] y = { 0, 1, 2, 3, 2, 1,
                         0, -1, -2, -3, -2, -1,
                         0, 1, 2, 3, 2, 1,
                         0, -1, -2, -3, -2, -1,
                         0, 1, 2, 3, 2, 1, 0 };
    final List<WeightedObservedPoint> points = new ArrayList<WeightedObservedPoint>();
    for (int i = 0; i < y.length; i++) {
        points.add(new WeightedObservedPoint(1, i, y[i]));
    }

    // The guesser fails because the function is far from an harmonic
    // function: It is a triangular periodic function with amplitude 3
    // and period 12, and all sample points are taken at integer abscissae
    // so function values all belong to the integer subset {-3, -2, -1, 0,
    // 1, 2, 3}.
    new HarmonicCurveFitter.ParameterGuesser(points);
}
 

import org.apache.commons.math3.exception.MathIllegalStateException; //导入依赖的package包/类
/**
 * Generates a random value from this distribution.
 * <strong>Preconditions:</strong><ul>
 * <li>the distribution must be loaded before invoking this method</li></ul>
 * @return the random value.
 * @throws MathIllegalStateException if the distribution has not been loaded
 */
public double getNextValue() throws MathIllegalStateException {

    if (!loaded) {
        throw new MathIllegalStateException(LocalizedFormats.DISTRIBUTION_NOT_LOADED);
    }

    // Start with a uniformly distributed random number in (0,1)
    final double x = randomData.nextUniform(0,1);

    // Use this to select the bin and generate a Gaussian within the bin
    for (int i = 0; i < binCount; i++) {
       if (x <= upperBounds[i]) {
           SummaryStatistics stats = binStats.get(i);
           if (stats.getN() > 0) {
               if (stats.getStandardDeviation() > 0) {  // more than one obs
                   return getKernel(stats).sample();
               } else {
                   return stats.getMean(); // only one obs in bin
               }
           }
       }
    }
    throw new MathIllegalStateException(LocalizedFormats.NO_BIN_SELECTED);
}
 

import org.apache.commons.math3.exception.MathIllegalStateException; //导入依赖的package包/类
/**
 * Constructor with restricted access, solely used for deserialization.
 *
 * @param nextId Next available identifier.
 * @param featureSize Number of features.
 * @param neuronList Neurons.
 * @param neighbourIdList Links associated to each of the neurons in
 * {@code neuronList}.
 * @throws MathIllegalStateException if an inconsistency is detected
 * (which probably means that the serialized form has been corrupted).
 */
Network(long nextId,
        int featureSize,
        Neuron[] neuronList,
        long[][] neighbourIdList) {
    final int numNeurons = neuronList.length;
    if (numNeurons != neighbourIdList.length) {
        throw new MathIllegalStateException();
    }

    for (int i = 0; i < numNeurons; i++) {
        final Neuron n = neuronList[i];
        final long id = n.getIdentifier();
        if (id >= nextId) {
            throw new MathIllegalStateException();
        }
        neuronMap.put(id, n);
        linkMap.put(id, new HashSet<Long>());
    }

    for (int i = 0; i < numNeurons; i++) {
        final long aId = neuronList[i].getIdentifier();
        final Set<Long> aLinks = linkMap.get(aId);
        for (Long bId : neighbourIdList[i]) {
            if (neuronMap.get(bId) == null) {
                throw new MathIllegalStateException();
            }
            addLinkToLinkSet(aLinks, bId);
        }
    }

    this.nextId = new AtomicLong(nextId);
    this.featureSize = featureSize;
}
 

import org.apache.commons.math3.exception.MathIllegalStateException; //导入依赖的package包/类
/**
 * Builds a finder to retrieve the locations of neurons that
 * belong to the given {@code map}.
 *
 * @param map Map.
 *
 * @throws MathIllegalStateException if the network contains non-unique
 * identifiers.  This indicates an inconsistent state due to a bug in
 * the construction code of the underlying
 * {@link org.apache.commons.math3.ml.neuralnet.Network network}.
 */
public LocationFinder(NeuronSquareMesh2D map) {
    final int nR = map.getNumberOfRows();
    final int nC = map.getNumberOfColumns();

    for (int r = 0; r < nR; r++) {
        for (int c = 0; c < nC; c++) {
            final Long id = map.getNeuron(r, c).getIdentifier();
            if (locations.get(id) != null) {
                throw new MathIllegalStateException();
            }
            locations.put(id, new Location(r, c));
        }
    }
}
 

import org.apache.commons.math3.exception.MathIllegalStateException; //导入依赖的package包/类
/** Start the integration.
 * <p>This method computes one step using the underlying starter integrator,
 * and initializes the Nordsieck vector at step start. The starter integrator
 * purpose is only to establish initial conditions, it does not really change
 * time by itself. The top level multistep integrator remains in charge of
 * handling time propagation and events handling as it will starts its own
 * computation right from the beginning. In a sense, the starter integrator
 * can be seen as a dummy one and so it will never trigger any user event nor
 * call any user step handler.</p>
 * @param equations complete set of differential equations to integrate
 * @param initialState initial state (time, primary and secondary state vectors)
 * @param t target time for the integration
 * (can be set to a value smaller than <code>t0</code> for backward integration)
 * @exception DimensionMismatchException if arrays dimension do not match equations settings
 * @exception NumberIsTooSmallException if integration step is too small
 * @exception MaxCountExceededException if the number of functions evaluations is exceeded
 * @exception NoBracketingException if the location of an event cannot be bracketed
 */
protected void start(final FieldExpandableODE<T> equations, final FieldODEState<T> initialState, final T t)
    throws DimensionMismatchException, NumberIsTooSmallException,
           MaxCountExceededException, NoBracketingException {

    // make sure NO user event nor user step handler is triggered,
    // this is the task of the top level integrator, not the task
    // of the starter integrator
    starter.clearEventHandlers();
    starter.clearStepHandlers();

    // set up one specific step handler to extract initial Nordsieck vector
    starter.addStepHandler(new FieldNordsieckInitializer(equations.getMapper(), (nSteps + 3) / 2));

    // start integration, expecting a InitializationCompletedMarkerException
    try {

        starter.integrate(equations, initialState, t);

        // we should not reach this step
        throw new MathIllegalStateException(LocalizedFormats.MULTISTEP_STARTER_STOPPED_EARLY);

    } catch (InitializationCompletedMarkerException icme) { // NOPMD
        // this is the expected nominal interruption of the start integrator

        // count the evaluations used by the starter
        getEvaluationsCounter().increment(starter.getEvaluations());

    }

    // remove the specific step handler
    starter.clearStepHandlers();

}
 

import org.apache.commons.math3.exception.MathIllegalStateException; //导入依赖的package包/类
/** Get the edge that should naturally follow another one.
 * @param previous edge to be continued
 * @return other edge, starting where the previous one ends (they
 * have not been connected yet)
 * @exception MathIllegalStateException if there is not a single other edge
 */
private Edge getFollowingEdge(final Edge previous)
    throws MathIllegalStateException {

    // get the candidate nodes
    final S2Point point = previous.getEnd().getLocation();
    final List<BSPTree<Sphere2D>> candidates = root.getCloseCuts(point, tolerance);

    // the following edge we are looking for must start from one of the candidates nodes
    double closest = tolerance;
    Edge following = null;
    for (final BSPTree<Sphere2D> node : candidates) {
        for (final Edge edge : nodeToEdgesList.get(node)) {
            if (edge != previous && edge.getStart().getIncoming() == null) {
                final Vector3D edgeStart = edge.getStart().getLocation().getVector();
                final double gap         = Vector3D.angle(point.getVector(), edgeStart);
                if (gap <= closest) {
                    closest   = gap;
                    following = edge;
                }
            }
        }
    }

    if (following == null) {
        final Vector3D previousStart = previous.getStart().getLocation().getVector();
        if (Vector3D.angle(point.getVector(), previousStart) <= tolerance) {
            // the edge connects back to itself
            return previous;
        }

        // this should never happen
        throw new MathIllegalStateException(LocalizedFormats.OUTLINE_BOUNDARY_LOOP_OPEN);

    }

    return following;

}