commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pste...@apache.org
Subject svn commit: r476930 [16/22] - in /jakarta/commons/proper/math/trunk/src/mantissa: ./ src/ src/org/ src/org/spaceroots/ src/org/spaceroots/mantissa/ src/org/spaceroots/mantissa/algebra/ src/org/spaceroots/mantissa/estimation/ src/org/spaceroots/mantissa...
Date Sun, 19 Nov 2006 21:36:23 GMT
Added: jakarta/commons/proper/math/trunk/src/mantissa/tests-src/org/spaceroots/mantissa/estimation/EstimatedParameterTest.java
URL: http://svn.apache.org/viewvc/jakarta/commons/proper/math/trunk/src/mantissa/tests-src/org/spaceroots/mantissa/estimation/EstimatedParameterTest.java?view=auto&rev=476930
==============================================================================
--- jakarta/commons/proper/math/trunk/src/mantissa/tests-src/org/spaceroots/mantissa/estimation/EstimatedParameterTest.java
(added)
+++ jakarta/commons/proper/math/trunk/src/mantissa/tests-src/org/spaceroots/mantissa/estimation/EstimatedParameterTest.java
Sun Nov 19 13:36:15 2006
@@ -0,0 +1,74 @@
+// 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.spaceroots.mantissa.estimation;
+
+import junit.framework.*;
+
+public class EstimatedParameterTest
+  extends TestCase {
+
+  public EstimatedParameterTest(String name) {
+    super(name);
+  }
+
+  public void testConstruction() {
+
+    EstimatedParameter p1 = new EstimatedParameter("p1", 1.0);
+    assertTrue(p1.getName().equals("p1"));
+    checkValue(p1.getEstimate(), 1.0);
+    assertTrue(! p1.isBound());
+
+    EstimatedParameter p2 = new EstimatedParameter("p2", 2.0, true);
+    assertTrue(p2.getName().equals("p2"));
+    checkValue(p2.getEstimate(), 2.0);
+    assertTrue(p2.isBound());
+
+  }
+
+  public void testBound() {
+
+    EstimatedParameter p = new EstimatedParameter("p", 0.0);
+    assertTrue(! p.isBound());
+    p.setBound(true);
+    assertTrue(p.isBound());
+    p.setBound(false);
+    assertTrue(! p.isBound());
+
+  }
+
+  public void testEstimate() {
+
+    EstimatedParameter p = new EstimatedParameter("p", 0.0);
+    checkValue(p.getEstimate(), 0.0);
+
+    for (double e = 0.0; e < 10.0; e += 0.5) {
+      p.setEstimate(e);
+      checkValue(p.getEstimate(), e);
+    }
+
+  }
+
+  public static Test suite() {
+    return new TestSuite(EstimatedParameterTest.class);
+  }
+
+  private void checkValue(double value, double expected) {
+    assertTrue(Math.abs(value - expected) < 1.0e-10);
+  }
+
+}

