From 6261e6a91b0bf2e65e223850ea8321694e1ce951 Mon Sep 17 00:00:00 2001 From: Luc Maisonobe Date: Mon, 10 Sep 2007 19:00:09 +0000 Subject: [PATCH] removed factories from the new ODE package git-svn-id: https://svn.apache.org/repos/asf/commons/proper/math/trunk@574335 13f79535-47bb-0310-9956-ffa450edef68 --- .../math/ode/FirstOrderIntegratorFactory.java | 297 ------------------ .../ode/FirstOrderIntegratorFactoryImpl.java | 278 ---------------- .../ode/GraggBulirschStoerIntegratorTest.java | 4 +- 3 files changed, 1 insertion(+), 578 deletions(-) delete mode 100644 src/java/org/apache/commons/math/ode/FirstOrderIntegratorFactory.java delete mode 100644 src/java/org/apache/commons/math/ode/FirstOrderIntegratorFactoryImpl.java diff --git a/src/java/org/apache/commons/math/ode/FirstOrderIntegratorFactory.java b/src/java/org/apache/commons/math/ode/FirstOrderIntegratorFactory.java deleted file mode 100644 index fe648398f..000000000 --- a/src/java/org/apache/commons/math/ode/FirstOrderIntegratorFactory.java +++ /dev/null @@ -1,297 +0,0 @@ -/* - * 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.math.ode; - -import org.apache.commons.discovery.tools.DiscoverClass; - -/** - * Abstract factory class used to create {@link FirstOrderIntegrator} instances. - *

- * Integrators implementing the following fixed stepsize algorithms are supported: - *

- * Concrete factories extending this class also specify a default fixed stepsize integrator, - * instances of which are returned by newDefaultFixedStepsizeIntegrator. - *

- *

- * Integrators implementing the following adaptive stepsize algorithms are supported: - *

- * Concrete factories extending this class also specify default adaptive stepsize integrators, - * instances of which are returned by the two newDefaultAdaptiveStepsizeIntegrator - * methods. - *

- * Common usage:

