1 files changed, 161 insertions, 0 deletions
diff --git a/src/main/java/org/apache/commons/math3/dfp/BracketingNthOrderBrentSolverDFP.java b/src/main/java/org/apache/commons/math3/dfp/BracketingNthOrderBrentSolverDFP.java
new file mode 100644
index 0000000..23d4861
--- /dev/null
+++ b/src/main/java/org/apache/commons/math3/dfp/BracketingNthOrderBrentSolverDFP.java
@@ -0,0 +1,161 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.math3.dfp;
+
+import org.apache.commons.math3.analysis.RealFieldUnivariateFunction;
+import org.apache.commons.math3.analysis.solvers.AllowedSolution;
+import org.apache.commons.math3.analysis.solvers.FieldBracketingNthOrderBrentSolver;
+import org.apache.commons.math3.exception.NoBracketingException;
+import org.apache.commons.math3.exception.NullArgumentException;
+import org.apache.commons.math3.exception.NumberIsTooSmallException;
+import org.apache.commons.math3.util.MathUtils;
+
+/**
+ * This class implements a modification of the <a
+ * href="http://mathworld.wolfram.com/BrentsMethod.html">Brent algorithm</a>.
+ *
+ * <p>The changes with respect to the original Brent algorithm are:
+ *
+ * <ul>
+ *   <li>the returned value is chosen in the current interval according to user specified {@link
+ *       AllowedSolution},
+ *   <li>the maximal order for the invert polynomial root search is user-specified instead of being
+ *       invert quadratic only
+ * </ul>
+ *
+ * The given interval must bracket the root.
+ *
+ * @deprecated as of 3.6 replaced with {@link FieldBracketingNthOrderBrentSolver}
+ */
+@Deprecated
+public class BracketingNthOrderBrentSolverDFP extends FieldBracketingNthOrderBrentSolver<Dfp> {
+
+    /**
+     * Construct a solver.
+     *
+     * @param relativeAccuracy Relative accuracy.
+     * @param absoluteAccuracy Absolute accuracy.
+     * @param functionValueAccuracy Function value accuracy.
+     * @param maximalOrder maximal order.
+     * @exception NumberIsTooSmallException if maximal order is lower than 2
+     */
+    public BracketingNthOrderBrentSolverDFP(
+            final Dfp relativeAccuracy,
+            final Dfp absoluteAccuracy,
+            final Dfp functionValueAccuracy,
+            final int maximalOrder)
+            throws NumberIsTooSmallException {
+        super(relativeAccuracy, absoluteAccuracy, functionValueAccuracy, maximalOrder);
+    }
+
+    /**
+     * Get the absolute accuracy.
+     *
+     * @return absolute accuracy
+     */
+    @Override
+    public Dfp getAbsoluteAccuracy() {
+        return super.getAbsoluteAccuracy();
+    }
+
+    /**
+     * Get the relative accuracy.
+     *
+     * @return relative accuracy
+     */
+    @Override
+    public Dfp getRelativeAccuracy() {
+        return super.getRelativeAccuracy();
+    }
+
+    /**
+     * Get the function accuracy.
+     *
+     * @return function accuracy
+     */
+    @Override
+    public Dfp getFunctionValueAccuracy() {
+        return super.getFunctionValueAccuracy();
+    }
+
+    /**
+     * Solve for a zero in the given interval. A solver may require that the interval brackets a
+     * single zero root. Solvers that do require bracketing should be able to handle the case where
+     * one of the endpoints is itself a root.
+     *
+     * @param maxEval Maximum number of evaluations.
+     * @param f Function to solve.
+     * @param min Lower bound for the interval.
+     * @param max Upper bound for the interval.
+     * @param allowedSolution The kind of solutions that the root-finding algorithm may accept as
+     *     solutions.
+     * @return a value where the function is zero.
+     * @exception NullArgumentException if f is null.
+     * @exception NoBracketingException if root cannot be bracketed
+     */
+    public Dfp solve(
+            final int maxEval,
+            final UnivariateDfpFunction f,
+            final Dfp min,
+            final Dfp max,
+            final AllowedSolution allowedSolution)
+            throws NullArgumentException, NoBracketingException {
+        return solve(maxEval, f, min, max, min.add(max).divide(2), allowedSolution);
+    }
+
+    /**
+     * Solve for a zero in the given interval, start at {@code startValue}. A solver may require
+     * that the interval brackets a single zero root. Solvers that do require bracketing should be
+     * able to handle the case where one of the endpoints is itself a root.
+     *
+     * @param maxEval Maximum number of evaluations.
+     * @param f Function to solve.
+     * @param min Lower bound for the interval.
+     * @param max Upper bound for the interval.
+     * @param startValue Start value to use.
+     * @param allowedSolution The kind of solutions that the root-finding algorithm may accept as
+     *     solutions.
+     * @return a value where the function is zero.
+     * @exception NullArgumentException if f is null.
+     * @exception NoBracketingException if root cannot be bracketed
+     */
+    public Dfp solve(
+            final int maxEval,
+            final UnivariateDfpFunction f,
+            final Dfp min,
+            final Dfp max,
+            final Dfp startValue,
+            final AllowedSolution allowedSolution)
+            throws NullArgumentException, NoBracketingException {
+
+        // checks
+        MathUtils.checkNotNull(f);
+
+        // wrap the function
+        RealFieldUnivariateFunction<Dfp> fieldF =
+                new RealFieldUnivariateFunction<Dfp>() {
+
+                    /** {@inheritDoc} */
+                    public Dfp value(final Dfp x) {
+                        return f.value(x);
+                    }
+                };
+
+        // delegate to general field solver
+        return solve(maxEval, fieldF, min, max, startValue, allowedSolution);
+    }
+}