From 0155238a3c86691ebb6b5d5a067088c2d0c9273c Mon Sep 17 00:00:00 2001 From: Gilles Sadowski Date: Wed, 21 Aug 2013 02:03:30 +0000 Subject: [PATCH] MATH-1014 Container for storing observations, to allow separating the curve fitting algorithms from the data to be fitted. git-svn-id: https://svn.apache.org/repos/asf/commons/proper/math/trunk@1516059 13f79535-47bb-0310-9956-ffa450edef68 --- .../math3/fitting/WeightedObservedPoints.java | 113 ++++++++++++++++ .../fitting/WeightedObservedPointsTest.java | 126 ++++++++++++++++++ 2 files changed, 239 insertions(+) create mode 100644 src/main/java/org/apache/commons/math3/fitting/WeightedObservedPoints.java create mode 100644 src/test/java/org/apache/commons/math3/fitting/WeightedObservedPointsTest.java diff --git a/src/main/java/org/apache/commons/math3/fitting/WeightedObservedPoints.java b/src/main/java/org/apache/commons/math3/fitting/WeightedObservedPoints.java new file mode 100644 index 000000000..4a564ff6e --- /dev/null +++ b/src/main/java/org/apache/commons/math3/fitting/WeightedObservedPoints.java @@ -0,0 +1,113 @@ +/* + * 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.fitting; + +import java.util.List; +import java.util.ArrayList; +import java.io.Serializable; + +/** + * Simple container for weighted observed points used + * in {@link AbstractCurveFitter curve fitting} algorithms. + * + * @version $Id$ + * @since 3.3 + */ +public class WeightedObservedPoints implements Serializable { + /** Serializable version id. */ + private static final long serialVersionUID = 20130813L; + + /** Observed points. */ + private final List observations + = new ArrayList(); + + /** + * Adds a point to the sample. + * Calling this method is equivalent to calling + * {@code add(1.0, x, y)}. + * + * @param x Abscissa of the point. + * @param y Observed value at {@code x}. After fitting we should + * have {@code f(x)} as close as possible to this value. + * + * @see #add(double, double, double) + * @see #add(WeightedObservedPoint) + * @see #getObservations() + */ + public void add(double x, double y) { + add(1d, x, y); + } + + /** + * Adds a point to the sample. + * + * @param weight Weight of the observed point. + * @param x Abscissa of the point. + * @param y Observed value at {@code x}. After fitting we should + * have {@code f(x)} as close as possible to this value. + * + * @see #add(double, double) + * @see #add(WeightedObservedPoint) + * @see #getObservations() + */ + public void add(double weight, double x, double y) { + observations.add(new WeightedObservedPoint(weight, x, y)); + } + + /** + * Adds a point to the sample. + * + * @param observed Observed point to add. + * + * @see #add(double, double) + * @see #add(double, double, double) + * @see #getObservations() + */ + public void add(WeightedObservedPoint observed) { + observations.add(observed); + } + + /** + * Gets a snapshot of the observed points. + * The list of stored points is copied in order to ensure that + * modification of the returned instance does not affect this + * container. + * Conversely, further modification of this container (through + * the {@code add} or {@code clear} methods) will not affect the + * returned list. + * + * @return the observed points, in the order they were added to this + * container. + * + * @see #add(double, double) + * @see #add(double, double, double) + * @see #add(WeightedObservedPoint) + */ + public List toList() { + // The copy is necessary to ensure thread-safety because of the + // "clear" method (which otherwise would be able to empty the + // list of points while it is being used by another thread). + return new ArrayList(observations); + } + + /** + * Removes all observations from this container. + */ + public void clear() { + observations.clear(); + } +} diff --git a/src/test/java/org/apache/commons/math3/fitting/WeightedObservedPointsTest.java b/src/test/java/org/apache/commons/math3/fitting/WeightedObservedPointsTest.java new file mode 100644 index 000000000..3e63811b0 --- /dev/null +++ b/src/test/java/org/apache/commons/math3/fitting/WeightedObservedPointsTest.java @@ -0,0 +1,126 @@ +/* + * 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.fitting; + +import java.util.List; +import org.junit.Assert; +import org.junit.Test; +import org.apache.commons.math3.util.Precision; + +/** + * Tests {@link WeightedObservedPoints}. + * + * @version $Id$ + */ +public class WeightedObservedPointsTest { + @Test + public void testAdd1() { + final WeightedObservedPoints store = new WeightedObservedPoints(); + + final double x = 1.2; + final double y = 34.56; + final double w = 0.789; + + store.add(w, x, y); + + Assert.assertTrue(lastElementIsSame(store, new WeightedObservedPoint(w, x, y))); + } + + @Test + public void testAdd2() { + final WeightedObservedPoints store = new WeightedObservedPoints(); + + final double x = 1.2; + final double y = 34.56; + final double w = 0.789; + + store.add(new WeightedObservedPoint(w, x, y)); + + Assert.assertTrue(lastElementIsSame(store, new WeightedObservedPoint(w, x, y))); + } + + @Test + public void testAdd3() { + final WeightedObservedPoints store = new WeightedObservedPoints(); + + final double x = 1.2; + final double y = 34.56; + + store.add(x, y); + + Assert.assertTrue(lastElementIsSame(store, new WeightedObservedPoint(1, x, y))); + } + + @Test + public void testClear() { + final WeightedObservedPoints store = new WeightedObservedPoints(); + + store.add(new WeightedObservedPoint(1, 2, 3)); + store.add(new WeightedObservedPoint(2, -1, -2)); + Assert.assertTrue(store.toList().size() == 2); + + store.clear(); + Assert.assertTrue(store.toList().size() == 0); + } + + // Ensure that an instance returned by "toList()" is independent from + // the original container. + @Test + public void testToListCopy() { + final WeightedObservedPoints store = new WeightedObservedPoints(); + + store.add(new WeightedObservedPoint(1, 2, 3)); + store.add(new WeightedObservedPoint(2, -3, -4)); + + final List list = store.toList(); + Assert.assertTrue(list.size() == 2); + + // Adding an element to "list" has no impact on "store". + list.add(new WeightedObservedPoint(1.2, 3.4, 5.6)); + Assert.assertFalse(list.size() == store.toList().size()); + + // Clearing "store" has no impact on "list". + store.clear(); + Assert.assertFalse(list.size() == 0); + } + + /** + * Checks that the contents of the last element is equal to the + * contents of {@code p}. + * + * @param store Container. + * @param point Observation. + * @return {@code true} if both elements have the same contents. + */ + private boolean lastElementIsSame(WeightedObservedPoints store, + WeightedObservedPoint point) { + final List list = store.toList(); + final WeightedObservedPoint lastPoint = list.get(list.size() - 1); + + if (!Precision.equals(lastPoint.getX(), point.getX())) { + return false; + } + if (!Precision.equals(lastPoint.getY(), point.getY())) { + return false; + } + if (!Precision.equals(lastPoint.getWeight(), point.getWeight())) { + return false; + } + + return true; + } +}