Propchange: jakarta/commons/proper/math/trunk/src/mantissa/tests-src/org/spaceroots/mantissa/estimation/EstimatedParameterTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: jakarta/commons/proper/math/trunk/src/mantissa/tests-src/org/spaceroots/mantissa/estimation/GaussNewtonEstimatorTest.java
URL: http://svn.apache.org/viewvc/jakarta/commons/proper/math/trunk/src/mantissa/tests-src/org/spaceroots/mantissa/estimation/GaussNewtonEstimatorTest.java?view=auto&rev=476930
==============================================================================
--- jakarta/commons/proper/math/trunk/src/mantissa/tests-src/org/spaceroots/mantissa/estimation/GaussNewtonEstimatorTest.java
(added)
+++ jakarta/commons/proper/math/trunk/src/mantissa/tests-src/org/spaceroots/mantissa/estimation/GaussNewtonEstimatorTest.java
Sun Nov 19 13:36:15 2006
@@ -0,0 +1,262 @@
+// 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.spaceroots.mantissa.estimation;
+
+import java.util.Random;
+import junit.framework.*;
+
+public class GaussNewtonEstimatorTest
+  extends TestCase
+  implements EstimationProblem {
+
+  public GaussNewtonEstimatorTest(String name) {
+    super(name);
+  }
+
+  public void testNoMeasurementError()
+    throws EstimationException {
+    initRandomizedGrid(2.3);
+    initProblem(0.0);
+    GaussNewtonEstimator estimator =
+      new GaussNewtonEstimator(100, 1.0e-7, 1.0e-10, 1.0e-10);
+    estimator.estimate(this);
+    checkGrid(0.01);
+  }
+
+  public void testSmallMeasurementError()
+    throws EstimationException {
+    initRandomizedGrid(2.3);
+    initProblem(0.02);
+    GaussNewtonEstimator estimator =
+      new GaussNewtonEstimator(100, 1.0e-7, 1.0e-10, 1.0e-10);
+    estimator.estimate(this);
+    checkGrid(0.1);
+  }
+
+  public void testNoError()
+    throws EstimationException {
+    initRandomizedGrid(0.0);
+    initProblem(0.0);
+    GaussNewtonEstimator estimator =
+      new GaussNewtonEstimator(100, 1.0e-7, 1.0e-10, 1.0e-10);
+    estimator.estimate(this);
+    checkGrid(1.0e-10);
+  }
+
+  public void testUnsolvableProblem() {
+
+    initRandomizedGrid(2.3);
+    initProblem(0.0);
+
+    // reduce the number of measurements below the limit threshold
+    int unknowns = unboundPars.length;
+    WeightedMeasurement[] reducedSet = new WeightedMeasurement[unknowns - 1];
+    for (int i = 0; i < reducedSet.length; ++i) {
+      reducedSet[i] = measurements[i];
+    }
+    measurements = reducedSet;
+
+    boolean gotIt = false;
+    try {
+      GaussNewtonEstimator estimator =
+        new GaussNewtonEstimator(100, 1.0e-7, 1.0e-10, 1.0e-10);
+      estimator.estimate(this);
+    } catch(EstimationException e) {
+      gotIt = true;
+    }
+
+    assertTrue(gotIt);
+
+  }
+
+  public static Test suite() {
+    return new TestSuite(GaussNewtonEstimatorTest.class);
+  }
+
+  public void setUp() {
+    initPerfectGrid(5);
+  }
+
+  public void tearDown() {
+    perfectPars    = null;
+    randomizedPars = null;
+    unboundPars    = null;
+    measurements   = null;
+  }
+
+  private void initPerfectGrid(int gridSize) {
+    perfectPars = new EstimatedParameter[gridSize * gridSize * 2];
+
+    int k = 0;
+    for (int i = 0; i < gridSize; ++i) {
+      for (int j = 0; j < gridSize; ++j) {
+
+        String name            = new Integer(k).toString();
+        perfectPars[2 * k]     = new EstimatedParameter("x" + name, i);
+        perfectPars[2 * k + 1] = new EstimatedParameter("y" + name, j);
+        ++k;
+      }
+    }
+
+  }
+
+  private void initRandomizedGrid(double initialGuessError) {
+    Random randomizer = new Random(2353995334l);
+    randomizedPars    = new EstimatedParameter[perfectPars.length];
+
+    // add an error to every point coordinate
+    for (int k = 0; k < randomizedPars.length; ++k) {
+      String name  = perfectPars[k].getName();
+      double value = perfectPars[k].getEstimate();
+      double error = randomizer.nextGaussian() * initialGuessError;
+      randomizedPars[k] = new EstimatedParameter(name, value + error);
+    }
+
+  }
+
+  private void initProblem(double measurementError) {
+
+    int pointsNumber       = randomizedPars.length / 2;
+    int measurementsNumber = pointsNumber * (pointsNumber - 1) / 2;
+    measurements           = new WeightedMeasurement[measurementsNumber];
+
+    Random randomizer = new Random(5785631926l);
+
+    // for the test, we consider that the perfect grid is the reality
+    // and that the randomized grid is the first (wrong) estimate.
+    int i = 0;
+    for (int l = 0; l < (pointsNumber - 1); ++l) {
+      for (int m = l + 1; m < pointsNumber; ++m) {
+        // perfect measurements on the real data
+        double dx = perfectPars[2 * l].getEstimate()
+          - perfectPars[2 * m].getEstimate();
+        double dy = perfectPars[2 * l + 1].getEstimate()
+          - perfectPars[2 * m + 1].getEstimate();
+        double d = Math.sqrt(dx * dx + dy * dy);
+
+        // adding a noise to the measurements
+        d += randomizer.nextGaussian() * measurementError;
+
+        // add the measurement to the current problem
+        measurements[i++] = new Distance(1.0, d,
+                                         randomizedPars[2 * l],
+                                         randomizedPars[2 * l + 1],
+                                         randomizedPars[2 * m],
+                                         randomizedPars[2 * m + 1]);
+
+      }
+    }
+
+    // fix three values in the randomized grid and bind them (there
+    // are two abscissas and one ordinate, so if there were no error
+    // at all, the estimated grid should be correctly centered on the
+    // perfect grid)
+    int oddNumber = 2 * (randomizedPars.length / 4) - 1;
+    for (int k = 0; k < 2 * oddNumber + 1; k += oddNumber) {
+      randomizedPars[k].setEstimate(perfectPars[k].getEstimate());
+      randomizedPars[k].setBound(true);
+    }
+
+    // store the unbound parameters in a specific table
+    unboundPars = new EstimatedParameter[randomizedPars.length - 3];
+    for (int src = 0, dst = 0; src < randomizedPars.length; ++src) {
+      if (! randomizedPars[src].isBound()) {
+        unboundPars[dst++] = randomizedPars[src];
+      }
+    }
+
+  }
+
+  private void checkGrid(double threshold) {
+
+    double rms = 0;
+    for (int i = 0; i < perfectPars.length; ++i) {
+      rms += perfectPars[i].getEstimate() - randomizedPars[i].getEstimate();
+    }
+    rms = Math.sqrt(rms / perfectPars.length);
+
+    assertTrue(rms <= threshold);
+
+  }
+
+  private class Distance extends WeightedMeasurement {
+
+    public Distance(double weight, double measuredValue,
+                    EstimatedParameter x1, EstimatedParameter y1,
+                    EstimatedParameter x2, EstimatedParameter y2) {
+      super(weight, measuredValue);
+      this.x1 = x1;
+      this.y1 = y1;
+      this.x2 = x2;
+      this.y2 = y2;
+    }
+
+    public double getTheoreticalValue() {
+      double dx = x2.getEstimate() - x1.getEstimate();
+      double dy = y2.getEstimate() - y1.getEstimate();
+      return Math.sqrt(dx * dx + dy * dy);
+    }
+
+    public double getPartial(EstimatedParameter p) {
+
+      // first quick answer for most parameters
+      if ((p != x1) && (p != y1) && (p != x2) && (p != y2)) {
+        return 0.0;
+      }
+
+      // compute the value now as we know we depend on the specified parameter
+      double distance = getTheoreticalValue();
+
+      if (p == x1) {
+        return (x1.getEstimate() - x2.getEstimate()) / distance;
+      } else if (p == x2) {
+        return (x2.getEstimate() - x1.getEstimate()) / distance;
+      } else if (p == y1) {
+        return (y1.getEstimate() - y2.getEstimate()) / distance;
+      } else {
+        return (y2.getEstimate() - y1.getEstimate()) / distance;
+      }
+
+    }
+
+    private EstimatedParameter x1;
+    private EstimatedParameter y1;
+    private EstimatedParameter x2;
+    private EstimatedParameter y2;
+    private static final long serialVersionUID = 4090004243280980746L;
+
+  }
+
+  public WeightedMeasurement[] getMeasurements() {
+    return measurements;
+  }
+
+  public EstimatedParameter[] getUnboundParameters() {
+    return unboundPars;
+  }
+
+  public EstimatedParameter[] getAllParameters() {
+    return randomizedPars;
+  }
+
+  private EstimatedParameter[]  perfectPars;
+  private EstimatedParameter[]  randomizedPars;
+  private EstimatedParameter[]  unboundPars;
+  private WeightedMeasurement[] measurements;
+
+}

Propchange: jakarta/commons/proper/math/trunk/src/mantissa/tests-src/org/spaceroots/mantissa/estimation/GaussNewtonEstimatorTest.java
------------------------------------------------------------------------------
    svn:eol-style = native



---------------------------------------------------------------------
To unsubscribe, e-mail: commons-dev-unsubscribe@jakarta.apache.org
For additional commands, e-mail: commons-dev-help@jakarta.apache.org


Mime
View raw message