- * FirstOrderIntegratorFactory factory = FirstOrderIntegratorFactory.newInstance();
- *
- * // create a Dormand-Prince 8(5,3) integrator to use with some step control parameters
- * AdaptiveStepsizeIntegrator integrator =
- *   factory.newDormandPrince853Integrator(minStep, maxStep,
- *                                         scalAbsoluteTolerance,
- *                                         scalRelativeTolerance);
- *
- * - * Apache Commons Discovery - * is used to determine the concrete factory returned by - * FirstOrderIntegratorFactory.newInstance(). The default is - * {@link FirstOrderIntegratorFactoryImpl} - * - * @version $Revision: 480440 $ $Date: 2006-11-29 08:14:12 +0100 (mer., 29 nov. 2006) $ - */ -public abstract class FirstOrderIntegratorFactory { - - /** - * Default constructor. - */ - protected FirstOrderIntegratorFactory() { - } - - /** - * Create a new factory. - * @return a new factory - */ - public static FirstOrderIntegratorFactory newInstance() { - FirstOrderIntegratorFactory factory = null; - try { - DiscoverClass dc = new DiscoverClass(); - factory = (FirstOrderIntegratorFactory) dc.newInstance( - FirstOrderIntegratorFactory.class, - "org.apache.commons.math.analysis.FirstOrderIntegratorFactoryImpl"); - } catch(Throwable t) { - return new FirstOrderIntegratorFactoryImpl(); - } - return factory; - } - - /** - * Create a new fixed stepsize {@link FirstOrderIntegrator}. - * The actual integrator returned is determined by the underlying factory. - * @param step the fixed stepsize. - * @return the new fixed step integrator - */ - public abstract FirstOrderIntegrator newDefaultFixedStepsizeIntegrator(double step); - - /** - * Create a new {@link AdaptiveStepsizeIntegrator}. - * The actual integrator returned is determined by the underlying factory. - * @param minStep minimal step (must be positive even for backward - * integration), the last step can be smaller than this - * @param maxStep maximal step (must be positive even for backward - * integration) - * @param scalAbsoluteTolerance allowed absolute error - * @param scalRelativeTolerance allowed relative error - * @return the new adaptive stepsize integrator - */ - public abstract AdaptiveStepsizeIntegrator newDefaultAdaptiveStepsizeIntegrator( - double minStep, double maxStep, - double scalAbsoluteTolerance, - double scalRelativeTolerance); - - /** - * Create a new {@link AdaptiveStepsizeIntegrator}. - * The actual integrator returned is determined by the underlying factory. - * @param minStep minimal step (must be positive even for backward - * integration), the last step can be smaller than this - * @param maxStep maximal step (must be positive even for backward - * integration) - * @param vecAbsoluteTolerance allowed absolute error - * @param vecRelativeTolerance allowed relative error - * @return the new adaptive stepsize integrator - */ - public abstract AdaptiveStepsizeIntegrator newDefaultAdaptiveStepsizeIntegrator( - double minStep, double maxStep, - double[] vecAbsoluteTolerance, - double[] vecRelativeTolerance); - - /** - * Create a new {@link FirstOrderIntegrator}. - * The integrator is an implementation of the Euler method. - * @param step the fixed stepsize. - * @return the new fixed step integrator - */ - public abstract FirstOrderIntegrator newEulerIntegrator(double step); - - /** - * Create a new {@link FirstOrderIntegrator}. - * The integrator is an implementation of the midpoint method. - * @param step the fixed stepsize. - * @return the new fixed step integrator - */ - public abstract FirstOrderIntegrator newMidpointIntegrator(double step); - - /** - * Create a new {@link FirstOrderIntegrator}. - * The integrator is an implementation of the classical Runge-Kutta method. - * @param step the fixed stepsize. - * @return the new fixed step integrator - */ - public abstract FirstOrderIntegrator newClassicalRungeKuttaIntegrator(double step); - - /** - * Create a new {@link FirstOrderIntegrator}. - * The integrator is an implementation of the Gill method. - * @param step the fixed stepsize. - * @return the new fixed step integrator - */ - public abstract FirstOrderIntegrator newGillIntegrator(double step); - - /** - * Create a new {@link FirstOrderIntegrator}. - * The integrator is an implementation of the 3/8 method. - * @param step the fixed stepsize. - * @return the new fixed step integrator - */ - public abstract FirstOrderIntegrator newThreeEighthesIntegrator(double step); - - /** - * Create a new {@link AdaptiveStepsizeIntegrator}. - * The integrator is an implementation of the Higham-Hall method. - * @param minStep minimal step (must be positive even for backward - * integration), the last step can be smaller than this - * @param maxStep maximal step (must be positive even for backward - * integration) - * @param scalAbsoluteTolerance allowed absolute error - * @param scalRelativeTolerance allowed relative error - * @return the new adaptive stepsize integrator - */ - public abstract AdaptiveStepsizeIntegrator newHighamHall54Integrator( - double minStep, double maxStep, - double scalAbsoluteTolerance, - double scalRelativeTolerance); - - /** - * Create a new {@link AdaptiveStepsizeIntegrator}. - * The integrator is an implementation of the Higham-Hall method. - * @param minStep minimal step (must be positive even for backward - * integration), the last step can be smaller than this - * @param maxStep maximal step (must be positive even for backward - * integration) - * @param vecAbsoluteTolerance allowed absolute error - * @param vecRelativeTolerance allowed relative error - * @return the new adaptive stepsize integrator - */ - public abstract AdaptiveStepsizeIntegrator newHighamHall54Integrator( - double minStep, double maxStep, - double[] vecAbsoluteTolerance, - double[] vecRelativeTolerance); - - /** - * Create a new {@link AdaptiveStepsizeIntegrator}. - * The integrator is an implementation of the Dormand-Prince 5(4) method. - * @param minStep minimal step (must be positive even for backward - * integration), the last step can be smaller than this - * @param maxStep maximal step (must be positive even for backward - * integration) - * @param scalAbsoluteTolerance allowed absolute error - * @param scalRelativeTolerance allowed relative error - * @return the new adaptive stepsize integrator - */ - public abstract AdaptiveStepsizeIntegrator newDormandPrince54Integrator( - double minStep, double maxStep, - double scalAbsoluteTolerance, - double scalRelativeTolerance); - - /** - * Create a new {@link AdaptiveStepsizeIntegrator}. - * The integrator is an implementation of the Dormand-Prince 5(4) method. - * @param minStep minimal step (must be positive even for backward - * integration), the last step can be smaller than this - * @param maxStep maximal step (must be positive even for backward - * integration) - * @param vecAbsoluteTolerance allowed absolute error - * @param vecRelativeTolerance allowed relative error - * @return the new adaptive stepsize integrator - */ - public abstract AdaptiveStepsizeIntegrator newDormandPrince54Integrator( - double minStep, double maxStep, - double[] vecAbsoluteTolerance, - double[] vecRelativeTolerance); - - /** - * Create a new {@link AdaptiveStepsizeIntegrator}. - * The integrator is an implementation of the Dormand-Prince 8(5,3) method. - * @param minStep minimal step (must be positive even for backward - * integration), the last step can be smaller than this - * @param maxStep maximal step (must be positive even for backward - * integration) - * @param scalAbsoluteTolerance allowed absolute error - * @param scalRelativeTolerance allowed relative error - * @return the new adaptive stepsize integrator - */ - public abstract AdaptiveStepsizeIntegrator newDormandPrince853Integrator( - double minStep, double maxStep, - double scalAbsoluteTolerance, - double scalRelativeTolerance); - - /** - * Create a new {@link AdaptiveStepsizeIntegrator}. - * The integrator is an implementation of the Dormand-Prince 8(5,3) method. - * @param minStep minimal step (must be positive even for backward - * integration), the last step can be smaller than this - * @param maxStep maximal step (must be positive even for backward - * integration) - * @param vecAbsoluteTolerance allowed absolute error - * @param vecRelativeTolerance allowed relative error - * @return the new adaptive stepsize integrator - */ - public abstract AdaptiveStepsizeIntegrator newDormandPrince853Integrator( - double minStep, double maxStep, - double[] vecAbsoluteTolerance, - double[] vecRelativeTolerance); - - /** - * Create a new {@link AdaptiveStepsizeIntegrator}. - * The integrator is an implementation of the Gragg-Burlisch-Stoer method. - * @param minStep minimal step (must be positive even for backward - * integration), the last step can be smaller than this - * @param maxStep maximal step (must be positive even for backward - * integration) - * @param scalAbsoluteTolerance allowed absolute error - * @param scalRelativeTolerance allowed relative error - * @return the new adaptive stepsize integrator - */ - public abstract AdaptiveStepsizeIntegrator newGraggBulirschStoerIntegrator( - double minStep, double maxStep, - double scalAbsoluteTolerance, - double scalRelativeTolerance); - - /** - * Create a new {@link AdaptiveStepsizeIntegrator}. - * The integrator is an implementation of the Gragg-Burlisch-Stoer method. - * @param minStep minimal step (must be positive even for backward - * integration), the last step can be smaller than this - * @param maxStep maximal step (must be positive even for backward - * integration) - * @param vecAbsoluteTolerance allowed absolute error - * @param vecRelativeTolerance allowed relative error - * @return the new adaptive stepsize integrator - */ - public abstract AdaptiveStepsizeIntegrator newGraggBulirschStoerIntegrator( - double minStep, double maxStep, - double[] vecAbsoluteTolerance, - double[] vecRelativeTolerance); - -} diff --git a/src/java/org/apache/commons/math/ode/FirstOrderIntegratorFactoryImpl.java b/src/java/org/apache/commons/math/ode/FirstOrderIntegratorFactoryImpl.java deleted file mode 100644 index f51fb0df6..000000000 --- a/src/java/org/apache/commons/math/ode/FirstOrderIntegratorFactoryImpl.java +++ /dev/null @@ -1,278 +0,0 @@ -/* - * 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.math.ode; - -/** - * Provide a default implementation for several functions useful to generic - * integrators. - * - * @version $Revision: 480440 $ $Date: 2006-11-29 08:14:12 +0100 (mer., 29 nov. 2006) $ - */ -public class FirstOrderIntegratorFactoryImpl extends - FirstOrderIntegratorFactory { - - /** - * Create a new fixed stepsize {@link FirstOrderIntegrator}. - * This factory buid a {@link ClassicalRungeKuttaIntegrator - * classical Runge-Kutta} integrator by default. - * @param step the fixed stepsize. - * @return the new fixed step integrator - */ - public FirstOrderIntegrator newDefaultFixedStepsizeIntegrator(double step) { - return newClassicalRungeKuttaIntegrator(step); - } - - /** - * Create a new {@link AdaptiveStepsizeIntegrator}. - * This factory buid a {@link DormandPrince853Integrator - * Dormand-Prince 8(5,3)} integrator by default. - * @param minStep minimal step (must be positive even for backward - * integration), the last step can be smaller than this - * @param maxStep maximal step (must be positive even for backward - * integration) - * @param scalAbsoluteTolerance allowed absolute error - * @param scalRelativeTolerance allowed relative error - * @return the new adaptive stepsize integrator - */ - public AdaptiveStepsizeIntegrator newDefaultAdaptiveStepsizeIntegrator( - double minStep, double maxStep, double scalAbsoluteTolerance, - double scalRelativeTolerance) { - return newDormandPrince853Integrator(minStep, maxStep, - scalAbsoluteTolerance, scalRelativeTolerance); - } - - /** - * Create a new {@link AdaptiveStepsizeIntegrator}. - * This factory buid a {@link DormandPrince853Integrator - * Dormand-Prince 8(5,3)} integrator by default. - * @param minStep minimal step (must be positive even for backward - * integration), the last step can be smaller than this - * @param maxStep maximal step (must be positive even for backward - * integration) - * @param vecAbsoluteTolerance allowed absolute error - * @param vecRelativeTolerance allowed relative error - * @return the new adaptive stepsize integrator - */ - public AdaptiveStepsizeIntegrator newDefaultAdaptiveStepsizeIntegrator( - double minStep, double maxStep, double[] vecAbsoluteTolerance, - double[] vecRelativeTolerance) { - return newDormandPrince853Integrator(minStep, maxStep, - vecAbsoluteTolerance, vecRelativeTolerance); - } - - /** - * Create a new fixed stepsize {@link FirstOrderIntegrator}. - * This factory buid a {@link EulerIntegrator Euler} integrator. - * @param step the fixed stepsize. - * @return the new fixed step integrator - */ - public FirstOrderIntegrator newEulerIntegrator(double step) { - return new EulerIntegrator(step); - } - - /** - * Create a new fixed stepsize {@link FirstOrderIntegrator}. - * This factory buid a {@link MidpointIntegrator midpoint} integrator. - * @param step the fixed stepsize. - * @return the new fixed step integrator - */ - public FirstOrderIntegrator newMidpointIntegrator(double step) { - return new MidpointIntegrator(step); - } - /** - * Create a new fixed stepsize {@link FirstOrderIntegrator}. - * This factory buid a {@link ClassicalRungeKuttaIntegrator - * classical Runge-Kutta} integrator. - * @param step the fixed stepsize. - * @return the new fixed step integrator - */ - - public FirstOrderIntegrator newClassicalRungeKuttaIntegrator(double step) { - return new ClassicalRungeKuttaIntegrator(step); - } - - /** - * Create a new fixed stepsize {@link FirstOrderIntegrator}. - * This factory buid a {@link GillIntegrator Gill} integrator. - * @param step the fixed stepsize. - * @return the new fixed step integrator - */ - public FirstOrderIntegrator newGillIntegrator(double step) { - return new GillIntegrator(step); - } - - /** - * Create a new fixed stepsize {@link FirstOrderIntegrator}. - * This factory buid a {@link ThreeEighthesIntegrator 3/8} integrator. - * @param step the fixed stepsize. - * @return the new fixed step integrator - */ - public FirstOrderIntegrator newThreeEighthesIntegrator(double step) { - return new ThreeEighthesIntegrator(step); - } - - /** - * Create a new {@link AdaptiveStepsizeIntegrator}. - * This factory buid a {@link HighamHall54Integrator Higham-Hall} integrator. - * @param minStep minimal step (must be positive even for backward - * integration), the last step can be smaller than this - * @param maxStep maximal step (must be positive even for backward - * integration) - * @param scalAbsoluteTolerance allowed absolute error - * @param scalRelativeTolerance allowed relative error - * @return the new adaptive stepsize integrator - */ - public AdaptiveStepsizeIntegrator newHighamHall54Integrator(double minStep, - double maxStep, double scalAbsoluteTolerance, - double scalRelativeTolerance) { - return new HighamHall54Integrator(minStep, maxStep, - scalAbsoluteTolerance, scalRelativeTolerance); - } - - /** - * Create a new {@link AdaptiveStepsizeIntegrator}. - * This factory buid a {@link HighamHall54Integrator Higham-Hall} integrator. - * @param minStep minimal step (must be positive even for backward - * integration), the last step can be smaller than this - * @param maxStep maximal step (must be positive even for backward - * integration) - * @param vecAbsoluteTolerance allowed absolute error - * @param vecRelativeTolerance allowed relative error - * @return the new adaptive stepsize integrator - */ - public AdaptiveStepsizeIntegrator newHighamHall54Integrator(double minStep, - double maxStep, double[] vecAbsoluteTolerance, - double[] vecRelativeTolerance) { - return new HighamHall54Integrator(minStep, maxStep, - vecAbsoluteTolerance, vecRelativeTolerance); - } - - /** - * Create a new {@link AdaptiveStepsizeIntegrator}. - * This factory buid a {@link DormandPrince54Integrator - * Dormand-Prince 5(4)} integrator. - * @param minStep minimal step (must be positive even for backward - * integration), the last step can be smaller than this - * @param maxStep maximal step (must be positive even for backward - * integration) - * @param scalAbsoluteTolerance allowed absolute error - * @param scalRelativeTolerance allowed relative error - * @return the new adaptive stepsize integrator - */ - public AdaptiveStepsizeIntegrator newDormandPrince54Integrator( - double minStep, double maxStep, double scalAbsoluteTolerance, - double scalRelativeTolerance) { - return new DormandPrince54Integrator(minStep, maxStep, - scalAbsoluteTolerance, scalRelativeTolerance); - } - - /** - * Create a new {@link AdaptiveStepsizeIntegrator}. - * This factory buid a {@link DormandPrince54Integrator - * Dormand-Prince 5(4)} integrator. - * @param minStep minimal step (must be positive even for backward - * integration), the last step can be smaller than this - * @param maxStep maximal step (must be positive even for backward - * integration) - * @param vecAbsoluteTolerance allowed absolute error - * @param vecRelativeTolerance allowed relative error - * @return the new adaptive stepsize integrator - */ - public AdaptiveStepsizeIntegrator newDormandPrince54Integrator(double minStep, - double maxStep, double[] vecAbsoluteTolerance, - double[] vecRelativeTolerance) { - return new DormandPrince54Integrator(minStep, maxStep, - vecAbsoluteTolerance, vecRelativeTolerance); - } - - /** - * Create a new {@link AdaptiveStepsizeIntegrator}. - * This factory buid a {@link DormandPrince853Integrator - * Dormand-Prince 8(5,3)} integrator. - * @param minStep minimal step (must be positive even for backward - * integration), the last step can be smaller than this - * @param maxStep maximal step (must be positive even for backward - * integration) - * @param scalAbsoluteTolerance allowed absolute error - * @param scalRelativeTolerance allowed relative error - * @return the new adaptive stepsize integrator - */ - public AdaptiveStepsizeIntegrator newDormandPrince853Integrator( - double minStep, double maxStep, double scalAbsoluteTolerance, - double scalRelativeTolerance) { - return new DormandPrince853Integrator(minStep, maxStep, - scalAbsoluteTolerance, scalRelativeTolerance); - } - - /** - * Create a new {@link AdaptiveStepsizeIntegrator}. - * This factory buid a {@link DormandPrince853Integrator - * Dormand-Prince 8(5,3)} integrator. - * @param minStep minimal step (must be positive even for backward - * integration), the last step can be smaller than this - * @param maxStep maximal step (must be positive even for backward - * integration) - * @param vecAbsoluteTolerance allowed absolute error - * @param vecRelativeTolerance allowed relative error - * @return the new adaptive stepsize integrator - */ - public AdaptiveStepsizeIntegrator newDormandPrince853Integrator( - double minStep, double maxStep, double[] vecAbsoluteTolerance, - double[] vecRelativeTolerance) { - return new DormandPrince853Integrator(minStep, maxStep, - vecAbsoluteTolerance, vecRelativeTolerance); - } - - /** - * Create a new {@link AdaptiveStepsizeIntegrator}. - * This factory buid a {@link GraggBulirschStoerIntegrator - * Gragg-Bulirsch-Stoer} integrator. - * @param minStep minimal step (must be positive even for backward - * integration), the last step can be smaller than this - * @param maxStep maximal step (must be positive even for backward - * integration) - * @param scalAbsoluteTolerance allowed absolute error - * @param scalRelativeTolerance allowed relative error - * @return the new adaptive stepsize integrator - */ - public AdaptiveStepsizeIntegrator newGraggBulirschStoerIntegrator( - double minStep, double maxStep, double scalAbsoluteTolerance, - double scalRelativeTolerance) { - return new GraggBulirschStoerIntegrator(minStep, maxStep, - scalAbsoluteTolerance, scalRelativeTolerance); - } - - /** - * Create a new {@link AdaptiveStepsizeIntegrator}. - * This factory buid a {@link GraggBulirschStoerIntegrator - * Gragg-Bulirsch-Stoer} integrator. - * @param minStep minimal step (must be positive even for backward - * integration), the last step can be smaller than this - * @param maxStep maximal step (must be positive even for backward - * integration) - * @param vecAbsoluteTolerance allowed absolute error - * @param vecRelativeTolerance allowed relative error - * @return the new adaptive stepsize integrator - */ - public AdaptiveStepsizeIntegrator newGraggBulirschStoerIntegrator( - double minStep, double maxStep, double[] vecAbsoluteTolerance, - double[] vecRelativeTolerance) { - return new GraggBulirschStoerIntegrator(minStep, maxStep, - vecAbsoluteTolerance, vecRelativeTolerance); - } - -} diff --git a/src/test/org/apache/commons/math/ode/GraggBulirschStoerIntegratorTest.java b/src/test/org/apache/commons/math/ode/GraggBulirschStoerIntegratorTest.java index 3a6346b8d..fca8f2050 100644 --- a/src/test/org/apache/commons/math/ode/GraggBulirschStoerIntegratorTest.java +++ b/src/test/org/apache/commons/math/ode/GraggBulirschStoerIntegratorTest.java @@ -37,10 +37,8 @@ public class GraggBulirschStoerIntegratorTest public void testDimensionCheck() { try { TestProblem1 pb = new TestProblem1(); - FirstOrderIntegratorFactory factory = - FirstOrderIntegratorFactory.newInstance(); AdaptiveStepsizeIntegrator integrator = - factory.newGraggBulirschStoerIntegrator(0.0, 1.0, 1.0e-10, 1.0e-10); + new GraggBulirschStoerIntegrator(0.0, 1.0, 1.0e-10, 1.0e-10); integrator.integrate(pb, 0.0, new double[pb.getDimension()+10], 1.0, new double[pb.getDimension()+10]);