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     */
017    
018    package org.apache.commons.math;
019    
020    /**
021     * Provide a default implementation for several functions useful to generic
022     * converging algorithms.
023     *
024     * @version $Revision: 1062691 $ $Date: 2011-01-24 10:12:47 +0100 (lun. 24 janv. 2011) $
025     * @since 2.0
026     * @deprecated in 2.2 (to be removed in 3.0).
027     */
028    public abstract class ConvergingAlgorithmImpl implements ConvergingAlgorithm {
029    
030        /** Maximum absolute error. */
031        protected double absoluteAccuracy;
032    
033        /** Maximum relative error. */
034        protected double relativeAccuracy;
035    
036        /** Maximum number of iterations. */
037        protected int maximalIterationCount;
038    
039        /** Default maximum absolute error. */
040        protected double defaultAbsoluteAccuracy;
041    
042        /** Default maximum relative error. */
043        protected double defaultRelativeAccuracy;
044    
045        /** Default maximum number of iterations. */
046        protected int defaultMaximalIterationCount;
047    
048        /** The last iteration count. */
049        protected int iterationCount;
050    
051        /**
052         * Construct an algorithm with given iteration count and accuracy.
053         *
054         * @param defaultAbsoluteAccuracy maximum absolute error
055         * @param defaultMaximalIterationCount maximum number of iterations
056         * @throws IllegalArgumentException if f is null or the
057         * defaultAbsoluteAccuracy is not valid
058         * @deprecated in 2.2. Derived classes should use the "setter" methods
059         * in order to assign meaningful values to all the instances variables.
060         */
061        @Deprecated
062        protected ConvergingAlgorithmImpl(final int defaultMaximalIterationCount,
063                                          final double defaultAbsoluteAccuracy) {
064            this.defaultAbsoluteAccuracy = defaultAbsoluteAccuracy;
065            this.defaultRelativeAccuracy = 1.0e-14;
066            this.absoluteAccuracy = defaultAbsoluteAccuracy;
067            this.relativeAccuracy = defaultRelativeAccuracy;
068            this.defaultMaximalIterationCount = defaultMaximalIterationCount;
069            this.maximalIterationCount = defaultMaximalIterationCount;
070            this.iterationCount = 0;
071        }
072    
073        /**
074         * Default constructor.
075         *
076         * @since 2.2
077         * @deprecated in 2.2 (to be removed as soon as the single non-default one
078         * has been removed).
079         */
080        @Deprecated
081        protected ConvergingAlgorithmImpl() {}
082    
083        /** {@inheritDoc} */
084        public int getIterationCount() {
085            return iterationCount;
086        }
087    
088        /** {@inheritDoc} */
089        public void setAbsoluteAccuracy(double accuracy) {
090            absoluteAccuracy = accuracy;
091        }
092    
093        /** {@inheritDoc} */
094        public double getAbsoluteAccuracy() {
095            return absoluteAccuracy;
096        }
097    
098        /** {@inheritDoc} */
099        public void resetAbsoluteAccuracy() {
100            absoluteAccuracy = defaultAbsoluteAccuracy;
101        }
102    
103        /** {@inheritDoc} */
104        public void setMaximalIterationCount(int count) {
105            maximalIterationCount = count;
106        }
107    
108        /** {@inheritDoc} */
109        public int getMaximalIterationCount() {
110            return maximalIterationCount;
111        }
112    
113        /** {@inheritDoc} */
114        public void resetMaximalIterationCount() {
115            maximalIterationCount = defaultMaximalIterationCount;
116        }
117    
118        /** {@inheritDoc} */
119        public void setRelativeAccuracy(double accuracy) {
120            relativeAccuracy = accuracy;
121        }
122    
123        /** {@inheritDoc} */
124        public double getRelativeAccuracy() {
125            return relativeAccuracy;
126        }
127    
128        /** {@inheritDoc} */
129        public void resetRelativeAccuracy() {
130            relativeAccuracy = defaultRelativeAccuracy;
131        }
132    
133        /**
134         * Reset the iterations counter to 0.
135         *
136         * @since 2.2
137         */
138        protected void resetIterationsCounter() {
139            iterationCount = 0;
140        }
141    
142        /**
143         * Increment the iterations counter by 1.
144         *
145         * @throws MaxIterationsExceededException if the maximal number
146         * of iterations is exceeded.
147         * @since 2.2
148         */
149        protected void incrementIterationsCounter()
150            throws MaxIterationsExceededException {
151            if (++iterationCount > maximalIterationCount) {
152                throw new MaxIterationsExceededException(maximalIterationCount);
153            }
154        }
155    }