commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From l..@apache.org
Subject svn commit: r1144830 - in /commons/proper/math/trunk/src: main/java/org/apache/commons/math/analysis/solvers/ test/java/org/apache/commons/math/analysis/solvers/
Date Sun, 10 Jul 2011 11:10:56 GMT
Author: luc
Date: Sun Jul 10 11:10:55 2011
New Revision: 1144830

URL: http://svn.apache.org/viewvc?rev=1144830&view=rev
Log:
Select bracketing side from the solve method instead of through a setter for consistency with
the other solvers.

Modified:
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/AllowedSolutions.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/BracketedUnivariateRealSolver.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/IllinoisSolver.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/PegasusSolver.java
    commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/RegulaFalsiSolver.java
    commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/BaseSecantSolverAbstractTest.java

Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/AllowedSolutions.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/AllowedSolutions.java?rev=1144830&r1=1144829&r2=1144830&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/AllowedSolutions.java
(original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/AllowedSolutions.java
Sun Jul 10 11:10:55 2011
@@ -23,7 +23,7 @@ package org.apache.commons.math.analysis
  * This basically controls whether or not under-approximations and
  * over-approximations are allowed.
  *
- * <p>If all solutions are accepted ({@link #EITHER_SIDE}), then the solution
+ * <p>If all solutions are accepted ({@link #ANY_SIDE}), then the solution
  * that the root-finding algorithm returns for a given root may be equal to the
  * actual root, but it may also be an approximation that is slightly smaller
  * or slightly larger than the actual root. Root-finding algorithms generally
@@ -45,7 +45,7 @@ public enum AllowedSolutions {
      * root-finding result s may be smaller than x0, equal to x0, or greater
      * than x0.
      */
-    EITHER_SIDE,
+    ANY_SIDE,
 
     /** Only solutions that are less than or equal to the actual root are
      * acceptable as solutions for root-finding. In other words,

Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/BracketedUnivariateRealSolver.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/BracketedUnivariateRealSolver.java?rev=1144830&r1=1144829&r2=1144830&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/BracketedUnivariateRealSolver.java
(original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/BracketedUnivariateRealSolver.java
Sun Jul 10 11:10:55 2011
@@ -17,6 +17,8 @@
 
 package org.apache.commons.math.analysis.solvers;
 
+import org.apache.commons.math.analysis.UnivariateRealFunction;
+
 /** Interface for {@link UnivariateRealSolver (univariate real) root-finding
  * algorithms} that maintain a bracketed solution. There are several advantages
  * to having such root-finding algorithms:
@@ -34,27 +36,57 @@ package org.apache.commons.math.analysis
  * </ul>
  *
  * <p>For backwards compatibility, all root-finding algorithms must have
- * {@link AllowedSolutions#EITHER_SIDE EITHER_SIDE} as default for the allowed
+ * {@link AllowedSolutions#ANY_SIDE ANY_SIDE} as default for the allowed
  * solutions.</p>
  *
  * @see AllowedSolutions
  * @since 3.0
  * @version $Id$
  */
-public interface BracketedUnivariateRealSolver extends UnivariateRealSolver {
-    /** Returns the kind of solutions that the root-finding algorithm may
-     * accept as solutions.
+public interface BracketedUnivariateRealSolver<FUNC extends UnivariateRealFunction>
+    extends BaseUnivariateRealSolver<FUNC> {
+
+    /**
+     * 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.
      *
-     * @return the kind of solutions that the root-finding algorithm may
-     * accept as solutions
+     * @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 allowedSolutions the kind of solutions that the root-finding algorithm may
+     * accept as solutions.
+     * @return a value where the function is zero.
+     * @throws org.apache.commons.math.exception.MathIllegalArgumentException
+     * if the arguments do not satisfy the requirements specified by the solver.
+     * @throws org.apache.commons.math.exception.TooManyEvaluationsException if
+     * the allowed number of evaluations is exceeded.
      */
-    AllowedSolutions getAllowedSolutions();
+    double solve(int maxEval, FUNC f, double min, double max,
+                 AllowedSolutions allowedSolutions);
 
-    /** Sets the kind of solutions that the root-finding algorithm may accept
-     * as solutions.
+    /**
+     * 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 allowedSolutions the kind of solutions that the root-finding
-     * algorithm may accept as solutions
+     * @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 allowedSolutions the kind of solutions that the root-finding algorithm may
+     * accept as solutions.
+     * @return a value where the function is zero.
+     * @throws org.apache.commons.math.exception.MathIllegalArgumentException
+     * if the arguments do not satisfy the requirements specified by the solver.
+     * @throws org.apache.commons.math.exception.TooManyEvaluationsException if
+     * the allowed number of evaluations is exceeded.
      */
-    void setAllowedSolutions(AllowedSolutions allowedSolutions);
+    double solve(int maxEval, FUNC f, double min, double max, double startValue,
+                 AllowedSolutions allowedSolutions);
+
 }

Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/IllinoisSolver.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/IllinoisSolver.java?rev=1144830&r1=1144829&r2=1144830&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/IllinoisSolver.java
(original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/IllinoisSolver.java
Sun Jul 10 11:10:55 2011
@@ -38,7 +38,8 @@ package org.apache.commons.math.analysis
  * @since 3.0
  * @version $Id$
  */
-public class IllinoisSolver extends BaseBracketedSecantSolver {
+public class IllinoisSolver extends BaseSecantSolver {
+
     /** Construct a solver with default accuracy (1e-6). */
     public IllinoisSolver() {
         super(DEFAULT_ABSOLUTE_ACCURACY, Method.ILLINOIS);

Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/PegasusSolver.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/PegasusSolver.java?rev=1144830&r1=1144829&r2=1144830&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/PegasusSolver.java
(original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/PegasusSolver.java
Sun Jul 10 11:10:55 2011
@@ -40,7 +40,8 @@ package org.apache.commons.math.analysis
  * @since 3.0
  * @version $Id$
  */
-public class PegasusSolver extends BaseBracketedSecantSolver {
+public class PegasusSolver extends BaseSecantSolver {
+
     /** Construct a solver with default accuracy (1e-6). */
     public PegasusSolver() {
         super(DEFAULT_ABSOLUTE_ACCURACY, Method.PEGASUS);

Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/RegulaFalsiSolver.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/RegulaFalsiSolver.java?rev=1144830&r1=1144829&r2=1144830&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/RegulaFalsiSolver.java
(original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/analysis/solvers/RegulaFalsiSolver.java
Sun Jul 10 11:10:55 2011
@@ -35,7 +35,8 @@ package org.apache.commons.math.analysis
  * @since 3.0
  * @version $Id$
  */
-public class RegulaFalsiSolver extends BaseBracketedSecantSolver {
+public class RegulaFalsiSolver extends BaseSecantSolver {
+
     /** Construct a solver with default accuracy (1e-6). */
     public RegulaFalsiSolver() {
         super(DEFAULT_ABSOLUTE_ACCURACY, Method.REGULA_FALSI);

Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/BaseSecantSolverAbstractTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/BaseSecantSolverAbstractTest.java?rev=1144830&r1=1144829&r2=1144830&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/BaseSecantSolverAbstractTest.java
(original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/analysis/solvers/BaseSecantSolverAbstractTest.java
Sun Jul 10 11:10:55 2011
@@ -162,14 +162,14 @@ public abstract class BaseSecantSolverAb
     public void testSolutionLeftSide() {
         UnivariateRealFunction f = new SinFunction();
         UnivariateRealSolver solver = getSolver();
-        if (!(solver instanceof BracketedUnivariateRealSolver)) return;
-        ((BracketedUnivariateRealSolver)solver).setAllowedSolutions(AllowedSolutions.LEFT_SIDE);
         double left = -1.5;
         double right = 0.05;
         for(int i = 0; i < 10; i++) {
             // Test whether the allowed solutions are taken into account.
-            double solution = solver.solve(100, f, left, right);
-            Assert.assertTrue(solution <= 0.0);
+            double solution = getSolution(solver, 100, f, left, right, AllowedSolutions.LEFT_SIDE);
+            if (!Double.isNaN(solution)) {
+                Assert.assertTrue(solution <= 0.0);
+            }
 
             // Prepare for next test.
             left -= 0.1;
@@ -181,14 +181,14 @@ public abstract class BaseSecantSolverAb
     public void testSolutionRightSide() {
         UnivariateRealFunction f = new SinFunction();
         UnivariateRealSolver solver = getSolver();
-        if (!(solver instanceof BracketedUnivariateRealSolver)) return;
-        ((BracketedUnivariateRealSolver)solver).setAllowedSolutions(AllowedSolutions.RIGHT_SIDE);
         double left = -1.5;
         double right = 0.05;
         for(int i = 0; i < 10; i++) {
             // Test whether the allowed solutions are taken into account.
-            double solution = solver.solve(100, f, left, right);
-            Assert.assertTrue(solution >= 0.0);
+            double solution = getSolution(solver, 100, f, left, right, AllowedSolutions.RIGHT_SIDE);
+            if (!Double.isNaN(solution)) {
+                Assert.assertTrue(solution >= 0.0);
+            }
 
             // Prepare for next test.
             left -= 0.1;
@@ -199,14 +199,14 @@ public abstract class BaseSecantSolverAb
     public void testSolutionBelowSide() {
         UnivariateRealFunction f = new SinFunction();
         UnivariateRealSolver solver = getSolver();
-        if (!(solver instanceof BracketedUnivariateRealSolver)) return;
-        ((BracketedUnivariateRealSolver)solver).setAllowedSolutions(AllowedSolutions.BELOW_SIDE);
         double left = -1.5;
         double right = 0.05;
         for(int i = 0; i < 10; i++) {
             // Test whether the allowed solutions are taken into account.
-            double solution = solver.solve(100, f, left, right);
-            Assert.assertTrue(f.value(solution) <= 0.0);
+            double solution = getSolution(solver, 100, f, left, right, AllowedSolutions.BELOW_SIDE);
+            if (!Double.isNaN(solution)) {
+                Assert.assertTrue(f.value(solution) <= 0.0);
+            }
 
             // Prepare for next test.
             left -= 0.1;
@@ -218,14 +218,14 @@ public abstract class BaseSecantSolverAb
     public void testSolutionAboveSide() {
         UnivariateRealFunction f = new SinFunction();
         UnivariateRealSolver solver = getSolver();
-        if (!(solver instanceof BracketedUnivariateRealSolver)) return;
-        ((BracketedUnivariateRealSolver)solver).setAllowedSolutions(AllowedSolutions.ABOVE_SIDE);
         double left = -1.5;
         double right = 0.05;
         for(int i = 0; i < 10; i++) {
             // Test whether the allowed solutions are taken into account.
-            double solution = solver.solve(100, f, left, right);
-            Assert.assertTrue(f.value(solution) >= 0.0);
+            double solution = getSolution(solver, 100, f, left, right, AllowedSolutions.ABOVE_SIDE);
+            if (!Double.isNaN(solution)) {
+                Assert.assertTrue(f.value(solution) >= 0.0);
+            }
 
             // Prepare for next test.
             left -= 0.1;
@@ -233,4 +233,25 @@ public abstract class BaseSecantSolverAb
         }
     }
 
+    private double getSolution(UnivariateRealSolver solver, int maxEval, UnivariateRealFunction
f,
+                               double left, double right, AllowedSolutions allowedSolutions)
{
+        try {
+            @SuppressWarnings("unchecked")
+            BracketedUnivariateRealSolver<UnivariateRealFunction> bracketing =
+            (BracketedUnivariateRealSolver<UnivariateRealFunction>) solver;
+            return bracketing.solve(100, f, left, right, allowedSolutions);
+        } catch (ClassCastException cce) {
+            double baseRoot = solver.solve(maxEval, f, left, right);
+            if ((baseRoot <= left) || (baseRoot >= right)) {
+                // the solution slipped out of interval
+                return Double.NaN;
+            }
+            PegasusSolver bracketing =
+                    new PegasusSolver(solver.getRelativeAccuracy(), solver.getAbsoluteAccuracy());
+            return UnivariateRealSolverUtils.forceSide(maxEval - solver.getEvaluations(),
+                                                       f, bracketing, baseRoot, left, right,
+                                                       allowedSolutions);
+        }
+    }
+
 }



Mime
View raw message