001/*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements.  See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License.  You may obtain a copy of the License at
008 *
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017package org.apache.commons.math3.exception;
018
019import org.apache.commons.math3.util.MathArrays;
020import org.apache.commons.math3.exception.util.LocalizedFormats;
021
022/**
023 * Exception to be thrown when the a sequence of values is not monotonically
024 * increasing or decreasing.
025 *
026 * @since 2.2 (name changed to "NonMonotonicSequenceException" in 3.0)
027 * @version $Id: NonMonotonicSequenceException.java 1504729 2013-07-18 23:54:52Z sebb $
028 */
029public class NonMonotonicSequenceException extends MathIllegalNumberException {
030    /** Serializable version Id. */
031    private static final long serialVersionUID = 3596849179428944575L;
032    /**
033     * Direction (positive for increasing, negative for decreasing).
034     */
035    private final MathArrays.OrderDirection direction;
036    /**
037     * Whether the sequence must be strictly increasing or decreasing.
038     */
039    private final boolean strict;
040    /**
041     * Index of the wrong value.
042     */
043    private final int index;
044    /**
045     * Previous value.
046     */
047    private final Number previous;
048
049    /**
050     * Construct the exception.
051     * This constructor uses default values assuming that the sequence should
052     * have been strictly increasing.
053     *
054     * @param wrong Value that did not match the requirements.
055     * @param previous Previous value in the sequence.
056     * @param index Index of the value that did not match the requirements.
057     */
058    public NonMonotonicSequenceException(Number wrong,
059                                         Number previous,
060                                         int index) {
061        this(wrong, previous, index, MathArrays.OrderDirection.INCREASING, true);
062    }
063
064    /**
065     * Construct the exception.
066     *
067     * @param wrong Value that did not match the requirements.
068     * @param previous Previous value in the sequence.
069     * @param index Index of the value that did not match the requirements.
070     * @param direction Strictly positive for a sequence required to be
071     * increasing, negative (or zero) for a decreasing sequence.
072     * @param strict Whether the sequence must be strictly increasing or
073     * decreasing.
074     */
075    public NonMonotonicSequenceException(Number wrong,
076                                         Number previous,
077                                         int index,
078                                         MathArrays.OrderDirection direction,
079                                         boolean strict) {
080        super(direction == MathArrays.OrderDirection.INCREASING ?
081              (strict ?
082               LocalizedFormats.NOT_STRICTLY_INCREASING_SEQUENCE :
083               LocalizedFormats.NOT_INCREASING_SEQUENCE) :
084              (strict ?
085               LocalizedFormats.NOT_STRICTLY_DECREASING_SEQUENCE :
086               LocalizedFormats.NOT_DECREASING_SEQUENCE),
087              wrong, previous, Integer.valueOf(index), Integer.valueOf(index - 1));
088
089        this.direction = direction;
090        this.strict = strict;
091        this.index = index;
092        this.previous = previous;
093    }
094
095    /**
096     * @return the order direction.
097     **/
098    public MathArrays.OrderDirection getDirection() {
099        return direction;
100    }
101    /**
102     * @return {@code true} is the sequence should be strictly monotonic.
103     **/
104    public boolean getStrict() {
105        return strict;
106    }
107    /**
108     * Get the index of the wrong value.
109     *
110     * @return the current index.
111     */
112    public int getIndex() {
113        return index;
114    }
115    /**
116     * @return the previous value.
117     */
118    public Number getPrevious() {
119        return previous;
120    }
121}